workflow-agent-cli 2.2.1 → 2.3.0

package/dist/cli/index.js

@@ -1,27 +1,31 @@
 #!/usr/bin/env node
+import {
+  generateAuditReport,
+  hasUncommittedChanges,
+  runAllChecks,
+  runAllSetups,
+  stageAllChanges
+} from "../chunk-YI3LBZ7I.js";
 import {
   validateBranchName,
   validateCommitMessage,
   validatePRTitle
 } from "../chunk-NMHWD2GA.js";
 import {
-  DEFAULT_RESERVED_SCOPE_NAMES,
   hasConfig,
   loadConfig,
-  validateConfig,
-  validateScopeDefinitions,
-  validateScopeName
-} from "../chunk-JCDT4363.js";
+  validateScopeDefinitions
+} from "../chunk-RDVTKGQV.js";
 
 // src/cli/index.ts
-import { Command as Command2 } from "commander";
+import { Command } from "commander";
 
 // src/cli/commands/init.ts
 import * as p from "@clack/prompts";
 import chalk from "chalk";
-import { existsSync as existsSync4 } from "fs";
-import { writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { join as join4, dirname } from "path";
+import { existsSync } from "fs";
+import { writeFile, mkdir } from "fs/promises";
+import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 
 // src/templates/renderer.ts
@@ -192,6 +196,18 @@ async function renderTemplateFile(templatePath, outputPath, context) {
   await fs.mkdir(path.dirname(outputPath), { recursive: true });
   await fs.writeFile(outputPath, rendered, "utf-8");
 }
+async function renderTemplateDirectory(templateDir, outputDir, context) {
+  const files = await fs.readdir(templateDir);
+  const rendered = [];
+  for (const file of files) {
+    if (!file.match(/\.(md|ts|json)$/)) continue;
+    const templatePath = path.join(templateDir, file);
+    const outputPath = path.join(outputDir, file);
+    await renderTemplateFile(templatePath, outputPath, context);
+    rendered.push(file);
+  }
+  return rendered;
+}
 async function getProjectName(projectPath) {
   try {
     const pkgPath = path.join(projectPath, "package.json");
@@ -222,694 +238,13 @@ async function validateTemplateDirectory(templateDir) {
   }
 }
 
-// src/templates/metadata.ts
-var templateMetadata = {
-  "AGENT_EDITING_INSTRUCTIONS.md": {
-    filename: "AGENT_EDITING_INSTRUCTIONS.md",
-    displayName: "Agent Editing Instructions",
-    mandatory: true,
-    category: "workflow",
-    validators: ["implementation-plan"],
-    description: "Core rules for AI agents: implementation plans, coding standards, architecture"
-  },
-  "BRANCHING_STRATEGY.md": {
-    filename: "BRANCHING_STRATEGY.md",
-    displayName: "Branching Strategy",
-    mandatory: true,
-    category: "workflow",
-    validators: ["branch-name", "pr-title"],
-    description: "Git branch naming conventions, PR requirements, merge policies"
-  },
-  "TESTING_STRATEGY.md": {
-    filename: "TESTING_STRATEGY.md",
-    displayName: "Testing Strategy",
-    mandatory: true,
-    category: "development",
-    validators: ["test-coverage"],
-    description: "Testing pyramid, Vitest/Playwright patterns, when tests are required"
-  },
-  "SELF_IMPROVEMENT_MANDATE.md": {
-    filename: "SELF_IMPROVEMENT_MANDATE.md",
-    displayName: "Self-Improvement Mandate",
-    mandatory: true,
-    category: "workflow",
-    validators: [],
-    description: "Continuous improvement tracking, changelog requirements"
-  },
-  "SINGLE_SOURCE_OF_TRUTH.md": {
-    filename: "SINGLE_SOURCE_OF_TRUTH.md",
-    displayName: "Single Source of Truth",
-    mandatory: true,
-    category: "workflow",
-    validators: [],
-    description: "Canonical code locations, service patterns, avoiding duplication"
-  },
-  "COMPONENT_LIBRARY.md": {
-    filename: "COMPONENT_LIBRARY.md",
-    displayName: "Component Library",
-    mandatory: false,
-    category: "development",
-    validators: [],
-    description: "UI component patterns, design tokens, decision tree"
-  },
-  "DEPLOYMENT_STRATEGY.md": {
-    filename: "DEPLOYMENT_STRATEGY.md",
-    displayName: "Deployment Strategy",
-    mandatory: false,
-    category: "development",
-    validators: [],
-    description: "Deployment workflow, environments, migrations, rollback"
-  },
-  "LIBRARY_INVENTORY.md": {
-    filename: "LIBRARY_INVENTORY.md",
-    displayName: "Library Inventory",
-    mandatory: false,
-    category: "development",
-    validators: [],
-    description: "Dependency catalog, approved libraries, new library process"
-  },
-  "SCOPE_CREATION_WORKFLOW.md": {
-    filename: "SCOPE_CREATION_WORKFLOW.md",
-    displayName: "Scope Creation Workflow",
-    mandatory: false,
-    category: "workflow",
-    validators: [],
-    description: "Workflow for AI agents creating custom scopes"
-  },
-  "CUSTOM_SCOPE_TEMPLATE.md": {
-    filename: "CUSTOM_SCOPE_TEMPLATE.md",
-    displayName: "Custom Scope Template",
-    mandatory: false,
-    category: "workflow",
-    validators: [],
-    description: "Template for defining custom scope packages"
-  },
-  "PROJECT_TEMPLATE_README.md": {
-    filename: "PROJECT_TEMPLATE_README.md",
-    displayName: "Project Template README",
-    mandatory: false,
-    category: "documentation",
-    validators: [],
-    description: "Meta-document describing project structure"
-  },
-  "Guidelines.md": {
-    filename: "Guidelines.md",
-    displayName: "Custom Guidelines",
-    mandatory: false,
-    category: "documentation",
-    validators: [],
-    description: "Placeholder for custom user guidelines"
-  }
-};
-function getMandatoryTemplates() {
-  return Object.values(templateMetadata).filter((t) => t.mandatory);
-}
-function getOptionalTemplates() {
-  return Object.values(templateMetadata).filter((t) => !t.mandatory);
-}
-function getMandatoryTemplateFilenames() {
-  return getMandatoryTemplates().map((t) => t.filename);
-}
-
-// src/utils/hooks.ts
-import { existsSync } from "fs";
-import { readFile, writeFile, unlink, chmod, rename, mkdir } from "fs/promises";
-import { join } from "path";
-function getGitHooksDir(projectPath = process.cwd()) {
-  return join(projectPath, ".git", "hooks");
-}
-function hasGitRepo(projectPath = process.cwd()) {
-  return existsSync(join(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 = join(hooksDir, hookType);
-  const originalPath = join(hooksDir, `${hookType}.original`);
-  const status = {
-    installed: false,
-    hookType,
-    hasExistingHook: false,
-    wrappedOriginal: false
-  };
-  if (!existsSync(hookPath)) {
-    return status;
-  }
-  status.hasExistingHook = true;
-  if (await isWorkflowHook(hookPath)) {
-    status.installed = true;
-    status.wrappedOriginal = existsSync(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 = join(hooksDir, hookType);
-  const originalPath = join(hooksDir, `${hookType}.original`);
-  const result = {
-    success: false,
-    hookType,
-    wrappedExisting: false
-  };
-  try {
-    if (!existsSync(hooksDir)) {
-      await mkdir(hooksDir, { recursive: true });
-    }
-    if (existsSync(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 writeFile(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 = join(hooksDir, hookType);
-  const originalPath = join(hooksDir, `${hookType}.original`);
-  const result = {
-    success: false,
-    hookType,
-    wrappedExisting: false
-  };
-  try {
-    if (!existsSync(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 (existsSync(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/utils/git-repo.ts
-import { execa } from "execa";
-import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile2 } from "fs/promises";
-import { join as join2 } from "path";
-async function isGitRepo(projectPath = process.cwd()) {
-  try {
-    await execa("git", ["rev-parse", "--git-dir"], { cwd: projectPath });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function getGitRemoteUrl(projectPath = process.cwd()) {
-  try {
-    const { stdout } = await execa("git", ["remote", "get-url", "origin"], {
-      cwd: projectPath
-    });
-    return stdout.trim() || null;
-  } catch {
-    return null;
-  }
-}
-function isGitHubRemote(remoteUrl) {
-  if (!remoteUrl) return false;
-  return remoteUrl.includes("github.com");
-}
-function parseGitHubUrl(remoteUrl) {
-  if (!remoteUrl || !isGitHubRemote(remoteUrl)) return null;
-  const match = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
-  if (match) {
-    return {
-      owner: match[1],
-      repo: match[2].replace(/\.git$/, "")
-    };
-  }
-  return null;
-}
-async function getDefaultBranch(projectPath = process.cwd()) {
-  try {
-    const { stdout } = await execa(
-      "git",
-      ["symbolic-ref", "refs/remotes/origin/HEAD"],
-      {
-        cwd: projectPath
-      }
-    );
-    return stdout.trim().replace("refs/remotes/origin/", "") || "main";
-  } catch {
-    try {
-      const { stdout } = await execa(
-        "git",
-        ["rev-parse", "--abbrev-ref", "HEAD"],
-        {
-          cwd: projectPath
-        }
-      );
-      return stdout.trim() || "main";
-    } catch {
-      return "main";
-    }
-  }
-}
-async function getRepoInfo(projectPath = process.cwd()) {
-  const isRepo = await isGitRepo(projectPath);
-  if (!isRepo) {
-    return {
-      isGitRepo: false,
-      remoteUrl: null,
-      isGitHub: false,
-      github: null,
-      defaultBranch: null
-    };
-  }
-  const remoteUrl = await getGitRemoteUrl(projectPath);
-  const isGitHub = isGitHubRemote(remoteUrl);
-  const github = parseGitHubUrl(remoteUrl);
-  const defaultBranch = await getDefaultBranch(projectPath);
-  return {
-    isGitRepo: true,
-    remoteUrl,
-    isGitHub,
-    github,
-    defaultBranch
-  };
-}
-async function detectPackageManager(projectPath = process.cwd()) {
-  if (existsSync2(join2(projectPath, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (existsSync2(join2(projectPath, "yarn.lock"))) {
-    return "yarn";
-  }
-  if (existsSync2(join2(projectPath, "bun.lockb"))) {
-    return "bun";
-  }
-  if (existsSync2(join2(projectPath, "package-lock.json"))) {
-    return "npm";
-  }
-  try {
-    const pkgPath = join2(projectPath, "package.json");
-    if (existsSync2(pkgPath)) {
-      const pkg = JSON.parse(await readFile2(pkgPath, "utf-8"));
-      if (pkg.packageManager) {
-        if (pkg.packageManager.startsWith("pnpm")) return "pnpm";
-        if (pkg.packageManager.startsWith("yarn")) return "yarn";
-        if (pkg.packageManager.startsWith("bun")) return "bun";
-      }
-    }
-  } catch {
-  }
-  return "npm";
-}
-async function isMonorepo(projectPath = process.cwd()) {
-  if (existsSync2(join2(projectPath, "pnpm-workspace.yaml"))) {
-    return true;
-  }
-  try {
-    const pkgPath = join2(projectPath, "package.json");
-    if (existsSync2(pkgPath)) {
-      const pkg = JSON.parse(await readFile2(pkgPath, "utf-8"));
-      if (pkg.workspaces) {
-        return true;
-      }
-    }
-  } catch {
-  }
-  if (existsSync2(join2(projectPath, "lerna.json"))) {
-    return true;
-  }
-  if (existsSync2(join2(projectPath, "nx.json"))) {
-    return true;
-  }
-  if (existsSync2(join2(projectPath, "turbo.json"))) {
-    return true;
-  }
-  return false;
-}
-async function getPackageScripts(projectPath = process.cwd()) {
-  try {
-    const pkgPath = join2(projectPath, "package.json");
-    if (!existsSync2(pkgPath)) {
-      return {};
-    }
-    const pkg = JSON.parse(await readFile2(pkgPath, "utf-8"));
-    return pkg.scripts || {};
-  } catch {
-    return {};
-  }
-}
-async function getProjectInfo(projectPath = process.cwd()) {
-  const packageManager = await detectPackageManager(projectPath);
-  const monorepo = await isMonorepo(projectPath);
-  const scripts = await getPackageScripts(projectPath);
-  return {
-    packageManager,
-    isMonorepo: monorepo,
-    hasLintScript: "lint" in scripts,
-    hasTypecheckScript: "typecheck" in scripts || "type-check" in scripts,
-    hasFormatScript: "format" in scripts || "format:check" in scripts,
-    hasTestScript: "test" in scripts,
-    hasBuildScript: "build" in scripts
-  };
-}
-function getInstallCommand(packageManager) {
-  switch (packageManager) {
-    case "pnpm":
-      return "pnpm install --frozen-lockfile";
-    case "yarn":
-      return "yarn install --frozen-lockfile";
-    case "bun":
-      return "bun install --frozen-lockfile";
-    case "npm":
-    default:
-      return "npm ci";
-  }
-}
-function getRunCommand(packageManager, script, isMonorepo2 = false) {
-  switch (packageManager) {
-    case "pnpm":
-      return isMonorepo2 ? `pnpm -r run ${script}` : `pnpm run ${script}`;
-    case "yarn":
-      return isMonorepo2 ? `yarn workspaces run ${script}` : `yarn run ${script}`;
-    case "bun":
-      return `bun run ${script}`;
-    case "npm":
-    default:
-      return isMonorepo2 ? `npm run ${script} --workspaces --if-present` : `npm run ${script}`;
-  }
-}
-
-// src/utils/github-actions.ts
-import { existsSync as existsSync3 } from "fs";
-import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join3 } from "path";
-function generateCIWorkflowContent(options) {
-  const {
-    packageManager,
-    isMonorepo: isMonorepo2,
-    checks,
-    nodeVersions,
-    defaultBranch,
-    hasLintScript,
-    hasTypecheckScript,
-    hasFormatScript,
-    hasTestScript,
-    hasBuildScript
-  } = options;
-  const installCmd = getInstallCommand(packageManager);
-  const steps = [];
-  steps.push(`      - name: Checkout
-        uses: actions/checkout@v4`);
-  let cacheType = packageManager;
-  if (packageManager === "bun") {
-    cacheType = "npm";
-  }
-  const useMatrix = nodeVersions.length > 1;
-  const nodeVersionValue = useMatrix ? `\${{ matrix.node-version }}` : nodeVersions[0] || "20";
-  steps.push(`
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '${nodeVersionValue}'
-          cache: '${cacheType}'`);
-  if (packageManager === "pnpm") {
-    steps.push(`
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9`);
-  }
-  steps.push(`
-      - name: Install dependencies
-        run: ${installCmd}`);
-  if (checks.includes("lint")) {
-    if (hasLintScript) {
-      const lintCmd = getRunCommand(packageManager, "lint", isMonorepo2);
-      steps.push(`
-      - name: Lint
-        run: ${lintCmd}`);
-    } else {
-      steps.push(`
-      - name: Lint
-        run: echo "No lint script configured - add 'lint' to package.json scripts"`);
-    }
-  }
-  if (checks.includes("typecheck")) {
-    if (hasTypecheckScript) {
-      const typecheckCmd = getRunCommand(
-        packageManager,
-        "typecheck",
-        isMonorepo2
-      );
-      steps.push(`
-      - name: Type check
-        run: ${typecheckCmd}`);
-    } else {
-      steps.push(`
-      - name: Type check
-        run: npx tsc --noEmit`);
-    }
-  }
-  if (checks.includes("format")) {
-    if (hasFormatScript) {
-      const formatCmd = getRunCommand(
-        packageManager,
-        "format:check",
-        isMonorepo2
-      );
-      steps.push(`
-      - name: Format check
-        run: ${formatCmd} || npx prettier --check "**/*.{ts,tsx,js,jsx,json,md}"`);
-    } else {
-      steps.push(`
-      - name: Format check
-        run: npx prettier --check "**/*.{ts,tsx,js,jsx,json,md}"`);
-    }
-  }
-  if (checks.includes("build")) {
-    if (hasBuildScript) {
-      const buildCmd = getRunCommand(packageManager, "build", isMonorepo2);
-      steps.push(`
-      - name: Build
-        run: ${buildCmd}`);
-    } else {
-      steps.push(`
-      - name: Build
-        run: echo "No build script configured - add 'build' to package.json scripts"`);
-    }
-  }
-  if (checks.includes("test")) {
-    if (hasTestScript) {
-      const testCmd = getRunCommand(packageManager, "test", isMonorepo2);
-      steps.push(`
-      - name: Test
-        run: ${testCmd}`);
-    } else {
-      steps.push(`
-      - name: Test
-        run: echo "No test script configured - add 'test' to package.json scripts"`);
-    }
-  }
-  let matrixStrategy = "";
-  if (useMatrix) {
-    matrixStrategy = `
-    strategy:
-      matrix:
-        node-version: [${nodeVersions.map((v) => `'${v}'`).join(", ")}]`;
-  }
-  const workflow = `# Workflow Agent CI Pipeline
-# Auto-generated - modifications will be preserved on regeneration
-# To regenerate: workflow github:setup
-
-name: CI
-
-on:
-  push:
-    branches: [${defaultBranch}, develop]
-  pull_request:
-    branches: [${defaultBranch}, develop]
-
-jobs:
-  ci:
-    runs-on: ubuntu-latest${matrixStrategy}
-
-    steps:
-${steps.join("\n")}
-`;
-  return workflow;
-}
-async function createCIWorkflow(options = {}) {
-  const projectPath = options.projectPath || process.cwd();
-  const workflowsDir = join3(projectPath, ".github", "workflows");
-  const workflowPath = join3(workflowsDir, "ci.yml");
-  const result = {
-    success: false,
-    filePath: workflowPath
-  };
-  try {
-    const projectInfo = await getProjectInfo(projectPath);
-    const packageManager = options.packageManager || projectInfo.packageManager;
-    const isMonorepo2 = options.isMonorepo ?? projectInfo.isMonorepo;
-    const checks = options.ciConfig?.checks || [
-      "lint",
-      "typecheck",
-      "format",
-      "build",
-      "test"
-    ];
-    const nodeVersions = options.nodeVersions || ["20"];
-    const defaultBranch = options.defaultBranch || "main";
-    if (!existsSync3(workflowsDir)) {
-      await mkdir2(workflowsDir, { recursive: true });
-    }
-    const content = generateCIWorkflowContent({
-      packageManager,
-      isMonorepo: isMonorepo2,
-      checks,
-      nodeVersions,
-      defaultBranch,
-      hasLintScript: projectInfo.hasLintScript,
-      hasTypecheckScript: projectInfo.hasTypecheckScript,
-      hasFormatScript: projectInfo.hasFormatScript,
-      hasTestScript: projectInfo.hasTestScript,
-      hasBuildScript: projectInfo.hasBuildScript
-    });
-    await writeFile2(workflowPath, content, "utf-8");
-    result.success = true;
-  } catch (error) {
-    result.error = error instanceof Error ? error.message : String(error);
-  }
-  return result;
-}
-function hasCIWorkflow(projectPath = process.cwd()) {
-  const workflowsDir = join3(projectPath, ".github", "workflows");
-  const possibleNames = ["ci.yml", "ci.yaml", "main.yml", "main.yaml"];
-  return possibleNames.some((name) => existsSync3(join3(workflowsDir, name)));
-}
-
 // src/cli/commands/init.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
 async function initCommand(options) {
   console.log(chalk.bold.cyan("\n\u{1F680} Workflow Agent Initialization\n"));
   const cwd = process.cwd();
-  const isNonInteractive = !!(options.preset && options.name) || !!options.yes;
+  const isNonInteractive = !!(options.preset && options.name);
   if (hasConfig(cwd) && !options.yes && !isNonInteractive) {
     const shouldContinue = await p.confirm({
       message: "Workflow Agent is already configured. Continue and overwrite?",
@@ -979,32 +314,16 @@ async function initCommand(options) {
         )
       );
       scopes = [
-        {
-          name: "feat",
-          description: "New features and enhancements",
-          emoji: "\u2728"
-        },
-        { name: "fix", description: "Bug fixes and patches", emoji: "\u{1F41B}" },
-        {
-          name: "documentation",
-          description: "Documentation updates and improvements",
-          emoji: "\u{1F4DA}"
-        }
+        { name: "feat", description: "New features", emoji: "\u2728" },
+        { name: "fix", description: "Bug fixes", emoji: "\u{1F41B}" },
+        { name: "docs", description: "Documentation", emoji: "\u{1F4DA}" }
       ];
     }
   } else {
     scopes = [
-      {
-        name: "feat",
-        description: "New features and enhancements",
-        emoji: "\u2728"
-      },
-      { name: "fix", description: "Bug fixes and patches", emoji: "\u{1F41B}" },
-      {
-        name: "documentation",
-        description: "Documentation updates and improvements",
-        emoji: "\u{1F4DA}"
-      }
+      { name: "feat", description: "New features", emoji: "\u2728" },
+      { name: "fix", description: "Bug fixes", emoji: "\u{1F41B}" },
+      { name: "docs", description: "Documentation", emoji: "\u{1F4DA}" }
     ];
     console.log(
       chalk.dim(
@@ -1016,169 +335,89 @@ async function initCommand(options) {
     projectName,
     scopes,
     enforcement: "strict",
-    language: "en",
-    hooks: {
-      enabled: true,
-      preCommit: ["validate-branch", "check-guidelines"],
-      commitMsg: ["validate-commit"]
-    },
-    ci: {
-      enabled: true,
-      provider: "github",
-      checks: ["lint", "typecheck", "format", "build", "test"]
-    },
-    reservedScopeNames: DEFAULT_RESERVED_SCOPE_NAMES
+    language: "en"
   };
-  const configPath = join4(cwd, "workflow.config.json");
-  await writeFile3(configPath, JSON.stringify(config, null, 2));
-  const workflowDir = join4(cwd, ".workflow");
-  if (!existsSync4(workflowDir)) {
-    await mkdir3(workflowDir, { recursive: true });
+  const configPath = join(cwd, "workflow.config.json");
+  await writeFile(configPath, JSON.stringify(config, null, 2));
+  const workflowDir = join(cwd, ".workflow");
+  if (!existsSync(workflowDir)) {
+    await mkdir(workflowDir, { recursive: true });
+  }
+  const shouldGenerateGuidelines = await p.confirm({
+    message: "Generate workflow guidelines from templates?",
+    initialValue: true
+  });
+  if (p.isCancel(shouldGenerateGuidelines)) {
+    p.cancel("Initialization cancelled");
+    process.exit(0);
   }
-  const repoInfo = await getRepoInfo(cwd);
-  const projectInfo = await getProjectInfo(cwd);
-  const mandatoryTemplates = getMandatoryTemplates();
-  const optionalTemplates = getOptionalTemplates();
-  console.log(
-    chalk.dim(
-      `
-\u{1F4CB} Generating ${mandatoryTemplates.length} mandatory guidelines...`
-    )
-  );
-  const guidelinesDir = join4(cwd, "guidelines");
-  const templatesDir = join4(__dirname, "../../templates");
-  let mandatoryGenerated = 0;
-  let optionalGenerated = 0;
-  try {
-    await validateTemplateDirectory(templatesDir);
-    const context = await buildTemplateContext(config, cwd);
-    await mkdir3(guidelinesDir, { recursive: true });
-    for (const template of mandatoryTemplates) {
-      try {
-        const templatePath = join4(templatesDir, template.filename);
-        const outputPath = join4(guidelinesDir, template.filename);
-        await renderTemplateFile(templatePath, outputPath, {
-          ...context,
-          reservedScopeNames: (config.reservedScopeNames || []).join(", ")
-        });
-        mandatoryGenerated++;
-      } catch (error) {
-        console.log(
-          chalk.yellow(`  \u26A0\uFE0F  Could not generate ${template.filename}`)
-        );
-      }
-    }
-    console.log(
-      chalk.green(`\u2713 Generated ${mandatoryGenerated} mandatory guidelines`)
-    );
-    let shouldGenerateOptional = isNonInteractive;
-    if (!isNonInteractive) {
-      const response = await p.confirm({
-        message: `Generate ${optionalTemplates.length} optional guidelines (deployment, library inventory, etc.)?`,
-        initialValue: true
-      });
-      shouldGenerateOptional = !p.isCancel(response) && response;
-    }
-    if (shouldGenerateOptional) {
-      for (const template of optionalTemplates) {
-        try {
-          const templatePath = join4(templatesDir, template.filename);
-          const outputPath = join4(guidelinesDir, template.filename);
-          await renderTemplateFile(templatePath, outputPath, context);
-          optionalGenerated++;
-        } catch {
-        }
-      }
+  if (shouldGenerateGuidelines) {
+    const spinner5 = p.spinner();
+    spinner5.start("Generating guidelines...");
+    try {
+      const templatesDir = join(__dirname, "../../templates");
+      await validateTemplateDirectory(templatesDir);
+      const context = await buildTemplateContext(config, cwd);
+      const guidelinesDir = join(cwd, "guidelines");
+      await mkdir(guidelinesDir, { recursive: true });
+      const renderedFiles = await renderTemplateDirectory(
+        templatesDir,
+        guidelinesDir,
+        context
+      );
+      spinner5.stop(`\u2713 Generated ${renderedFiles.length} guideline documents`);
+    } catch (error) {
+      spinner5.stop("\u26A0\uFE0F  Could not generate guidelines");
+      console.log(
+        chalk.yellow(
+          `
+Reason: ${error instanceof Error ? error.message : String(error)}`
+        )
+      );
       console.log(
-        chalk.green(`\u2713 Generated ${optionalGenerated} optional guidelines`)
+        chalk.dim("You can manually copy guidelines later if needed.")
       );
     }
-  } catch (error) {
-    console.log(
-      chalk.yellow(
-        `
-\u26A0\uFE0F  Could not generate guidelines: ${error instanceof Error ? error.message : String(error)}`
-      )
-    );
-    console.log(chalk.dim("You can manually copy guidelines later if needed."));
   }
-  if (hasGitRepo(cwd)) {
-    let shouldInstallHooks = isNonInteractive;
-    if (!isNonInteractive) {
-      const response = await p.confirm({
-        message: "Install git hooks for pre-commit validation?",
-        initialValue: true
-      });
-      shouldInstallHooks = !p.isCancel(response) && response;
-    }
-    if (shouldInstallHooks) {
-      const hookSpinner = p.spinner();
-      hookSpinner.start("Installing git hooks...");
-      const hookResults = await installHooks(
-        config.hooks || {
-          enabled: true,
-          preCommit: ["validate-branch", "check-guidelines"],
-          commitMsg: ["validate-commit"]
-        },
-        cwd
+  const shouldAutoSetup = options.yes ? true : await p.confirm({
+    message: "Set up linting, formatting, testing, and CI automatically?",
+    initialValue: true
+  });
+  if (p.isCancel(shouldAutoSetup)) {
+    p.cancel("Initialization cancelled");
+    process.exit(0);
+  }
+  if (shouldAutoSetup) {
+    const setupSpinner = p.spinner();
+    setupSpinner.start("Running auto-setup...");
+    try {
+      const report = await generateAuditReport(cwd);
+      setupSpinner.stop(
+        `\u2713 Found ${report.totalChanges} configurations to apply`
       );
-      const allSuccess = hookResults.every((r) => r.success);
-      if (allSuccess) {
-        hookSpinner.stop("\u2713 Installed git hooks");
-      } else {
-        hookSpinner.stop("\u26A0\uFE0F  Some hooks could not be installed");
+      if (report.totalChanges > 0 || report.allDevDependencies.length > 0) {
+        const autoSetupSpinner = p.spinner();
+        await runAllSetups(cwd, (step, status) => {
+          if (status === "start") {
+            autoSetupSpinner.start(step);
+          } else if (status === "done") {
+            autoSetupSpinner.stop(`\u2713 ${step}`);
+          } else {
+            autoSetupSpinner.stop(`\u2717 ${step}`);
+          }
+        });
       }
-    }
-  }
-  if (repoInfo.isGitHub) {
-    const existingCI = hasCIWorkflow(cwd);
-    if (!existingCI) {
+    } catch (error) {
+      setupSpinner.stop("\u26A0\uFE0F  Auto-setup encountered issues");
       console.log(
-        chalk.dim(
-          "\n\u{1F527} Setting up GitHub Actions CI (mandatory for GitHub repos)..."
+        chalk.yellow(
+          `
+Reason: ${error instanceof Error ? error.message : String(error)}`
         )
       );
-      const ciResult = await createCIWorkflow({
-        projectPath: cwd,
-        packageManager: projectInfo.packageManager,
-        isMonorepo: projectInfo.isMonorepo,
-        ciConfig: config.ci || {
-          enabled: true,
-          provider: "github",
-          checks: ["lint", "typecheck", "format", "build", "test"]
-        },
-        defaultBranch: repoInfo.defaultBranch || "main"
-      });
-      if (ciResult.success) {
-        console.log(chalk.green("\u2713 Created GitHub Actions CI workflow"));
-        console.log(chalk.dim(`  File: .github/workflows/ci.yml`));
-      } else {
-        console.log(
-          chalk.yellow(`\u26A0\uFE0F  Could not create CI workflow: ${ciResult.error}`)
-        );
-      }
-    } else {
-      console.log(chalk.dim("\n\u2713 GitHub Actions CI workflow already exists"));
-    }
-  } else if (repoInfo.isGitRepo) {
-    let shouldSetupCI = false;
-    if (!isNonInteractive) {
-      const response = await p.confirm({
-        message: "No GitHub remote detected. Create CI workflow anyway?",
-        initialValue: false
-      });
-      shouldSetupCI = !p.isCancel(response) && response;
-    }
-    if (shouldSetupCI) {
-      const ciResult = await createCIWorkflow({
-        projectPath: cwd,
-        packageManager: projectInfo.packageManager,
-        isMonorepo: projectInfo.isMonorepo,
-        defaultBranch: repoInfo.defaultBranch || "main"
-      });
-      if (ciResult.success) {
-        console.log(chalk.green("\u2713 Created CI workflow"));
-      }
+      console.log(
+        chalk.dim("You can run 'workflow auto-setup' later to retry.")
+      );
     }
   }
   p.outro(chalk.green("\u2713 Workflow Agent initialized successfully!"));
@@ -1186,24 +425,25 @@ async function initCommand(options) {
   console.log(
     chalk.dim("  1. Review your configuration in workflow.config.json")
   );
-  console.log(
-    chalk.dim("  2. Review generated guidelines in guidelines/ directory")
-  );
-  console.log(chalk.dim("  3. Run: workflow validate branch"));
-  console.log(chalk.dim("  4. Run: workflow doctor (for health check)\n"));
-  if (repoInfo.isGitHub) {
+  if (shouldGenerateGuidelines) {
     console.log(
-      chalk.cyan("\u{1F4A1} Recommended: Enable branch protection on GitHub")
+      chalk.dim("  2. Review generated guidelines in guidelines/ directory")
     );
+    console.log(chalk.dim("  3. Run: workflow verify (to check everything)"));
     console.log(
-      chalk.dim("   Settings \u2192 Branches \u2192 Add rule \u2192 Require status checks\n")
+      chalk.dim("  4. Run: workflow doctor (for optimization suggestions)\n")
+    );
+  } else {
+    console.log(chalk.dim("  2. Run: workflow verify (to check everything)"));
+    console.log(
+      chalk.dim("  3. Run: workflow doctor (for optimization suggestions)\n")
     );
   }
 }
 
 // src/cli/commands/validate.ts
 import chalk2 from "chalk";
-import { execa as execa2 } from "execa";
+import { execa } from "execa";
 async function validateCommand(type, value, _options = {}) {
   const config = await loadConfig();
   if (!config) {
@@ -1218,7 +458,7 @@ async function validateCommand(type, value, _options = {}) {
     switch (type) {
       case "branch": {
         if (!targetValue) {
-          const { stdout } = await execa2("git", ["branch", "--show-current"]);
+          const { stdout } = await execa("git", ["branch", "--show-current"]);
           targetValue = stdout.trim();
         }
         result = await validateBranchName(targetValue, config);
@@ -1226,7 +466,7 @@ async function validateCommand(type, value, _options = {}) {
       }
       case "commit": {
         if (!targetValue) {
-          const { stdout } = await execa2("git", ["log", "-1", "--pretty=%s"]);
+          const { stdout } = await execa("git", ["log", "-1", "--pretty=%s"]);
           targetValue = stdout.trim();
         }
         result = await validateCommitMessage(targetValue, config);
@@ -1275,324 +515,10 @@ async function validateCommand(type, value, _options = {}) {
 }
 
 // src/cli/commands/config.ts
-import { Command } from "commander";
-import { join as join5 } from "path";
-import { existsSync as existsSync5, writeFileSync } from "fs";
-import prompts from "prompts";
 import chalk3 from "chalk";
-function createConfigCommand() {
-  const command = new Command("config").description("Manage workflow configuration").option("-f, --force", "Skip validation checks").option("--cwd <path>", "Working directory", process.cwd());
-  command.command("validate").description("Validate workflow configuration").action(async () => {
-    const opts = command.opts();
-    await validateConfigAction(opts);
-  });
-  command.command("add").description("Add configuration items").argument("<type>", "Type to add (scope)").action(async (type) => {
-    const opts = command.opts();
-    if (type === "scope") {
-      await addScopeAction(opts);
-    } else {
-      console.error(
-        chalk3.red(
-          `Unknown type: ${type}. Currently only "scope" is supported.`
-        )
-      );
-      process.exit(1);
-    }
-  });
-  command.command("remove").description("Remove configuration items").argument("<type>", "Type to remove (scope)").argument("<name>", "Name of the item to remove").action(async (type, name) => {
-    const opts = command.opts();
-    if (type === "scope") {
-      await removeScopeAction(name, opts);
-    } else {
-      console.error(
-        chalk3.red(
-          `Unknown type: ${type}. Currently only "scope" is supported.`
-        )
-      );
-      process.exit(1);
-    }
-  });
-  command.command("list").description("List configuration items").argument("[type]", "Type to list (scopes, reserved, all)", "all").action(async (type) => {
-    const opts = command.opts();
-    await listConfigAction(type, opts);
-  });
-  command.command("get").description("Get a configuration value").argument("<path>", "Configuration path (e.g., scopes[0].name)").action(async (path2) => {
-    const opts = command.opts();
-    await getConfigValue(path2, opts);
-  });
-  command.command("set").description("Set a configuration value").argument("<path>", "Configuration path (e.g., reservedScopeNames)").argument("<value>", "Value to set").action(async (path2, value) => {
-    const opts = command.opts();
-    await setConfigValue(path2, value, opts);
-  });
-  return command;
-}
-async function validateConfigAction(opts) {
-  console.log(chalk3.blue("\u{1F50D} Validating workflow configuration..."));
-  const result = await validateConfig(opts.cwd || process.cwd());
-  if (result.valid) {
-    console.log(chalk3.green("\u2713 Configuration is valid"));
-    process.exit(0);
-  } else {
-    console.log(chalk3.red("\u2717 Configuration has errors:\n"));
-    result.errors.forEach((err) => {
-      console.log(chalk3.red(`  \u2022 ${err}`));
-    });
-    if (result.warnings.length > 0) {
-      console.log(chalk3.yellow("\n\u26A0 Warnings:\n"));
-      result.warnings.forEach((warn) => {
-        console.log(chalk3.yellow(`  \u2022 ${warn}`));
-      });
-    }
-    console.log(chalk3.gray("\n\u{1F4A1} Fix these issues in workflow.config.json"));
-    process.exit(1);
-  }
-}
-async function addScopeAction(opts) {
-  const cwd = opts.cwd || process.cwd();
-  const configPath = join5(cwd, "workflow.config.json");
-  if (!existsSync5(configPath)) {
-    console.error(
-      chalk3.red("No workflow.config.json found. Run: workflow init")
-    );
-    process.exit(1);
-  }
-  const config = await loadConfig(cwd);
-  if (!config) {
-    console.error(chalk3.red("Failed to load configuration"));
-    process.exit(1);
-  }
-  const reservedNames = config.reservedScopeNames || DEFAULT_RESERVED_SCOPE_NAMES;
-  const existingNames = config.scopes.map((s) => s.name);
-  const response = await prompts([
-    {
-      type: "text",
-      name: "name",
-      message: "Scope name:",
-      validate: (value) => {
-        if (!value) return "Name is required";
-        if (existingNames.includes(value))
-          return `Scope "${value}" already exists`;
-        const validation = validateScopeName(value, reservedNames);
-        if (!validation.valid) {
-          return validation.error + (validation.suggestion ? ` Try: ${validation.suggestion}` : "");
-        }
-        return true;
-      }
-    },
-    {
-      type: "text",
-      name: "description",
-      message: "Description:",
-      validate: (value) => value ? true : "Description is required"
-    },
-    {
-      type: "multiselect",
-      name: "allowedTypes",
-      message: "Allowed commit types (space to select, enter to continue):",
-      choices: [
-        { title: "feat", value: "feat", selected: true },
-        { title: "fix", value: "fix", selected: true },
-        { title: "docs", value: "docs", selected: false },
-        { title: "style", value: "style", selected: false },
-        { title: "refactor", value: "refactor", selected: false },
-        { title: "perf", value: "perf", selected: false },
-        { title: "test", value: "test", selected: false },
-        { title: "build", value: "build", selected: false },
-        { title: "ci", value: "ci", selected: false },
-        { title: "chore", value: "chore", selected: false },
-        { title: "revert", value: "revert", selected: false }
-      ],
-      min: 1
-    },
-    {
-      type: "text",
-      name: "mandatoryGuidelines",
-      message: "Mandatory guidelines (comma-separated, or press enter to skip):",
-      initial: ""
-    }
-  ]);
-  if (!response.name) {
-    console.log(chalk3.yellow("Cancelled"));
-    process.exit(0);
-  }
-  if (!opts.force) {
-    const validation = validateScopeName(response.name, reservedNames);
-    if (!validation.valid) {
-      console.error(chalk3.red(`
-\u2717 ${validation.error}`));
-      if (validation.suggestion) {
-        console.log(chalk3.yellow(`\u{1F4A1} Suggestion: ${validation.suggestion}`));
-      }
-      console.log(chalk3.gray("\nUse --force to override this check"));
-      process.exit(1);
-    }
-  }
-  const newScope = {
-    name: response.name,
-    description: response.description,
-    allowedTypes: response.allowedTypes
-  };
-  if (response.mandatoryGuidelines) {
-    const guidelines = response.mandatoryGuidelines.split(",").map((g) => g.trim()).filter((g) => g.length > 0);
-    if (guidelines.length > 0) {
-      newScope.mandatoryGuidelines = guidelines;
-    }
-  }
-  config.scopes.push(newScope);
-  const configContent = JSON.stringify(config, null, 2) + "\n";
-  writeFileSync(configPath, configContent, "utf-8");
-  console.log(chalk3.green(`
-\u2713 Added scope: ${response.name}`));
-  console.log(chalk3.gray(`  Description: ${response.description}`));
-  console.log(chalk3.gray(`  Types: ${response.allowedTypes.join(", ")}`));
-  if (newScope.mandatoryGuidelines) {
-    console.log(
-      chalk3.gray(`  Guidelines: ${newScope.mandatoryGuidelines.join(", ")}`)
-    );
-  }
-}
-async function removeScopeAction(name, opts) {
-  const cwd = opts.cwd || process.cwd();
-  const configPath = join5(cwd, "workflow.config.json");
-  if (!existsSync5(configPath)) {
-    console.error(chalk3.red("No workflow.config.json found"));
-    process.exit(1);
-  }
-  const config = await loadConfig(cwd);
-  if (!config) {
-    console.error(chalk3.red("Failed to load configuration"));
-    process.exit(1);
-  }
-  const scopeIndex = config.scopes.findIndex((s) => s.name === name);
-  if (scopeIndex === -1) {
-    console.error(chalk3.red(`Scope "${name}" not found`));
-    process.exit(1);
-  }
-  const response = await prompts({
-    type: "confirm",
-    name: "confirmed",
-    message: `Remove scope "${name}"?`,
-    initial: false
-  });
-  if (!response.confirmed) {
-    console.log(chalk3.yellow("Cancelled"));
-    process.exit(0);
-  }
-  config.scopes.splice(scopeIndex, 1);
-  const configContent = JSON.stringify(config, null, 2) + "\n";
-  writeFileSync(configPath, configContent, "utf-8");
-  console.log(chalk3.green(`\u2713 Removed scope: ${name}`));
-}
-async function listConfigAction(type, opts) {
-  const cwd = opts.cwd || process.cwd();
-  const config = await loadConfig(cwd);
-  if (!config) {
-    console.error(chalk3.red("No configuration found"));
-    process.exit(1);
-  }
-  if (type === "scopes" || type === "all") {
-    console.log(chalk3.blue("\n\u{1F4CB} Scopes:"));
-    if (config.scopes.length === 0) {
-      console.log(chalk3.gray("  (none)"));
-    } else {
-      config.scopes.forEach((scope, index) => {
-        console.log(chalk3.green(`
-  ${index + 1}. ${scope.name}`));
-        console.log(chalk3.gray(`     ${scope.description}`));
-        console.log(
-          chalk3.gray(`     Types: ${scope.allowedTypes?.join(", ") || "all"}`)
-        );
-        if (scope.mandatoryGuidelines && scope.mandatoryGuidelines.length > 0) {
-          console.log(
-            chalk3.gray(
-              `     Guidelines: ${scope.mandatoryGuidelines.join(", ")}`
-            )
-          );
-        }
-      });
-    }
-  }
-  if (type === "reserved" || type === "all") {
-    const reserved = config.reservedScopeNames || DEFAULT_RESERVED_SCOPE_NAMES;
-    console.log(chalk3.blue("\n\u{1F6AB} Reserved Scope Names:"));
-    console.log(chalk3.gray(`  ${reserved.join(", ")}`));
-    console.log(
-      chalk3.gray(
-        '\n  \u{1F4A1} Configure in workflow.config.json: "reservedScopeNames"'
-      )
-    );
-  }
-}
-async function getConfigValue(path2, opts) {
-  const cwd = opts.cwd || process.cwd();
-  const config = await loadConfig(cwd);
-  if (!config) {
-    console.error(chalk3.red("No configuration found"));
-    process.exit(1);
-  }
-  const value = resolvePath(config, path2);
-  if (value === void 0) {
-    console.error(chalk3.red(`Path not found: ${path2}`));
-    process.exit(1);
-  }
-  console.log(JSON.stringify(value, null, 2));
-}
-async function setConfigValue(path2, value, opts) {
-  const cwd = opts.cwd || process.cwd();
-  const configPath = join5(cwd, "workflow.config.json");
-  if (!existsSync5(configPath)) {
-    console.error(chalk3.red("No workflow.config.json found"));
-    process.exit(1);
-  }
-  const config = await loadConfig(cwd);
-  if (!config) {
-    console.error(chalk3.red("Failed to load configuration"));
-    process.exit(1);
-  }
-  let parsedValue;
-  try {
-    parsedValue = JSON.parse(value);
-  } catch {
-    parsedValue = value;
-  }
-  setPath(config, path2, parsedValue);
-  if (!opts.force) {
-    const validation = await validateConfig(cwd);
-    if (!validation.valid) {
-      console.error(chalk3.red("\u2717 Invalid configuration after change:"));
-      validation.errors.forEach(
-        (err) => console.error(chalk3.red(`  \u2022 ${err}`))
-      );
-      console.log(chalk3.gray("\nUse --force to skip validation"));
-      process.exit(1);
-    }
-  }
-  const configContent = JSON.stringify(config, null, 2) + "\n";
-  writeFileSync(configPath, configContent, "utf-8");
-  console.log(chalk3.green(`\u2713 Set ${path2} = ${JSON.stringify(parsedValue)}`));
-}
-function resolvePath(obj, path2) {
-  const parts = path2.split(/[\.\[\]]+/).filter(Boolean);
-  let current = obj;
-  for (const part of parts) {
-    if (current === void 0 || current === null) {
-      return void 0;
-    }
-    current = current[part];
-  }
-  return current;
-}
-function setPath(obj, path2, value) {
-  const parts = path2.split(/[\.\[\]]+/).filter(Boolean);
-  let current = obj;
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i];
-    if (current[part] === void 0) {
-      current[part] = {};
-    }
-    current = current[part];
-  }
-  current[parts[parts.length - 1]] = value;
+async function configCommand(action, key, value) {
+  console.log(chalk3.yellow("Config command not yet implemented"));
+  console.log({ action, key, value });
 }
 
 // src/cli/commands/suggest.ts
@@ -1638,349 +564,32 @@ async function suggestCommand(feedback, options = {}) {
   );
 }
 
-// src/cli/commands/doctor.ts
-import chalk5 from "chalk";
-
-// src/validators/guidelines.ts
-import { existsSync as existsSync6 } from "fs";
-import { readFile as readFile3, readdir } from "fs/promises";
-import { join as join6 } from "path";
-function getEffectiveMandatoryTemplates(guidelinesConfig) {
-  const coreMandatory = getMandatoryTemplateFilenames();
-  if (!guidelinesConfig) {
-    return coreMandatory;
-  }
-  let mandatory = [...coreMandatory];
-  if (guidelinesConfig.additionalMandatory) {
-    for (const template of guidelinesConfig.additionalMandatory) {
-      if (!mandatory.includes(template) && templateMetadata[template]) {
-        mandatory.push(template);
-      }
-    }
-  }
-  if (guidelinesConfig.optionalOverrides) {
-    mandatory = mandatory.filter(
-      (t) => !guidelinesConfig.optionalOverrides.includes(t)
-    );
-  }
-  return mandatory;
-}
-async function validateGuidelinesExist(projectPath = process.cwd(), config) {
-  const guidelinesDir = join6(projectPath, "guidelines");
-  const result = {
-    valid: true,
-    missingMandatory: [],
-    presentMandatory: [],
-    presentOptional: [],
-    errors: []
-  };
-  if (!existsSync6(guidelinesDir)) {
-    const mandatory2 = getEffectiveMandatoryTemplates(config?.guidelines);
-    result.valid = false;
-    result.missingMandatory = mandatory2;
-    result.errors.push(
-      "Guidelines directory does not exist. Run: workflow init"
-    );
-    return result;
-  }
-  let existingFiles = [];
-  try {
-    existingFiles = await readdir(guidelinesDir);
-  } catch (error) {
-    result.valid = false;
-    result.errors.push(
-      `Cannot read guidelines directory: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return result;
-  }
-  const mandatory = getEffectiveMandatoryTemplates(config?.guidelines);
-  for (const template of mandatory) {
-    if (existingFiles.includes(template)) {
-      result.presentMandatory.push(template);
-    } else {
-      result.missingMandatory.push(template);
-    }
-  }
-  const allTemplateNames = Object.keys(templateMetadata);
-  for (const file of existingFiles) {
-    if (allTemplateNames.includes(file) && !mandatory.includes(file)) {
-      result.presentOptional.push(file);
-    }
-  }
-  if (result.missingMandatory.length > 0) {
-    result.valid = false;
-    result.errors.push(
-      `Missing mandatory guidelines: ${result.missingMandatory.join(", ")}. Run: workflow init`
-    );
-  }
-  return result;
-}
-async function validateGitHubActionsSetup(projectPath = process.cwd()) {
-  const workflowsDir = join6(projectPath, ".github", "workflows");
-  const result = {
-    valid: true,
-    hasWorkflowFile: false,
-    hasLintCheck: false,
-    hasTypecheckCheck: false,
-    hasFormatCheck: false,
-    hasBuildCheck: false,
-    hasTestCheck: false,
-    errors: [],
-    warnings: []
-  };
-  if (!existsSync6(workflowsDir)) {
-    result.valid = false;
-    result.errors.push(
-      "GitHub Actions workflows directory does not exist. Run: workflow github:setup"
-    );
-    return result;
-  }
-  let workflowFiles = [];
-  try {
-    workflowFiles = await readdir(workflowsDir);
-  } catch (error) {
-    result.valid = false;
-    result.errors.push(
-      `Cannot read workflows directory: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return result;
-  }
-  const ciWorkflowNames = [
-    "ci.yml",
-    "ci.yaml",
-    "main.yml",
-    "main.yaml",
-    "build.yml",
-    "build.yaml",
-    "test.yml",
-    "test.yaml"
-  ];
-  const ciWorkflows = workflowFiles.filter(
-    (f) => ciWorkflowNames.includes(f.toLowerCase())
-  );
-  if (ciWorkflows.length === 0) {
-    result.valid = false;
-    result.errors.push("No CI workflow file found. Run: workflow github:setup");
-    return result;
-  }
-  result.hasWorkflowFile = true;
-  const workflowPath = join6(workflowsDir, ciWorkflows[0]);
-  let workflowContent = "";
-  try {
-    workflowContent = await readFile3(workflowPath, "utf-8");
-  } catch (error) {
-    result.warnings.push(
-      `Cannot read workflow file: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return result;
-  }
-  const contentLower = workflowContent.toLowerCase();
-  if (contentLower.includes("lint") || contentLower.includes("eslint")) {
-    result.hasLintCheck = true;
-  } else {
-    result.warnings.push("CI workflow may be missing lint check");
-  }
-  if (contentLower.includes("typecheck") || contentLower.includes("type-check") || contentLower.includes("tsc")) {
-    result.hasTypecheckCheck = true;
-  } else {
-    result.warnings.push("CI workflow may be missing typecheck");
-  }
-  if (contentLower.includes("format") || contentLower.includes("prettier")) {
-    result.hasFormatCheck = true;
-  } else {
-    result.warnings.push("CI workflow may be missing format check");
-  }
-  if (contentLower.includes("build")) {
-    result.hasBuildCheck = true;
-  } else {
-    result.warnings.push("CI workflow may be missing build step");
-  }
-  if (contentLower.includes("test") && !contentLower.includes("typecheck")) {
-    result.hasTestCheck = true;
-  } else {
-    result.warnings.push("CI workflow may be missing test step");
-  }
-  const mandatoryChecks = [
-    result.hasLintCheck,
-    result.hasTypecheckCheck,
-    result.hasFormatCheck
-  ];
-  if (!mandatoryChecks.every(Boolean)) {
-    result.valid = false;
-    result.errors.push(
-      "CI workflow is missing mandatory checks (lint, typecheck, format)"
-    );
-  }
-  return result;
-}
-
-// src/cli/commands/doctor.ts
-async function doctorCommand(options = {}) {
-  const cwd = process.cwd();
-  if (options.checkGuidelinesOnly) {
-    const result = await validateGuidelinesExist(cwd);
-    if (!result.valid) {
-      console.error(chalk5.red("\u2717 Missing mandatory guidelines"));
-      for (const missing of result.missingMandatory) {
-        console.error(chalk5.red(`  \u2022 ${missing}`));
-      }
-      process.exit(1);
-    }
-    process.exit(0);
-  }
-  console.log(chalk5.bold.cyan("\n\u{1F3E5} Workflow Agent Health Check\n"));
-  const config = await loadConfig();
-  let hasErrors = false;
-  let hasWarnings = false;
-  console.log(chalk5.bold("\u{1F4CB} Configuration"));
-  if (!config) {
-    console.error(chalk5.red("  \u2717 No workflow configuration found"));
-    console.log(chalk5.yellow("    Run: workflow init"));
-    process.exit(1);
-  }
-  console.log(chalk5.green("  \u2713 Configuration loaded successfully"));
-  console.log(chalk5.dim(`    Project: ${config.projectName}`));
-  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.bold("\n\u{1F4DA} Guidelines"));
-  const guidelinesResult = await validateGuidelinesExist(cwd, config);
-  if (guidelinesResult.valid) {
-    console.log(
-      chalk5.green(
-        `  \u2713 All ${guidelinesResult.presentMandatory.length} mandatory guidelines present`
-      )
-    );
-    if (guidelinesResult.presentOptional.length > 0) {
-      console.log(
-        chalk5.dim(
-          `    + ${guidelinesResult.presentOptional.length} optional guidelines`
-        )
-      );
-    }
-  } else {
-    hasErrors = true;
-    console.log(
-      chalk5.red(
-        `  \u2717 Missing ${guidelinesResult.missingMandatory.length} mandatory guidelines:`
-      )
-    );
-    for (const missing of guidelinesResult.missingMandatory) {
-      console.log(chalk5.red(`    \u2022 ${missing}`));
-    }
-    console.log(chalk5.yellow("    Run: workflow init"));
-  }
-  console.log(chalk5.bold("\n\u{1F517} Git Hooks"));
-  if (!hasGitRepo(cwd)) {
-    console.log(chalk5.yellow("  \u26A0 No git repository found"));
-    hasWarnings = true;
-  } else {
-    const hookStatuses = await getAllHooksStatus(cwd);
-    const installedHooks = hookStatuses.filter((h) => h.installed);
-    if (installedHooks.length === hookStatuses.length) {
-      console.log(
-        chalk5.green(`  \u2713 All ${installedHooks.length} hooks installed`)
-      );
-      for (const hook of hookStatuses) {
-        const extra = hook.wrappedOriginal ? " (wrapping original)" : "";
-        console.log(chalk5.dim(`    \u2022 ${hook.hookType}${extra}`));
-      }
-    } else if (installedHooks.length > 0) {
-      hasWarnings = true;
-      console.log(
-        chalk5.yellow(
-          `  \u26A0 ${installedHooks.length}/${hookStatuses.length} hooks installed`
-        )
-      );
-      for (const hook of hookStatuses) {
-        if (hook.installed) {
-          console.log(chalk5.green(`    \u2713 ${hook.hookType}`));
-        } else {
-          console.log(chalk5.yellow(`    \u2717 ${hook.hookType}`));
-        }
-      }
-      console.log(chalk5.yellow("    Run: workflow hooks install"));
-    } else {
-      hasWarnings = true;
-      console.log(chalk5.yellow("  \u26A0 No hooks installed"));
-      console.log(chalk5.yellow("    Run: workflow hooks install"));
-    }
-  }
-  console.log(chalk5.bold("\n\u{1F680} CI/CD Pipeline"));
-  const repoInfo = await getRepoInfo(cwd);
-  if (!repoInfo.isGitRepo) {
-    console.log(chalk5.dim("  \u25CB No git repository (CI check skipped)"));
-  } else if (!repoInfo.isGitHub) {
-    console.log(chalk5.dim("  \u25CB Not a GitHub repository (CI check skipped)"));
-    console.log(chalk5.dim(`    Remote: ${repoInfo.remoteUrl || "none"}`));
-  } else {
-    console.log(
-      chalk5.dim(
-        `    Repository: ${repoInfo.github?.owner}/${repoInfo.github?.repo}`
-      )
-    );
-    const ciResult = await validateGitHubActionsSetup(cwd);
-    if (ciResult.valid) {
-      console.log(chalk5.green("  \u2713 GitHub Actions CI configured correctly"));
-      const checks = [
-        ciResult.hasLintCheck && "lint",
-        ciResult.hasTypecheckCheck && "typecheck",
-        ciResult.hasFormatCheck && "format",
-        ciResult.hasBuildCheck && "build",
-        ciResult.hasTestCheck && "test"
-      ].filter(Boolean);
-      console.log(chalk5.dim(`    Checks: ${checks.join(", ")}`));
-    } else if (!ciResult.hasWorkflowFile) {
-      hasErrors = true;
-      console.log(chalk5.red("  \u2717 No CI workflow found"));
-      console.log(chalk5.yellow("    Run: workflow github:setup"));
-    } else {
-      hasWarnings = true;
-      console.log(chalk5.yellow("  \u26A0 CI workflow may be incomplete"));
-      for (const warning of ciResult.warnings) {
-        console.log(chalk5.yellow(`    \u2022 ${warning}`));
-      }
-      console.log(chalk5.yellow("    Run: workflow github:setup to regenerate"));
-    }
-  }
-  console.log(chalk5.bold("\n\u{1F4A1} Suggestions"));
-  if (repoInfo.isGitHub && hasCIWorkflow(cwd)) {
-    console.log(chalk5.cyan("  \u2192 Enable branch protection on GitHub"));
-    console.log(chalk5.dim("    Settings \u2192 Branches \u2192 Add rule"));
-    console.log(
-      chalk5.dim("    \u2611 Require status checks to pass before merging")
-    );
-    console.log(
-      chalk5.dim("    \u2611 Require branches to be up to date before merging")
-    );
-  }
-  if (config.enforcement !== "strict") {
-    console.log(chalk5.cyan(`  \u2192 Consider switching to 'strict' enforcement`));
-    console.log(chalk5.dim(`    Current: ${config.enforcement}`));
-  }
-  if (config.scopes.length < 5) {
-    console.log(
-      chalk5.cyan("  \u2192 Consider adding more scopes for better organization")
-    );
-    console.log(chalk5.dim("    Run: workflow config add scope <name>"));
-  }
-  console.log(chalk5.bold("\n\u{1F4CA} Summary"));
-  if (hasErrors) {
-    console.log(chalk5.red("  \u2717 Health check failed - issues found"));
+// src/cli/commands/doctor.ts
+import chalk5 from "chalk";
+async function doctorCommand() {
+  console.log(chalk5.bold.cyan("\n\u{1F3E5} Workflow Agent Health Check\n"));
+  const config = await loadConfig();
+  if (!config) {
+    console.error(chalk5.red("\u2717 No workflow configuration found"));
+    console.log(chalk5.yellow("  Run: workflow init"));
     process.exit(1);
-  } else if (hasWarnings) {
-    console.log(chalk5.yellow("  \u26A0 Health check passed with warnings"));
-  } else {
-    console.log(chalk5.green("  \u2713 All checks passed"));
   }
-  console.log("");
+  console.log(chalk5.green("\u2713 Configuration loaded successfully"));
+  console.log(chalk5.dim(`  Project: ${config.projectName}`));
+  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"));
 }
 
 // src/cli/commands/setup.ts
 import * as p3 from "@clack/prompts";
 import chalk6 from "chalk";
-import { readFileSync, writeFileSync as writeFileSync2, existsSync as existsSync7 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync, writeFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
 var WORKFLOW_SCRIPTS = {
   "workflow:init": "workflow-agent init",
   "workflow:validate": "workflow-agent validate",
@@ -1990,8 +599,8 @@ var WORKFLOW_SCRIPTS = {
 async function setupCommand() {
   p3.intro(chalk6.bgBlue(" workflow-agent setup "));
   const cwd = process.cwd();
-  const packageJsonPath = join7(cwd, "package.json");
-  if (!existsSync7(packageJsonPath)) {
+  const packageJsonPath = join2(cwd, "package.json");
+  if (!existsSync2(packageJsonPath)) {
     p3.cancel("No package.json found in current directory");
     process.exit(1);
   }
@@ -2034,7 +643,7 @@ async function setupCommand() {
   for (const [scriptName, scriptCommand] of Object.entries(scriptsToAdd)) {
     packageJson.scripts[scriptName] = scriptCommand;
   }
-  writeFileSync2(
+  writeFileSync(
     packageJsonPath,
     JSON.stringify(packageJson, null, 2) + "\n",
     "utf-8"
@@ -2052,15 +661,15 @@ async function setupCommand() {
 // src/cli/commands/scope-create.ts
 import * as p4 from "@clack/prompts";
 import chalk7 from "chalk";
-import { existsSync as existsSync8 } from "fs";
-import { writeFile as writeFile4, mkdir as mkdir4, readFile as readFile4 } from "fs/promises";
-import { join as join8 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { writeFile as writeFile2, mkdir as mkdir2, readFile } from "fs/promises";
+import { join as join3 } 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 = existsSync8(join8(cwd, "pnpm-workspace.yaml"));
-  if (isMonorepo2) {
+  const isMonorepo = existsSync3(join3(cwd, "pnpm-workspace.yaml"));
+  if (isMonorepo) {
     console.log(chalk7.dim("\u2713 Detected monorepo workspace\n"));
   }
   const packageNameInput = isNonInteractive ? options.name : await p4.text({
@@ -2204,8 +813,8 @@ async function scopeCreateCommand(options) {
   let outputDir;
   if (options.outputDir) {
     outputDir = options.outputDir;
-  } else if (isMonorepo2) {
-    outputDir = join8(cwd, "packages", `scopes-${packageName}`);
+  } else if (isMonorepo) {
+    outputDir = join3(cwd, "packages", `scopes-${packageName}`);
   } else {
     const customDir = await p4.text({
       message: "Output directory:",
@@ -2216,9 +825,9 @@ async function scopeCreateCommand(options) {
       p4.cancel("Operation cancelled");
       process.exit(0);
     }
-    outputDir = join8(cwd, customDir);
+    outputDir = join3(cwd, customDir);
   }
-  if (existsSync8(outputDir)) {
+  if (existsSync3(outputDir)) {
     const shouldOverwrite = await p4.confirm({
       message: `Directory ${outputDir} already exists. Overwrite?`,
       initialValue: false
@@ -2231,7 +840,7 @@ async function scopeCreateCommand(options) {
   const spinner5 = p4.spinner();
   spinner5.start("Creating package structure...");
   try {
-    await mkdir4(join8(outputDir, "src"), { recursive: true });
+    await mkdir2(join3(outputDir, "src"), { recursive: true });
     const packageJson = {
       name: `@workflow/scopes-${packageName}`,
       version: "1.0.0",
@@ -2271,8 +880,8 @@ async function scopeCreateCommand(options) {
         access: "public"
       }
     };
-    await writeFile4(
-      join8(outputDir, "package.json"),
+    await writeFile2(
+      join3(outputDir, "package.json"),
       JSON.stringify(packageJson, null, 2),
       "utf-8"
     );
@@ -2284,8 +893,8 @@ async function scopeCreateCommand(options) {
       },
       include: ["src/**/*"]
     };
-    await writeFile4(
-      join8(outputDir, "tsconfig.json"),
+    await writeFile2(
+      join3(outputDir, "tsconfig.json"),
       JSON.stringify(tsconfig, null, 2),
       "utf-8"
     );
@@ -2299,7 +908,7 @@ export default defineConfig({
   sourcemap: true,
 });
 `;
-    await writeFile4(join8(outputDir, "tsup.config.ts"), tsupConfig, "utf-8");
+    await writeFile2(join3(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)};
@@ -2313,7 +922,7 @@ export const preset = {
 
 export default preset;
 `;
-    await writeFile4(join8(outputDir, "src", "index.ts"), indexTs, "utf-8");
+    await writeFile2(join3(outputDir, "src", "index.ts"), indexTs, "utf-8");
     if (!options.noTest) {
       const testFile = `import { describe, it, expect } from 'vitest';
 import { scopes, preset } from './index.js';
@@ -2354,16 +963,16 @@ describe('${presetName} Scope Preset', () => {
   });
 });
 `;
-      await writeFile4(
-        join8(outputDir, "src", "index.test.ts"),
+      await writeFile2(
+        join3(outputDir, "src", "index.test.ts"),
         testFile,
         "utf-8"
       );
     }
     spinner5.stop("\u2713 Package structure created");
-    if (isMonorepo2) {
-      const workspaceFile = join8(cwd, "pnpm-workspace.yaml");
-      const workspaceContent = await readFile4(workspaceFile, "utf-8");
+    if (isMonorepo) {
+      const workspaceFile = join3(cwd, "pnpm-workspace.yaml");
+      const workspaceContent = await readFile(workspaceFile, "utf-8");
       const packagePath = `packages/scopes-${packageName}`;
       if (!workspaceContent.includes(packagePath) && !workspaceContent.includes("packages/*")) {
         console.log(
@@ -2421,9 +1030,9 @@ describe('${presetName} Scope Preset', () => {
 // src/cli/commands/scope-migrate.ts
 import * as p5 from "@clack/prompts";
 import chalk8 from "chalk";
-import { existsSync as existsSync9 } from "fs";
-import { writeFile as writeFile5, mkdir as mkdir5, readFile as readFile5 } from "fs/promises";
-import { join as join9 } from "path";
+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";
 async function scopeMigrateCommand(options) {
   console.log(chalk8.bold.cyan("\n\u{1F504} Migrate Scopes to Custom Package\n"));
   const cwd = process.cwd();
@@ -2467,8 +1076,8 @@ async function scopeMigrateCommand(options) {
     p5.cancel("Migration cancelled");
     process.exit(0);
   }
-  const isMonorepo2 = existsSync9(join9(cwd, "pnpm-workspace.yaml"));
-  if (isMonorepo2) {
+  const isMonorepo = existsSync4(join4(cwd, "pnpm-workspace.yaml"));
+  if (isMonorepo) {
     console.log(chalk8.dim("\n\u2713 Detected monorepo workspace\n"));
   }
   const packageNameInput = options.name || await p5.text({
@@ -2516,8 +1125,8 @@ async function scopeMigrateCommand(options) {
   let outputDir;
   if (options.outputDir) {
     outputDir = options.outputDir;
-  } else if (isMonorepo2) {
-    outputDir = join9(cwd, "packages", `scopes-${packageName}`);
+  } else if (isMonorepo) {
+    outputDir = join4(cwd, "packages", `scopes-${packageName}`);
   } else {
     const customDir = await p5.text({
       message: "Output directory:",
@@ -2528,9 +1137,9 @@ async function scopeMigrateCommand(options) {
       p5.cancel("Migration cancelled");
       process.exit(0);
     }
-    outputDir = join9(cwd, customDir);
+    outputDir = join4(cwd, customDir);
   }
-  if (existsSync9(outputDir)) {
+  if (existsSync4(outputDir)) {
     const shouldOverwrite = await p5.confirm({
       message: `Directory ${outputDir} already exists. Overwrite?`,
       initialValue: false
@@ -2543,7 +1152,7 @@ async function scopeMigrateCommand(options) {
   const spinner5 = p5.spinner();
   spinner5.start("Migrating scopes to package...");
   try {
-    await mkdir5(join9(outputDir, "src"), { recursive: true });
+    await mkdir3(join4(outputDir, "src"), { recursive: true });
     const packageJson = {
       name: `@workflow/scopes-${packageName}`,
       version: "1.0.0",
@@ -2583,8 +1192,8 @@ async function scopeMigrateCommand(options) {
         access: "public"
       }
     };
-    await writeFile5(
-      join9(outputDir, "package.json"),
+    await writeFile3(
+      join4(outputDir, "package.json"),
       JSON.stringify(packageJson, null, 2),
       "utf-8"
     );
@@ -2596,8 +1205,8 @@ async function scopeMigrateCommand(options) {
       },
       include: ["src/**/*"]
     };
-    await writeFile5(
-      join9(outputDir, "tsconfig.json"),
+    await writeFile3(
+      join4(outputDir, "tsconfig.json"),
       JSON.stringify(tsconfig, null, 2),
       "utf-8"
     );
@@ -2611,7 +1220,7 @@ export default defineConfig({
   sourcemap: true,
 });
 `;
-    await writeFile5(join9(outputDir, "tsup.config.ts"), tsupConfig, "utf-8");
+    await writeFile3(join4(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)};
@@ -2625,7 +1234,7 @@ export const preset = {
 
 export default preset;
 `;
-    await writeFile5(join9(outputDir, "src", "index.ts"), indexTs, "utf-8");
+    await writeFile3(join4(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';
@@ -2668,11 +1277,11 @@ describe('${presetName} Scope Preset (Migrated)', () => {
   });
 });
 `;
-    await writeFile5(join9(outputDir, "src", "index.test.ts"), testFile, "utf-8");
+    await writeFile3(join4(outputDir, "src", "index.test.ts"), testFile, "utf-8");
     spinner5.stop("\u2713 Package created from migrated scopes");
-    if (isMonorepo2) {
-      const workspaceFile = join9(cwd, "pnpm-workspace.yaml");
-      const workspaceContent = await readFile5(workspaceFile, "utf-8");
+    if (isMonorepo) {
+      const workspaceFile = join4(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(
@@ -2688,7 +1297,7 @@ describe('${presetName} Scope Preset (Migrated)', () => {
       initialValue: false
     });
     if (!p5.isCancel(keepConfig) && !keepConfig) {
-      const configPath = join9(cwd, "workflow.config.json");
+      const configPath = join4(cwd, "workflow.config.json");
       const updatedConfig = {
         ...config,
         scopes: [],
@@ -2696,7 +1305,7 @@ describe('${presetName} Scope Preset (Migrated)', () => {
         preset: `scopes-${packageName}`
         // Reference the new package
       };
-      await writeFile5(
+      await writeFile3(
         configPath,
         JSON.stringify(updatedConfig, null, 2),
         "utf-8"
@@ -2747,704 +1356,240 @@ describe('${presetName} Scope Preset (Migrated)', () => {
   }
 }
 
-// src/cli/commands/hooks.ts
+// src/cli/commands/verify.ts
 import chalk9 from "chalk";
-async function hooksCommand(action) {
+import { execa as execa2 } from "execa";
+async function verifyCommand(options) {
   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(chalk9.red(`Unknown action: ${action}`));
-      console.log(chalk9.dim("Available actions: install, uninstall, status"));
-      process.exit(1);
-  }
-}
-async function installHooksAction(cwd) {
-  console.log(chalk9.bold.cyan("\n\u{1F517} Installing Workflow Agent Git Hooks\n"));
-  if (!hasGitRepo(cwd)) {
-    console.error(chalk9.red("\u2717 No git repository found"));
-    console.log(chalk9.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(
-          chalk9.green(
-            `\u2713 Installed ${result.hookType} hook (wrapped existing hook)`
-          )
-        );
-      } else {
-        console.log(chalk9.green(`\u2713 Installed ${result.hookType} hook`));
-      }
-    } else {
-      console.error(
-        chalk9.red(`\u2717 Failed to install ${result.hookType}: ${result.error}`)
-      );
-      hasErrors = true;
-    }
-  }
-  if (!hasErrors) {
-    console.log(chalk9.green("\n\u2713 Git hooks installed successfully"));
-    console.log(chalk9.dim("\nHooks will run automatically on commit."));
-    console.log(chalk9.dim("They will be skipped in CI environments."));
-  } else {
-    process.exit(1);
-  }
-}
-async function uninstallHooksAction(cwd) {
-  console.log(chalk9.bold.cyan("\n\u{1F513} Uninstalling Workflow Agent Git Hooks\n"));
-  if (!hasGitRepo(cwd)) {
-    console.error(chalk9.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(
-          chalk9.green(`\u2713 Removed ${result.hookType} hook (restored original)`)
-        );
+  const maxRetries = options.maxRetries ? parseInt(options.maxRetries, 10) : 10;
+  const autoFix = options.fix ?? false;
+  const shouldCommit = options.commit ?? false;
+  const dryRun = options.dryRun ?? false;
+  console.log(chalk9.bold.cyan("\n\u{1F50D} Workflow Agent Quality Verification\n"));
+  if (dryRun) {
+    console.log(chalk9.yellow("\u{1F4CB} DRY-RUN MODE: No changes will be applied\n"));
+  }
+  console.log(chalk9.dim(`  Auto-fix: ${autoFix ? "enabled" : "disabled"}`));
+  console.log(chalk9.dim(`  Max retries: ${maxRetries}`));
+  console.log(chalk9.dim(`  Commit on success: ${shouldCommit ? "yes" : "no"}`));
+  console.log(chalk9.dim(`  Dry-run: ${dryRun ? "yes" : "no"}`));
+  const startTime = Date.now();
+  const result = await runAllChecks(cwd, {
+    maxRetries,
+    autoFix,
+    dryRun
+  });
+  const totalTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+  console.log(`
+${"\u2501".repeat(50)}`);
+  if (result.success) {
+    console.log(chalk9.bold.green("\n\u2705 ALL QUALITY CHECKS PASSED!\n"));
+    console.log(chalk9.dim(`  Total time: ${totalTime}s`));
+    console.log(chalk9.dim(`  Validation cycles: ${result.totalAttempts}`));
+    console.log(chalk9.dim(`  Fixes applied: ${result.fixesApplied}`));
+    if (shouldCommit) {
+      const hasChanges = await hasUncommittedChanges(cwd);
+      if (hasChanges) {
+        console.log(chalk9.cyan("\n\u{1F4E6} Staging and committing changes...\n"));
+        const staged = await stageAllChanges(cwd);
+        if (!staged) {
+          console.log(chalk9.red("\u274C Failed to stage changes"));
+          process.exit(1);
+        }
+        try {
+          await execa2(
+            "git",
+            ["commit", "-m", "chore: auto-fix quality issues"],
+            { cwd }
+          );
+          console.log(chalk9.green("\u2705 Changes committed successfully"));
+        } catch (error) {
+          console.log(chalk9.red("\u274C Failed to commit changes"));
+          console.log(chalk9.dim(error.message));
+          process.exit(1);
+        }
       } else {
-        console.log(chalk9.green(`\u2713 Removed ${result.hookType} hook`));
+        console.log(chalk9.dim("\n  No changes to commit."));
       }
-    } else if (result.error) {
-      console.error(
-        chalk9.red(`\u2717 Failed to remove ${result.hookType}: ${result.error}`)
-      );
-      hasErrors = true;
     }
-  }
-  if (!hasErrors) {
-    console.log(chalk9.green("\n\u2713 Git hooks uninstalled successfully"));
+    console.log(chalk9.cyan("\n\u{1F4A1} Next steps:\n"));
+    console.log(chalk9.dim("  1. git add ."));
+    console.log(
+      chalk9.dim('  2. git commit -m "<type>(<scope>): <description>"')
+    );
+    console.log(chalk9.dim("  3. git push origin <branch-name>"));
+    console.log("");
+    process.exit(0);
   } else {
-    process.exit(1);
-  }
-}
-async function statusHooksAction(cwd) {
-  console.log(chalk9.bold.cyan("\n\u{1F4CA} Workflow Agent Git Hooks Status\n"));
-  if (!hasGitRepo(cwd)) {
-    console.error(chalk9.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 ? chalk9.green : chalk9.yellow;
-    let message = `${icon} ${status.hookType}`;
-    if (status.installed) {
-      message += " - installed";
-      if (status.wrappedOriginal) {
-        message += " (wrapping original hook)";
+    console.log(chalk9.bold.red("\n\u274C QUALITY CHECKS FAILED\n"));
+    console.log(chalk9.dim(`  Total time: ${totalTime}s`));
+    console.log(chalk9.dim(`  Validation cycles: ${result.totalAttempts}`));
+    console.log(chalk9.dim(`  Fixes applied: ${result.fixesApplied}`));
+    if (result.pendingFixes && result.pendingFixes.length > 0) {
+      console.log(chalk9.yellow("\n\u{1F4CB} Pending fixes (dry-run):"));
+      for (const fix of result.pendingFixes) {
+        console.log(chalk9.dim(`  \u2022 ${fix.check.displayName}: ${fix.command}`));
       }
-    } 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(chalk9.dim("\nTo install hooks: workflow hooks install"));
-  }
-}
-
-// src/cli/commands/github-actions.ts
-import chalk10 from "chalk";
-import * as p6 from "@clack/prompts";
-async function githubCommand(action) {
-  const cwd = process.cwd();
-  switch (action) {
-    case "setup":
-      await setupAction(cwd);
-      break;
-    case "check":
-      await checkAction(cwd);
-      break;
-    default:
-      console.error(chalk10.red(`Unknown action: ${action}`));
-      console.log(chalk10.dim("Available actions: setup, check"));
-      process.exit(1);
-  }
-}
-async function setupAction(cwd) {
-  console.log(chalk10.bold.cyan("\n\u{1F527} Setting Up GitHub Actions CI\n"));
-  const repoInfo = await getRepoInfo(cwd);
-  if (!repoInfo.isGitRepo) {
-    console.error(chalk10.red("\u2717 No git repository found"));
-    console.log(chalk10.yellow("  Run: git init"));
-    process.exit(1);
-  }
-  if (!repoInfo.isGitHub) {
-    console.log(chalk10.yellow("\u26A0\uFE0F  No GitHub remote detected"));
-    const shouldContinue = await p6.confirm({
-      message: "Create GitHub Actions workflow anyway?",
-      initialValue: true
-    });
-    if (p6.isCancel(shouldContinue) || !shouldContinue) {
-      p6.cancel("Setup cancelled");
-      process.exit(0);
     }
-  } else {
     console.log(
-      chalk10.dim(
-        `Repository: ${repoInfo.github?.owner}/${repoInfo.github?.repo}`
-      )
+      chalk9.yellow("\n\u26A0\uFE0F  Please fix the errors above and run again.")
     );
-  }
-  if (hasCIWorkflow(cwd)) {
-    const shouldOverwrite = await p6.confirm({
-      message: "CI workflow already exists. Overwrite?",
-      initialValue: false
-    });
-    if (p6.isCancel(shouldOverwrite) || !shouldOverwrite) {
-      p6.cancel("Setup cancelled");
-      process.exit(0);
-    }
-  }
-  const projectInfo = await getProjectInfo(cwd);
-  console.log(chalk10.dim(`Package manager: ${projectInfo.packageManager}`));
-  console.log(chalk10.dim(`Monorepo: ${projectInfo.isMonorepo ? "yes" : "no"}`));
-  const config = await loadConfig();
-  const ciConfig = config?.ci;
-  const spinner5 = p6.spinner();
-  spinner5.start("Creating CI workflow...");
-  const result = await createCIWorkflow({
-    projectPath: cwd,
-    packageManager: projectInfo.packageManager,
-    isMonorepo: projectInfo.isMonorepo,
-    ciConfig,
-    defaultBranch: repoInfo.defaultBranch || "main"
-  });
-  if (result.success) {
-    spinner5.stop(chalk10.green("\u2713 Created CI workflow"));
-    console.log(chalk10.dim(`  File: ${result.filePath}`));
-    console.log(chalk10.green("\n\u2713 GitHub Actions CI setup complete"));
-    console.log(chalk10.dim("\nThe workflow will run on:"));
-    console.log(chalk10.dim("  \u2022 Push to main/develop branches"));
-    console.log(chalk10.dim("  \u2022 Pull requests to main/develop branches"));
-    console.log(chalk10.dim("\nChecks included:"));
-    const checks = ciConfig?.checks || [
-      "lint",
-      "typecheck",
-      "format",
-      "build",
-      "test"
-    ];
-    for (const check of checks) {
-      const hasScript = check === "lint" ? projectInfo.hasLintScript : check === "typecheck" ? projectInfo.hasTypecheckScript : check === "format" ? projectInfo.hasFormatScript : check === "test" ? projectInfo.hasTestScript : check === "build" ? projectInfo.hasBuildScript : false;
-      const status = hasScript ? chalk10.green("\u2713") : chalk10.yellow("\u26A0");
-      const note = hasScript ? "" : " (add script to package.json)";
-      console.log(chalk10.dim(`  ${status} ${check}${note}`));
-    }
-    console.log(chalk10.cyan("\n\u{1F4A1} Recommended: Enable branch protection"));
-    console.log(chalk10.dim("  Go to GitHub \u2192 Settings \u2192 Branches \u2192 Add rule"));
     console.log(
-      chalk10.dim('  Enable "Require status checks to pass before merging"')
+      chalk9.dim("  Run with --fix to auto-fix lint and format issues.")
     );
-    console.log(chalk10.dim('  Select the "ci" status check'));
-  } else {
-    spinner5.stop(chalk10.red("\u2717 Failed to create CI workflow"));
-    console.error(chalk10.red(`  Error: ${result.error}`));
-    process.exit(1);
-  }
-}
-async function checkAction(cwd) {
-  console.log(chalk10.bold.cyan("\n\u{1F50D} Checking GitHub Actions CI Setup\n"));
-  const result = await validateGitHubActionsSetup(cwd);
-  if (result.hasWorkflowFile) {
-    console.log(chalk10.green("\u2713 CI workflow file found"));
-  } else {
-    console.log(chalk10.red("\u2717 No CI workflow file found"));
-    console.log(chalk10.yellow("  Run: workflow github:setup"));
-    process.exit(1);
-  }
-  const checks = [
-    { name: "Lint", present: result.hasLintCheck },
-    { name: "Type check", present: result.hasTypecheckCheck },
-    { name: "Format", present: result.hasFormatCheck },
-    { name: "Build", present: result.hasBuildCheck },
-    { name: "Test", present: result.hasTestCheck }
-  ];
-  console.log(chalk10.dim("\nCI checks:"));
-  for (const check of checks) {
-    const icon = check.present ? chalk10.green("\u2713") : chalk10.yellow("\u26A0");
-    console.log(`  ${icon} ${check.name}`);
-  }
-  if (result.errors.length > 0) {
-    console.log(chalk10.red("\nErrors:"));
-    for (const error of result.errors) {
-      console.log(chalk10.red(`  \u2022 ${error}`));
-    }
-  }
-  if (result.warnings.length > 0) {
-    console.log(chalk10.yellow("\nWarnings:"));
-    for (const warning of result.warnings) {
-      console.log(chalk10.yellow(`  \u2022 ${warning}`));
-    }
-  }
-  if (result.valid) {
-    console.log(chalk10.green("\n\u2713 CI setup is valid"));
-  } else {
-    console.log(chalk10.red("\n\u2717 CI setup has issues"));
-    console.log(chalk10.yellow("  Run: workflow github:setup"));
+    console.log("");
     process.exit(1);
   }
 }
 
-// src/cli/commands/fix.ts
-import { existsSync as existsSync10, readFileSync as readFileSync2, writeFileSync as writeFileSync3, mkdirSync } from "fs";
-import { dirname as dirname2, join as join10, relative } from "path";
-import { execa as execa3 } from "execa";
-import * as p7 from "@clack/prompts";
-import pc from "picocolors";
-function extractFilePaths(errorMessage, cwd) {
-  const paths = /* @__PURE__ */ new Set();
-  const patterns = [
-    /(?:at\s+)?([\/\w\.\-]+\.(?:ts|js|tsx|jsx|mjs|cjs|vue|svelte))(?::\d+(?::\d+)?)?/g,
-    /(?:Error in |from )\.?([\/\w\.\-]+\.(?:ts|js|tsx|jsx|mjs|cjs|vue|svelte))/g,
-    /['"]([\/\w\.\-]+\.(?:ts|js|tsx|jsx|mjs|cjs|vue|svelte))['"]/g
-  ];
-  for (const pattern of patterns) {
-    let match;
-    while ((match = pattern.exec(errorMessage)) !== null) {
-      let filePath = match[1];
-      if (!filePath.startsWith("/")) {
-        filePath = join10(cwd, filePath);
-      }
-      if (existsSync10(filePath)) {
-        paths.add(filePath);
-      }
-    }
-  }
-  return Array.from(paths);
-}
-function readFileContents(paths) {
-  const contents = {};
-  for (const filePath of paths) {
-    try {
-      if (existsSync10(filePath)) {
-        contents[filePath] = readFileSync2(filePath, "utf-8");
-      }
-    } catch {
-    }
-  }
-  return contents;
-}
-async function generateFixWithLLM(errorMessage, _fileContents, _context) {
-  console.log(pc.dim("  Analyzing error with LLM..."));
-  return {
-    analysis: `Error analysis for: ${errorMessage.slice(0, 100)}...`,
-    rootCause: "Unable to determine root cause without LLM API access",
-    suggestedFix: {
-      description: "Manual intervention required - LLM API not configured",
-      files: []
-    },
-    confidence: 0
-  };
-}
-async function applyChanges(changes, dryRun) {
-  for (const change of changes) {
-    const actionColor = change.action === "create" ? pc.green : change.action === "delete" ? pc.red : pc.yellow;
-    console.log(`  ${actionColor(change.action.toUpperCase())} ${change.path}`);
-    if (dryRun) {
-      console.log(pc.dim("    (dry run - no changes made)"));
-      continue;
-    }
-    switch (change.action) {
-      case "create":
-      case "modify":
-        if (change.content) {
-          const dir = dirname2(change.path);
-          if (!existsSync10(dir)) {
-            mkdirSync(dir, { recursive: true });
-          }
-          writeFileSync3(change.path, change.content);
-        }
-        break;
-      case "delete":
-        console.log(pc.dim("    (delete skipped for safety)"));
-        break;
-    }
-  }
-}
-async function commitAndPush(message, cwd) {
+// src/cli/commands/auto-setup-command.ts
+import * as p6 from "@clack/prompts";
+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 spinner5 = p6.spinner();
+  spinner5.start("Analyzing project...");
+  let report;
   try {
-    await execa3("git", ["add", "-A"], { cwd });
-    const { stdout: status } = await execa3(
-      "git",
-      ["status", "--porcelain"],
-      { cwd }
-    );
-    if (!status.trim()) {
-      return { success: true };
-    }
-    await execa3("git", ["commit", "-m", message], { cwd });
-    await execa3("git", ["push"], { cwd });
-    return { success: true };
+    report = await generateAuditReport(cwd);
+    spinner5.stop("\u2713 Project analysis complete");
   } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function fixCommand(options) {
-  const cwd = process.cwd();
-  console.log(pc.cyan("\n\u{1F527} Auto-Heal: Fixing Pipeline Error\n"));
-  if (!options.error) {
-    console.error(pc.red("Error: --error flag is required"));
-    process.exit(1);
-  }
-  console.log(pc.bold("Error Message:"));
-  console.log(pc.dim(options.error.slice(0, 500)));
-  if (options.error.length > 500) {
-    console.log(pc.dim(`... (${options.error.length - 500} more characters)`));
-  }
-  console.log("");
-  let filePaths = options.files || [];
-  if (filePaths.length === 0) {
-    console.log(pc.dim("Extracting file paths from error..."));
-    filePaths = extractFilePaths(options.error, cwd);
-  }
-  if (filePaths.length > 0) {
-    console.log(pc.bold("\nRelevant Files:"));
-    for (const path2 of filePaths) {
-      console.log(`  \u{1F4C4} ${relative(cwd, path2)}`);
-    }
-    console.log("");
-  }
-  const fileContents = readFileContents(filePaths);
-  let context;
-  if (options.context) {
-    try {
-      context = JSON.parse(options.context);
-    } catch {
-      context = options.context;
-    }
-  }
-  console.log(pc.bold("Generating Fix...\n"));
-  const fix = await generateFixWithLLM(options.error, fileContents, context);
-  console.log(pc.bold("Analysis:"));
-  console.log(`  ${fix.analysis}`);
-  console.log("");
-  console.log(pc.bold("Root Cause:"));
-  console.log(`  ${fix.rootCause}`);
-  console.log("");
-  console.log(pc.bold("Suggested Fix:"));
-  console.log(`  ${fix.suggestedFix.description}`);
-  console.log(`  Confidence: ${Math.round(fix.confidence * 100)}%`);
-  console.log("");
-  if (fix.suggestedFix.files.length === 0) {
-    console.log(
-      pc.yellow("\u26A0\uFE0F  No automatic fix available. Manual intervention required.")
-    );
-    process.exit(1);
-  }
-  if (fix.confidence < 0.5) {
-    console.log(
-      pc.yellow(
-        `\u26A0\uFE0F  Low confidence (${Math.round(fix.confidence * 100)}%). Skipping automatic fix.`
+    spinner5.stop("\u2717 Failed to analyze project");
+    console.error(
+      chalk10.red(
+        `Error: ${error instanceof Error ? error.message : String(error)}`
       )
     );
     process.exit(1);
   }
-  if (!options.auto) {
-    const shouldApply = await p7.confirm({
-      message: "Apply suggested changes?",
-      initialValue: false
-    });
-    if (p7.isCancel(shouldApply) || !shouldApply) {
-      console.log(pc.dim("Fix cancelled."));
-      process.exit(0);
-    }
+  console.log("\n" + formatAuditReportColored(report));
+  if (options.audit) {
+    console.log(chalk10.dim("\n--audit mode: No changes applied.\n"));
+    return;
   }
-  console.log(pc.bold("\nApplying Changes...\n"));
-  await applyChanges(fix.suggestedFix.files, options.dryRun || false);
-  if (options.dryRun) {
-    console.log(pc.yellow("\n\u26A0\uFE0F  Dry run complete. No changes were made."));
-    process.exit(0);
+  if (report.totalChanges === 0 && report.allDevDependencies.length === 0) {
+    p6.outro(chalk10.green("\u2713 Project is already fully configured!"));
+    return;
   }
-  if (options.auto) {
-    console.log(pc.bold("\nCommitting and Pushing...\n"));
-    const scope = filePaths.length > 0 ? dirname2(relative(cwd, filePaths[0])).split("/")[0] || "core" : "core";
-    const commitMessage = `fix(${scope}): auto-heal pipeline failure
-
-${fix.rootCause}
-
-Auto-generated fix with ${Math.round(fix.confidence * 100)}% confidence.
-`;
-    const result = await commitAndPush(commitMessage, cwd);
-    if (result.success) {
-      console.log(pc.green("\u2705 Fix applied, committed, and pushed!"));
-    } else {
-      console.log(pc.red(`\u274C Failed to commit/push: ${result.error}`));
-      process.exit(1);
+  if (!options.yes) {
+    const shouldProceed = await p6.confirm({
+      message: `Apply ${report.totalChanges} changes and install ${report.allDevDependencies.length} packages?`,
+      initialValue: true
+    });
+    if (p6.isCancel(shouldProceed) || !shouldProceed) {
+      p6.cancel("Setup cancelled");
+      process.exit(0);
     }
   } else {
-    console.log(pc.green("\n\u2705 Fix applied! Don't forget to commit and push."));
-  }
-}
-
-// src/cli/commands/visual.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname3, join as join11 } from "path";
-import * as p8 from "@clack/prompts";
-import pc2 from "picocolors";
-function getBaselinesDir() {
-  const cwd = process.cwd();
-  return join11(cwd, ".visual-baselines");
-}
-function getMetadataPath() {
-  return join11(getBaselinesDir(), "baselines.json");
-}
-function loadMetadata() {
-  const metadataPath = getMetadataPath();
-  if (!existsSync11(metadataPath)) {
-    return {};
-  }
-  try {
-    return JSON.parse(readFileSync3(metadataPath, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function saveMetadata(metadata) {
-  const dir = getBaselinesDir();
-  if (!existsSync11(dir)) {
-    mkdirSync2(dir, { recursive: true });
-  }
-  writeFileSync4(getMetadataPath(), JSON.stringify(metadata, null, 2));
-}
-async function checkPlaywright() {
-  try {
-    await import("playwright");
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function visualCaptureCommand(name, url, options) {
-  console.log(pc2.cyan("\n\u{1F4F8} Capturing Visual Baseline\n"));
-  const hasPlaywright = await checkPlaywright();
-  if (!hasPlaywright) {
-    console.log(pc2.yellow("\u26A0\uFE0F  Playwright is not installed."));
-    console.log(pc2.dim("Install it with: npm install playwright"));
-    console.log(
-      pc2.dim("Then install browsers: npx playwright install chromium")
-    );
-    process.exit(1);
+    console.log(chalk10.dim("\n--yes mode: Auto-approving all changes.\n"));
   }
-  const width = parseInt(options.width || "1280");
-  const height = parseInt(options.height || "720");
-  const delay = parseInt(options.delay || "0");
-  console.log(`  Name: ${pc2.bold(name)}`);
-  console.log(`  URL: ${url}`);
-  console.log(`  Viewport: ${width}x${height}`);
   console.log("");
-  try {
-    const { chromium } = await import("playwright");
-    const browser = await chromium.launch({ headless: true });
-    const context = await browser.newContext({
-      viewport: { width, height }
-    });
-    const page = await context.newPage();
-    console.log(pc2.dim("  Loading page..."));
-    await page.goto(url, { waitUntil: "networkidle" });
-    if (options.waitFor) {
-      console.log(pc2.dim(`  Waiting for selector: ${options.waitFor}`));
-      await page.waitForSelector(options.waitFor, { timeout: 1e4 });
-    }
-    if (delay > 0) {
-      console.log(pc2.dim(`  Waiting ${delay}ms...`));
-      await page.waitForTimeout(delay);
-    }
-    const baselinesDir = getBaselinesDir();
-    const outputPath = options.output || join11(baselinesDir, "screenshots", `${name}.png`);
-    const outputDir = dirname3(outputPath);
-    if (!existsSync11(outputDir)) {
-      mkdirSync2(outputDir, { recursive: true });
+  const setupSpinner = p6.spinner();
+  const stepMessages = [];
+  const results = await runAllSetups(cwd, (step, status) => {
+    if (status === "start") {
+      setupSpinner.start(step);
+    } else if (status === "done") {
+      setupSpinner.stop(`\u2713 ${step}`);
+      stepMessages.push(`\u2713 ${step}`);
+    } else {
+      setupSpinner.stop(`\u2717 ${step}`);
+      stepMessages.push(`\u2717 ${step}`);
     }
-    console.log(pc2.dim("  Capturing screenshot..."));
-    await page.screenshot({
-      path: outputPath,
-      fullPage: options.fullPage
-    });
-    await browser.close();
-    const metadata = loadMetadata();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    metadata[name] = {
-      name,
-      url,
-      path: outputPath,
-      width,
-      height,
-      createdAt: metadata[name]?.createdAt || now,
-      updatedAt: now
-    };
-    saveMetadata(metadata);
-    console.log(pc2.green(`
-\u2705 Baseline "${name}" saved to ${outputPath}`));
-  } catch (error) {
-    console.error(pc2.red("\n\u274C Failed to capture screenshot:"), error);
-    process.exit(1);
-  }
-}
-async function visualCompareCommand(url, options) {
-  console.log(pc2.cyan("\n\u{1F50D} Comparing Against Baseline\n"));
-  const metadata = loadMetadata();
-  const baseline = metadata[options.baseline];
-  if (!baseline) {
-    console.log(pc2.red(`\u274C Baseline "${options.baseline}" not found`));
-    console.log(pc2.dim("Available baselines:"));
-    Object.keys(metadata).forEach((name) => {
-      console.log(pc2.dim(`  - ${name}`));
-    });
-    process.exit(1);
-  }
-  if (!existsSync11(baseline.path)) {
-    console.log(pc2.red(`\u274C Baseline screenshot not found: ${baseline.path}`));
-    process.exit(1);
-  }
-  console.log(`  Baseline: ${pc2.bold(options.baseline)}`);
-  console.log(`  URL: ${url}`);
-  console.log(`  Viewport: ${baseline.width}x${baseline.height}`);
+  });
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.filter((r) => !r.success).length;
   console.log("");
-  const hasPlaywright = await checkPlaywright();
-  if (!hasPlaywright) {
-    console.log(pc2.yellow("\u26A0\uFE0F  Playwright is not installed."));
-    process.exit(1);
+  if (failCount === 0) {
+    p6.outro(
+      chalk10.green(
+        `\u2713 Auto-setup complete! (${successCount} configurations applied)`
+      )
+    );
+  } else {
+    p6.outro(
+      chalk10.yellow(
+        `\u26A0 Setup completed with issues: ${successCount} succeeded, ${failCount} failed`
+      )
+    );
   }
-  try {
-    const { chromium } = await import("playwright");
-    const browser = await chromium.launch({ headless: true });
-    const context = await browser.newContext({
-      viewport: { width: baseline.width, height: baseline.height }
-    });
-    const page = await context.newPage();
-    console.log(pc2.dim("  Loading page..."));
-    await page.goto(url, { waitUntil: "networkidle" });
-    const baselinesDir = getBaselinesDir();
-    const comparePath = options.output || join11(
-      baselinesDir,
-      "comparisons",
-      `${options.baseline}-${Date.now()}.png`
+  console.log(chalk10.dim("\nNext steps:"));
+  console.log(chalk10.dim("  1. Review the generated configuration files"));
+  console.log(chalk10.dim("  2. Run: pnpm verify (or npm/yarn)"));
+  console.log(chalk10.dim("  3. Commit your changes\n"));
+}
+function formatAuditReportColored(report) {
+  const lines = [];
+  lines.push(chalk10.bold("\u{1F4CB} Audit Report\n"));
+  lines.push(chalk10.dim(`Framework: ${report.analysis.framework}`));
+  lines.push(chalk10.dim(`Package Manager: ${report.analysis.packageManager}`));
+  lines.push(
+    chalk10.dim(`TypeScript: ${report.analysis.isTypeScript ? "Yes" : "No"}`)
+  );
+  lines.push(
+    chalk10.dim(`Monorepo: ${report.analysis.isMonorepo ? "Yes" : "No"}`)
+  );
+  lines.push("");
+  for (const plan of report.plans) {
+    const hasChanges = plan.changes.some((c) => c.type !== "unchanged");
+    const icon = hasChanges ? "\u{1F527}" : "\u2713";
+    const titleColor = hasChanges ? chalk10.yellow : chalk10.green;
+    lines.push(
+      titleColor(
+        `${icon} ${plan.name.charAt(0).toUpperCase() + plan.name.slice(1)} - ${plan.description}`
+      )
     );
-    const compareDir = dirname3(comparePath);
-    if (!existsSync11(compareDir)) {
-      mkdirSync2(compareDir, { recursive: true });
+    for (const change of plan.changes) {
+      let symbol;
+      let line;
+      switch (change.type) {
+        case "add":
+          symbol = chalk10.green("+");
+          line = chalk10.green(change.description);
+          break;
+        case "modify":
+          symbol = chalk10.yellow("~");
+          line = chalk10.yellow(change.description);
+          if (change.key && change.oldValue !== void 0 && change.newValue !== void 0) {
+            line += chalk10.dim(
+              ` (${String(change.oldValue)} \u2192 ${String(change.newValue)})`
+            );
+          }
+          break;
+        case "unchanged":
+        default:
+          symbol = chalk10.dim("=");
+          line = chalk10.dim(change.description);
+      }
+      lines.push(`  ${symbol} ${line}`);
     }
-    console.log(pc2.dim("  Capturing screenshot..."));
-    await page.screenshot({ path: comparePath });
-    await browser.close();
-    const baselineBuffer = readFileSync3(baseline.path);
-    const compareBuffer = readFileSync3(comparePath);
-    const areSameSize = baselineBuffer.length === compareBuffer.length;
-    const areIdentical = areSameSize && baselineBuffer.equals(compareBuffer);
-    console.log("");
-    if (areIdentical) {
-      console.log(pc2.green("\u2705 Screenshots are identical"));
-    } else {
-      console.log(pc2.yellow("\u26A0\uFE0F  Screenshots differ"));
-      console.log(pc2.dim(`  Baseline size: ${baselineBuffer.length} bytes`));
-      console.log(pc2.dim(`  Current size: ${compareBuffer.length} bytes`));
-      console.log("");
-      console.log(
-        pc2.dim(
-          "For detailed LLM-based comparison, use the GitHub App's visual testing."
-        )
+    if (plan.devDependencies.length > 0) {
+      lines.push(
+        chalk10.blue(`  \u{1F4E6} Install: ${plan.devDependencies.join(", ")}`)
       );
-      console.log(pc2.dim(`Comparison saved to: ${comparePath}`));
-      process.exit(1);
     }
-  } catch (error) {
-    console.error(pc2.red("\n\u274C Failed to compare:"), error);
-    process.exit(1);
-  }
-}
-async function visualListCommand(options) {
-  const metadata = loadMetadata();
-  const baselines = Object.values(metadata);
-  if (options.json) {
-    console.log(JSON.stringify(baselines, null, 2));
-    return;
-  }
-  if (baselines.length === 0) {
-    console.log(pc2.dim("No baselines found."));
-    console.log(pc2.dim("Create one with: workflow visual capture <name> <url>"));
-    return;
-  }
-  console.log(pc2.cyan("\n\u{1F4F8} Visual Baselines\n"));
-  for (const baseline of baselines) {
-    console.log(`  ${pc2.bold(baseline.name)}`);
-    console.log(`    URL: ${baseline.url}`);
-    console.log(`    Viewport: ${baseline.width}x${baseline.height}`);
-    console.log(`    Path: ${baseline.path}`);
-    console.log(`    Updated: ${baseline.updatedAt}`);
-    console.log("");
-  }
-}
-async function visualUpdateCommand(name, options) {
-  const metadata = loadMetadata();
-  const baseline = metadata[name];
-  if (!baseline) {
-    console.log(pc2.red(`\u274C Baseline "${name}" not found`));
-    process.exit(1);
+    lines.push("");
   }
-  console.log(pc2.cyan(`
-\u{1F504} Updating baseline "${name}"...
-`));
-  await visualCaptureCommand(name, baseline.url, {
-    width: options.width || String(baseline.width),
-    height: options.height || String(baseline.height),
-    fullPage: options.fullPage,
-    output: baseline.path
-  });
-}
-async function visualApproveCommand(name) {
-  const metadata = loadMetadata();
-  const baseline = metadata[name];
-  if (!baseline) {
-    console.log(pc2.red(`\u274C Baseline "${name}" not found`));
-    process.exit(1);
-  }
-  const confirm8 = await p8.confirm({
-    message: `Update baseline "${name}" with the latest comparison?`,
-    initialValue: false
-  });
-  if (p8.isCancel(confirm8) || !confirm8) {
-    console.log(pc2.dim("Cancelled."));
-    return;
-  }
-  const baselinesDir = getBaselinesDir();
-  const comparisonsDir = join11(baselinesDir, "comparisons");
-  if (!existsSync11(comparisonsDir)) {
-    console.log(pc2.yellow("No comparisons found to approve."));
-    return;
+  if (report.allDevDependencies.length > 0) {
+    lines.push(chalk10.bold("Dependencies to install (batched):"));
+    const pm = report.analysis.packageManager;
+    const cmd = pm === "npm" ? "npm install" : pm === "yarn" ? "yarn add" : `${pm} add`;
+    lines.push(
+      chalk10.cyan(`  ${cmd} -D ${report.allDevDependencies.join(" ")}`)
+    );
+    lines.push("");
   }
-  console.log(
-    pc2.yellow(
-      "To approve, re-capture the baseline with: workflow visual update " + name
+  lines.push(
+    chalk10.bold(
+      `Total: ${report.totalChanges} changes, ${report.allDevDependencies.length} packages`
     )
   );
+  return lines.join("\n");
 }
 
 // src/cli/index.ts
-var program = new Command2();
+var program = new Command();
 program.name("workflow").description(
   "A self-evolving workflow management system for AI agent development"
 ).version("1.0.0");
@@ -3459,43 +1604,19 @@ program.command("validate <type>").description("Validate branch name, commit mes
   "--suggest-on-error",
   "Offer improvement suggestions on validation errors"
 ).action(validateCommand);
-program.addCommand(createConfigCommand());
+program.command("config <action>").description("Manage workflow configuration").argument("<action>", "Action: get, set, add, remove").argument("[key]", "Config key").argument("[value]", "Config value").action(configCommand);
 program.command("suggest").description("Submit an improvement suggestion").argument("<feedback>", "Your improvement suggestion").option("--author <author>", "Your name or username").option(
   "--category <category>",
   "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").option(
-  "--check-guidelines-only",
-  "Only check mandatory guidelines exist (exits 0 or 1)"
-).action(doctorCommand);
-program.command("hooks").description("Manage git hooks (install, uninstall, status)").argument("<action>", "Action: install, uninstall, status").action(hooksCommand);
-program.command("github").description("Manage GitHub Actions CI (setup, check)").argument("<action>", "Action: setup, check").action(githubCommand);
+program.command("doctor").description("Run health check and get optimization suggestions").action(doctorCommand);
 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)"
 ).option("--preset-name <preset>", "Preset display name").option("--output-dir <dir>", "Output directory").option("--no-test", "Skip test file generation").action(scopeCreateCommand);
 program.command("scope:migrate").description("Migrate inline scopes to a custom package").option("--name <name>", "Package name for the preset").option("--output-dir <dir>", "Output directory").option("--keep-config", "Keep inline scopes in config after migration").action(scopeMigrateCommand);
-program.command("fix").description("Auto-heal pipeline failures using LLM").option("--error <error>", "Error message to fix (required)").option("--context <context>", "Additional context JSON").option("--files <files>", "Comma-separated file paths to analyze").option("--auto", "Apply fix automatically without confirmation").option("--dry-run", "Show what would be changed without applying").action((options) => {
-  fixCommand({
-    error: options.error,
-    context: options.context,
-    files: options.files?.split(","),
-    auto: options.auto,
-    dryRun: options.dryRun
-  });
-});
-var visual = program.command("visual").description("Visual testing commands");
-visual.command("capture").description("Capture a new baseline screenshot").argument("<name>", "Name for the baseline").argument("<url>", "URL to capture").option("-w, --width <width>", "Viewport width", "1280").option("-h, --height <height>", "Viewport height", "720").option("--full-page", "Capture full page").option("-o, --output <path>", "Output path").option("--wait-for <selector>", "Wait for selector before capture").option("--delay <ms>", "Additional delay in ms").action(visualCaptureCommand);
-visual.command("compare").description("Compare a URL against a baseline").argument("<url>", "URL to compare").option("-b, --baseline <name>", "Baseline name to compare against (required)").option("-o, --output <path>", "Output path for comparison screenshot").option("-t, --threshold <percent>", "Difference threshold percentage").action((url, options) => {
-  if (!options.baseline) {
-    console.error("Error: --baseline is required");
-    process.exit(1);
-  }
-  visualCompareCommand(url, options);
-});
-visual.command("list").description("List all baselines").option("--json", "Output as JSON").action(visualListCommand);
-visual.command("update").description("Update an existing baseline").argument("<name>", "Baseline name to update").option("-w, --width <width>", "Override viewport width").option("-h, --height <height>", "Override viewport height").option("--full-page", "Capture full page").action(visualUpdateCommand);
-visual.command("approve").description("Approve a comparison as the new baseline").argument("<name>", "Baseline name to approve").action(visualApproveCommand);
+program.command("verify").description("Run all quality checks with fix-and-revalidate pattern").option("--fix", "Enable auto-fix for lint and format issues").option("--max-retries <n>", "Maximum retry cycles (default: 10)", "10").option("--commit", "Commit changes if all checks pass").option("--dry-run", "Preview fixes without applying them").action(verifyCommand);
+program.command("auto-setup").description("Automatically configure linting, formatting, testing, and CI").option("-y, --yes", "Auto-approve all prompts").option("--audit", "Show audit report without applying changes").action(autoSetupCommand);
 program.parse();
 //# sourceMappingURL=index.js.map