@harness-engineering/cli 1.13.0 → 1.14.0

package/dist/{chunk-L2KLU56K.js → chunk-AOZRDOIP.js}

@@ -1,9 +1,9 @@
 import {
   resolveSkillsDir
-} from "./chunk-HD4IBGLA.js";
+} from "./chunk-N5G5QMS3.js";
 import {
   SkillMetadataSchema
-} from "./chunk-VRFZWGMS.js";
+} from "./chunk-XYLGHKG6.js";
 
 // src/persona/skill-executor.ts
 import * as fs from "fs";

package/dist/{chunk-QPEH2QPG.js → chunk-DBSOCI3G.js}

@@ -264,6 +264,49 @@ async function validate(options) {
   }
   return { success: true, ruleCount: parseResult.data.rules.length };
 }
+function resolveOutputDir(options, configOutput) {
+  const configDir = path3.dirname(path3.resolve(options.configPath));
+  return options.outputDir ? path3.resolve(options.outputDir) : path3.resolve(configDir, configOutput);
+}
+async function prepareOutputDir(outputDir, clean) {
+  if (clean) {
+    try {
+      await fs3.rm(outputDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  await fs3.mkdir(outputDir, { recursive: true });
+}
+async function processRule(rule, templates, configDir, outputDir, configPath, dryRun, errors) {
+  const templateResult = await loadTemplate(rule.type, templates, configDir);
+  if (!templateResult.success) {
+    errors.push({ type: "template", error: templateResult.error, ruleName: rule.name });
+    return null;
+  }
+  const ruleResult = generateRule(rule, templateResult.source, outputDir, configPath);
+  if (!ruleResult.success) {
+    errors.push({ type: "render", error: ruleResult.error, ruleName: ruleResult.ruleName });
+    return null;
+  }
+  if (!dryRun) {
+    try {
+      await fs3.writeFile(ruleResult.rule.outputPath, ruleResult.rule.content, "utf-8");
+    } catch (err) {
+      errors.push({ type: "write", error: err, path: ruleResult.rule.outputPath });
+      return null;
+    }
+  }
+  return rule.name;
+}
+async function writeIndexFile(outputDir, generatedRules, errors) {
+  const indexContent = generateIndex(generatedRules);
+  const indexPath = path3.join(outputDir, "index.ts");
+  try {
+    await fs3.writeFile(indexPath, indexContent, "utf-8");
+  } catch (err) {
+    errors.push({ type: "write", error: err, path: indexPath });
+  }
+}
 async function generate(options) {
   const errors = [];
   const parseResult = await parseConfig(options.configPath);
@@ -271,69 +314,25 @@ async function generate(options) {
     return { success: false, errors: [{ type: "parse", error: parseResult.error }] };
   }
   const config = parseResult.data;
+  const outputDir = resolveOutputDir(options, config.output);
+  const dryRun = options.dryRun ?? false;
   const configDir = path3.dirname(path3.resolve(options.configPath));
-  const outputDir = options.outputDir ? path3.resolve(options.outputDir) : path3.resolve(configDir, config.output);
-  if (options.clean && !options.dryRun) {
-    try {
-      await fs3.rm(outputDir, { recursive: true, force: true });
-    } catch {
-    }
-  }
-  if (!options.dryRun) {
-    await fs3.mkdir(outputDir, { recursive: true });
+  if (!dryRun) {
+    await prepareOutputDir(outputDir, options.clean ?? false);
   }
   const generatedRules = [];
   for (const rule of config.rules) {
-    const templateResult = await loadTemplate(rule.type, config.templates, configDir);
-    if (!templateResult.success) {
-      errors.push({
-        type: "template",
-        error: templateResult.error,
-        ruleName: rule.name
-      });
-      continue;
-    }
-    const ruleResult = generateRule(rule, templateResult.source, outputDir, options.configPath);
-    if (!ruleResult.success) {
-      errors.push({
-        type: "render",
-        error: ruleResult.error,
-        ruleName: ruleResult.ruleName
-      });
-      continue;
-    }
-    if (!options.dryRun) {
-      try {
-        await fs3.writeFile(ruleResult.rule.outputPath, ruleResult.rule.content, "utf-8");
-      } catch (err) {
-        errors.push({
-          type: "write",
-          error: err,
-          path: ruleResult.rule.outputPath
-        });
-        continue;
-      }
-    }
-    generatedRules.push(rule.name);
+    const name = await processRule(rule, config.templates, configDir, outputDir, options.configPath, dryRun, errors);
+    if (name)
+      generatedRules.push(name);
   }
-  if (generatedRules.length > 0 && !options.dryRun) {
-    const indexContent = generateIndex(generatedRules);
-    const indexPath = path3.join(outputDir, "index.ts");
-    try {
-      await fs3.writeFile(indexPath, indexContent, "utf-8");
-    } catch (err) {
-      errors.push({ type: "write", error: err, path: indexPath });
-    }
+  if (generatedRules.length > 0 && !dryRun) {
+    await writeIndexFile(outputDir, generatedRules, errors);
   }
   if (errors.length > 0) {
     return { success: false, errors };
   }
-  return {
-    success: true,
-    rulesGenerated: generatedRules,
-    outputDir,
-    dryRun: options.dryRun ?? false
-  };
+  return { success: true, rulesGenerated: generatedRules, outputDir, dryRun };
 }
 
 export {

package/dist/{chunk-MHBMTPW7.js → chunk-ERS5EVUZ.js}

@@ -1,4 +1,12 @@
 // ../types/dist/index.mjs
+var SESSION_SECTION_NAMES = [
+  "terminology",
+  "decisions",
+  "constraints",
+  "risks",
+  "openQuestions",
+  "evidence"
+];
 function Ok(value) {
   return { ok: true, value };
 }
@@ -21,6 +29,7 @@ var STANDARD_COGNITIVE_MODES = [
 ];
 
 export {
+  SESSION_SECTION_NAMES,
   Ok,
   Err,
   isOk,

package/dist/{chunk-JSTQ3AWB.js → chunk-FIAPHX37.js}

@@ -4,7 +4,7 @@ import {
 import {
   Err,
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/persona/generators/runtime.ts
 function generateRuntime(persona) {

package/dist/{chunk-2YPZKGAG.js → chunk-FTMXDOR6.js}

@@ -15,7 +15,7 @@ function evictIfNeeded() {
   }
 }
 async function doLoadGraphStore(projectRoot) {
-  const { GraphStore } = await import("./dist-M6BQODWC.js");
+  const { GraphStore } = await import("./dist-B26DFXMP.js");
   const graphDir = path.join(projectRoot, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);

package/dist/{chunk-72GHBOL2.js → chunk-GZKSBLQL.js}

@@ -1,6 +1,6 @@
 import {
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/commands/validate-cross-check.ts
 import * as fs from "fs";

package/dist/{chunk-K6XAPGML.js → chunk-H7Y5CKTM.js}

@@ -1,7 +1,7 @@
 import {
   Err,
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/mcp/utils/config-resolver.ts
 import * as fs from "fs";

package/dist/{chunk-HD4IBGLA.js → chunk-N5G5QMS3.js}

@@ -69,6 +69,28 @@ function resolveCommunitySkillsDir(platform = "claude-code") {
   }
   return path.join(__dirname, "agents", "skills", "community", platform);
 }
+function resolveAllSkillsDirs(platform = "claude-code") {
+  const dirs = [];
+  const projectDir = resolveProjectSkillsDir();
+  if (projectDir) {
+    const platformDir = path.join(path.dirname(projectDir), platform);
+    if (fs.existsSync(platformDir)) {
+      dirs.push(platformDir);
+    }
+  }
+  const communityDir = resolveCommunitySkillsDir(platform);
+  if (fs.existsSync(communityDir)) {
+    dirs.push(communityDir);
+  }
+  const globalDir = resolveGlobalSkillsDir();
+  const globalPlatformDir = path.join(path.dirname(globalDir), platform);
+  if (fs.existsSync(globalPlatformDir)) {
+    if (!dirs.some((d) => path.resolve(d) === path.resolve(globalPlatformDir))) {
+      dirs.push(globalPlatformDir);
+    }
+  }
+  return dirs;
+}
 
 export {
   resolveTemplatesDir,
@@ -76,5 +98,6 @@ export {
   resolveSkillsDir,
   resolveProjectSkillsDir,
   resolveGlobalSkillsDir,
-  resolveCommunitySkillsDir
+  resolveCommunitySkillsDir,
+  resolveAllSkillsDirs
 };

package/dist/{chunk-LD3DKUK5.js → chunk-NLVUVUGD.js}

@@ -45,7 +45,7 @@ var runCodeReviewDefinition = {
 };
 async function handleRunCodeReview(input) {
   try {
-    const { parseDiff, runReviewPipeline } = await import("./dist-WF4C7A4A.js");
+    const { parseDiff, runReviewPipeline } = await import("./dist-HWXF2C3R.js");
     const parseResult = parseDiff(input.diff);
     if (!parseResult.ok) {
       return {

package/dist/{chunk-3KOLLWWE.js → chunk-O5OJVPL6.js}

@@ -1,22 +1,14 @@
-import {
-  logger
-} from "./chunk-EBJQ6N4M.js";
 import {
   CLIError,
   ExitCode
 } from "./chunk-3WGJMBKH.js";
 import {
   ArchConfigSchema
-} from "./chunk-KELT6K6M.js";
+} from "./chunk-ABQHQ6I5.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";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/config/loader.ts
 import * as fs from "fs";
@@ -192,12 +184,23 @@ var HarnessConfigSchema = z.object({
   performance: PerformanceConfigSchema.optional(),
   /** Project template settings (used by 'harness init') */
   template: z.object({
-    /** Complexity level of the template */
-    level: z.enum(["basic", "intermediate", "advanced"]),
+    /** Complexity level of the template (JS/TS only) */
+    level: z.enum(["basic", "intermediate", "advanced"]).optional(),
+    /** Target language */
+    language: z.enum(["typescript", "python", "go", "rust", "java"]).optional(),
     /** Primary technology framework */
     framework: z.string().optional(),
     /** Template version */
-    version: z.number()
+    version: z.number(),
+    /** Language-specific tooling configuration */
+    tooling: z.object({
+      packageManager: z.string().optional(),
+      linter: z.string().optional(),
+      formatter: z.string().optional(),
+      buildTool: z.string().optional(),
+      testRunner: z.string().optional(),
+      lockFile: z.string().optional()
+    }).optional()
   }).optional(),
   /** Phase gate and readiness check configuration */
   phaseGates: PhaseGatesConfigSchema.optional(),
@@ -209,6 +212,15 @@ var HarnessConfigSchema = z.object({
   review: ReviewConfigSchema.optional(),
   /** General architectural enforcement settings */
   architecture: ArchConfigSchema.optional(),
+  /** Skill loading, suggestion, and tier override settings */
+  skills: z.object({
+    /** Skills to always suggest in the dispatcher, regardless of scoring */
+    alwaysSuggest: z.array(z.string()).default([]),
+    /** Skills to never suggest in the dispatcher, even if they score highly */
+    neverSuggest: z.array(z.string()).default([]),
+    /** Override the tier of specific skills (e.g., promote a Tier 3 skill to Tier 2) */
+    tierOverrides: z.record(z.string(), z.number().int().min(1).max(3)).default({})
+  }).optional(),
   /** How often (in ms) to check for CLI updates */
   updateCheckInterval: z.number().int().min(0).optional()
 });
@@ -266,205 +278,8 @@ function resolveConfig(configPath) {
   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
+  resolveConfig
 };

package/dist/{chunk-NKDM3FMH.js → chunk-OD3S2NHN.js}

@@ -1,7 +1,7 @@
 import {
   Err,
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/persona/generators/agents-md.ts
 function formatTrigger(trigger) {

package/dist/{chunk-5VY23YK3.js → chunk-OSXBPAMK.js}

@@ -26,7 +26,7 @@ var runSecurityScanDefinition = {
 };
 async function handleRunSecurityScan(input) {
   try {
-    const core = await import("./dist-WF4C7A4A.js");
+    const core = await import("./dist-HWXF2C3R.js");
     const projectRoot = sanitizePath(input.path);
     let configData = {};
     try {
@@ -49,7 +49,7 @@ async function handleRunSecurityScan(input) {
     if (input.files && input.files.length > 0) {
       filesToScan = input.files.map((f) => path.resolve(projectRoot, f));
     } else {
-      const { globFiles } = await import("./glob-helper-5OHBUQAI.js");
+      const { globFiles } = await import("./glob-helper-R5FXNUPS.js");
       filesToScan = await globFiles(projectRoot, securityConfig.exclude);
     }
     const result = await scanner.scanFiles(filesToScan);

package/dist/{chunk-MACVXDZK.js → chunk-OXLLOSSR.js}

@@ -6,14 +6,14 @@ import {
 } from "./chunk-W6Y7ZW3Y.js";
 import {
   Ok
-} from "./chunk-MHBMTPW7.js";
+} from "./chunk-ERS5EVUZ.js";
 
 // src/mcp/tools/entropy.ts
 async function loadEntropyGraphOptions(projectPath) {
-  const { loadGraphStore } = await import("./graph-loader-KO4GJ5N2.js");
+  const { loadGraphStore } = await import("./graph-loader-2M2HXDQI.js");
   const store = await loadGraphStore(projectPath);
   if (!store) return void 0;
-  const { GraphEntropyAdapter } = await import("./dist-M6BQODWC.js");
+  const { GraphEntropyAdapter } = await import("./dist-B26DFXMP.js");
   const adapter = new GraphEntropyAdapter(store);
   const driftData = adapter.computeDriftData();
   const deadCodeData = adapter.computeDeadCodeData();
@@ -82,9 +82,48 @@ var detectEntropyDefinition = {
     required: ["path"]
   }
 };
+function summarizeDrift(drift) {
+  const driftIssues = (drift.drifts ?? []).map(
+    (d) => `Drift: ${d.type}${d.file ? ` in ${d.file}` : ""}`
+  );
+  return { issueCount: driftIssues.length, topIssues: driftIssues.slice(0, 3) };
+}
+function summarizeDeadCode(deadCode) {
+  const deadIssues = [
+    ...(deadCode.unusedImports ?? []).map(
+      (i) => `Unused import: ${i.specifiers.join(", ")} from ${i.source}`
+    ),
+    ...(deadCode.deadExports ?? []).map(
+      (e) => `Dead export: ${e.name} in ${e.file}`
+    ),
+    ...(deadCode.deadFiles ?? []).map((f) => `Dead file: ${f.path}`)
+  ];
+  return { issueCount: deadIssues.length, topIssues: deadIssues.slice(0, 3) };
+}
+function summarizePatterns(patterns) {
+  const patternIssues = (patterns.violations ?? []).map(
+    (v) => `${v.pattern}: ${v.file}`
+  );
+  return { issueCount: patternIssues.length, topIssues: patternIssues.slice(0, 3) };
+}
+function buildSummaryResponse(report) {
+  const summary = {};
+  if (report.drift) summary["drift"] = summarizeDrift(report.drift);
+  if (report.deadCode) summary["deadCode"] = summarizeDeadCode(report.deadCode);
+  if (report.patterns) summary["patterns"] = summarizePatterns(report.patterns);
+  const totalIssues = Object.values(summary).reduce((s, c) => s + c.issueCount, 0);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ mode: "summary", totalIssues, categories: summary })
+      }
+    ]
+  };
+}
 async function handleDetectEntropy(input) {
   try {
-    const { EntropyAnalyzer } = await import("./dist-WF4C7A4A.js");
+    const { EntropyAnalyzer } = await import("./dist-HWXF2C3R.js");
     const typeFilter = input.type ?? "all";
     const analyzer = new EntropyAnalyzer({
       rootDir: sanitizePath(input.path),
@@ -97,54 +136,13 @@ async function handleDetectEntropy(input) {
     const graphOptions = await loadEntropyGraphOptions(sanitizePath(input.path));
     const result = await analyzer.analyze(graphOptions);
     if (input.mode === "summary" && result.ok && !input.autoFix) {
-      const report2 = result.value;
-      const summary = {};
-      if (report2.drift) {
-        const driftIssues = (report2.drift.drifts ?? []).map(
-          (d) => `Drift: ${d.type}${d.file ? ` in ${d.file}` : ""}`
-        );
-        summary["drift"] = {
-          issueCount: driftIssues.length,
-          topIssues: driftIssues.slice(0, 3)
-        };
-      }
-      if (report2.deadCode) {
-        const deadIssues = [
-          ...(report2.deadCode.unusedImports ?? []).map(
-            (i) => `Unused import: ${i.specifiers.join(", ")} from ${i.source}`
-          ),
-          ...(report2.deadCode.deadExports ?? []).map((e) => `Dead export: ${e.name} in ${e.file}`),
-          ...(report2.deadCode.deadFiles ?? []).map((f) => `Dead file: ${f.path}`)
-        ];
-        summary["deadCode"] = {
-          issueCount: deadIssues.length,
-          topIssues: deadIssues.slice(0, 3)
-        };
-      }
-      if (report2.patterns) {
-        const patternIssues = (report2.patterns.violations ?? []).map(
-          (v) => `${v.pattern}: ${v.file}`
-        );
-        summary["patterns"] = {
-          issueCount: patternIssues.length,
-          topIssues: patternIssues.slice(0, 3)
-        };
-      }
-      const totalIssues = Object.values(summary).reduce((s, c) => s + c.issueCount, 0);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ mode: "summary", totalIssues, categories: summary })
-          }
-        ]
-      };
+      return buildSummaryResponse(result.value);
     }
     if (!input.autoFix) {
       return resultToMcpResponse(result);
     }
     if (!result.ok) return resultToMcpResponse(result);
-    const { createFixes, applyFixes, generateSuggestions } = await import("./dist-WF4C7A4A.js");
+    const { createFixes, applyFixes, generateSuggestions } = await import("./dist-HWXF2C3R.js");
     const report = result.value;
     const deadCode = report.deadCode;
     const fixTypesConfig = input.fixTypes ? { fixTypes: input.fixTypes } : void 0;