@harness-engineering/cli 1.9.0 → 1.11.0

package/dist/agents/skills/gemini-cli/harness-pre-commit-review/SKILL.md

@@ -81,6 +81,26 @@ If a knowledge graph exists at `.harness/graph/` and code files have changed sin
 
 If no graph exists, skip this step — the tools fall back to non-graph behavior.
 
+### Impact Preview
+
+After mechanical checks pass, run `harness impact-preview` to surface the blast radius of staged changes. This is informational only — it never blocks the commit.
+
+```bash
+harness impact-preview
+```
+
+Include the output in the report between the mechanical checks section and the AI review section:
+
+```
+Impact Preview (3 staged files)
+  Code:   12 files   (routes/login.ts, middleware/verify.ts, +10)
+  Tests:   3 tests   (auth.test.ts, integration.test.ts, +1)
+  Docs:    2 docs    (auth-guide.md, api-reference.md)
+  Total:  17 affected
+```
+
+If no graph exists, the command prints a nudge message and returns — no action needed. If no files are staged, it says so. Neither case blocks the workflow.
+
 ### Phase 2: Classify Changes
 
 Determine whether AI review is needed based on what changed.
@@ -192,6 +212,12 @@ Mechanical Checks:
 - Tests: PASS (12/12)
 - Security Scan: PASS (0 errors, 0 warnings)
 
+Impact Preview (3 staged files)
+  Code:   12 files   (routes/login.ts, middleware/verify.ts, +10)
+  Tests:   3 tests   (auth.test.ts, integration.test.ts, +1)
+  Docs:    2 docs    (auth-guide.md, api-reference.md)
+  Total:  17 affected
+
 AI Review: PASS (no issues found)
 ```
 
@@ -207,6 +233,11 @@ Mechanical Checks:
 - Security Scan: WARN (0 errors, 1 warning)
   - [SEC-NET-001] src/cors.ts:5 — CORS wildcard origin
 
+Impact Preview (2 staged files)
+  Code:    8 files   (cors.ts, server.ts, +6)
+  Tests:   2 tests   (cors.test.ts, server.test.ts)
+  Total:  10 affected
+
 AI Review: 2 observations
 1. [file:line] Possible null dereference — `user.email` accessed without null check after `findUser()` which can return null.
 2. [file:line] Debug artifact — `console.log('debug:', payload)` appears to be left from debugging.
@@ -244,6 +275,7 @@ fi
 - Complements harness-code-review (full review) — use pre-commit for quick checks, code-review for thorough analysis
 - **`assess_project`** — Used in Phase 1 for harness-specific health checks (validate + deps) in a single call.
 - **`review_changes`** — Used in Phase 4 with `depth: 'quick'` for fast pre-commit diff analysis.
+- **`harness impact-preview`** — Run after mechanical checks pass to show blast radius of staged changes. Informational only — never blocks.
 
 ## Success Criteria
 
@@ -264,6 +296,11 @@ Mechanical Checks:
 - Types: PASS
 - Tests: PASS (12/12)
 
+Impact Preview (2 staged files)
+  Code:    5 files   (auth.ts, login.ts, +3)
+  Tests:   2 tests   (auth.test.ts, login.test.ts)
+  Total:   7 affected
+
 AI Review: PASS (no issues found)
 ```
 

package/dist/agents-md-ZFV6RR5J.js

@@ -0,0 +1,8 @@
+import {
+  generateAgentsMd
+} from "./chunk-NKDM3FMH.js";
+import "./chunk-2YSQOUHO.js";
+import "./chunk-MHBMTPW7.js";
+export {
+  generateAgentsMd
+};

package/dist/architecture-EXNUMH5R.js

@@ -0,0 +1,13 @@
+import {
+  checkDependenciesDefinition,
+  handleCheckDependencies
+} from "./chunk-TI4TGEX6.js";
+import "./chunk-K6XAPGML.js";
+import "./chunk-IDZNPTYD.js";
+import "./chunk-W6Y7ZW3Y.js";
+import "./chunk-2YSQOUHO.js";
+import "./chunk-MHBMTPW7.js";
+export {
+  checkDependenciesDefinition,
+  handleCheckDependencies
+};

