@living-architecture/riviere-cli 0.8.12 → 0.9.0

package/dist/bin.js

@@ -23541,13 +23541,6 @@ async function fileExists(path2) {
 }
 
 // src/platform/infra/cli-presentation/error-codes.ts
-var ExtractionFieldFailureError = class extends Error {
-  constructor(failedFields) {
-    const uniqueFields = [...new Set(failedFields)];
-    super(`Extraction failed for fields: ${uniqueFields.join(", ")}`);
-    this.name = "ExtractionFieldFailureError";
-  }
-};
 var ConfigValidationError = class extends Error {
   errorCode;
   constructor(code, message) {
@@ -25177,6 +25170,69 @@ Examples:
 // src/features/extract/entrypoint/extract.ts
 import { Command as Command21 } from "commander";
 
+// src/platform/infra/cli-presentation/exit-with-cli-error.ts
+function exitWithCliError(code, message, exitCode) {
+  console.log(JSON.stringify(formatError2(code, message)));
+  process.exit(exitCode);
+}
+
+// src/platform/infra/cli-presentation/extract-validator.ts
+function rejectMutuallyExclusive(flagA, flagB, aPresent, bPresent) {
+  if (aPresent && bPresent) {
+    throw new ConfigValidationError(
+      "VALIDATION_ERROR" /* ValidationError */,
+      `${flagA} and ${flagB} cannot be used together`
+    );
+  }
+}
+function validateMutualExclusions(options) {
+  rejectMutuallyExclusive(
+    "--components-only",
+    "--enrich",
+    options.componentsOnly === true,
+    options.enrich !== void 0
+  );
+  rejectMutuallyExclusive("--pr", "--files", options.pr === true, options.files !== void 0);
+  rejectMutuallyExclusive("--pr", "--enrich", options.pr === true, options.enrich !== void 0);
+  rejectMutuallyExclusive(
+    "--files",
+    "--enrich",
+    options.files !== void 0,
+    options.enrich !== void 0
+  );
+}
+function validateFormatOption(options) {
+  if (options.format !== void 0 && options.format !== "json" && options.format !== "markdown") {
+    throw new ConfigValidationError(
+      "VALIDATION_ERROR" /* ValidationError */,
+      `Invalid format '${options.format}'. Must be 'json' or 'markdown'.`
+    );
+  }
+  if (options.format === "markdown" && !options.pr && options.files === void 0) {
+    throw new ConfigValidationError(
+      "VALIDATION_ERROR" /* ValidationError */,
+      "--format markdown requires --pr or --files"
+    );
+  }
+}
+function validateFlagCombinations(options) {
+  validateMutualExclusions(options);
+  if (options.base !== void 0 && !options.pr) {
+    throw new ConfigValidationError(
+      "VALIDATION_ERROR" /* ValidationError */,
+      "--base can only be used with --pr"
+    );
+  }
+  validateFormatOption(options);
+}
+
+// src/features/extract/infra/persistence/extraction-project/extraction-project-repository.ts
+import {
+  posix as posix5,
+  resolve as resolve7
+} from "node:path";
+import { globSync as globSync2 } from "glob";
+
 // src/platform/infra/extraction-config/config-loader.ts
 import {
   dirname as dirname2,
@@ -29701,13 +29757,46 @@ ${formatValidationErrors2(validationResult.errors)}`
   };
 }
 
-// src/platform/infra/source-filtering/filter-source-files.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { resolve as resolve4 } from "node:path";
+// src/platform/infra/extraction-config/draft-component-loader.ts
+import {
+  existsSync as existsSync3,
+  readFileSync as readFileSync3
+} from "node:fs";
+var DraftComponentLoadError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DraftComponentLoadError";
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+};
+function isDraftComponentArray(value) {
+  if (!Array.isArray(value)) return false;
+  return value.every(
+    (item) => typeof item === "object" && item !== null && "type" in item && "name" in item && "domain" in item && "location" in item
+  );
+}
+function parseJsonFile(filePath) {
+  try {
+    return JSON.parse(readFileSync3(filePath, "utf-8"));
+  } catch {
+    throw new DraftComponentLoadError(`Enrich file contains invalid JSON: ${filePath}`);
+  }
+}
+function loadDraftComponentsFromFile(filePath) {
+  if (!existsSync3(filePath)) {
+    throw new DraftComponentLoadError(`Enrich file not found: ${filePath}`);
+  }
+  const parsed = parseJsonFile(filePath);
+  if (!isDraftComponentArray(parsed)) {
+    throw new DraftComponentLoadError(
+      `Enrich file does not contain valid draft components: ${filePath}`
+    );
+  }
+  return parsed;
+}
 
-// src/platform/infra/git/git-changed-files.ts
+// src/platform/infra/git/git-repository-info.ts
 import { execFileSync } from "node:child_process";
-import { resolve as resolve3 } from "node:path";
 
 // src/platform/infra/git/git-errors.ts
 var GitError = class extends Error {
@@ -29719,8 +29808,22 @@ var GitError = class extends Error {
     Error.captureStackTrace?.(this, this.constructor);
   }
 };
-function isGitError(error48) {
-  return error48 instanceof GitError;
+
+// src/platform/infra/git/git-repository-info.ts
+var RepositoryUrlParseError = class extends Error {
+  /* v8 ignore start -- @preserve: Error constructor; tested via integration */
+  constructor(url2) {
+    super(`Expected owner and repo in git URL, got ${url2}`);
+    this.name = "RepositoryUrlParseError";
+  }
+  /* v8 ignore stop */
+};
+function defaultGitExecutor(binary, args, cwd) {
+  return execFileSync(binary, args, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
 }
 function extractStderr(error48) {
   if (!Object.hasOwn(error48, "stderr")) {
@@ -29732,16 +29835,98 @@ function extractStderr(error48) {
   }
   return String(stderrValue);
 }
+function runGit(executor, gitBinary, cwd, args) {
+  try {
+    return executor(gitBinary, args, cwd);
+  } catch (error48) {
+    if (error48 instanceof Error && "code" in error48 && error48.code === "ENOENT") {
+      throw new GitError("GIT_NOT_FOUND", "Install git to detect repository information.");
+    }
+    if (error48 instanceof Error) {
+      const stderr = extractStderr(error48);
+      if (stderr.includes("not a git repository")) {
+        throw new GitError("NOT_A_REPOSITORY", "Run from within a git repository.");
+      }
+    }
+    throw error48;
+  }
+}
+function parseRepositoryUrl(url2) {
+  const sshRegex = /^git@[^:]+:([^/]+)\/(.+?)(?:\.git)?$/;
+  const sshMatch = sshRegex.exec(url2);
+  if (sshMatch) {
+    const [, owner, repo] = sshMatch;
+    if (!owner || !repo) {
+      throw new RepositoryUrlParseError(url2);
+    }
+    return {
+      name: `${owner}/${repo}`,
+      owner,
+      url: url2
+    };
+  }
+  const httpsRegex = /^https?:\/\/[^/]+\/([^/]+)\/(.+?)(?:\.git)?$/;
+  const httpsMatch = httpsRegex.exec(url2);
+  if (httpsMatch) {
+    const [, owner, repo] = httpsMatch;
+    if (!owner || !repo) {
+      throw new RepositoryUrlParseError(url2);
+    }
+    return {
+      name: `${owner}/${repo}`,
+      owner,
+      url: url2
+    };
+  }
+  return {
+    name: url2,
+    url: url2
+  };
+}
+function getRepositoryInfo(gitBinary = "git", cwd = process.cwd(), executor = defaultGitExecutor) {
+  try {
+    const url2 = runGit(executor, gitBinary, cwd, ["remote", "get-url", "origin"]);
+    return parseRepositoryUrl(url2);
+  } catch (error48) {
+    if (error48 instanceof GitError) throw error48;
+    if (error48 instanceof Error) {
+      const stderr = extractStderr(error48);
+      if (stderr.includes("No such remote")) {
+        throw new GitError("NO_REMOTE", 'No git remote named "origin" found.');
+      }
+    }
+    throw error48;
+  }
+}
+
+// src/platform/infra/source-filtering/filter-source-files.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { resolve as resolve4 } from "node:path";
 
 // src/platform/infra/git/git-changed-files.ts
-function defaultGitExecutor(binary, args, cwd) {
-  return execFileSync(binary, args, {
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { resolve as resolve3 } from "node:path";
+function extractStderr2(error48) {
+  if (!Object.hasOwn(error48, "stderr")) {
+    throw error48;
+  }
+  const stderrValue = Object.getOwnPropertyDescriptor(error48, "stderr")?.value;
+  if (!stderrValue) {
+    throw error48;
+  }
+  return String(stderrValue);
+}
+function isGitError(error48) {
+  return error48 instanceof GitError;
+}
+function defaultGitExecutor2(binary, args, cwd) {
+  return execFileSync2(binary, args, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
   }).trim();
 }
-function runGit(executor, gitBinary, cwd, args) {
+function runGit2(executor, gitBinary, cwd, args) {
   try {
     return executor(gitBinary, args, cwd);
   } catch (error48) {
@@ -29749,7 +29934,7 @@ function runGit(executor, gitBinary, cwd, args) {
       throw new GitError("GIT_NOT_FOUND", "Install git to use --pr flag.");
     }
     if (error48 instanceof Error) {
-      const stderr = extractStderr(error48);
+      const stderr = extractStderr2(error48);
       if (stderr.includes("not a git repository")) {
         throw new GitError("NOT_A_REPOSITORY", "Run from within a git repository.");
       }
@@ -29762,7 +29947,7 @@ function isTypeScriptFile(filePath) {
 }
 function isDetachedHead(executor, gitBinary, cwd) {
   try {
-    runGit(executor, gitBinary, cwd, ["symbolic-ref", "HEAD"]);
+    runGit2(executor, gitBinary, cwd, ["symbolic-ref", "HEAD"]);
     return false;
   } catch {
     return true;
@@ -29773,25 +29958,25 @@ function detectBaseBranch(executor, gitBinary, cwd, explicitBase) {
     return explicitBase;
   }
   try {
-    const ref = runGit(executor, gitBinary, cwd, ["symbolic-ref", "refs/remotes/origin/HEAD"]);
+    const ref = runGit2(executor, gitBinary, cwd, ["symbolic-ref", "refs/remotes/origin/HEAD"]);
     return ref.replace("refs/remotes/origin/", "");
   } catch {
     return "main";
   }
 }
 function getUntrackedTypeScriptFiles(executor, gitBinary, cwd) {
-  const output = runGit(executor, gitBinary, cwd, ["ls-files", "--others", "--exclude-standard"]);
+  const output = runGit2(executor, gitBinary, cwd, ["ls-files", "--others", "--exclude-standard"]);
   if (output === "") return [];
   return output.split("\n").filter(isTypeScriptFile);
 }
 function getStagedFiles(executor, gitBinary, cwd, base) {
-  const output = runGit(executor, gitBinary, cwd, ["diff", "--name-only", "--cached", base]);
+  const output = runGit2(executor, gitBinary, cwd, ["diff", "--name-only", "--cached", base]);
   if (output === "") return [];
   return output.split("\n").filter(isTypeScriptFile);
 }
 function getCommittedChangedFiles(executor, gitBinary, cwd, base) {
   try {
-    const output = runGit(executor, gitBinary, cwd, ["diff", "--name-only", `${base}...HEAD`]);
+    const output = runGit2(executor, gitBinary, cwd, ["diff", "--name-only", `${base}...HEAD`]);
     if (output === "") return [];
     return output.split("\n").filter(isTypeScriptFile);
   } catch (error48) {
@@ -29799,9 +29984,9 @@ function getCommittedChangedFiles(executor, gitBinary, cwd, base) {
     throw new GitError("BASE_BRANCH_NOT_FOUND", `Base branch '${base}' not found.`);
   }
 }
-function detectChangedTypeScriptFiles(cwd, options, executor = defaultGitExecutor) {
+function detectChangedTypeScriptFiles(cwd, options, executor = defaultGitExecutor2) {
   const gitBinary = "git";
-  runGit(executor, gitBinary, cwd, ["rev-parse", "--git-dir"]);
+  runGit2(executor, gitBinary, cwd, ["rev-parse", "--git-dir"]);
   const warnings = [];
   const detached = isDetachedHead(executor, gitBinary, cwd);
   const base = detached ? "HEAD~1" : detectBaseBranch(executor, gitBinary, cwd, options.base);
@@ -29847,7 +30032,7 @@ function filterSourceFiles(allSourceFiles, options) {
     }
   }
   if (options.files !== void 0) {
-    const missingFiles = options.files.filter((f) => !existsSync3(resolve4(f)));
+    const missingFiles = options.files.filter((f) => !existsSync4(resolve4(f)));
     if (missingFiles.length > 0) {
       throw new SourceFilterError("FILES_NOT_FOUND", `Files not found: ${missingFiles.join(", ")}`);
     }
@@ -29860,203 +30045,191 @@ function resolveFilteredSourceFiles(allSourceFiles, options) {
   return filterSourceFiles(allSourceFiles, options).files;
 }
 
-// src/platform/infra/cli-presentation/extract-validator.ts
-function rejectMutuallyExclusive(flagA, flagB, aPresent, bPresent) {
-  if (aPresent && bPresent) {
-    throw new ConfigValidationError(
-      "VALIDATION_ERROR" /* ValidationError */,
-      `${flagA} and ${flagB} cannot be used together`
+// src/features/extract/domain/extraction-project.ts
+import { posix as posix4 } from "node:path";
+var OrphanedDraftComponentError = class extends Error {
+  constructor(orphanedModules, knownModules) {
+    super(
+      `Draft components reference unknown modules: [${orphanedModules.join(", ")}]. Known modules: [${knownModules.join(", ")}]`
     );
+    this.name = "OrphanedDraftComponentError";
   }
-}
-function validateMutualExclusions(options) {
-  rejectMutuallyExclusive(
-    "--components-only",
-    "--enrich",
-    options.componentsOnly === true,
-    options.enrich !== void 0
-  );
-  rejectMutuallyExclusive("--pr", "--files", options.pr === true, options.files !== void 0);
-  rejectMutuallyExclusive("--pr", "--enrich", options.pr === true, options.enrich !== void 0);
-  rejectMutuallyExclusive(
-    "--files",
-    "--enrich",
-    options.files !== void 0,
-    options.enrich !== void 0
-  );
-}
-function validateFormatOption(options) {
-  if (options.format !== void 0 && options.format !== "json" && options.format !== "markdown") {
-    throw new ConfigValidationError(
-      "VALIDATION_ERROR" /* ValidationError */,
-      `Invalid format '${options.format}'. Must be 'json' or 'markdown'.`
+};
+var ExtractionProject = class {
+  constructor(configDir, moduleContexts, resolvedConfig, repositoryName, draftComponents = []) {
+    this.configDir = configDir;
+    this.moduleContexts = moduleContexts;
+    this.resolvedConfig = resolvedConfig;
+    this.repositoryName = repositoryName;
+    this.draftComponents = draftComponents;
+  }
+  extractDraftComponents(options) {
+    const draftComponents = this.moduleContexts.flatMap(
+      (moduleContext) => extractComponents(
+        moduleContext.project,
+        moduleContext.files,
+        this.resolvedConfig,
+        matchesGlob,
+        this.configDir
+      )
     );
+    if (!options.includeConnections) {
+      return {
+        kind: "draftOnly",
+        components: draftComponents
+      };
+    }
+    const enrichment = this.enrichDraftComponentValues(draftComponents, options.allowIncomplete);
+    if (enrichment.kind === "fieldFailure") {
+      return enrichment;
+    }
+    const connectionResult = this.detectConnections(enrichment.components, options.allowIncomplete);
+    return {
+      kind: "full",
+      components: enrichment.components,
+      failedFields: enrichment.failedFields,
+      links: connectionResult.links,
+      timings: connectionResult.timings
+    };
   }
-  if (options.format === "markdown" && !options.pr && options.files === void 0) {
-    throw new ConfigValidationError(
-      "VALIDATION_ERROR" /* ValidationError */,
-      "--format markdown requires --pr or --files"
+  enrichDraftComponents(options) {
+    if (!options.includeConnections) {
+      return {
+        kind: "draftOnly",
+        components: this.draftComponents
+      };
+    }
+    const enrichment = this.enrichDraftComponentValues(
+      this.draftComponents,
+      options.allowIncomplete
     );
+    if (enrichment.kind === "fieldFailure") {
+      return enrichment;
+    }
+    const connectionResult = this.detectConnections(enrichment.components, options.allowIncomplete);
+    return {
+      kind: "full",
+      components: enrichment.components,
+      failedFields: enrichment.failedFields,
+      links: connectionResult.links,
+      timings: connectionResult.timings
+    };
   }
-}
-function validateFlagCombinations(options) {
-  validateMutualExclusions(options);
-  if (options.base !== void 0 && !options.pr) {
-    throw new ConfigValidationError(
-      "VALIDATION_ERROR" /* ValidationError */,
-      "--base can only be used with --pr"
-    );
+  get moduleContextProjectNames() {
+    return this.moduleContexts.map((moduleContext) => moduleContext.module.name);
   }
-  validateFormatOption(options);
-}
-
-// src/platform/infra/extraction-config/draft-component-loader.ts
-import {
-  existsSync as existsSync4,
-  readFileSync as readFileSync3
-} from "node:fs";
-var DraftComponentLoadError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "DraftComponentLoadError";
-    Error.captureStackTrace?.(this, this.constructor);
-  }
-};
-function isDraftComponentArray(value) {
-  if (!Array.isArray(value)) return false;
-  return value.every(
-    (item) => typeof item === "object" && item !== null && "type" in item && "name" in item && "domain" in item && "location" in item
-  );
-}
-function parseJsonFile(filePath) {
-  try {
-    return JSON.parse(readFileSync3(filePath, "utf-8"));
-  } catch {
-    throw new DraftComponentLoadError(`Enrich file contains invalid JSON: ${filePath}`);
-  }
-}
-function loadDraftComponentsFromFile(filePath) {
-  if (!existsSync4(filePath)) {
-    throw new DraftComponentLoadError(`Enrich file not found: ${filePath}`);
-  }
-  const parsed = parseJsonFile(filePath);
-  if (!isDraftComponentArray(parsed)) {
-    throw new DraftComponentLoadError(
-      `Enrich file does not contain valid draft components: ${filePath}`
-    );
-  }
-  return parsed;
-}
-
-// src/platform/infra/git/git-repository-info.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
-var RepositoryUrlParseError = class extends Error {
-  /* v8 ignore start -- @preserve: Error constructor; tested via integration */
-  constructor(url2) {
-    super(`Expected owner and repo in git URL, got ${url2}`);
-    this.name = "RepositoryUrlParseError";
-  }
-  /* v8 ignore stop */
-};
-function defaultGitExecutor2(binary, args, cwd) {
-  return execFileSync2(binary, args, {
-    cwd,
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  }).trim();
-}
-function runGit2(executor, gitBinary, cwd, args) {
-  try {
-    return executor(gitBinary, args, cwd);
-  } catch (error48) {
-    if (error48 instanceof Error && "code" in error48 && error48.code === "ENOENT") {
-      throw new GitError("GIT_NOT_FOUND", "Install git to detect repository information.");
-    }
-    if (error48 instanceof Error) {
-      const stderr = extractStderr(error48);
-      if (stderr.includes("not a git repository")) {
-        throw new GitError("NOT_A_REPOSITORY", "Run from within a git repository.");
+  detectConnections(enrichedComponents, allowIncomplete) {
+    const links = [];
+    const timings = [];
+    for (const moduleContext of this.moduleContexts) {
+      const moduleComponents = enrichedComponents.filter(
+        (component) => component.domain === moduleContext.module.name
+      );
+      if (moduleComponents.length === 0) {
+        continue;
       }
+      const result = detectPerModuleConnections(
+        moduleContext.project,
+        moduleComponents,
+        {
+          allowIncomplete,
+          moduleGlobs: [posix4.join(moduleContext.module.path, moduleContext.module.glob)],
+          repository: this.repositoryName
+        },
+        matchesGlob
+      );
+      links.push(...result.links);
+      timings.push({
+        callGraphMs: result.timings.callGraphMs,
+        asyncDetectionMs: 0,
+        configurableMs: result.timings.configurableMs,
+        setupMs: result.timings.setupMs,
+        totalMs: result.timings.callGraphMs + result.timings.configurableMs + result.timings.setupMs
+      });
     }
-    throw error48;
-  }
-}
-function parseRepositoryUrl(url2) {
-  const sshRegex = /^git@[^:]+:([^/]+)\/(.+?)(?:\.git)?$/;
-  const sshMatch = sshRegex.exec(url2);
-  if (sshMatch) {
-    const [, owner, repo] = sshMatch;
-    if (!owner || !repo) {
-      throw new RepositoryUrlParseError(url2);
-    }
+    const crossResult = detectCrossModuleConnections(enrichedComponents, {
+      allowIncomplete,
+      repository: this.repositoryName
+    });
+    links.push(...crossResult.links);
+    timings.push({
+      callGraphMs: 0,
+      asyncDetectionMs: crossResult.timings.asyncDetectionMs,
+      configurableMs: 0,
+      setupMs: 0,
+      totalMs: crossResult.timings.asyncDetectionMs
+    });
     return {
-      name: `${owner}/${repo}`,
-      owner,
-      url: url2
+      links: deduplicateCrossStrategy(links),
+      timings
     };
   }
-  const httpsRegex = /^https?:\/\/[^/]+\/([^/]+)\/(.+?)(?:\.git)?$/;
-  const httpsMatch = httpsRegex.exec(url2);
-  if (httpsMatch) {
-    const [, owner, repo] = httpsMatch;
-    if (!owner || !repo) {
-      throw new RepositoryUrlParseError(url2);
+  enrichDraftComponentValues(draftComponents, allowIncomplete) {
+    const moduleNames = new Set(this.moduleContextProjectNames);
+    const draftsByModule = groupDraftsByModule(draftComponents);
+    assertAllDraftsMatchModules(draftsByModule, moduleNames);
+    const components = [];
+    const failedFieldSet = /* @__PURE__ */ new Set();
+    for (const moduleContext of this.moduleContexts) {
+      const moduleDrafts = draftsByModule.get(moduleContext.module.name) ?? [];
+      if (moduleDrafts.length === 0) {
+        continue;
+      }
+      const result = enrichComponents(
+        moduleDrafts,
+        this.resolvedConfig,
+        moduleContext.project,
+        matchesGlob,
+        this.configDir
+      );
+      components.push(...result.components);
+      for (const failure of result.failures) {
+        failedFieldSet.add(failure.field);
+      }
+    }
+    const failedFields = [...failedFieldSet];
+    if (failedFields.length > 0 && !allowIncomplete) {
+      return {
+        kind: "fieldFailure",
+        failedFields
+      };
     }
     return {
-      name: `${owner}/${repo}`,
-      owner,
-      url: url2
+      kind: "enriched",
+      components,
+      failedFields
     };
   }
-  return {
-    name: url2,
-    url: url2
-  };
+};
+function assertAllDraftsMatchModules(draftsByModule, moduleNames) {
+  const orphanedModules = [...draftsByModule.keys()].filter((name) => !moduleNames.has(name));
+  if (orphanedModules.length > 0) {
+    throw new OrphanedDraftComponentError(orphanedModules, [...moduleNames]);
+  }
 }
-function getRepositoryInfo(gitBinary = "git", cwd = process.cwd(), executor = defaultGitExecutor2) {
-  try {
-    const url2 = runGit2(executor, gitBinary, cwd, ["remote", "get-url", "origin"]);
-    return parseRepositoryUrl(url2);
-  } catch (error48) {
-    if (error48 instanceof GitError) throw error48;
-    if (error48 instanceof Error) {
-      const stderr = extractStderr(error48);
-      if (stderr.includes("No such remote")) {
-        throw new GitError("NO_REMOTE", 'No git remote named "origin" found.');
-      }
+function groupDraftsByModule(drafts) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const draft of drafts) {
+    const existing = grouped.get(draft.domain);
+    if (existing !== void 0) {
+      existing.push(draft);
+      continue;
     }
-    throw error48;
+    grouped.set(draft.domain, [draft]);
   }
+  return grouped;
 }
 
-// src/features/extract/infra/external-clients/create-module-contexts.ts
-import {
-  posix as posix4,
-  resolve as resolve7
-} from "node:path";
-import { globSync as globSync2 } from "glob";
-
-// src/features/extract/infra/external-clients/find-module-tsconfig-dir.ts
+// src/features/extract/infra/external-clients/create-configured-project.ts
 import { existsSync as existsSync5 } from "node:fs";
 import { resolve as resolve5 } from "node:path";
-function findModuleTsConfigDir(configDir, modulePath) {
-  const moduleTsConfigPath = resolve5(configDir, modulePath, "tsconfig.json");
-  if (existsSync5(moduleTsConfigPath)) {
-    return resolve5(configDir, modulePath);
-  }
-  return configDir;
-}
-
-// src/features/extract/infra/external-clients/create-configured-project.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { resolve as resolve6 } from "node:path";
 import { Project as Project2 } from "ts-morph";
 function createConfiguredProject(configDir, skipTsConfig) {
   if (skipTsConfig) {
     return new Project2();
   }
-  const tsConfigPath = resolve6(configDir, "tsconfig.json");
-  if (!existsSync6(tsConfigPath)) {
+  const tsConfigPath = resolve5(configDir, "tsconfig.json");
+  if (!existsSync5(tsConfigPath)) {
     return new Project2();
   }
   return new Project2({
@@ -30065,200 +30238,238 @@ function createConfiguredProject(configDir, skipTsConfig) {
   });
 }
 
-// src/features/extract/infra/external-clients/load-extraction-project.ts
-function loadExtractionProject(configDir, sourceFilePaths, skipTsConfig) {
-  const project = createConfiguredProject(configDir, skipTsConfig);
-  project.addSourceFilesAtPaths(sourceFilePaths);
-  return project;
+// src/features/extract/infra/external-clients/find-module-tsconfig-dir.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { resolve as resolve6 } from "node:path";
+function findModuleTsConfigDir(configDir, modulePath) {
+  const moduleTsConfigPath = resolve6(configDir, modulePath, "tsconfig.json");
+  if (existsSync6(moduleTsConfigPath)) {
+    return resolve6(configDir, modulePath);
+  }
+  return configDir;
 }
 
-// src/features/extract/infra/external-clients/create-module-contexts.ts
-function createModuleContexts(resolvedConfig, configDir, sourceFilePaths, skipTsConfig) {
-  const sourceFileSet = new Set(sourceFilePaths);
-  return resolvedConfig.modules.map((module) => {
-    const allModuleFiles = globSync2(posix4.join(module.path, module.glob), { cwd: configDir }).map(
-      (f) => resolve7(configDir, f)
+// src/features/extract/infra/persistence/extraction-project/extraction-project-repository.ts
+var ExtractionProjectRepository = class {
+  loadFromChangedProject(loadChangedProjectParams) {
+    const parsedConfigState = this.loadParsedConfigState(loadChangedProjectParams.configPath);
+    const sourceFilePaths = resolveFilteredSourceFiles(
+      this.resolveSourceFilePaths(parsedConfigState),
+      loadChangedProjectParams.baseBranch === void 0 ? { pr: true } : {
+        base: loadChangedProjectParams.baseBranch,
+        pr: true
+      }
     );
-    const moduleFiles = allModuleFiles.filter((f) => sourceFileSet.has(f));
-    const tsConfigDir = findModuleTsConfigDir(configDir, module.path);
-    const project = loadExtractionProject(tsConfigDir, moduleFiles, skipTsConfig);
-    return {
-      module,
-      files: moduleFiles,
-      project
-    };
+    return this.createExtractionProject(
+      parsedConfigState,
+      sourceFilePaths,
+      loadChangedProjectParams.useTsConfig
+    );
+  }
+  loadFromDraftEnrichment(draftEnrichmentParams) {
+    const parsedConfigState = this.loadParsedConfigState(draftEnrichmentParams.configPath);
+    return this.createExtractionProject(
+      parsedConfigState,
+      this.resolveSourceFilePaths(parsedConfigState),
+      draftEnrichmentParams.useTsConfig,
+      loadDraftComponentsFromFile(draftEnrichmentParams.draftComponentsPath)
+    );
+  }
+  loadFromFullProject(loadFullProjectParams) {
+    const parsedConfigState = this.loadParsedConfigState(loadFullProjectParams.configPath);
+    return this.createExtractionProject(
+      parsedConfigState,
+      this.resolveSourceFilePaths(parsedConfigState),
+      loadFullProjectParams.useTsConfig
+    );
+  }
+  loadFromSelectedFiles(selectedFilesProjectParams) {
+    const parsedConfigState = this.loadParsedConfigState(selectedFilesProjectParams.configPath);
+    const sourceFilePaths = resolveFilteredSourceFiles(
+      this.resolveSourceFilePaths(parsedConfigState),
+      { files: selectedFilesProjectParams.filePaths }
+    );
+    return this.createExtractionProject(
+      parsedConfigState,
+      sourceFilePaths,
+      selectedFilesProjectParams.useTsConfig
+    );
+  }
+  createExtractionProject(parsedConfigState, sourceFilePaths, useTsConfig, draftComponents = []) {
+    return new ExtractionProject(
+      parsedConfigState.configDir,
+      this.createModuleContexts(parsedConfigState, sourceFilePaths, useTsConfig),
+      parsedConfigState.resolvedConfig,
+      getRepositoryInfo().name,
+      draftComponents
+    );
+  }
+  createModuleContexts(parsedConfigState, sourceFilePaths, useTsConfig) {
+    const sourceFileSet = new Set(sourceFilePaths);
+    return parsedConfigState.resolvedConfig.modules.map((module) => {
+      const allModuleFiles = globSync2(posix5.join(module.path, module.glob), { cwd: parsedConfigState.configDir }).map((filePath) => resolve7(parsedConfigState.configDir, filePath));
+      const moduleFiles = allModuleFiles.filter((filePath) => sourceFileSet.has(filePath));
+      const moduleConfigDir = findModuleTsConfigDir(parsedConfigState.configDir, module.path);
+      const project = createConfiguredProject(moduleConfigDir, !useTsConfig);
+      project.addSourceFilesAtPaths(moduleFiles);
+      return {
+        files: moduleFiles,
+        module,
+        project
+      };
+    });
+  }
+  loadParsedConfigState(configPath) {
+    return loadAndValidateConfig(configPath);
+  }
+  resolveSourceFilePaths(parsedConfigState) {
+    return resolveSourceFiles(parsedConfigState.resolvedConfig, parsedConfigState.configDir);
+  }
+};
+
+// src/features/extract/commands/enrich-draft-components.ts
+function enrichDraftComponents(enrichDraftComponentsInput) {
+  const extractionProjectRepository = new ExtractionProjectRepository();
+  const extractionProject = extractionProjectRepository.loadFromDraftEnrichment({
+    configPath: enrichDraftComponentsInput.configPath,
+    draftComponentsPath: enrichDraftComponentsInput.draftComponentsPath,
+    useTsConfig: enrichDraftComponentsInput.useTsConfig
+  });
+  return extractionProject.enrichDraftComponents({
+    allowIncomplete: enrichDraftComponentsInput.allowIncomplete,
+    includeConnections: enrichDraftComponentsInput.includeConnections
   });
 }
 
-// src/features/extract/domain/extract-draft-components.ts
-function extractDraftComponents(moduleContexts, resolvedConfig, configDir) {
-  return moduleContexts.flatMap(
-    (ctx) => extractComponents(ctx.project, ctx.files, resolvedConfig, matchesGlob, configDir)
+// src/features/extract/commands/extract-draft-components.ts
+function extractDraftComponents(extractDraftComponentsInput) {
+  const extractionProjectRepository = new ExtractionProjectRepository();
+  const extractionProject = loadProjectFromInput(
+    extractionProjectRepository,
+    extractDraftComponentsInput
   );
+  return extractionProject.extractDraftComponents({
+    allowIncomplete: extractDraftComponentsInput.allowIncomplete,
+    includeConnections: extractDraftComponentsInput.includeConnections
+  });
 }
-
-// src/features/extract/domain/enrich-per-module.ts
-var OrphanedDraftComponentError = class extends Error {
-  constructor(orphanedModules, knownModules) {
-    super(
-      `Draft components reference unknown modules: [${orphanedModules.join(", ")}]. Known modules: [${knownModules.join(", ")}]`
-    );
-    this.name = "OrphanedDraftComponentError";
+function loadProjectFromInput(extractionProjectRepository, extractDraftComponentsInput) {
+  if (extractDraftComponentsInput.sourceMode === "pull-request") {
+    return extractionProjectRepository.loadFromChangedProject({
+      configPath: extractDraftComponentsInput.configPath,
+      ...extractDraftComponentsInput.baseBranch === void 0 ? {} : { baseBranch: extractDraftComponentsInput.baseBranch },
+      useTsConfig: extractDraftComponentsInput.useTsConfig
+    });
   }
-};
-function enrichPerModule(moduleContexts, draftComponents, resolvedConfig, configDir) {
-  const moduleNames = new Set(moduleContexts.map((ctx) => ctx.module.name));
-  const draftsByModule = groupDraftsByModule(draftComponents);
-  assertAllDraftsMatchModules(draftsByModule, moduleNames);
-  const components = [];
-  const failedFieldSet = /* @__PURE__ */ new Set();
-  for (const ctx of moduleContexts) {
-    const moduleDrafts = draftsByModule.get(ctx.module.name) ?? [];
-    if (moduleDrafts.length === 0) {
-      continue;
-    }
-    const result = enrichComponents(
-      moduleDrafts,
-      resolvedConfig,
-      ctx.project,
-      matchesGlob,
-      configDir
-    );
-    components.push(...result.components);
-    for (const f of result.failures) {
-      failedFieldSet.add(f.field);
-    }
+  if (extractDraftComponentsInput.sourceMode === "files") {
+    return extractionProjectRepository.loadFromSelectedFiles({
+      configPath: extractDraftComponentsInput.configPath,
+      filePaths: extractDraftComponentsInput.files ?? [],
+      useTsConfig: extractDraftComponentsInput.useTsConfig
+    });
   }
+  return extractionProjectRepository.loadFromFullProject({
+    configPath: extractDraftComponentsInput.configPath,
+    useTsConfig: extractDraftComponentsInput.useTsConfig
+  });
+}
+
+// src/features/extract/commands/create-extract-draft-components-input.ts
+function createExtractDraftComponentsInput(options) {
   return {
-    components,
-    failedFields: [...failedFieldSet]
+    allowIncomplete: options.allowIncomplete === true,
+    ...options.base === void 0 ? {} : { baseBranch: options.base },
+    configPath: options.config,
+    ...options.files === void 0 ? {} : { files: options.files },
+    includeConnections: !shouldStopAtDraftComponents(options),
+    ...options.output === void 0 ? {} : { output: options.output },
+    sourceMode: readSourceMode(options),
+    useTsConfig: options.tsConfig !== false
   };
 }
-function assertAllDraftsMatchModules(draftsByModule, moduleNames) {
-  const orphanedModules = [...draftsByModule.keys()].filter((name) => !moduleNames.has(name));
-  if (orphanedModules.length > 0) {
-    throw new OrphanedDraftComponentError(orphanedModules, [...moduleNames]);
-  }
+function shouldStopAtDraftComponents(options) {
+  return options.dryRun === true || options.format === "markdown" || options.componentsOnly === true;
 }
-function groupDraftsByModule(drafts) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const draft of drafts) {
-    const existing = grouped.get(draft.domain);
-    if (existing) {
-      existing.push(draft);
-    } else {
-      grouped.set(draft.domain, [draft]);
-    }
+function readSourceMode(options) {
+  if (options.pr === true) {
+    return "pull-request";
   }
-  return grouped;
+  return options.files === void 0 ? "all" : "files";
 }
 
-// src/features/extract/domain/detect-connections-per-module.ts
-import { posix as posix5 } from "node:path";
-function detectConnectionsPerModule(moduleContexts, enrichedComponents, repositoryName, allowIncomplete) {
-  const links = [];
-  const timings = [];
-  for (const ctx of moduleContexts) {
-    const moduleComponents = enrichedComponents.filter((c) => c.domain === ctx.module.name);
-    if (moduleComponents.length === 0) {
-      continue;
-    }
-    const result = detectPerModuleConnections(
-      ctx.project,
-      moduleComponents,
-      {
-        allowIncomplete,
-        moduleGlobs: [posix5.join(ctx.module.path, ctx.module.glob)],
-        repository: repositoryName
-      },
-      matchesGlob
-    );
-    links.push(...result.links);
-    timings.push({
-      callGraphMs: result.timings.callGraphMs,
-      asyncDetectionMs: 0,
-      configurableMs: result.timings.configurableMs,
-      setupMs: result.timings.setupMs,
-      totalMs: result.timings.callGraphMs + result.timings.configurableMs + result.timings.setupMs
-    });
-  }
-  const crossResult = detectCrossModuleConnections(enrichedComponents, {
-    allowIncomplete,
-    repository: repositoryName
-  });
-  links.push(...crossResult.links);
-  timings.push({
-    callGraphMs: 0,
-    asyncDetectionMs: crossResult.timings.asyncDetectionMs,
-    configurableMs: 0,
-    setupMs: 0,
-    totalMs: crossResult.timings.asyncDetectionMs
-  });
+// src/features/extract/commands/create-enrich-draft-components-input.ts
+function createEnrichDraftComponentsInput(options, enrichPath) {
   return {
-    links: deduplicateCrossStrategy(links),
-    timings
+    allowIncomplete: options.allowIncomplete === true,
+    configPath: options.config,
+    draftComponentsPath: enrichPath,
+    includeConnections: !shouldStopAtDraftComponents2(options),
+    ...options.output === void 0 ? {} : { output: options.output },
+    useTsConfig: options.tsConfig !== false
   };
 }
+function shouldStopAtDraftComponents2(options) {
+  return options.dryRun === true || options.format === "markdown" || options.componentsOnly === true;
+}
 
-// src/features/extract/commands/run-extraction.ts
-function runExtraction(options, resolvedConfig, configDir, sourceFilePaths) {
-  const skipTsConfig = options.tsConfig === false;
-  const moduleContexts = createModuleContexts(
-    resolvedConfig,
-    configDir,
-    sourceFilePaths,
-    skipTsConfig
-  );
-  const draftComponents = options.enrich === void 0 ? extractDraftComponents(moduleContexts, resolvedConfig, configDir) : loadDraftComponentsFromFile(options.enrich);
-  if (options.dryRun || options.format === "markdown" || options.componentsOnly) {
+// src/platform/infra/cli-presentation/categorize-components.ts
+function componentKey(component) {
+  return `${component.domain}:${component.type}:${component.name}`;
+}
+function toComponentSummary(component) {
+  return {
+    type: component.type,
+    name: component.name,
+    domain: component.domain
+  };
+}
+function categorizeComponents(current, baseline) {
+  if (baseline === void 0) {
     return {
-      kind: "draftOnly",
-      components: draftComponents
+      added: current.map(toComponentSummary),
+      modified: [],
+      removed: []
     };
   }
-  const allowIncomplete = options.allowIncomplete === true;
-  const enrichment = enrichPerModule(moduleContexts, draftComponents, resolvedConfig, configDir);
-  if (enrichment.failedFields.length > 0 && !allowIncomplete) {
-    throw new ExtractionFieldFailureError(enrichment.failedFields);
-  }
-  const repositoryInfo = getRepositoryInfo();
-  const connectionResult = detectConnectionsPerModule(
-    moduleContexts,
-    enrichment.components,
-    repositoryInfo.name,
-    allowIncomplete
-  );
+  const baselineKeys = new Set(baseline.map((c) => componentKey(c)));
+  const currentKeys = new Set(current.map((c) => componentKey(c)));
+  const added = current.filter((c) => !baselineKeys.has(componentKey(c))).map(toComponentSummary);
+  const removed = baseline.filter((c) => !currentKeys.has(componentKey(c))).map(toComponentSummary);
   return {
-    kind: "full",
-    components: enrichment.components,
-    links: connectionResult.links,
-    timings: connectionResult.timings,
-    failedFields: enrichment.failedFields
+    added,
+    modified: [],
+    removed
   };
 }
 
-// src/platform/infra/cli-presentation/format-pr-markdown.ts
-function formatComponentLine(component) {
-  return `- **${component.type}** \`${component.name}\` in \`${component.domain}\` domain`;
+// src/platform/infra/cli-presentation/format-extraction-stats.ts
+function countLinksByType(componentCount, links) {
+  const syncLinkCount = links.filter((l) => l.type === "sync").length;
+  const asyncLinkCount = links.filter((l) => l.type === "async").length;
+  const uncertainLinkCount = links.filter((l) => l._uncertain !== void 0).length;
+  return {
+    componentCount,
+    linkCount: links.length,
+    syncLinkCount,
+    asyncLinkCount,
+    uncertainLinkCount
+  };
 }
-function formatSection(title, components) {
-  const header = `### ${title} (${components.length})`;
-  if (components.length === 0) {
-    return `${header}
-None`;
+function formatSeconds(ms) {
+  return (ms / 1e3).toFixed(2) + "s";
+}
+function formatExtractionStats(stats) {
+  const lines = [`Components: ${stats.componentCount}`];
+  if (stats.linkCount !== void 0) {
+    lines.push(
+      `Links: ${stats.linkCount} (sync: ${stats.syncLinkCount}, async: ${stats.asyncLinkCount})`
+    );
+    lines.push(`Uncertain: ${stats.uncertainLinkCount}`);
   }
-  return `${header}
-${components.map(formatComponentLine).join("\n")}`;
+  return lines;
 }
-function formatPrMarkdown(categorized) {
-  const sections = [
-    formatSection("Added Components", categorized.added),
-    formatSection("Modified Components", categorized.modified),
-    formatSection("Removed Components", categorized.removed)
-  ];
-  return `## Architecture Changes
-
-${sections.join("\n\n")}`;
+function formatTimingLine(timings) {
+  return `Extraction completed in ${formatSeconds(timings.totalMs)} (call graph: ${formatSeconds(timings.callGraphMs)}, detection: ${formatSeconds(timings.asyncDetectionMs)}, setup: ${formatSeconds(timings.setupMs)})`;
 }
 
 // src/platform/infra/cli-presentation/extract-output-formatter.ts
@@ -30287,6 +30498,30 @@ function formatDryRunOutput(components) {
   return lines;
 }
 
+// src/platform/infra/cli-presentation/format-pr-markdown.ts
+function formatComponentLine(component) {
+  return `- **${component.type}** \`${component.name}\` in \`${component.domain}\` domain`;
+}
+function formatSection(title, components) {
+  const header = `### ${title} (${components.length})`;
+  if (components.length === 0) {
+    return `${header}
+None`;
+  }
+  return `${header}
+${components.map(formatComponentLine).join("\n")}`;
+}
+function formatPrMarkdown(categorized) {
+  const sections = [
+    formatSection("Added Components", categorized.added),
+    formatSection("Modified Components", categorized.modified),
+    formatSection("Removed Components", categorized.removed)
+  ];
+  return `## Architecture Changes
+
+${sections.join("\n\n")}`;
+}
+
 // src/platform/infra/cli-presentation/output-writer.ts
 import { writeFileSync } from "node:fs";
 function outputResult(data, options) {
@@ -30309,67 +30544,7 @@ function outputResult(data, options) {
   console.log(JSON.stringify(data));
 }
 
-// src/platform/infra/cli-presentation/format-extraction-stats.ts
-function countLinksByType(componentCount, links) {
-  const syncLinkCount = links.filter((l) => l.type === "sync").length;
-  const asyncLinkCount = links.filter((l) => l.type === "async").length;
-  const uncertainLinkCount = links.filter((l) => l._uncertain !== void 0).length;
-  return {
-    componentCount,
-    linkCount: links.length,
-    syncLinkCount,
-    asyncLinkCount,
-    uncertainLinkCount
-  };
-}
-function formatSeconds(ms) {
-  return (ms / 1e3).toFixed(2) + "s";
-}
-function formatExtractionStats(stats) {
-  const lines = [`Components: ${stats.componentCount}`];
-  if (stats.linkCount !== void 0) {
-    lines.push(
-      `Links: ${stats.linkCount} (sync: ${stats.syncLinkCount}, async: ${stats.asyncLinkCount})`
-    );
-    lines.push(`Uncertain: ${stats.uncertainLinkCount}`);
-  }
-  return lines;
-}
-function formatTimingLine(timings) {
-  return `Extraction completed in ${formatSeconds(timings.totalMs)} (call graph: ${formatSeconds(timings.callGraphMs)}, detection: ${formatSeconds(timings.asyncDetectionMs)}, setup: ${formatSeconds(timings.setupMs)})`;
-}
-
-// src/platform/infra/cli-presentation/categorize-components.ts
-function componentKey(component) {
-  return `${component.domain}:${component.type}:${component.name}`;
-}
-function toComponentSummary(component) {
-  return {
-    type: component.type,
-    name: component.name,
-    domain: component.domain
-  };
-}
-function categorizeComponents(current, baseline) {
-  if (baseline === void 0) {
-    return {
-      added: current.map(toComponentSummary),
-      modified: [],
-      removed: []
-    };
-  }
-  const baselineKeys = new Set(baseline.map((c) => componentKey(c)));
-  const currentKeys = new Set(current.map((c) => componentKey(c)));
-  const added = current.filter((c) => !baselineKeys.has(componentKey(c))).map(toComponentSummary);
-  const removed = baseline.filter((c) => !currentKeys.has(componentKey(c))).map(toComponentSummary);
-  return {
-    added,
-    modified: [],
-    removed
-  };
-}
-
-// src/features/extract/infra/mappers/present-extraction-result.ts
+// src/features/extract/infra/cli/output/present-extraction-result.ts
 function presentExtractionResult(result, options) {
   if (result.kind === "draftOnly") {
     presentDraftResult(result.components, options);
@@ -30390,7 +30565,7 @@ function presentDraftResult(components, options) {
     console.log(markdown);
     return;
   }
-  outputResult(formatSuccess(components), { output: options.output });
+  outputResult(formatSuccess(components), createOutputOptions(options.output));
 }
 function presentFullResult(result, options) {
   if (result.failedFields.length > 0) {
@@ -30412,21 +30587,25 @@ function presentFullResult(result, options) {
       components: result.components,
       links: result.links
     }),
-    { output: options.output }
+    createOutputOptions(options.output)
   );
 }
+function createOutputOptions(outputPath) {
+  return outputPath === void 0 ? {} : { output: outputPath };
+}
 
 // src/features/extract/entrypoint/extract.ts
 function createExtractCommand() {
   return new Command21("extract").description("Extract architectural components from source code").requiredOption("--config <path>", "Path to extraction config file").option("--dry-run", "Show component counts per domain without full output").option("-o, --output <file>", "Write output to file instead of stdout").option("--components-only", "Output only component identity (no metadata enrichment)").option("--enrich <file>", "Read draft components from file and enrich with extraction rules").option("--allow-incomplete", "Output components even when some extraction fields fail").option("--pr", "Extract from files changed in current branch vs base branch").option("--base <branch>", "Override base branch for --pr (default: auto-detect)").option("--files <paths...>", "Extract from specific files").option("--format <type>", "Output format: json (default) or markdown").option("--stats", "Show extraction statistics on stderr").option("--patterns", "Enable pattern-based connection detection").option("--no-ts-config", "Skip tsconfig.json auto-discovery (disables full type resolution)").action((options) => {
     validateFlagCombinations(options);
-    const {
-      resolvedConfig,
-      configDir
-    } = loadAndValidateConfig(options.config);
-    const allSourceFilePaths = resolveSourceFiles(resolvedConfig, configDir);
-    const sourceFilePaths = resolveFilteredSourceFiles(allSourceFilePaths, options);
-    const result = runExtraction(options, resolvedConfig, configDir, sourceFilePaths);
+    const result = options.enrich === void 0 ? extractDraftComponents(createExtractDraftComponentsInput(options)) : enrichDraftComponents(createEnrichDraftComponentsInput(options, options.enrich));
+    if (result.kind === "fieldFailure") {
+      exitWithCliError(
+        "VALIDATION_ERROR" /* ValidationError */,
+        `Extraction failed for fields: ${result.failedFields.join(", ")}`,
+        1 /* ExtractionFailure */
+      );
+    }
     presentExtractionResult(result, options);
   });
 }
@@ -30443,7 +30622,7 @@ function parsePackageJson(pkg) {
 }
 function loadPackageJson() {
   if (true) {
-    return { version: "0.8.11" };
+    return { version: "0.8.13" };
   }
   const require2 = createRequire2(import.meta.url);
   return parsePackageJson(require2("../../package.json"));
@@ -30484,10 +30663,6 @@ function handleGlobalError(error48) {
     console.log(JSON.stringify(formatError2(error48.errorCode, error48.message)));
     process.exit(2 /* ConfigValidation */);
   }
-  if (error48 instanceof ExtractionFieldFailureError) {
-    console.log(JSON.stringify(formatError2("VALIDATION_ERROR" /* ValidationError */, error48.message)));
-    process.exit(1 /* ExtractionFailure */);
-  }
   if (error48 instanceof GitError) {
     console.log(JSON.stringify(formatError2("VALIDATION_ERROR" /* ValidationError */, error48.message)));
     process.exit(3 /* RuntimeError */);
@@ -30540,9 +30715,9 @@ program.parseAsync().catch(handleGlobalError);
 /* v8 ignore next -- @preserve: yaml library always throws Error instances; defensive guard */
 /* v8 ignore next -- @preserve: error is always Error from yaml parser; defensive guard */
 /* v8 ignore start -- @preserve: default executor delegates to execFileSync; tested via CLI integration */
-/* v8 ignore start -- @preserve: detectChangedTypeScriptFiles only throws GitError; non-GitError path is unreachable */
-/* v8 ignore start -- @preserve: git execution; mocked in all integration tests */
+/* v8 ignore next -- @preserve: defensive optional chain; property existence guaranteed by hasOwn check above */
 /* v8 ignore start -- @preserve: defensive check; regex ([^/]+) requires non-empty groups */
+/* v8 ignore start -- @preserve: detectChangedTypeScriptFiles only throws GitError; non-GitError path is unreachable */
 /* v8 ignore start -- @preserve: trivial comparator, Map keys guarantee a !== b */
 /* v8 ignore start -- @preserve: dry-run output formatting; tested via CLI integration */
 /* v8 ignore start -- @preserve: dry-run tested via CLI integration */