package/dist/bin/harness-mcp.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin/harness-mcp.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import {
+  startServer
+} from "../chunk-I6JZYEGT.js";
+import "../chunk-Z75JC6I2.js";
+import "../chunk-GSIVNYVJ.js";
+import "../chunk-PA2XHK75.js";
+import "../chunk-X3MN5UQJ.js";
+import "../chunk-WUJTCNOU.js";
+import "../chunk-ZOAWBDWU.js";
+import "../chunk-WJZDO6OY.js";
+import "../chunk-2YPZKGAG.js";
+import "../chunk-TI4TGEX6.js";
+import "../chunk-K6XAPGML.js";
+import "../chunk-NC6PXVWT.js";
+import "../chunk-IDZNPTYD.js";
+import "../chunk-W6Y7ZW3Y.js";
+import "../chunk-HD4IBGLA.js";
+import "../chunk-3WGJMBKH.js";
+import "../chunk-VRFZWGMS.js";
+import "../chunk-2YSQOUHO.js";
+import "../chunk-MHBMTPW7.js";
+
+// src/bin/harness-mcp.ts
+startServer().catch((error) => {
+  console.error("Failed to start MCP server:", error);
+  process.exit(1);
+});

package/dist/bin/harness.js

@@ -1,21 +1,55 @@
 #!/usr/bin/env node
 import {
-  CLI_VERSION,
-  createProgram,
+  createProgram
+} from "../chunk-ZWC3MN5E.js";
+import "../chunk-VUCPTQ6G.js";
+import {
   findConfigFile,
   loadConfig
-} from "../chunk-RTPHUDZS.js";
-import "../chunk-6JIT7CEM.js";
+} from "../chunk-2NCIKJES.js";
+import "../chunk-GNGELAXY.js";
+import "../chunk-Q6AB7W5Z.js";
+import "../chunk-TRAPF4IX.js";
+import "../chunk-L2KLU56K.js";
+import "../chunk-TEFCFC4H.js";
+import "../chunk-6N4R6FVX.js";
+import "../chunk-EBJQ6N4M.js";
+import "../chunk-QPEH2QPG.js";
+import "../chunk-JSTQ3AWB.js";
+import "../chunk-KET4QQZB.js";
+import "../chunk-NKDM3FMH.js";
+import "../chunk-I6JZYEGT.js";
+import "../chunk-Z75JC6I2.js";
+import "../chunk-GSIVNYVJ.js";
+import "../chunk-PA2XHK75.js";
+import "../chunk-X3MN5UQJ.js";
+import "../chunk-WUJTCNOU.js";
+import "../chunk-ZOAWBDWU.js";
+import "../chunk-WJZDO6OY.js";
+import "../chunk-2YPZKGAG.js";
+import "../chunk-TI4TGEX6.js";
+import "../chunk-K6XAPGML.js";
+import "../chunk-NC6PXVWT.js";
+import "../chunk-IDZNPTYD.js";
+import "../chunk-W6Y7ZW3Y.js";
+import "../chunk-HD4IBGLA.js";
+import {
+  handleError
+} from "../chunk-3WGJMBKH.js";
+import "../chunk-VRFZWGMS.js";
+import {
+  CLI_VERSION
+} from "../chunk-BM3PWGXQ.js";
+import "../chunk-72GHBOL2.js";
+import "../chunk-C2ERUR3L.js";
 import {
   getUpdateNotification,
   isUpdateCheckEnabled,
   readCheckState,
   shouldRunCheck,
   spawnBackgroundCheck
-} from "../chunk-CGSHUJES.js";
-import {
-  handleError
-} from "../chunk-ULSRSP53.js";
+} from "../chunk-2YSQOUHO.js";
+import "../chunk-MHBMTPW7.js";
 
 // src/bin/update-check-hooks.ts
 var DEFAULT_INTERVAL_MS = 864e5;

package/dist/check-phase-gate-VZFOY2PO.js

@@ -0,0 +1,12 @@
+import {
+  createCheckPhaseGateCommand,
+  runCheckPhaseGate
+} from "./chunk-2NCIKJES.js";
+import "./chunk-EBJQ6N4M.js";
+import "./chunk-3WGJMBKH.js";
+import "./chunk-2YSQOUHO.js";
+import "./chunk-MHBMTPW7.js";
+export {
+  createCheckPhaseGateCommand,
+  runCheckPhaseGate
+};

package/dist/chunk-2NCIKJES.js

@@ -0,0 +1,470 @@
+import {
+  logger
+} from "./chunk-EBJQ6N4M.js";
+import {
+  CLIError,
+  ExitCode
+} from "./chunk-3WGJMBKH.js";
+import {
+  ArchConfigSchema
+} from "./chunk-2YSQOUHO.js";
+import {
+  Err,
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/commands/check-phase-gate.ts
+import { Command } from "commander";
+import * as path2 from "path";
+import * as fs2 from "fs";
+
+// src/config/loader.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/config/schema.ts
+import { z } from "zod";
+var LayerSchema = z.object({
+  /** Human-readable name of the layer */
+  name: z.string(),
+  /** Glob pattern matching files in this layer */
+  pattern: z.string(),
+  /** Names of other layers this layer is allowed to import from */
+  allowedDependencies: z.array(z.string())
+});
+var ForbiddenImportSchema = z.object({
+  /** Glob pattern matching source files this rule applies to */
+  from: z.string(),
+  /** List of modules or patterns that are not allowed to be imported */
+  disallow: z.array(z.string()),
+  /** Optional custom message to display on violation */
+  message: z.string().optional()
+});
+var BoundaryConfigSchema = z.object({
+  /** List of globs where files MUST have a corresponding schema/definition */
+  requireSchema: z.array(z.string())
+});
+var AgentConfigSchema = z.object({
+  /** The execution environment for agents */
+  executor: z.enum(["subprocess", "cloud", "noop"]).default("subprocess"),
+  /** Maximum execution time in milliseconds */
+  timeout: z.number().default(3e5),
+  /** Optional list of skill IDs pre-authorized for the agent */
+  skills: z.array(z.string()).optional()
+});
+var EntropyConfigSchema = z.object({
+  /** Patterns to exclude from entropy analysis */
+  excludePatterns: z.array(z.string()).default(["**/node_modules/**", "**/*.test.ts"]),
+  /** Whether to automatically attempt to fix simple entropy issues */
+  autoFix: z.boolean().default(false)
+});
+var PhaseGateMappingSchema = z.object({
+  /** Pattern for implementation files */
+  implPattern: z.string(),
+  /** Pattern for corresponding specification files */
+  specPattern: z.string()
+});
+var PhaseGatesConfigSchema = z.object({
+  /** Whether phase gate checks are enabled */
+  enabled: z.boolean().default(false),
+  /** Severity level when a phase gate check fails */
+  severity: z.enum(["error", "warning"]).default("error"),
+  /** List of implementation-to-spec mappings */
+  mappings: z.array(PhaseGateMappingSchema).default([{ implPattern: "src/**/*.ts", specPattern: "docs/changes/{feature}/proposal.md" }])
+});
+var SecurityConfigSchema = z.object({
+  /** Whether security scanning is enabled */
+  enabled: z.boolean().default(true),
+  /** Whether to fail on any security warning */
+  strict: z.boolean().default(false),
+  /** Rule-specific severity overrides */
+  rules: z.record(z.string(), z.enum(["off", "error", "warning", "info"])).optional(),
+  /** Patterns to exclude from security scans */
+  exclude: z.array(z.string()).optional()
+}).passthrough();
+var PerformanceConfigSchema = z.object({
+  /** Complexity thresholds per module or pattern */
+  complexity: z.record(z.unknown()).optional(),
+  /** Coupling limits between modules */
+  coupling: z.record(z.unknown()).optional(),
+  /** Size budget for bundles or directories */
+  sizeBudget: z.record(z.unknown()).optional()
+}).passthrough();
+var DesignConfigSchema = z.object({
+  /** Strictness of design system enforcement */
+  strictness: z.enum(["strict", "standard", "permissive"]).default("standard"),
+  /** Supported target platforms */
+  platforms: z.array(z.enum(["web", "mobile"])).default([]),
+  /** Path to design tokens (e.g. JSON or CSS) */
+  tokenPath: z.string().optional(),
+  /** Brief description of the intended aesthetic direction */
+  aestheticIntent: z.string().optional()
+});
+var I18nCoverageConfigSchema = z.object({
+  /** Minimum required translation percentage */
+  minimumPercent: z.number().min(0).max(100).default(100),
+  /** Whether plural forms are required for all keys */
+  requirePlurals: z.boolean().default(true),
+  /** Whether to detect untranslated strings in source code */
+  detectUntranslated: z.boolean().default(true)
+});
+var I18nMcpConfigSchema = z.object({
+  /** Name or URL of the MCP server */
+  server: z.string(),
+  /** Project ID on the remote i18n platform */
+  projectId: z.string().optional()
+});
+var I18nConfigSchema = z.object({
+  /** Whether i18n management is enabled */
+  enabled: z.boolean().default(false),
+  /** Strictness of i18n rule enforcement */
+  strictness: z.enum(["strict", "standard", "permissive"]).default("standard"),
+  /** The primary language used for development */
+  sourceLocale: z.string().default("en"),
+  /** List of locales that translations are required for */
+  targetLocales: z.array(z.string()).default([]),
+  /** The i18n framework in use */
+  framework: z.enum([
+    "auto",
+    "i18next",
+    "react-intl",
+    "vue-i18n",
+    "flutter-intl",
+    "apple",
+    "android",
+    "custom"
+  ]).default("auto"),
+  /** Storage format for translation files */
+  format: z.string().default("json"),
+  /** Syntax used for message formatting */
+  messageFormat: z.enum(["icu", "i18next", "custom"]).default("icu"),
+  /** Convention for translation keys */
+  keyConvention: z.enum(["dot-notation", "snake_case", "camelCase", "custom"]).default("dot-notation"),
+  /** Mapping of locales to their file paths */
+  translationPaths: z.record(z.string(), z.string()).optional(),
+  /** Platforms targeted by this configuration */
+  platforms: z.array(z.enum(["web", "mobile", "backend"])).default([]),
+  /** Industry vertical (for contextual translations) */
+  industry: z.string().optional(),
+  /** Translation coverage requirements */
+  coverage: I18nCoverageConfigSchema.optional(),
+  /** Locale used for pseudo-localization testing */
+  pseudoLocale: z.string().optional(),
+  /** MCP server for AI-assisted translation */
+  mcp: I18nMcpConfigSchema.optional()
+});
+var ModelTierConfigSchema = z.object({
+  /** Model ID to use for fast/cheap operations */
+  fast: z.string().optional(),
+  /** Model ID to use for standard reasoning tasks */
+  standard: z.string().optional(),
+  /** Model ID to use for complex/critical analysis */
+  strong: z.string().optional()
+});
+var ReviewConfigSchema = z.object({
+  /** Custom model tier mappings for reviewers */
+  model_tiers: ModelTierConfigSchema.optional()
+});
+var HarnessConfigSchema = z.object({
+  /** Configuration schema version */
+  version: z.literal(1),
+  /** Human-readable name of the project */
+  name: z.string().optional(),
+  /** Root directory of the project, relative to the config file */
+  rootDir: z.string().default("."),
+  /** Layered architecture definitions */
+  layers: z.array(LayerSchema).optional(),
+  /** Rules for forbidden cross-module imports */
+  forbiddenImports: z.array(ForbiddenImportSchema).optional(),
+  /** Boundary enforcement settings */
+  boundaries: BoundaryConfigSchema.optional(),
+  /** Path to the project's knowledge map (AGENTS.md) */
+  agentsMapPath: z.string().default("./AGENTS.md"),
+  /** Directory containing project documentation */
+  docsDir: z.string().default("./docs"),
+  /** Agent orchestration settings */
+  agent: AgentConfigSchema.optional(),
+  /** Drift and stale code management settings */
+  entropy: EntropyConfigSchema.optional(),
+  /** Security scanning configuration */
+  security: SecurityConfigSchema.optional(),
+  /** Performance and complexity budget settings */
+  performance: PerformanceConfigSchema.optional(),
+  /** Project template settings (used by 'harness init') */
+  template: z.object({
+    /** Complexity level of the template */
+    level: z.enum(["basic", "intermediate", "advanced"]),
+    /** Primary technology framework */
+    framework: z.string().optional(),
+    /** Template version */
+    version: z.number()
+  }).optional(),
+  /** Phase gate and readiness check configuration */
+  phaseGates: PhaseGatesConfigSchema.optional(),
+  /** Design system consistency settings */
+  design: DesignConfigSchema.optional(),
+  /** Internationalization (i18n) settings */
+  i18n: I18nConfigSchema.optional(),
+  /** Code review settings */
+  review: ReviewConfigSchema.optional(),
+  /** General architectural enforcement settings */
+  architecture: ArchConfigSchema.optional(),
+  /** How often (in ms) to check for CLI updates */
+  updateCheckInterval: z.number().int().min(0).optional()
+});
+
+// src/config/loader.ts
+var CONFIG_FILENAMES = ["harness.config.json"];
+function findConfigFile(startDir = process.cwd()) {
+  let currentDir = path.resolve(startDir);
+  const root = path.parse(currentDir).root;
+  while (currentDir !== root) {
+    for (const filename of CONFIG_FILENAMES) {
+      const configPath = path.join(currentDir, filename);
+      if (fs.existsSync(configPath)) {
+        return Ok(configPath);
+      }
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  return Err(
+    new CLIError('No harness.config.json found. Run "harness init" to create one.', ExitCode.ERROR)
+  );
+}
+function loadConfig(configPath) {
+  if (!fs.existsSync(configPath)) {
+    return Err(new CLIError(`Config file not found: ${configPath}`, ExitCode.ERROR));
+  }
+  let rawConfig;
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    rawConfig = JSON.parse(content);
+  } catch (error) {
+    return Err(
+      new CLIError(
+        `Failed to parse config: ${error instanceof Error ? error.message : "Unknown error"}`,
+        ExitCode.ERROR
+      )
+    );
+  }
+  const parsed = HarnessConfigSchema.safeParse(rawConfig);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+    return Err(new CLIError(`Invalid config:
+${issues}`, ExitCode.ERROR));
+  }
+  return Ok(parsed.data);
+}
+function resolveConfig(configPath) {
+  if (configPath) {
+    return loadConfig(configPath);
+  }
+  const findResult = findConfigFile();
+  if (!findResult.ok) {
+    return findResult;
+  }
+  return loadConfig(findResult.value);
+}
+
+// src/utils/files.ts
+import { glob } from "glob";
+async function findFiles(pattern, cwd = process.cwd()) {
+  return glob(pattern, { cwd, absolute: true });
+}
+
+// src/output/formatter.ts
+import chalk from "chalk";
+var OutputMode = {
+  /** Output as formatted JSON */
+  JSON: "json",
+  /** Output as human-readable text */
+  TEXT: "text",
+  /** Minimal output, only errors and successes */
+  QUIET: "quiet",
+  /** Full output with detailed context and suggestions */
+  VERBOSE: "verbose"
+};
+var OutputFormatter = class {
+  /**
+   * Creates a new OutputFormatter.
+   *
+   * @param mode - The output mode to use. Defaults to TEXT.
+   */
+  constructor(mode = OutputMode.TEXT) {
+    this.mode = mode;
+  }
+  /**
+   * Formats raw data for output.
+   *
+   * @param data - The data to format.
+   * @returns A string representation of the data based on the current mode.
+   */
+  format(data) {
+    if (this.mode === OutputMode.JSON) {
+      return JSON.stringify(data, null, 2);
+    }
+    return String(data);
+  }
+  /**
+   * Formats a validation result into a user-friendly string.
+   *
+   * @param result - The validation result to format.
+   * @returns A formatted string containing the validation status and any issues.
+   */
+  formatValidation(result) {
+    if (this.mode === OutputMode.JSON) {
+      return JSON.stringify(result, null, 2);
+    }
+    if (this.mode === OutputMode.QUIET) {
+      if (result.valid) return "";
+      return result.issues.map((i) => `${i.file ?? ""}: ${i.message}`).join("\n");
+    }
+    const lines = [];
+    if (result.valid) {
+      lines.push(chalk.green("v validation passed"));
+    } else {
+      lines.push(chalk.red(`x Validation failed (${result.issues.length} issues)`));
+      lines.push("");
+      for (const issue of result.issues) {
+        const location = issue.file ? issue.line ? `${issue.file}:${issue.line}` : issue.file : "unknown";
+        lines.push(`  ${chalk.yellow("*")} ${chalk.dim(location)}`);
+        lines.push(`    ${issue.message}`);
+        if (issue.suggestion && this.mode === OutputMode.VERBOSE) {
+          lines.push(`    ${chalk.dim("->")} ${issue.suggestion}`);
+        }
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Formats a summary line with a success/failure icon and label.
+   *
+   * @param label - The name of the field to summarize.
+   * @param value - The value to display.
+   * @param success - Whether the summary represents a success or failure state.
+   * @returns A formatted summary string, or an empty string in JSON or QUIET modes.
+   */
+  formatSummary(label, value, success) {
+    if (this.mode === OutputMode.JSON || this.mode === OutputMode.QUIET) {
+      return "";
+    }
+    const icon = success ? chalk.green("v") : chalk.red("x");
+    return `${icon} ${label}: ${value}`;
+  }
+};
+
+// src/commands/check-phase-gate.ts
+function resolveSpecPath(implFile, implPattern, specPattern, cwd) {
+  const relImpl = path2.relative(cwd, implFile).replace(/\\/g, "/");
+  const implBase = (implPattern.split("*")[0] ?? "").replace(/\/+$/, "");
+  const afterBase = relImpl.startsWith(implBase + "/") ? relImpl.slice(implBase.length + 1) : relImpl;
+  const segments = afterBase.split("/");
+  const firstSegment = segments[0] ?? "";
+  const feature = segments.length > 1 ? firstSegment : path2.basename(firstSegment, path2.extname(firstSegment));
+  const specRelative = specPattern.replace("{feature}", feature);
+  return path2.resolve(cwd, specRelative);
+}
+async function runCheckPhaseGate(options) {
+  const configResult = resolveConfig(options.configPath);
+  if (!configResult.ok) {
+    return configResult;
+  }
+  const config = configResult.value;
+  const cwd = options.cwd ?? (options.configPath ? path2.dirname(path2.resolve(options.configPath)) : process.cwd());
+  if (!config.phaseGates?.enabled) {
+    return Ok({
+      pass: true,
+      skipped: true,
+      missingSpecs: [],
+      checkedFiles: 0
+    });
+  }
+  const phaseGates = config.phaseGates;
+  const missingSpecs = [];
+  let checkedFiles = 0;
+  for (const mapping of phaseGates.mappings) {
+    const implFiles = await findFiles(mapping.implPattern, cwd);
+    for (const implFile of implFiles) {
+      checkedFiles++;
+      const expectedSpec = resolveSpecPath(implFile, mapping.implPattern, mapping.specPattern, cwd);
+      if (!fs2.existsSync(expectedSpec)) {
+        missingSpecs.push({
+          implFile: path2.relative(cwd, implFile).replace(/\\/g, "/"),
+          expectedSpec: path2.relative(cwd, expectedSpec).replace(/\\/g, "/")
+        });
+      }
+    }
+  }
+  const pass = missingSpecs.length === 0;
+  return Ok({
+    pass,
+    skipped: false,
+    severity: phaseGates.severity,
+    missingSpecs,
+    checkedFiles
+  });
+}
+function createCheckPhaseGateCommand() {
+  const command = new Command("check-phase-gate").description("Verify that implementation files have matching spec documents").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
+    const formatter = new OutputFormatter(mode);
+    const result = await runCheckPhaseGate({
+      configPath: globalOpts.config,
+      json: globalOpts.json,
+      verbose: globalOpts.verbose,
+      quiet: globalOpts.quiet
+    });
+    if (!result.ok) {
+      if (mode === OutputMode.JSON) {
+        console.log(JSON.stringify({ error: result.error.message }));
+      } else {
+        logger.error(result.error.message);
+      }
+      process.exit(result.error.exitCode);
+    }
+    const value = result.value;
+    if (value.skipped) {
+      if (mode === OutputMode.JSON) {
+        console.log(formatter.format(value));
+      } else if (mode !== OutputMode.QUIET) {
+        logger.dim("Phase gates not enabled, skipping.");
+      }
+      process.exit(ExitCode.SUCCESS);
+    }
+    const output = formatter.formatValidation({
+      valid: value.pass,
+      issues: value.missingSpecs.map((m) => ({
+        file: m.implFile,
+        message: `Missing spec: ${m.expectedSpec}`
+      }))
+    });
+    if (output) {
+      console.log(output);
+    }
+    const summary = formatter.formatSummary(
+      "Phase gate check",
+      `${value.checkedFiles} files checked, ${value.missingSpecs.length} missing specs`,
+      value.pass
+    );
+    if (summary) {
+      console.log(summary);
+    }
+    if (!value.pass && value.severity === "error") {
+      process.exit(ExitCode.VALIDATION_FAILED);
+    }
+    process.exit(ExitCode.SUCCESS);
+  });
+  return command;
+}
+
+export {
+  findConfigFile,
+  loadConfig,
+  resolveConfig,
+  OutputMode,
+  OutputFormatter,
+  findFiles,
+  runCheckPhaseGate,
+  createCheckPhaseGateCommand
+};