@harness-engineering/cli 4.1.0 → 4.3.0

package/dist/{chunk-ABRYIEWJ.js → chunk-TDPQZAEE.js}

@@ -1,22 +1,22 @@
 import {
   generateRuntime
-} from "./chunk-N4AI2WFH.js";
+} from "./chunk-574JCBYH.js";
 import {
   generateAgentsMd
-} from "./chunk-VG4G3R2V.js";
+} from "./chunk-TKPAOB2T.js";
 import {
   generateCIWorkflow
-} from "./chunk-P4NA5OQX.js";
+} from "./chunk-GTHL3TRZ.js";
 import {
   readHarnessState
-} from "./chunk-YWRPQZL7.js";
+} from "./chunk-NEMB36N4.js";
 import {
   runCrossCheck
-} from "./chunk-GSYBGOY3.js";
+} from "./chunk-MIZQY35D.js";
 import {
   createGenerateAgentDefinitionsCommand,
   generateAgentDefinitions
-} from "./chunk-XZNCONFG.js";
+} from "./chunk-CMU4DNLY.js";
 import {
   toKebabCase
 } from "./chunk-KET4QQZB.js";
@@ -26,7 +26,7 @@ import {
 } from "./chunk-YYFSFSB3.js";
 import {
   TemplateEngine
-} from "./chunk-IGWJRAJT.js";
+} from "./chunk-6NEJPS7W.js";
 import {
   generate,
   validate
@@ -37,7 +37,7 @@ import {
 import {
   listPersonas,
   loadPersona
-} from "./chunk-NCMJXBEO.js";
+} from "./chunk-73QZ43DF.js";
 import {
   runPersona
 } from "./chunk-GISMXMVL.js";
@@ -51,7 +51,7 @@ import {
   OutputFormatter,
   OutputMode,
   createCheckPhaseGateCommand
-} from "./chunk-XW5XVVMI.js";
+} from "./chunk-LP764MGR.js";
 import {
   appendFrameworkAgents,
   captureHealthSnapshot,
@@ -79,7 +79,7 @@ import {
   runSecurityCraft,
   runSpecCraft,
   runTestCraft
-} from "./chunk-Z4XWWNYX.js";
+} from "./chunk-HSYU3RUW.js";
 import {
   VALID_PLATFORMS
 } from "./chunk-3ISINLYT.js";
@@ -108,7 +108,7 @@ import {
   BranchingConfigSchema,
   findConfigFile,
   resolveConfig
-} from "./chunk-Y5HPJMTM.js";
+} from "./chunk-LTYVAKWK.js";
 import {
   logger
 } from "./chunk-EBJQ6N4M.js";
@@ -225,7 +225,7 @@ import {
   writeConfig,
   writeLockfile,
   writeRegeneratedRoadmap
-} from "./chunk-UACYZCW4.js";
+} from "./chunk-CRHQYBDA.js";
 import {
   CLI_VERSION
 } from "./chunk-BM3PWGXQ.js";
@@ -238,14 +238,14 @@ import {
   detectDocDrift,
   generateSuggestions,
   validateDependencies
-} from "./chunk-YJYUJSWK.js";
+} from "./chunk-7RH2NTLA.js";
 import {
   Err,
   INDEXED_FILE_KINDS,
   INSIGHTS_KEYS,
   Ok,
   init_dist
-} from "./chunk-BDGTZRZ6.js";
+} from "./chunk-VJDSB7CI.js";
 import {
   DEFAULT_SKIP_DIRS,
   DesignConstraintAdapter,
@@ -434,6 +434,8 @@ function createAddCommand() {
 }
 
 // src/commands/adoption.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
 import { Command as Command2 } from "commander";
 function formatDuration(ms) {
   if (ms < 1e3) return `${ms}ms`;
@@ -451,7 +453,7 @@ function registerSkillsCommand(adoption) {
     const globalOpts = cmd.optsWithGlobals();
     const limit = Math.max(parseInt(opts.limit, 10) || 20, 1);
     const cwd = process.cwd();
-    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-MCTEX5QH.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-BWFFVKEW.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -487,7 +489,7 @@ function registerRecentCommand(adoption) {
     const globalOpts = cmd.optsWithGlobals();
     const limit = Math.max(parseInt(opts.limit, 10) || 20, 1);
     const cwd = process.cwd();
-    const { readAdoptionRecords } = await import("./dist-MCTEX5QH.js");
+    const { readAdoptionRecords } = await import("./dist-BWFFVKEW.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -565,7 +567,7 @@ function registerSkillCommand(adoption) {
   adoption.command("skill <name>").description("Show detail for a specific skill").action(async (name, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-MCTEX5QH.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-BWFFVKEW.js");
     const records = readAdoptionRecords(cwd);
     const skillRecords = records.filter((r) => r.skill === name);
     if (skillRecords.length === 0) {
@@ -584,11 +586,55 @@ function registerSkillCommand(adoption) {
     printSkillDetail(name, summary, phaseRates, skillRecords);
   });
 }
+function discoverCatalogSkills(projectRoot3) {
+  const skillsDir = path2.join(projectRoot3, "agents", "skills", "claude-code");
+  let entries;
+  try {
+    entries = fs2.readdirSync(skillsDir, { withFileTypes: true });
+  } catch {
+    return void 0;
+  }
+  const names = entries.filter((e) => e.isDirectory()).map((e) => e.name).filter((name) => fs2.existsSync(path2.join(skillsDir, name, "skill.yaml")));
+  return names.length > 0 ? names : void 0;
+}
+function registerRetrospectiveCommand(adoption) {
+  adoption.command("retrospective").description("Generate a catalog retrospective from adoption telemetry").option("--inactive-days <n>", "Inactivity threshold in days (default: 90)", "90").option("--top <n>", "Rows per ranked section (default: 10)", "10").option("--out <path>", "Output file path (default: docs/retrospectives/YYYY-MM-DD.md)").option("--no-write", "Print the report to stdout instead of writing a file").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const cwd = process.cwd();
+    const { readAdoptionRecords, getCatalogRetrospectiveReport, renderRetrospectiveMarkdown } = await import("./dist-BWFFVKEW.js");
+    const records = readAdoptionRecords(cwd);
+    const catalogSkills = discoverCatalogSkills(cwd);
+    const report = getCatalogRetrospectiveReport(records, {
+      inactiveDays: Math.max(parseInt(opts.inactiveDays, 10) || 90, 1),
+      topN: Math.max(parseInt(opts.top, 10) || 10, 1),
+      ...catalogSkills ? { catalogSkills } : {}
+    });
+    if (globalOpts.json) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    const markdown = renderRetrospectiveMarkdown(report);
+    if (opts.write === false) {
+      console.log(markdown);
+      return;
+    }
+    const date = report.generatedAt.slice(0, 10);
+    const outPath = opts.out ? path2.resolve(cwd, opts.out) : path2.join(cwd, "docs", "retrospectives", `${date}.md`);
+    fs2.mkdirSync(path2.dirname(outPath), { recursive: true });
+    fs2.writeFileSync(outPath, markdown, "utf-8");
+    const relPath = path2.relative(cwd, outPath).replaceAll("\\", "/");
+    logger.info(`Catalog retrospective written to ${relPath}`);
+    logger.info(
+      `${report.totalRecords} records \xB7 ${report.distinctSkills} skills \xB7 window ${report.windowDays}d`
+    );
+  });
+}
 function createAdoptionCommand() {
   const adoption = new Command2("adoption").description("View skill adoption telemetry").option("--json", "Output in JSON format");
   registerSkillsCommand(adoption);
   registerRecentCommand(adoption);
   registerSkillCommand(adoption);
+  registerRetrospectiveCommand(adoption);
   return adoption;
 }
 
@@ -599,7 +645,7 @@ import { Command as Command5 } from "commander";
 init_dist3();
 init_dist3();
 import { Command as Command3 } from "commander";
-import * as path2 from "path";
+import * as path3 from "path";
 import * as childProcess from "child_process";
 async function runAgentTask(task, options) {
   const configResult = resolveConfig(options.configPath);
@@ -671,7 +717,7 @@ function createCommandExecutor() {
 }
 async function runPersonaMode(opts, quiet) {
   const personasDir = resolvePersonasDir();
-  const filePath = path2.join(personasDir, `${opts.persona}.yaml`);
+  const filePath = path3.join(personasDir, `${opts.persona}.yaml`);
   const personaResult = loadPersona(filePath);
   if (!personaResult.ok) {
     logger.error(personaResult.error.message);
@@ -982,8 +1028,8 @@ function outcomeIcon(kind) {
 // src/commands/audit-protected.ts
 init_dist3();
 import { Command as Command7 } from "commander";
-import * as path3 from "path";
-import * as fs2 from "fs";
+import * as path4 from "path";
+import * as fs3 from "fs";
 import { glob } from "glob";
 async function runAuditProtected(options) {
   const cwd = options.cwd ?? process.cwd();
@@ -992,7 +1038,7 @@ async function runAuditProtected(options) {
     return Err(configResult.error);
   }
   const config = configResult.value;
-  const rootDir = path3.resolve(cwd, config.rootDir);
+  const rootDir = path4.resolve(cwd, config.rootDir);
   const excludePatterns = config.entropy?.excludePatterns ?? ["**/node_modules/**", "**/*.test.ts"];
   let files;
   try {
@@ -1006,10 +1052,10 @@ async function runAuditProtected(options) {
   const allRegions = [];
   const allIssues = [];
   for (const relativePath of files) {
-    const absolutePath = path3.resolve(rootDir, relativePath);
+    const absolutePath = path4.resolve(rootDir, relativePath);
     let content;
     try {
-      content = fs2.readFileSync(absolutePath, "utf-8");
+      content = fs3.readFileSync(absolutePath, "utf-8");
     } catch {
       continue;
     }
@@ -1079,41 +1125,41 @@ function createAuditProtectedCommand() {
 
 // src/commands/backfill-skill-provenance.ts
 import { Command as Command8 } from "commander";
-import * as fs3 from "fs";
-import * as path4 from "path";
+import * as fs4 from "fs";
+import * as path5 from "path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 function listSkillYamlFiles(skillsRoot) {
   const out = [];
   let hosts;
   try {
-    hosts = fs3.readdirSync(skillsRoot);
+    hosts = fs4.readdirSync(skillsRoot);
   } catch {
     return out;
   }
   for (const host of hosts) {
-    const hostDir = path4.join(skillsRoot, host);
+    const hostDir = path5.join(skillsRoot, host);
     let stat;
     try {
-      stat = fs3.statSync(hostDir);
+      stat = fs4.statSync(hostDir);
     } catch {
       continue;
     }
     if (!stat.isDirectory()) continue;
     let skills;
     try {
-      skills = fs3.readdirSync(hostDir);
+      skills = fs4.readdirSync(hostDir);
     } catch {
       continue;
     }
     for (const skill of skills) {
-      const skillDir = path4.join(hostDir, skill);
+      const skillDir = path5.join(hostDir, skill);
       try {
-        if (!fs3.statSync(skillDir).isDirectory()) continue;
+        if (!fs4.statSync(skillDir).isDirectory()) continue;
       } catch {
         continue;
       }
-      const yamlFile = path4.join(skillDir, "skill.yaml");
-      if (fs3.existsSync(yamlFile)) out.push(yamlFile);
+      const yamlFile = path5.join(skillDir, "skill.yaml");
+      if (fs4.existsSync(yamlFile)) out.push(yamlFile);
     }
   }
   return out;
@@ -1121,7 +1167,7 @@ function listSkillYamlFiles(skillsRoot) {
 function backfillFile(yamlFile) {
   let raw;
   try {
-    raw = fs3.readFileSync(yamlFile, "utf-8");
+    raw = fs4.readFileSync(yamlFile, "utf-8");
   } catch (err) {
     return { error: err instanceof Error ? err.message : String(err) };
   }
@@ -1139,11 +1185,11 @@ function backfillFile(yamlFile) {
     return "skipped";
   }
   obj["provenance"] = "user-authored";
-  fs3.writeFileSync(yamlFile, stringifyYaml(obj));
+  fs4.writeFileSync(yamlFile, stringifyYaml(obj));
   return "updated";
 }
-function runBackfillSkillProvenance(projectRoot2) {
-  const skillsRoot = path4.join(projectRoot2, "agents", "skills");
+function runBackfillSkillProvenance(projectRoot3) {
+  const skillsRoot = path5.join(projectRoot3, "agents", "skills");
   const files = listSkillYamlFiles(skillsRoot);
   const result = {
     scanned: files.length,
@@ -1179,19 +1225,19 @@ function createBackfillSkillProvenanceCommand() {
 // src/commands/blueprint.ts
 init_dist3();
 import { Command as Command9 } from "commander";
-import * as path5 from "path";
+import * as path6 from "path";
 function createBlueprintCommand() {
   return new Command9("blueprint").description("Generate a self-contained, interactive blueprint of the codebase").argument("[path]", "Path to the project root", ".").option("-o, --output <dir>", "Output directory", "docs/blueprint").action(async (projectPath, options) => {
     try {
-      const rootDir = path5.resolve(projectPath);
-      const outputDir = path5.resolve(options.output);
+      const rootDir = path6.resolve(projectPath);
+      const outputDir = path6.resolve(options.output);
       logger.info(`Scanning project at ${rootDir}...`);
       const scanner = new ProjectScanner(rootDir);
       const data = await scanner.scan();
       logger.info(`Generating blueprint to ${outputDir}...`);
       const generator = new BlueprintGenerator();
       await generator.generate(data, { outputDir });
-      logger.success(`Blueprint generated successfully at ${path5.join(outputDir, "index.html")}`);
+      logger.success(`Blueprint generated successfully at ${path6.join(outputDir, "index.html")}`);
     } catch (error) {
       logger.error(
         `Failed to generate blueprint: ${error instanceof Error ? error.message : String(error)}`
@@ -1373,7 +1419,7 @@ function createCheckArchCommand() {
 init_dist3();
 init_dist3();
 import { Command as Command11 } from "commander";
-import * as path6 from "path";
+import * as path7 from "path";
 async function runCheckDeps(options) {
   const cwd = options.cwd ?? process.cwd();
   const configResult = resolveConfig(options.configPath);
@@ -1389,7 +1435,7 @@ async function runCheckDeps(options) {
   if (!config.layers || config.layers.length === 0) {
     return Ok(result);
   }
-  const rootDir = path6.resolve(cwd, config.rootDir);
+  const rootDir = path7.resolve(cwd, config.rootDir);
   const parser = new TypeScriptParser();
   const layers = config.layers.map((l) => defineLayer(l.name, [l.pattern], l.allowedDependencies));
   const layerConfig = {
@@ -1703,9 +1749,9 @@ ${name} (${count} finding${count === 1 ? "" : "s"})`);
 }
 function printAnatomyFindings(findings, verbose) {
   const byFile = groupByFile(findings, (f) => f.file);
-  for (const [file, fs50] of byFile) {
+  for (const [file, fs51] of byFile) {
     console.log(`  ${file}`);
-    for (const f of fs50) {
+    for (const f of fs51) {
       const line = f.line !== null && f.line !== void 0 ? `:${f.line}` : "";
       console.log(`    ${f.code} [${f.severity}]    line${line}: ${f.message}`);
       if (verbose) {
@@ -1716,9 +1762,9 @@ function printAnatomyFindings(findings, verbose) {
 }
 function printCraftFindings(findings, verbose) {
   const byFile = groupByFile(findings, (f) => f.target.file);
-  for (const [file, fs50] of byFile) {
+  for (const [file, fs51] of byFile) {
     console.log(`  ${file}`);
-    for (const f of fs50) {
+    for (const f of fs51) {
       const line = f.target.line !== void 0 ? `:${f.target.line}` : "";
       const sev = craftTierToSeverity(f.tier);
       console.log(
@@ -1732,9 +1778,9 @@ function printCraftFindings(findings, verbose) {
 }
 function printDriftFindings(findings, verbose) {
   const byFile = groupByFile(findings, (f) => f.file);
-  for (const [file, fs50] of byFile) {
+  for (const [file, fs51] of byFile) {
     console.log(`  ${file}`);
-    for (const f of fs50) {
+    for (const f of fs51) {
       const line = f.line !== null && f.line !== void 0 ? `:${f.line}` : "";
       console.log(`    ${f.code} [${f.severity}]    line${line}: ${f.message}`);
       if (verbose) {
@@ -1745,9 +1791,9 @@ function printDriftFindings(findings, verbose) {
 }
 function printBrandFindings(findings, verbose) {
   const byFile = groupByFile(findings, (f) => f.file);
-  for (const [file, fs50] of byFile) {
+  for (const [file, fs51] of byFile) {
     console.log(`  ${file}`);
-    for (const f of fs50) {
+    for (const f of fs51) {
       const line = f.line !== null && f.line !== void 0 ? `:${f.line}` : "";
       console.log(`    ${f.code} [${f.severity}]    line${line}: ${f.message}`);
       if (verbose) {
@@ -1810,7 +1856,7 @@ function createCheckDesignCommand() {
 init_dist3();
 init_dist3();
 import { Command as Command13 } from "commander";
-import * as path7 from "path";
+import * as path8 from "path";
 async function runCheckDocs(options) {
   const cwd = options.cwd ?? process.cwd();
   const minCoverage = options.minCoverage ?? 80;
@@ -1819,8 +1865,8 @@ async function runCheckDocs(options) {
     return configResult;
   }
   const config = configResult.value;
-  const docsDir = path7.resolve(cwd, config.docsDir);
-  const sourceDir = path7.resolve(cwd, config.rootDir);
+  const docsDir = path8.resolve(cwd, config.docsDir);
+  const sourceDir = path8.resolve(cwd, config.rootDir);
   const coverageResult = await checkDocCoverage("project", {
     docsDir,
     sourceDir,
@@ -1919,12 +1965,12 @@ function createCheckDocsCommand() {
 // src/commands/check-harness-strength.ts
 init_dist3();
 import { Command as Command14 } from "commander";
-import * as path8 from "path";
+import * as path9 from "path";
 var SEVERITY_RANK = { error: 3, warning: 2, info: 1 };
 function runCheckHarnessStrength(cwd, options) {
-  const projectRoot2 = path8.resolve(cwd);
+  const projectRoot3 = path9.resolve(cwd);
   const auditor = new HarnessStrengthAuditor();
-  const result = auditor.audit(projectRoot2, options.mode ? { mode: options.mode } : {});
+  const result = auditor.audit(projectRoot3, options.mode ? { mode: options.mode } : {});
   if (!result.ok) return result;
   const audit = result.value;
   const threshold = options.severity ?? "warning";
@@ -1995,7 +2041,7 @@ function createCheckHarnessStrengthCommand() {
 // src/commands/check-perf.ts
 init_dist3();
 import { Command as Command15 } from "commander";
-import * as path9 from "path";
+import * as path10 from "path";
 function resolveConfiguredEntryPoints(configPath) {
   const configResult = resolveConfig(configPath);
   if (!configResult.ok) return void 0;
@@ -2012,7 +2058,7 @@ async function runCheckPerf(cwd, options) {
   const runAll2 = !options.structural && !options.size && !options.coupling;
   const entryPoints = resolveConfiguredEntryPoints(options.configPath);
   const analyzer = new EntropyAnalyzer({
-    rootDir: path9.resolve(cwd),
+    rootDir: path10.resolve(cwd),
     ...entryPoints && { entryPoints },
     analyze: {
       complexity: runAll2 || !!options.structural,
@@ -2134,7 +2180,7 @@ function createCheckPerfCommand() {
 // src/commands/check-security.ts
 init_dist3();
 import { Command as Command16 } from "commander";
-import * as path10 from "path";
+import * as path11 from "path";
 import { execSync as execSync3 } from "child_process";
 var SEVERITY_RANK2 = {
   error: 3,
@@ -2147,19 +2193,19 @@ function getChangedFiles(cwd) {
       cwd,
       encoding: "utf-8"
     });
-    return output.trim().split("\n").filter((f) => f.length > 0).map((f) => path10.resolve(cwd, f));
+    return output.trim().split("\n").filter((f) => f.length > 0).map((f) => path11.resolve(cwd, f));
   } catch {
     return [];
   }
 }
 async function runCheckSecurity(cwd, options) {
-  const projectRoot2 = path10.resolve(cwd);
+  const projectRoot3 = path11.resolve(cwd);
   let configData = {};
   try {
-    const fs50 = await import("fs");
-    const configPath = path10.join(projectRoot2, "harness.config.json");
-    if (fs50.existsSync(configPath)) {
-      const raw = fs50.readFileSync(configPath, "utf-8");
+    const fs51 = await import("fs");
+    const configPath = path11.join(projectRoot3, "harness.config.json");
+    if (fs51.existsSync(configPath)) {
+      const raw = fs51.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       configData = parsed.security ?? {};
     }
@@ -2167,10 +2213,10 @@ async function runCheckSecurity(cwd, options) {
   }
   const securityConfig = parseSecurityConfig(configData);
   const scanner = new SecurityScanner(securityConfig);
-  scanner.configureForProject(projectRoot2);
+  scanner.configureForProject(projectRoot3);
   let filesToScan;
   if (options.changedOnly) {
-    filesToScan = getChangedFiles(projectRoot2);
+    filesToScan = getChangedFiles(projectRoot3);
   } else {
     const { glob: glob2 } = await import("glob");
     const pattern = "**/*.{ts,tsx,js,jsx,go,py,java,rb}";
@@ -2180,15 +2226,15 @@ async function runCheckSecurity(cwd, options) {
       "**/*.test.ts",
       "**/fixtures/**"
     ];
-    filesToScan = await glob2(pattern, { cwd: projectRoot2, absolute: true, ignore });
+    filesToScan = await glob2(pattern, { cwd: projectRoot3, absolute: true, ignore });
   }
   const result = await scanner.scanFiles(filesToScan);
   try {
     const commitHash = execSync3("git rev-parse HEAD", {
-      cwd: projectRoot2,
+      cwd: projectRoot3,
       encoding: "utf-8"
     }).trim();
-    const timelineManager = new SecurityTimelineManager(projectRoot2);
+    const timelineManager = new SecurityTimelineManager(projectRoot3);
     timelineManager.capture(result, commitHash);
     timelineManager.updateLifecycles(result.findings, commitHash);
   } catch {
@@ -2353,8 +2399,8 @@ function createCheckCommand() {
 // src/commands/ci/init.ts
 init_dist3();
 import { Command as Command18 } from "commander";
-import * as fs4 from "fs";
-import * as path11 from "path";
+import * as fs5 from "fs";
+import * as path12 from "path";
 var ALL_CHECKS = [
   "validate",
   "deps",
@@ -2525,17 +2571,17 @@ function generateCIConfig(options) {
   });
 }
 function detectPlatform() {
-  if (fs4.existsSync(".github")) return "github";
-  if (fs4.existsSync(".gitlab-ci.yml")) return "gitlab";
+  if (fs5.existsSync(".github")) return "github";
+  if (fs5.existsSync(".gitlab-ci.yml")) return "gitlab";
   return null;
 }
 function writeGeneratedConfig(filename, content, platform) {
-  const targetPath = path11.resolve(filename);
-  const dir = path11.dirname(targetPath);
-  fs4.mkdirSync(dir, { recursive: true });
-  fs4.writeFileSync(targetPath, content);
+  const targetPath = path12.resolve(filename);
+  const dir = path12.dirname(targetPath);
+  fs5.mkdirSync(dir, { recursive: true });
+  fs5.writeFileSync(targetPath, content);
   if (platform === "generic" && process.platform !== "win32") {
-    fs4.chmodSync(targetPath, "755");
+    fs5.chmodSync(targetPath, "755");
   }
 }
 async function runInitAction(opts, globalOpts) {
@@ -2567,10 +2613,10 @@ function createInitCommand() {
 // src/commands/ci/notify.ts
 init_dist3();
 import { Command as Command19 } from "commander";
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 function loadReport(reportPath) {
   try {
-    const raw = fs5.readFileSync(reportPath, "utf-8");
+    const raw = fs6.readFileSync(reportPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -2680,7 +2726,7 @@ function createCICommand() {
 // src/commands/cleanup.ts
 init_dist3();
 import { Command as Command21 } from "commander";
-import * as path12 from "path";
+import * as path13 from "path";
 async function runCleanup(options) {
   const cwd = options.cwd ?? process.cwd();
   const type = options.type ?? "all";
@@ -2695,14 +2741,14 @@ async function runCleanup(options) {
     patternViolations: [],
     totalIssues: 0
   };
-  const rootDir = path12.resolve(cwd, config.rootDir);
-  const docsDir = path12.resolve(cwd, config.docsDir);
+  const rootDir = path13.resolve(cwd, config.rootDir);
+  const docsDir = path13.resolve(cwd, config.docsDir);
   const driftEnabled = type === "all" || type === "drift";
   const driftConfig = config.entropy?.drift;
   const entropyConfig = {
     rootDir,
     ...config.entropy?.entryPoints && { entryPoints: config.entropy.entryPoints },
-    docPaths: [path12.join(docsDir, "**/*.md")],
+    docPaths: [path13.join(docsDir, "**/*.md")],
     analyze: {
       drift: driftEnabled ? driftConfig ?? true : false,
       deadCode: type === "all" || type === "dead-code",
@@ -2802,8 +2848,8 @@ function createCleanupCommand() {
 // src/commands/cleanup-sessions.ts
 init_dist3();
 import { Command as Command22 } from "commander";
-import * as fs6 from "fs";
-import * as path13 from "path";
+import * as fs7 from "fs";
+import * as path14 from "path";
 var STALE_TTL_MS = 24 * 60 * 60 * 1e3;
 var ONE_HOUR_MS = 60 * 60 * 1e3;
 var ONE_DAY_MS = 24 * ONE_HOUR_MS;
@@ -2818,13 +2864,13 @@ var CLEANUP_TARGETS = [
 function getMostRecentMtime(dirPath) {
   let latest = 0;
   try {
-    const entries = fs6.readdirSync(dirPath, { withFileTypes: true });
+    const entries = fs7.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path13.join(dirPath, entry.name);
-      const stat = fs6.statSync(fullPath);
+      const fullPath = path14.join(dirPath, entry.name);
+      const stat = fs7.statSync(fullPath);
       if (stat.mtimeMs > latest) latest = stat.mtimeMs;
     }
-    const dirStat = fs6.statSync(dirPath);
+    const dirStat = fs7.statSync(dirPath);
     if (dirStat.mtimeMs > latest) latest = dirStat.mtimeMs;
   } catch {
   }
@@ -2833,14 +2879,14 @@ function getMostRecentMtime(dirPath) {
 async function runCleanupSessions(options) {
   const cwd = options.cwd ?? process.cwd();
   const dryRun = options.dryRun ?? false;
-  const sessionsDir = path13.join(cwd, ".harness", "sessions");
+  const sessionsDir = path14.join(cwd, ".harness", "sessions");
   const result = { removed: [], kept: [] };
-  if (!fs6.existsSync(sessionsDir)) {
+  if (!fs7.existsSync(sessionsDir)) {
     return Ok(result);
   }
   let entries;
   try {
-    entries = fs6.readdirSync(sessionsDir, { withFileTypes: true });
+    entries = fs7.readdirSync(sessionsDir, { withFileTypes: true });
   } catch (err) {
     return Err(
       new CLIError(
@@ -2852,14 +2898,14 @@ async function runCleanupSessions(options) {
   const now = Date.now();
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const sessionPath = path13.join(sessionsDir, entry.name);
+    const sessionPath = path14.join(sessionsDir, entry.name);
     const mostRecent = getMostRecentMtime(sessionPath);
     const ageMs = now - mostRecent;
     if (ageMs > STALE_TTL_MS) {
       result.removed.push(entry.name);
       if (!dryRun) {
         try {
-          fs6.rmSync(sessionPath, { recursive: true, force: true });
+          fs7.rmSync(sessionPath, { recursive: true, force: true });
         } catch (err) {
           return Err(
             new CLIError(
@@ -2916,7 +2962,7 @@ async function runCleanupAll(opts) {
   const results = [];
   for (const target of targets) {
     const ttlMs = (ttlOverrides[target.name] ?? 0) > 0 ? ttlOverrides[target.name] * ONE_HOUR_MS : target.defaultTtlMs;
-    const dir = path13.join(cwd, ".harness", target.relativeDir);
+    const dir = path14.join(cwd, ".harness", target.relativeDir);
     const sweepResult = await sweepDirectory(dir, ttlMs, dryRun);
     if (!sweepResult.ok) return Err(sweepResult.error);
     results.push({ target: target.name, ...sweepResult.value });
@@ -2926,10 +2972,10 @@ async function runCleanupAll(opts) {
 async function sweepDirectory(dir, ttlMs, dryRun) {
   const removed = [];
   const kept = [];
-  if (!fs6.existsSync(dir)) return Ok({ removed, kept });
+  if (!fs7.existsSync(dir)) return Ok({ removed, kept });
   let entries;
   try {
-    entries = fs6.readdirSync(dir, { withFileTypes: true });
+    entries = fs7.readdirSync(dir, { withFileTypes: true });
   } catch (err) {
     return Err(
       new CLIError(
@@ -2940,13 +2986,13 @@ async function sweepDirectory(dir, ttlMs, dryRun) {
   }
   const now = Date.now();
   for (const entry of entries) {
-    const entryPath = path13.join(dir, entry.name);
+    const entryPath = path14.join(dir, entry.name);
     const ageMs = now - mtimeOf(entryPath);
     if (ageMs > ttlMs) {
       removed.push(entry.name);
       if (!dryRun) {
         try {
-          fs6.rmSync(entryPath, { recursive: true, force: true });
+          fs7.rmSync(entryPath, { recursive: true, force: true });
         } catch (err) {
           return Err(
             new CLIError(
@@ -2964,7 +3010,7 @@ async function sweepDirectory(dir, ttlMs, dryRun) {
 }
 function mtimeOf(target) {
   try {
-    const stat = fs6.statSync(target);
+    const stat = fs7.statSync(target);
     if (stat.isDirectory()) return getMostRecentMtime(target);
     return stat.mtimeMs;
   } catch {
@@ -3004,7 +3050,7 @@ function createCleanupSessionsCommand() {
     "Comma-separated target names (mutually-exclusive with --exclude/--all)"
   ).option("--exclude <list>", "Comma-separated target names to skip").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const cwd = path13.resolve(opts.path);
+    const cwd = path14.resolve(opts.path);
     const asJson = Boolean(globalOpts.json);
     if (opts.all || opts.include || opts.exclude) {
       await runExtendedSweep(cwd, opts, asJson);
@@ -3050,8 +3096,8 @@ import { Command as Command24 } from "commander";
 
 // src/commands/compound/scan-candidates.ts
 init_dist3();
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname2, join as join8, resolve as resolve12 } from "path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname3, join as join9, resolve as resolve13 } from "path";
 import { Command as Command23 } from "commander";
 var HOTSPOT_THRESHOLD = 7;
 var DEFAULT_LOOKBACK = "7d";
@@ -3078,9 +3124,9 @@ async function runCompoundScanCandidatesCommand(opts) {
     isoWeek: week,
     lookback
   });
-  const outputPath = opts.outputPath ?? join8(cwd, "docs/solutions/.candidates", `${formatIsoWeek(week)}.md`);
-  mkdirSync3(dirname2(outputPath), { recursive: true });
-  writeFileSync4(outputPath, report);
+  const outputPath = opts.outputPath ?? join9(cwd, "docs/solutions/.candidates", `${formatIsoWeek(week)}.md`);
+  mkdirSync4(dirname3(outputPath), { recursive: true });
+  writeFileSync5(outputPath, report);
   const candidatesFound = undocumented.length + hotspots.length;
   const status = {
     status: candidatesFound === 0 ? "no-issues" : "success",
@@ -3120,9 +3166,9 @@ function createScanCandidatesCommand() {
       const nonInteractive = options.nonInteractive === true || !process.stdout.isTTY;
       const status = await runCompoundScanCandidatesCommand({
         lookback: options.lookback,
-        configPath: resolve12(process.cwd(), options.config),
-        outputPath: options.outputPath ? resolve12(process.cwd(), options.outputPath) : void 0,
-        solutionsDir: resolve12(process.cwd(), options.solutionsDir),
+        configPath: resolve13(process.cwd(), options.config),
+        outputPath: options.outputPath ? resolve13(process.cwd(), options.outputPath) : void 0,
+        solutionsDir: resolve13(process.cwd(), options.solutionsDir),
         nonInteractive
       });
       if (status.status === "failure") process.exitCode = 1;
@@ -3192,10 +3238,10 @@ function printResult2(result, mode, _formatter) {
       list.push(f);
       bySurface.set(f.target.surface, list);
     }
-    for (const [surface, fs50] of bySurface) {
+    for (const [surface, fs51] of bySurface) {
       console.log(`
 [${surface}]`);
-      for (const f of fs50) {
+      for (const f of fs51) {
         const line = f.target.line !== void 0 ? `:${f.target.line}` : "";
         console.log(`  ${f.code} [${f.tier}/${f.impact}/${f.confidence}] ${f.target.file}${line}`);
         console.log(`    "${truncate(f.target.snippet, 80)}"`);
@@ -3222,7 +3268,7 @@ function truncate(s, n) {
 
 // src/commands/cross-check.ts
 import { Command as Command26 } from "commander";
-import * as path14 from "path";
+import * as path15 from "path";
 import chalk from "chalk";
 function resolveOutputMode3(options) {
   if (options.json) return OutputMode.JSON;
@@ -3233,8 +3279,8 @@ function resolveOutputMode3(options) {
 async function runCrossCheckCommand(options) {
   const mode = resolveOutputMode3(options);
   const projectPath = process.cwd();
-  const specsDir = path14.resolve(projectPath, options.specsDir ?? "docs/specs");
-  const plansDir = path14.resolve(projectPath, options.plansDir ?? "docs/plans");
+  const specsDir = path15.resolve(projectPath, options.specsDir ?? "docs/specs");
+  const plansDir = path15.resolve(projectPath, options.plansDir ?? "docs/plans");
   const result = await runCrossCheck({ projectPath, specsDir, plansDir });
   if (!result.ok) {
     emitCrossCheckError(result.error.message, mode);
@@ -3287,13 +3333,13 @@ function createCrossCheckCommand() {
 // src/commands/dashboard.ts
 import { Command as Command27 } from "commander";
 import { spawn } from "child_process";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname3, join as join9, resolve as resolve14 } from "path";
+import { dirname as dirname4, join as join10, resolve as resolve15 } from "path";
 import { setTimeout } from "timers";
 import { fileURLToPath } from "url";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname3(__filename);
+var __dirname = dirname4(__filename);
 var require2 = createRequire(import.meta.url);
 var DEFAULT_CLIENT_PORT = 3700;
 var DEFAULT_API_PORT = 3701;
@@ -3304,22 +3350,22 @@ function openBrowser(url) {
 function resolveServerScript() {
   try {
     const pkgPath = require2.resolve("@harness-engineering/dashboard/package.json");
-    const pkgDir = dirname3(pkgPath);
-    const built2 = join9(pkgDir, "dist", "server", "serve.js");
-    if (existsSync5(built2)) return { script: built2, dev: false };
-    const dev2 = join9(pkgDir, "src", "server", "serve.ts");
-    if (existsSync5(dev2)) return { script: dev2, dev: true };
+    const pkgDir = dirname4(pkgPath);
+    const built2 = join10(pkgDir, "dist", "server", "serve.js");
+    if (existsSync6(built2)) return { script: built2, dev: false };
+    const dev2 = join10(pkgDir, "src", "server", "serve.ts");
+    if (existsSync6(dev2)) return { script: dev2, dev: true };
   } catch {
   }
   const built = [
-    join9(__dirname, "..", "..", "..", "dashboard", "dist", "server", "serve.js"),
-    join9(__dirname, "..", "..", "..", "..", "packages", "dashboard", "dist", "server", "serve.js")
-  ].find((p) => existsSync5(p));
+    join10(__dirname, "..", "..", "..", "dashboard", "dist", "server", "serve.js"),
+    join10(__dirname, "..", "..", "..", "..", "packages", "dashboard", "dist", "server", "serve.js")
+  ].find((p) => existsSync6(p));
   if (built) return { script: built, dev: false };
   const dev = [
-    join9(__dirname, "..", "..", "..", "dashboard", "src", "server", "serve.ts"),
-    join9(__dirname, "..", "..", "..", "..", "packages", "dashboard", "src", "server", "serve.ts")
-  ].find((p) => existsSync5(p));
+    join10(__dirname, "..", "..", "..", "dashboard", "src", "server", "serve.ts"),
+    join10(__dirname, "..", "..", "..", "..", "packages", "dashboard", "src", "server", "serve.ts")
+  ].find((p) => existsSync6(p));
   return dev ? { script: dev, dev: true } : null;
 }
 function spawnDashboardServer(server, env) {
@@ -3353,7 +3399,7 @@ function buildDashboardEnv(opts, clientPort, apiPort, projectPath) {
 function runDashboard(opts) {
   const clientPort = Number(opts.port ?? DEFAULT_CLIENT_PORT);
   const apiPort = Number(opts.apiPort ?? DEFAULT_API_PORT);
-  const projectPath = resolve14(opts.cwd ?? process.cwd());
+  const projectPath = resolve15(opts.cwd ?? process.cwd());
   const url = `http://localhost:${apiPort}`;
   const server = resolveServerScript();
   if (!server) {
@@ -3462,9 +3508,9 @@ function verdictBadge(verdict) {
 
 // src/commands/doctor.ts
 import { Command as Command29 } from "commander";
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 import * as os from "os";
-import * as path16 from "path";
+import * as path17 from "path";
 import chalk2 from "chalk";
 
 // src/utils/node-version.ts
@@ -3547,24 +3593,24 @@ var INTEGRATION_REGISTRY = [
 ];
 
 // src/integrations/config.ts
-import * as fs7 from "fs";
-import * as path15 from "path";
+import * as fs8 from "fs";
+import * as path16 from "path";
 function readJsonSafe(filePath) {
-  if (!fs7.existsSync(filePath)) return null;
+  if (!fs8.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs7.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs8.readFileSync(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeJson(filePath, data) {
-  const dir = path15.dirname(filePath);
-  if (!fs7.existsSync(dir)) {
-    fs7.mkdirSync(dir, { recursive: true });
+  const dir = path16.dirname(filePath);
+  if (!fs8.existsSync(dir)) {
+    fs8.mkdirSync(dir, { recursive: true });
   }
   const tmp = filePath + ".tmp";
-  fs7.writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n");
-  fs7.renameSync(tmp, filePath);
+  fs8.writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n");
+  fs8.renameSync(tmp, filePath);
 }
 function readMcpConfig(filePath) {
   const config = readJsonSafe(filePath);
@@ -3594,7 +3640,7 @@ function writeOpencodeMcpEntry(filePath, name, entry) {
   writeJson(filePath, config);
 }
 function removeMcpEntry(filePath, name) {
-  if (!fs7.existsSync(filePath)) return;
+  if (!fs8.existsSync(filePath)) return;
   const config = readMcpConfig(filePath);
   delete config.mcpServers[name];
   writeJson(filePath, config);
@@ -3633,7 +3679,7 @@ function checkNodeVersion2() {
 }
 function countCommandFiles(dir, ext) {
   try {
-    return fs8.readdirSync(dir).filter((f) => f.endsWith(ext)).length;
+    return fs9.readdirSync(dir).filter((f) => f.endsWith(ext)).length;
   } catch {
     return 0;
   }
@@ -3642,13 +3688,13 @@ function checkSlashCommands() {
   const platforms = [
     {
       name: "Claude Code",
-      dir: path16.join(os.homedir(), ".claude", "commands", "harness"),
+      dir: path17.join(os.homedir(), ".claude", "commands", "harness"),
       ext: ".md",
       client: "claude-code"
     },
     {
       name: "Gemini CLI",
-      dir: path16.join(os.homedir(), ".gemini", "commands", "harness"),
+      dir: path17.join(os.homedir(), ".gemini", "commands", "harness"),
       ext: ".toml",
       client: "gemini-cli"
     }
@@ -3672,7 +3718,7 @@ function checkSlashCommands() {
 }
 function checkMcpConfig(cwd) {
   const results = [];
-  const claudeConfig = readMcpConfig(path16.join(cwd, ".mcp.json"));
+  const claudeConfig = readMcpConfig(path17.join(cwd, ".mcp.json"));
   if (claudeConfig.mcpServers?.["harness"]) {
     results.push({
       name: "mcp-claude",
@@ -3687,9 +3733,9 @@ function checkMcpConfig(cwd) {
       fix: "Run: harness setup-mcp --client claude"
     });
   }
-  const geminiDir = path16.join(cwd, ".gemini");
-  if (fs8.existsSync(geminiDir)) {
-    const geminiConfig = readMcpConfig(path16.join(geminiDir, "settings.json"));
+  const geminiDir = path17.join(cwd, ".gemini");
+  if (fs9.existsSync(geminiDir)) {
+    const geminiConfig = readMcpConfig(path17.join(geminiDir, "settings.json"));
     if (geminiConfig.mcpServers?.["harness"]) {
       results.push({
         name: "mcp-gemini",
@@ -3708,12 +3754,12 @@ function checkMcpConfig(cwd) {
   return results;
 }
 function loadMcpPresence(cwd) {
-  const mcpPath = path16.join(cwd, ".mcp.json");
-  const geminiDir = path16.join(cwd, ".gemini");
-  const hasGemini = fs8.existsSync(geminiDir);
+  const mcpPath = path17.join(cwd, ".mcp.json");
+  const geminiDir = path17.join(cwd, ".gemini");
+  const hasGemini = fs9.existsSync(geminiDir);
   return {
     mcpConfig: readMcpConfig(mcpPath),
-    geminiConfig: hasGemini ? readMcpConfig(path16.join(geminiDir, "settings.json")) : null,
+    geminiConfig: hasGemini ? readMcpConfig(path17.join(geminiDir, "settings.json")) : null,
     hasGemini
   };
 }
@@ -3745,7 +3791,7 @@ function checkTier0Presence(def, presence) {
 function checkIntegrations(cwd) {
   const results = [];
   const presence = loadMcpPresence(cwd);
-  const configPath = path16.join(cwd, "harness.config.json");
+  const configPath = path17.join(cwd, "harness.config.json");
   const integrationsConfig = readIntegrationsConfig(configPath);
   for (const def of INTEGRATION_REGISTRY.filter((d) => d.tier === 0)) {
     results.push(checkTier0Presence(def, presence));
@@ -3813,12 +3859,12 @@ function checkLivePings(env = process.env) {
   return results;
 }
 function listHookFiles(cwd) {
-  const hooksDir = path16.join(cwd, ".harness", "hooks");
-  if (!fs8.existsSync(hooksDir)) return [];
+  const hooksDir = path17.join(cwd, ".harness", "hooks");
+  if (!fs9.existsSync(hooksDir)) return [];
   try {
-    return fs8.readdirSync(hooksDir).filter((f) => !f.startsWith(".")).map((f) => ({
-      relativePath: path16.join(".harness", "hooks", f),
-      absolutePath: path16.join(hooksDir, f)
+    return fs9.readdirSync(hooksDir).filter((f) => !f.startsWith(".")).map((f) => ({
+      relativePath: path17.join(".harness", "hooks", f),
+      absolutePath: path17.join(hooksDir, f)
     }));
   } catch {
     return [];
@@ -3868,7 +3914,7 @@ function validateShellHook(entry, content) {
 function validateHookEntry(entry) {
   let content;
   try {
-    content = fs8.readFileSync(entry.absolutePath, "utf-8");
+    content = fs9.readFileSync(entry.absolutePath, "utf-8");
   } catch (err) {
     return {
       name: `hook-validity-${entry.relativePath}`,
@@ -3915,8 +3961,8 @@ var DAY_MS = 24 * 60 * 60 * 1e3;
 function checkBaselineFreshness(cwd, now = Date.now()) {
   const results = [];
   for (const def of BASELINE_FILES) {
-    const absolutePath = path16.join(cwd, def.relativePath);
-    if (!fs8.existsSync(absolutePath)) {
+    const absolutePath = path17.join(cwd, def.relativePath);
+    if (!fs9.existsSync(absolutePath)) {
       results.push({
         name: `baseline-freshness-${def.relativePath}`,
         status: "info",
@@ -3926,7 +3972,7 @@ function checkBaselineFreshness(cwd, now = Date.now()) {
     }
     let mtimeMs;
     try {
-      mtimeMs = fs8.statSync(absolutePath).mtimeMs;
+      mtimeMs = fs9.statSync(absolutePath).mtimeMs;
     } catch (err) {
       results.push({
         name: `baseline-freshness-${def.relativePath}`,
@@ -3963,20 +4009,20 @@ function checkBaselineFreshness(cwd, now = Date.now()) {
 }
 var SESSIONS_SAMPLE_SIZE = 5;
 function listRecentSessions(cwd) {
-  const sessionsDir = path16.join(cwd, ".harness", "sessions");
-  if (!fs8.existsSync(sessionsDir)) return [];
+  const sessionsDir = path17.join(cwd, ".harness", "sessions");
+  if (!fs9.existsSync(sessionsDir)) return [];
   let entries;
   try {
-    entries = fs8.readdirSync(sessionsDir);
+    entries = fs9.readdirSync(sessionsDir);
   } catch {
     return [];
   }
   const dirs = [];
   for (const name of entries) {
     if (name.startsWith(".")) continue;
-    const absolutePath = path16.join(sessionsDir, name);
+    const absolutePath = path17.join(sessionsDir, name);
     try {
-      const stat = fs8.statSync(absolutePath);
+      const stat = fs9.statSync(absolutePath);
       if (!stat.isDirectory()) continue;
       dirs.push({ name, absolutePath, mtimeMs: stat.mtimeMs });
     } catch {
@@ -3991,13 +4037,13 @@ function scanSessionSummaries(sessions) {
   let missing = 0;
   const corrupt = [];
   for (const session of sessions) {
-    const summaryPath = path16.join(session.absolutePath, "session-summary.json");
-    if (!fs8.existsSync(summaryPath)) {
+    const summaryPath = path17.join(session.absolutePath, "session-summary.json");
+    if (!fs9.existsSync(summaryPath)) {
       missing += 1;
       continue;
     }
     try {
-      JSON.parse(fs8.readFileSync(summaryPath, "utf-8"));
+      JSON.parse(fs9.readFileSync(summaryPath, "utf-8"));
       parsed += 1;
     } catch {
       corrupt.push(session.name);
@@ -4094,7 +4140,7 @@ function createDoctorCommand() {
 // src/commands/fix-drift.ts
 init_dist3();
 import { Command as Command30 } from "commander";
-import * as path17 from "path";
+import * as path18 from "path";
 async function runFixDrift(options) {
   const cwd = options.cwd ?? process.cwd();
   const dryRun = options.dryRun !== false;
@@ -4103,12 +4149,12 @@ async function runFixDrift(options) {
     return Err(configResult.error);
   }
   const config = configResult.value;
-  const rootDir = path17.resolve(cwd, config.rootDir);
-  const docsDir = path17.resolve(cwd, config.docsDir);
+  const rootDir = path18.resolve(cwd, config.rootDir);
+  const docsDir = path18.resolve(cwd, config.docsDir);
   const entropyConfig = {
     rootDir,
     ...config.entropy?.entryPoints && { entryPoints: config.entropy.entryPoints },
-    docPaths: [path17.join(docsDir, "**/*.md")],
+    docPaths: [path18.join(docsDir, "**/*.md")],
     analyze: {
       drift: true,
       deadCode: true,
@@ -4260,10 +4306,10 @@ import { Command as Command33 } from "commander";
 
 // src/commands/gateway/token.ts
 import { Command as Command31 } from "commander";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve17 } from "path";
 import { TokenStore } from "@harness-engineering/orchestrator";
 function getStore() {
-  const p = process.env["HARNESS_TOKENS_PATH"] ?? resolve16(".harness", "tokens.json");
+  const p = process.env["HARNESS_TOKENS_PATH"] ?? resolve17(".harness", "tokens.json");
   return new TokenStore(p);
 }
 async function runTokenCreate(opts) {
@@ -4311,10 +4357,10 @@ function createTokenCommand() {
 // src/commands/gateway/deliveries.ts
 import { Command as Command32 } from "commander";
 import { createInterface } from "readline";
-import { resolve as resolve17 } from "path";
+import { resolve as resolve18 } from "path";
 import { WebhookQueue } from "@harness-engineering/orchestrator";
 function resolveQueuePath() {
-  return process.env["HARNESS_WEBHOOK_QUEUE_PATH"] ?? resolve17(".harness", "webhook-queue.sqlite");
+  return process.env["HARNESS_WEBHOOK_QUEUE_PATH"] ?? resolve18(".harness", "webhook-queue.sqlite");
 }
 function getQueue() {
   return new WebhookQueue(resolveQueuePath());
@@ -4499,13 +4545,13 @@ function createGenerateCommand() {
 import { Command as Command37 } from "commander";
 
 // src/commands/graph/status.ts
-import * as path18 from "path";
+import * as path19 from "path";
 async function readConnectorSyncStatus(graphDir) {
-  const fs50 = await import("fs/promises");
+  const fs51 = await import("fs/promises");
   const result = {};
   try {
-    const syncMetaPath = path18.join(graphDir, "sync-metadata.json");
-    const syncMeta = JSON.parse(await fs50.readFile(syncMetaPath, "utf-8"));
+    const syncMetaPath = path19.join(graphDir, "sync-metadata.json");
+    const syncMeta = JSON.parse(await fs51.readFile(syncMetaPath, "utf-8"));
     for (const [name, data] of Object.entries(syncMeta.connectors ?? {})) {
       result[name] = data.lastSyncTimestamp;
     }
@@ -4515,7 +4561,7 @@ async function readConnectorSyncStatus(graphDir) {
 }
 async function runGraphStatus(projectPath) {
   const { GraphStore: GraphStore2, loadGraphMetadata } = await import("./dist-DWBTZXR5.js");
-  const graphDir = path18.join(projectPath, ".harness", "graph");
+  const graphDir = path19.join(projectPath, ".harness", "graph");
   const metaResult = await loadGraphMetadata(graphDir);
   if (metaResult.status === "not_found") {
     return { status: "no_graph", message: "No graph found. Run `harness graph scan` first." };
@@ -4564,10 +4610,10 @@ async function runGraphStatus(projectPath) {
 }
 
 // src/commands/graph/export.ts
-import * as path19 from "path";
+import * as path20 from "path";
 async function runGraphExport(projectPath, format) {
   const { GraphStore: GraphStore2 } = await import("./dist-DWBTZXR5.js");
-  const graphDir = path19.join(projectPath, ".harness", "graph");
+  const graphDir = path20.join(projectPath, ".harness", "graph");
   const store = new GraphStore2();
   const loaded = await store.load(graphDir);
   if (!loaded) throw new Error("No graph found. Run `harness graph scan` first.");
@@ -4597,11 +4643,11 @@ async function runGraphExport(projectPath, format) {
 
 // src/commands/graph/query.ts
 import { Command as Command35 } from "commander";
-import * as path20 from "path";
+import * as path21 from "path";
 async function runQuery(projectPath, rootNodeId, opts) {
   const { GraphStore: GraphStore2, ContextQL } = await import("./dist-DWBTZXR5.js");
   const store = new GraphStore2();
-  const graphDir = path20.join(projectPath, ".harness", "graph");
+  const graphDir = path21.join(projectPath, ".harness", "graph");
   const loaded = await store.load(graphDir);
   if (!loaded) throw new Error("No graph found. Run `harness graph scan` first.");
   const params = {
@@ -4623,7 +4669,7 @@ function printQueryResult(result) {
   }
 }
 async function runQueryAction(rootNodeId, opts, globalOpts) {
-  const projectPath = path20.resolve(globalOpts.config ? path20.dirname(globalOpts.config) : ".");
+  const projectPath = path21.resolve(globalOpts.config ? path21.dirname(globalOpts.config) : ".");
   try {
     const result = await runQuery(projectPath, rootNodeId, {
       depth: parseInt(opts.depth),
@@ -4649,12 +4695,12 @@ function createQueryCommand() {
 
 // src/commands/graph/ingest.ts
 import { Command as Command36 } from "commander";
-import * as path21 from "path";
+import * as path22 from "path";
 async function loadConnectorConfig(projectPath, source) {
   try {
-    const fs50 = await import("fs/promises");
-    const configPath = path21.join(projectPath, "harness.config.json");
-    const config = JSON.parse(await fs50.readFile(configPath, "utf-8"));
+    const fs51 = await import("fs/promises");
+    const configPath = path22.join(projectPath, "harness.config.json");
+    const config = JSON.parse(await fs51.readFile(configPath, "utf-8"));
     const connector = config.graph?.connectors?.[source];
     return connector ?? {};
   } catch {
@@ -4663,9 +4709,9 @@ async function loadConnectorConfig(projectPath, source) {
 }
 async function ingestBusinessKnowledge(bk, projectPath) {
   return mergeResults(
-    await bk.ingest(path21.join(projectPath, "docs", "knowledge")),
-    await bk.ingestSolutions(path21.join(projectPath, "docs", "solutions")),
-    await bk.ingestStrategy(path21.join(projectPath, "STRATEGY.md"))
+    await bk.ingest(path22.join(projectPath, "docs", "knowledge")),
+    await bk.ingestSolutions(path22.join(projectPath, "docs", "solutions")),
+    await bk.ingestStrategy(path22.join(projectPath, "STRATEGY.md"))
   );
 }
 function mergeResults(...results) {
@@ -4705,7 +4751,7 @@ async function runIngest(projectPath, source, opts) {
     FigmaConnector,
     MiroConnector
   } = await import("./dist-DWBTZXR5.js");
-  const graphDir = path21.join(projectPath, ".harness", "graph");
+  const graphDir = path22.join(projectPath, ".harness", "graph");
   const store = new GraphStore2();
   await store.load(graphDir);
   const ingestOptions = loadIngestOptions(projectPath);
@@ -4717,11 +4763,11 @@ async function runIngest(projectPath, source, opts) {
     const bkInst = new BusinessKnowledgeIngestor(store);
     const bkResult = await ingestBusinessKnowledge(bkInst, projectPath);
     const reqResult = await new RequirementIngestor(store).ingestSpecs(
-      path21.join(projectPath, "docs", "changes")
+      path22.join(projectPath, "docs", "changes")
     );
     const gitResult = await new GitIngestor(store).ingest(projectPath);
     const { createExtractionRunner } = await import("./dist-DWBTZXR5.js");
-    const extractedDir = path21.join(projectPath, ".harness", "knowledge", "extracted");
+    const extractedDir = path22.join(projectPath, ".harness", "knowledge", "extracted");
     const signalsResult = await createExtractionRunner().run(projectPath, store, extractedDir);
     const syncManager = new SyncManager(store, graphDir);
     const connectorMap = {
@@ -4766,12 +4812,12 @@ async function runIngest(projectPath, source, opts) {
       break;
     case "requirements":
       result = await new RequirementIngestor(store).ingestSpecs(
-        path21.join(projectPath, "docs", "changes")
+        path22.join(projectPath, "docs", "changes")
       );
       break;
     case "business-signals": {
       const { createExtractionRunner } = await import("./dist-DWBTZXR5.js");
-      const extractedDir = path21.join(projectPath, ".harness", "knowledge", "extracted");
+      const extractedDir = path22.join(projectPath, ".harness", "knowledge", "extracted");
       result = await createExtractionRunner().run(projectPath, store, extractedDir);
       break;
     }
@@ -4820,7 +4866,7 @@ async function handleIngestAction(opts, cmd) {
     process.exit(1);
   }
   const globalOpts = cmd.optsWithGlobals();
-  const projectPath = path21.resolve(globalOpts.config ? path21.dirname(globalOpts.config) : ".");
+  const projectPath = path22.resolve(globalOpts.config ? path22.dirname(globalOpts.config) : ".");
   try {
     const runOpts = {};
     if (opts.full !== void 0) runOpts.full = opts.full;
@@ -4844,9 +4890,9 @@ function createIngestCommand() {
 }
 
 // src/commands/graph/index.ts
-import * as path22 from "path";
+import * as path23 from "path";
 function resolveProjectPath(globalOpts) {
-  return path22.resolve(globalOpts.config ? path22.dirname(globalOpts.config) : ".");
+  return path23.resolve(globalOpts.config ? path23.dirname(globalOpts.config) : ".");
 }
 function printGraphStatus(result) {
   if (result.status === "no_graph" || result.status === "schema_mismatch") {
@@ -4906,8 +4952,8 @@ import { Command as Command42 } from "commander";
 
 // src/commands/hooks/init.ts
 import { Command as Command38 } from "commander";
-import * as fs9 from "fs";
-import * as path23 from "path";
+import * as fs10 from "fs";
+import * as path24 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/hooks/profiles.ts
@@ -4958,17 +5004,17 @@ function supportFilesFor(hookNames) {
 
 // src/commands/hooks/init.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path23.dirname(__filename2);
+var __dirname2 = path24.dirname(__filename2);
 var VALID_PROFILES = ["minimal", "standard", "strict"];
 function resolveHookSourceDir() {
   const candidates = [
     // Dev layout: src/commands/hooks/ → ../../hooks/
-    path23.resolve(__dirname2, "..", "..", "hooks"),
+    path24.resolve(__dirname2, "..", "..", "hooks"),
     // Bundled layout: dist/ → ./hooks/ (copied by copy-assets.mjs)
-    path23.resolve(__dirname2, "hooks")
+    path24.resolve(__dirname2, "hooks")
   ];
   for (const candidate of candidates) {
-    if (fs9.existsSync(candidate)) {
+    if (fs10.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -5005,12 +5051,12 @@ function mergeSettings(existing, hooksConfig) {
 }
 function initHooks(options) {
   const { profile, projectDir } = options;
-  const hooksDestDir = path23.join(projectDir, ".harness", "hooks");
-  fs9.mkdirSync(hooksDestDir, { recursive: true });
-  if (fs9.existsSync(hooksDestDir)) {
-    for (const entry of fs9.readdirSync(hooksDestDir)) {
+  const hooksDestDir = path24.join(projectDir, ".harness", "hooks");
+  fs10.mkdirSync(hooksDestDir, { recursive: true });
+  if (fs10.existsSync(hooksDestDir)) {
+    for (const entry of fs10.readdirSync(hooksDestDir)) {
       if (entry.endsWith(".js")) {
-        fs9.unlinkSync(path23.join(hooksDestDir, entry));
+        fs10.unlinkSync(path24.join(hooksDestDir, entry));
       }
     }
   }
@@ -5019,29 +5065,29 @@ function initHooks(options) {
   const activeNames = PROFILES[profile];
   const activeScripts = HOOK_SCRIPTS.filter((h) => activeNames.includes(h.name));
   for (const script of activeScripts) {
-    const srcFile = path23.join(sourceDir, `${script.name}.js`);
-    const destFile = path23.join(hooksDestDir, `${script.name}.js`);
-    if (fs9.existsSync(srcFile)) {
-      fs9.copyFileSync(srcFile, destFile);
+    const srcFile = path24.join(sourceDir, `${script.name}.js`);
+    const destFile = path24.join(hooksDestDir, `${script.name}.js`);
+    if (fs10.existsSync(srcFile)) {
+      fs10.copyFileSync(srcFile, destFile);
       copiedScripts.push(script.name);
     }
   }
   for (const supportFile of supportFilesFor(activeNames)) {
-    const srcFile = path23.join(sourceDir, supportFile);
-    const destFile = path23.join(hooksDestDir, supportFile);
-    if (fs9.existsSync(srcFile)) {
-      fs9.copyFileSync(srcFile, destFile);
+    const srcFile = path24.join(sourceDir, supportFile);
+    const destFile = path24.join(hooksDestDir, supportFile);
+    if (fs10.existsSync(srcFile)) {
+      fs10.copyFileSync(srcFile, destFile);
     }
   }
-  const profilePath = path23.join(hooksDestDir, "profile.json");
-  fs9.writeFileSync(profilePath, JSON.stringify({ profile }, null, 2) + "\n");
-  const claudeDir = path23.join(projectDir, ".claude");
-  fs9.mkdirSync(claudeDir, { recursive: true });
-  const settingsPath = path23.join(claudeDir, "settings.json");
+  const profilePath = path24.join(hooksDestDir, "profile.json");
+  fs10.writeFileSync(profilePath, JSON.stringify({ profile }, null, 2) + "\n");
+  const claudeDir = path24.join(projectDir, ".claude");
+  fs10.mkdirSync(claudeDir, { recursive: true });
+  const settingsPath = path24.join(claudeDir, "settings.json");
   let existing = {};
-  if (fs9.existsSync(settingsPath)) {
+  if (fs10.existsSync(settingsPath)) {
     try {
-      existing = JSON.parse(fs9.readFileSync(settingsPath, "utf-8"));
+      existing = JSON.parse(fs10.readFileSync(settingsPath, "utf-8"));
     } catch (e) {
       throw new Error(
         `Malformed .claude/settings.json \u2014 fix the JSON syntax before running hooks init. Parse error: ${e instanceof Error ? e.message : String(e)}`,
@@ -5051,7 +5097,7 @@ function initHooks(options) {
   }
   const hooksConfig = buildSettingsHooks(profile);
   const merged = mergeSettings(existing, hooksConfig);
-  fs9.writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + "\n");
+  fs10.writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + "\n");
   return { copiedScripts, settingsPath, profilePath };
 }
 function createInitCommand2() {
@@ -5080,7 +5126,7 @@ function createInitCommand2() {
         );
         logger.info(`Profile: ${profile}`);
         logger.info(
-          `Settings: ${path23.relative(projectDir, result.settingsPath).replaceAll("\\", "/")}`
+          `Settings: ${path24.relative(projectDir, result.settingsPath).replaceAll("\\", "/")}`
         );
         logger.dim("Run 'harness hooks list' to see installed hooks");
       }
@@ -5094,18 +5140,18 @@ function createInitCommand2() {
 
 // src/commands/hooks/list.ts
 import { Command as Command39 } from "commander";
-import * as fs10 from "fs";
-import * as path24 from "path";
+import * as fs11 from "fs";
+import * as path25 from "path";
 function listHooks(projectDir) {
-  const hooksDir = path24.join(projectDir, ".harness", "hooks");
-  const profilePath = path24.join(hooksDir, "profile.json");
-  if (!fs10.existsSync(profilePath)) {
+  const hooksDir = path25.join(projectDir, ".harness", "hooks");
+  const profilePath = path25.join(hooksDir, "profile.json");
+  if (!fs11.existsSync(profilePath)) {
     return { installed: false, profile: null, hooks: [] };
   }
   let profile = "standard";
   let warning;
   try {
-    const data = JSON.parse(fs10.readFileSync(profilePath, "utf-8"));
+    const data = JSON.parse(fs11.readFileSync(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
       profile = data.profile;
     }
@@ -5117,7 +5163,7 @@ function listHooks(projectDir) {
     name: h.name,
     event: h.event,
     matcher: h.matcher,
-    scriptPath: path24.join(".harness", "hooks", `${h.name}.js`)
+    scriptPath: path25.join(".harness", "hooks", `${h.name}.js`)
   }));
   const result = { installed: true, profile, hooks };
   if (warning) {
@@ -5148,27 +5194,27 @@ function createListCommand() {
 
 // src/commands/hooks/remove.ts
 import { Command as Command40 } from "commander";
-import * as fs11 from "fs";
-import * as path25 from "path";
+import * as fs12 from "fs";
+import * as path26 from "path";
 function removeHooks(projectDir) {
-  const hooksDir = path25.join(projectDir, ".harness", "hooks");
-  const settingsPath = path25.join(projectDir, ".claude", "settings.json");
+  const hooksDir = path26.join(projectDir, ".harness", "hooks");
+  const settingsPath = path26.join(projectDir, ".claude", "settings.json");
   let removed = false;
   let settingsCleaned = false;
-  if (fs11.existsSync(hooksDir)) {
-    fs11.rmSync(hooksDir, { recursive: true, force: true });
+  if (fs12.existsSync(hooksDir)) {
+    fs12.rmSync(hooksDir, { recursive: true, force: true });
     removed = true;
   }
-  if (fs11.existsSync(settingsPath)) {
+  if (fs12.existsSync(settingsPath)) {
     try {
-      const settings = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
+      const settings = JSON.parse(fs12.readFileSync(settingsPath, "utf-8"));
       if (settings.hooks !== void 0) {
         delete settings.hooks;
         settingsCleaned = true;
         if (Object.keys(settings).length === 0) {
-          fs11.unlinkSync(settingsPath);
+          fs12.unlinkSync(settingsPath);
         } else {
-          fs11.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+          fs12.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
         }
       }
     } catch {
@@ -5200,20 +5246,20 @@ function createRemoveCommand() {
 
 // src/commands/hooks/add.ts
 import { Command as Command41 } from "commander";
-import * as fs12 from "fs";
-import * as path26 from "path";
+import * as fs13 from "fs";
+import * as path27 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-var __dirname3 = path26.dirname(fileURLToPath3(import.meta.url));
+var __dirname3 = path27.dirname(fileURLToPath3(import.meta.url));
 var ALIASES = {
   sentinel: ["sentinel-pre", "sentinel-post"]
 };
 function hookSourceDir() {
-  const d = path26.resolve(__dirname3, "..", "..", "hooks");
-  if (fs12.existsSync(d)) return d;
+  const d = path27.resolve(__dirname3, "..", "..", "hooks");
+  if (fs13.existsSync(d)) return d;
   throw new Error(`Hook scripts not found: ${d}`);
 }
 function readJson(p) {
-  return fs12.existsSync(p) ? JSON.parse(fs12.readFileSync(p, "utf-8")) : {};
+  return fs13.existsSync(p) ? JSON.parse(fs13.readFileSync(p, "utf-8")) : {};
 }
 function registerHook(s, ev, matcher, name) {
   if (!s.hooks[ev]) s.hooks[ev] = [];
@@ -5226,11 +5272,11 @@ function addHooks(hookName, projectDir) {
   const names = ALIASES[hookName] ?? [hookName];
   const result = { added: [], alreadyInstalled: [], notFound: [] };
   const srcDir = hookSourceDir();
-  const destDir = path26.join(projectDir, ".harness", "hooks");
-  fs12.mkdirSync(destDir, { recursive: true });
-  const claudeDir = path26.join(projectDir, ".claude");
-  fs12.mkdirSync(claudeDir, { recursive: true });
-  const settingsPath = path26.join(claudeDir, "settings.json");
+  const destDir = path27.join(projectDir, ".harness", "hooks");
+  fs13.mkdirSync(destDir, { recursive: true });
+  const claudeDir = path27.join(projectDir, ".claude");
+  fs13.mkdirSync(claudeDir, { recursive: true });
+  const settingsPath = path27.join(claudeDir, "settings.json");
   const settings = readJson(settingsPath);
   if (!settings.hooks) settings.hooks = {};
   for (const name of names) {
@@ -5239,27 +5285,27 @@ function addHooks(hookName, projectDir) {
       result.notFound.push(name);
       continue;
     }
-    const src = path26.join(srcDir, `${name}.js`);
-    const dest = path26.join(destDir, `${name}.js`);
-    if (fs12.existsSync(dest)) {
+    const src = path27.join(srcDir, `${name}.js`);
+    const dest = path27.join(destDir, `${name}.js`);
+    if (fs13.existsSync(dest)) {
       result.alreadyInstalled.push(name);
-    } else if (!fs12.existsSync(src)) {
+    } else if (!fs13.existsSync(src)) {
       result.notFound.push(name);
       continue;
     } else {
-      fs12.copyFileSync(src, dest);
+      fs13.copyFileSync(src, dest);
       result.added.push(name);
     }
     registerHook(settings, def.event, def.matcher, name);
   }
   for (const supportFile of supportFilesFor(names)) {
-    const src = path26.join(srcDir, supportFile);
-    const dest = path26.join(destDir, supportFile);
-    if (fs12.existsSync(src)) {
-      fs12.copyFileSync(src, dest);
+    const src = path27.join(srcDir, supportFile);
+    const dest = path27.join(destDir, supportFile);
+    if (fs13.existsSync(src)) {
+      fs13.copyFileSync(src, dest);
     }
   }
-  fs12.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  fs13.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   return result;
 }
 function createAddCommand2() {
@@ -5299,8 +5345,8 @@ function createHooksCommand() {
 // src/commands/impact-preview.ts
 import { Command as Command43 } from "commander";
 import { execSync as execSync4 } from "child_process";
-import * as path27 from "path";
-import * as fs13 from "fs";
+import * as path28 from "path";
+import * as fs14 from "fs";
 function getStagedFiles(cwd) {
   try {
     const output = execSync4("git diff --cached --name-only", {
@@ -5314,7 +5360,7 @@ function getStagedFiles(cwd) {
 }
 function graphExists(projectPath) {
   try {
-    return fs13.existsSync(path27.join(projectPath, ".harness", "graph", "graph.json"));
+    return fs14.existsSync(path28.join(projectPath, ".harness", "graph", "graph.json"));
   } catch {
     return false;
   }
@@ -5323,7 +5369,7 @@ function extractNodeName(id) {
   const parts = id.split(":");
   if (parts.length > 1) {
     const fullPath = parts.slice(1).join(":");
-    return path27.basename(fullPath);
+    return path28.basename(fullPath);
   }
   return id;
 }
@@ -5478,7 +5524,7 @@ function formatImpactOutput(stagedFiles, acc, options) {
   return options.detailed ? formatDetailed(stagedFiles.length, merged, acc.aggregateCounts) : formatCompact(stagedFiles.length, merged, acc.aggregateCounts);
 }
 async function runImpactPreview(options) {
-  const projectPath = path27.resolve(options.path ?? process.cwd());
+  const projectPath = path28.resolve(options.path ?? process.cwd());
   const stagedFiles = getStagedFiles(projectPath);
   if (stagedFiles.length === 0) return "Impact Preview: no staged changes";
   if (!graphExists(projectPath)) {
@@ -5512,26 +5558,26 @@ function createImpactPreviewCommand() {
 init_dist3();
 import { Command as Command45 } from "commander";
 import chalk4 from "chalk";
-import * as fs16 from "fs";
-import * as path30 from "path";
+import * as fs17 from "fs";
+import * as path31 from "path";
 
 // src/commands/setup-mcp.ts
 import { Command as Command44 } from "commander";
-import * as fs15 from "fs";
-import * as path29 from "path";
+import * as fs16 from "fs";
+import * as path30 from "path";
 import * as os2 from "os";
 import chalk3 from "chalk";
 import * as clack from "@clack/prompts";
 
 // src/integrations/toml.ts
-import * as fs14 from "fs";
-import * as path28 from "path";
+import * as fs15 from "fs";
+import * as path29 from "path";
 function writeTomlMcpEntry(filePath, name, entry) {
-  const dir = path28.dirname(filePath);
-  if (!fs14.existsSync(dir)) {
-    fs14.mkdirSync(dir, { recursive: true });
+  const dir = path29.dirname(filePath);
+  if (!fs15.existsSync(dir)) {
+    fs15.mkdirSync(dir, { recursive: true });
   }
-  const existing = fs14.existsSync(filePath) ? fs14.readFileSync(filePath, "utf-8") : "";
+  const existing = fs15.existsSync(filePath) ? fs15.readFileSync(filePath, "utf-8") : "";
   const blockHeader = `[mcp_servers.${name}]`;
   const newBlock = serializeTomlMcpBlock(name, entry);
   let updated;
@@ -5542,8 +5588,8 @@ function writeTomlMcpEntry(filePath, name, entry) {
     updated = existing + separator + newBlock;
   }
   const tmp = filePath + ".tmp";
-  fs14.writeFileSync(tmp, updated);
-  fs14.renameSync(tmp, filePath);
+  fs15.writeFileSync(tmp, updated);
+  fs15.renameSync(tmp, filePath);
 }
 function serializeTomlMcpBlock(name, entry) {
   const lines = [`[mcp_servers.${name}]`];
@@ -5664,6 +5710,7 @@ var ALL_MCP_TOOLS = [
   "ask_graph",
   "check_task_independence",
   "predict_conflicts",
+  "plan_parallelization",
   "detect_stale_constraints",
   "search_skills",
   "code_outline",
@@ -5759,20 +5806,20 @@ function writeCursorMcpEntryWithTools(configPath, tools) {
   });
 }
 function readJsonFile(filePath) {
-  if (!fs15.existsSync(filePath)) return null;
+  if (!fs16.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs15.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs16.readFileSync(filePath, "utf-8"));
   } catch {
-    fs15.copyFileSync(filePath, filePath + ".bak");
+    fs16.copyFileSync(filePath, filePath + ".bak");
     return null;
   }
 }
 function writeJsonFile(filePath, data) {
-  const dir = path29.dirname(filePath);
-  if (!fs15.existsSync(dir)) {
-    fs15.mkdirSync(dir, { recursive: true });
+  const dir = path30.dirname(filePath);
+  if (!fs16.existsSync(dir)) {
+    fs16.mkdirSync(dir, { recursive: true });
   }
-  fs15.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  fs16.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 }
 function configureMcpServer(configPath) {
   const config = readJsonFile(configPath) ?? {};
@@ -5787,7 +5834,7 @@ function configureMcpServer(configPath) {
   return true;
 }
 function addGeminiTrustedFolder(cwd) {
-  const trustedPath = path29.join(os2.homedir(), ".gemini", "trustedFolders.json");
+  const trustedPath = path30.join(os2.homedir(), ".gemini", "trustedFolders.json");
   const folders = readJsonFile(trustedPath) ?? {};
   if (folders[cwd] === "TRUST_FOLDER") {
     return false;
@@ -5801,7 +5848,7 @@ function setupMcp(cwd, client) {
   const skipped = [];
   let trustedFolder = false;
   if (client === "all" || client === "claude") {
-    const configPath = path29.join(cwd, ".mcp.json");
+    const configPath = path30.join(cwd, ".mcp.json");
     if (configureMcpServer(configPath)) {
       configured.push("Claude Code");
     } else {
@@ -5809,7 +5856,7 @@ function setupMcp(cwd, client) {
     }
   }
   if (client === "all" || client === "gemini") {
-    const configPath = path29.join(cwd, ".gemini", "settings.json");
+    const configPath = path30.join(cwd, ".gemini", "settings.json");
     if (configureMcpServer(configPath)) {
       configured.push("Gemini CLI");
     } else {
@@ -5818,10 +5865,10 @@ function setupMcp(cwd, client) {
     trustedFolder = addGeminiTrustedFolder(cwd);
   }
   if (client === "all" || client === "codex") {
-    const configPath = path29.join(cwd, ".codex", "config.toml");
+    const configPath = path30.join(cwd, ".codex", "config.toml");
     const alreadyConfigured = (() => {
-      if (!fs15.existsSync(configPath)) return false;
-      const content = fs15.readFileSync(configPath, "utf-8");
+      if (!fs16.existsSync(configPath)) return false;
+      const content = fs16.readFileSync(configPath, "utf-8");
       return content.includes("[mcp_servers.harness]");
     })();
     if (alreadyConfigured) {
@@ -5836,7 +5883,7 @@ function setupMcp(cwd, client) {
     }
   }
   if (client === "all" || client === "cursor") {
-    const configPath = path29.join(cwd, ".cursor", "mcp.json");
+    const configPath = path30.join(cwd, ".cursor", "mcp.json");
     const existing = readJsonFile(configPath);
     if (existing?.mcpServers?.["harness"]) {
       skipped.push("Cursor");
@@ -5846,7 +5893,7 @@ function setupMcp(cwd, client) {
     }
   }
   if (client === "all" || client === "opencode") {
-    const configPath = path29.join(cwd, "opencode.json");
+    const configPath = path30.join(cwd, "opencode.json");
     const existing = readJsonFile(configPath);
     if (existing?.mcp?.["harness"]) {
       skipped.push("OpenCode");
@@ -5860,7 +5907,7 @@ function setupMcp(cwd, client) {
 async function resolveCursorWithPicker(cwd, pick) {
   const configured = [];
   const skipped = [];
-  const cursorConfigPath = path29.join(cwd, ".cursor", "mcp.json");
+  const cursorConfigPath = path30.join(cwd, ".cursor", "mcp.json");
   const existing = readJsonFile(cursorConfigPath);
   if (existing?.mcpServers?.["harness"] && !pick) {
     skipped.push("Cursor");
@@ -5958,12 +6005,12 @@ function loadEngineAndTemplates(_options) {
 }
 function resolveInitDefaults(options) {
   const cwd = options.cwd ?? process.cwd();
-  return { cwd, name: options.name ?? path30.basename(cwd), force: options.force ?? false };
+  return { cwd, name: options.name ?? path31.basename(cwd), force: options.force ?? false };
 }
 async function runInit(options) {
   const { cwd, name, force } = resolveInitDefaults(options);
-  const configPath = path30.join(cwd, "harness.config.json");
-  if (!force && fs16.existsSync(configPath)) {
+  const configPath = path31.join(cwd, "harness.config.json");
+  if (!force && fs17.existsSync(configPath)) {
     return Err(
       new CLIError("Project already initialized. Use --force to overwrite.", ExitCode.ERROR)
     );
@@ -6059,15 +6106,15 @@ async function scaffoldProject(engine, ctx) {
 }
 function scaffoldShardedRoadmap(cwd, name) {
   if (roadmapSourceExists(cwd)) return [];
-  const shardDir = path30.join(cwd, "docs", "roadmap.d");
-  fs16.mkdirSync(shardDir, { recursive: true });
+  const shardDir = path31.join(cwd, "docs", "roadmap.d");
+  fs17.mkdirSync(shardDir, { recursive: true });
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   const meta = {
     frontmatter: { project: name, version: 1, lastSynced: nowIso, lastManualEdit: nowIso },
     milestones: []
   };
-  fs16.writeFileSync(path30.join(shardDir, "_meta.md"), serializeMeta(meta), "utf-8");
-  return [path30.join("docs", "roadmap.d", "_meta.md")];
+  fs17.writeFileSync(path31.join(shardDir, "_meta.md"), serializeMeta(meta), "utf-8");
+  return [path31.join("docs", "roadmap.d", "_meta.md")];
 }
 function printInitSuccess(filesCreated, mcpConfigured) {
   console.log("");
@@ -6162,7 +6209,7 @@ function createInsightsCommand() {
   return new Command46("insights").description("Composite project report \u2014 health, entropy, decay, attention, impact.").option("--json", "Emit JSON to stdout instead of pretty text").option("--skip <list>", `Comma-separated keys to skip (${INSIGHTS_KEYS.join(",")})`).action(async (opts) => {
     const cwd = process.cwd();
     const skip = parseSkip2(opts.skip);
-    const { composeInsights } = await import("./dist-MCTEX5QH.js");
+    const { composeInsights } = await import("./dist-BWFFVKEW.js");
     const report = await composeInsights(cwd, { skip });
     if (opts.json) {
       console.log(JSON.stringify(report, null, 2));
@@ -6173,16 +6220,16 @@ function createInsightsCommand() {
 }
 
 // src/commands/install.ts
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 import * as os5 from "os";
-import * as path35 from "path";
+import * as path36 from "path";
 import { execFileSync as execFileSync3 } from "child_process";
 import { Command as Command47 } from "commander";
 import { parse as yamlParse } from "yaml";
 
 // src/registry/npm-client.ts
-import * as fs17 from "fs";
-import * as path31 from "path";
+import * as fs18 from "fs";
+import * as path32 from "path";
 import * as os3 from "os";
 var NPM_REGISTRY = "https://registry.npmjs.org";
 var FETCH_TIMEOUT_MS = 3e4;
@@ -6205,10 +6252,10 @@ function extractSkillName(packageName) {
 function readNpmrcToken(registryUrl) {
   const { hostname: hostname2, pathname } = new URL(registryUrl);
   const registryPath = `//${hostname2}${pathname.replace(/\/$/, "")}/:_authToken=`;
-  const candidates = [path31.join(process.cwd(), ".npmrc"), path31.join(os3.homedir(), ".npmrc")];
+  const candidates = [path32.join(process.cwd(), ".npmrc"), path32.join(os3.homedir(), ".npmrc")];
   for (const npmrcPath of candidates) {
     try {
-      const content = fs17.readFileSync(npmrcPath, "utf-8");
+      const content = fs18.readFileSync(npmrcPath, "utf-8");
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (trimmed.startsWith(registryPath)) {
@@ -6303,19 +6350,19 @@ async function searchNpmRegistry(query, registryUrl) {
 }
 
 // src/registry/tarball.ts
-import * as fs18 from "fs";
-import * as path32 from "path";
+import * as fs19 from "fs";
+import * as path33 from "path";
 import * as os4 from "os";
 import { execFileSync as execFileSync2 } from "child_process";
 function extractTarball(tarballBuffer) {
-  const tmpDir = fs18.mkdtempSync(path32.join(os4.tmpdir(), "harness-skill-install-"));
-  const tarballPath = path32.join(tmpDir, "package.tgz");
+  const tmpDir = fs19.mkdtempSync(path33.join(os4.tmpdir(), "harness-skill-install-"));
+  const tarballPath = path33.join(tmpDir, "package.tgz");
   try {
-    fs18.writeFileSync(tarballPath, tarballBuffer);
+    fs19.writeFileSync(tarballPath, tarballBuffer);
     execFileSync2("tar", ["-xzf", tarballPath, "-C", tmpDir], {
       timeout: 3e4
     });
-    fs18.unlinkSync(tarballPath);
+    fs19.unlinkSync(tarballPath);
   } catch (err) {
     cleanupTempDir(tmpDir);
     throw new Error(
@@ -6326,37 +6373,37 @@ function extractTarball(tarballBuffer) {
   return tmpDir;
 }
 function placeSkillContent(extractedPkgDir, communityBaseDir, skillName, platforms) {
-  const files = fs18.readdirSync(extractedPkgDir);
+  const files = fs19.readdirSync(extractedPkgDir);
   for (const platform of platforms) {
-    const targetDir = path32.join(communityBaseDir, platform, skillName);
-    if (fs18.existsSync(targetDir)) {
-      fs18.rmSync(targetDir, { recursive: true, force: true });
+    const targetDir = path33.join(communityBaseDir, platform, skillName);
+    if (fs19.existsSync(targetDir)) {
+      fs19.rmSync(targetDir, { recursive: true, force: true });
     }
-    fs18.mkdirSync(targetDir, { recursive: true });
+    fs19.mkdirSync(targetDir, { recursive: true });
     for (const file of files) {
       if (file === "package.json" || file === "node_modules") continue;
-      const srcPath = path32.join(extractedPkgDir, file);
-      const destPath = path32.join(targetDir, file);
-      const stat = fs18.statSync(srcPath);
+      const srcPath = path33.join(extractedPkgDir, file);
+      const destPath = path33.join(targetDir, file);
+      const stat = fs19.statSync(srcPath);
       if (stat.isDirectory()) {
-        fs18.cpSync(srcPath, destPath, { recursive: true });
+        fs19.cpSync(srcPath, destPath, { recursive: true });
       } else {
-        fs18.copyFileSync(srcPath, destPath);
+        fs19.copyFileSync(srcPath, destPath);
       }
     }
   }
 }
 function removeSkillContent(communityBaseDir, skillName, platforms) {
   for (const platform of platforms) {
-    const targetDir = path32.join(communityBaseDir, platform, skillName);
-    if (fs18.existsSync(targetDir)) {
-      fs18.rmSync(targetDir, { recursive: true, force: true });
+    const targetDir = path33.join(communityBaseDir, platform, skillName);
+    if (fs19.existsSync(targetDir)) {
+      fs19.rmSync(targetDir, { recursive: true, force: true });
     }
   }
 }
 function cleanupTempDir(dirPath) {
   try {
-    fs18.rmSync(dirPath, { recursive: true, force: true });
+    fs19.rmSync(dirPath, { recursive: true, force: true });
   } catch {
   }
 }
@@ -6398,8 +6445,8 @@ function findDependentsOf(lockfile, targetPackageName) {
 }
 
 // src/registry/lockfile.ts
-import * as fs19 from "fs";
-import * as path33 from "path";
+import * as fs20 from "fs";
+import * as path34 from "path";
 function createEmptyLockfile() {
   return { version: 1, skills: {} };
 }
@@ -6419,10 +6466,10 @@ function sortedStringify(obj) {
   );
 }
 function readLockfile2(filePath) {
-  if (!fs19.existsSync(filePath)) {
+  if (!fs20.existsSync(filePath)) {
     return createEmptyLockfile();
   }
-  const raw = fs19.readFileSync(filePath, "utf-8");
+  const raw = fs20.readFileSync(filePath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -6439,9 +6486,9 @@ function readLockfile2(filePath) {
   return parsed;
 }
 function writeLockfile2(filePath, lockfile) {
-  const dir = path33.dirname(filePath);
-  fs19.mkdirSync(dir, { recursive: true });
-  fs19.writeFileSync(filePath, sortedStringify(lockfile) + "\n", "utf-8");
+  const dir = path34.dirname(filePath);
+  fs20.mkdirSync(dir, { recursive: true });
+  fs20.writeFileSync(filePath, sortedStringify(lockfile) + "\n", "utf-8");
 }
 function updateLockfileEntry(lockfile, name, entry) {
   return {
@@ -6464,17 +6511,17 @@ function removeLockfileEntry(lockfile, name) {
 }
 
 // src/registry/bundled-skills.ts
-import * as fs20 from "fs";
-import * as path34 from "path";
+import * as fs21 from "fs";
+import * as path35 from "path";
 function getBundledSkillNames(bundledSkillsDir) {
-  if (!fs20.existsSync(bundledSkillsDir)) {
+  if (!fs21.existsSync(bundledSkillsDir)) {
     return /* @__PURE__ */ new Set();
   }
-  const entries = fs20.readdirSync(bundledSkillsDir);
+  const entries = fs21.readdirSync(bundledSkillsDir);
   const names = /* @__PURE__ */ new Set();
   for (const entry of entries) {
     try {
-      const stat = fs20.statSync(path34.join(bundledSkillsDir, String(entry)));
+      const stat = fs21.statSync(path35.join(bundledSkillsDir, String(entry)));
       if (stat.isDirectory()) {
         names.add(String(entry));
       }
@@ -6502,12 +6549,12 @@ function validateSkillYaml(parsed) {
 function resolveCommunityBase(global) {
   if (global) {
     const communityBase2 = resolveGlobalCommunityBaseDir();
-    return { communityBase: communityBase2, lockfilePath: path35.join(communityBase2, "skills-lock.json") };
+    return { communityBase: communityBase2, lockfilePath: path36.join(communityBase2, "skills-lock.json") };
   }
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path35.dirname(globalDir);
-  const communityBase = path35.join(skillsDir, "community");
-  return { communityBase, lockfilePath: path35.join(communityBase, "skills-lock.json") };
+  const skillsDir = path36.dirname(globalDir);
+  const communityBase = path36.join(skillsDir, "community");
+  return { communityBase, lockfilePath: path36.join(communityBase, "skills-lock.json") };
 }
 function parseGitHubRef(from) {
   const ghPrefix = from.match(/^github:([^/]+)\/([^#]+?)(?:#(.+))?$/);
@@ -6523,7 +6570,7 @@ function parseGitHubRef(from) {
   return null;
 }
 function cloneGitHubRepo(owner, repo, ref) {
-  const tmpDir = fs21.mkdtempSync(path35.join(os5.tmpdir(), "harness-gh-install-"));
+  const tmpDir = fs22.mkdtempSync(path36.join(os5.tmpdir(), "harness-gh-install-"));
   const url = `https://github.com/${owner}/${repo}.git`;
   try {
     const cloneArgs = ["clone", "--depth", "1"];
@@ -6544,43 +6591,43 @@ function discoverSkillDirs(rootDir) {
   const skillDirs = [];
   function scan(dir, depth) {
     if (depth > 3) return;
-    if (!fs21.existsSync(dir)) return;
-    if (fs21.existsSync(path35.join(dir, "skill.yaml"))) {
+    if (!fs22.existsSync(dir)) return;
+    if (fs22.existsSync(path36.join(dir, "skill.yaml"))) {
       skillDirs.push(dir);
       return;
     }
-    const entries = fs21.readdirSync(dir, { withFileTypes: true });
+    const entries = fs22.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".") || DEFAULT_SKIP_DIRS.has(entry.name)) continue;
-      scan(path35.join(dir, entry.name), depth + 1);
+      scan(path36.join(dir, entry.name), depth + 1);
     }
   }
   scan(rootDir, 0);
   return skillDirs;
 }
 function resolveLocalPkgDir(fromPath) {
-  const resolvedPath = path35.resolve(fromPath);
-  if (!fs21.existsSync(resolvedPath)) {
+  const resolvedPath = path36.resolve(fromPath);
+  if (!fs22.existsSync(resolvedPath)) {
     throw new Error(`--from path does not exist: ${resolvedPath}`);
   }
-  const stat = fs21.statSync(resolvedPath);
+  const stat = fs22.statSync(resolvedPath);
   if (stat.isDirectory()) {
     return { pkgDir: resolvedPath, extractDir: null };
   }
   if (resolvedPath.endsWith(".tgz") || resolvedPath.endsWith(".tar.gz")) {
-    const tarballBuffer = fs21.readFileSync(resolvedPath);
+    const tarballBuffer = fs22.readFileSync(resolvedPath);
     const extractDir = extractTarball(tarballBuffer);
-    return { pkgDir: path35.join(extractDir, "package"), extractDir };
+    return { pkgDir: path36.join(extractDir, "package"), extractDir };
   }
   throw new Error(`--from path must be a directory or .tgz file. Got: ${resolvedPath}`);
 }
 function installSkillDir(pkgDir, resolvedPath, options) {
-  const skillYamlPath = path35.join(pkgDir, "skill.yaml");
-  if (!fs21.existsSync(skillYamlPath)) {
+  const skillYamlPath = path36.join(pkgDir, "skill.yaml");
+  if (!fs22.existsSync(skillYamlPath)) {
     throw new Error(`No skill.yaml found at ${skillYamlPath}`);
   }
-  const skillYaml = validateSkillYaml(yamlParse(fs21.readFileSync(skillYamlPath, "utf-8")));
+  const skillYaml = validateSkillYaml(yamlParse(fs22.readFileSync(skillYamlPath, "utf-8")));
   const shortName = skillYaml.name;
   const { communityBase, lockfilePath } = resolveCommunityBase(options.global ?? false);
   if (!options.global) {
@@ -6608,7 +6655,7 @@ function installSkillDir(pkgDir, resolvedPath, options) {
 async function runLocalInstall(fromPath, options) {
   const { pkgDir, extractDir } = resolveLocalPkgDir(fromPath);
   try {
-    return installSkillDir(pkgDir, path35.resolve(fromPath), options);
+    return installSkillDir(pkgDir, path36.resolve(fromPath), options);
   } finally {
     if (extractDir) cleanupTempDir(extractDir);
   }
@@ -6651,8 +6698,8 @@ async function runInstall(skillName, options) {
         version: installed.map((r) => r.version).join(", ")
       };
     }
-    const resolvedFrom = path35.resolve(options.from);
-    if (fs21.existsSync(resolvedFrom) && fs21.statSync(resolvedFrom).isDirectory() && !fs21.existsSync(path35.join(resolvedFrom, "skill.yaml"))) {
+    const resolvedFrom = path36.resolve(options.from);
+    if (fs22.existsSync(resolvedFrom) && fs22.statSync(resolvedFrom).isDirectory() && !fs22.existsSync(path36.join(resolvedFrom, "skill.yaml"))) {
       const results = await runBulkInstall(resolvedFrom, options);
       const installed = results.filter((r) => r.installed);
       return {
@@ -6693,12 +6740,12 @@ async function runInstall(skillName, options) {
   const extractDir = extractTarball(tarballBuffer);
   let skillYaml;
   try {
-    const extractedPkgDir = path35.join(extractDir, "package");
-    const skillYamlPath = path35.join(extractedPkgDir, "skill.yaml");
-    if (!fs21.existsSync(skillYamlPath)) {
+    const extractedPkgDir = path36.join(extractDir, "package");
+    const skillYamlPath = path36.join(extractedPkgDir, "skill.yaml");
+    if (!fs22.existsSync(skillYamlPath)) {
       throw new Error(`contains invalid skill.yaml: file not found in package`);
     }
-    const rawYaml = fs21.readFileSync(skillYamlPath, "utf-8");
+    const rawYaml = fs22.readFileSync(skillYamlPath, "utf-8");
     const parsed = yamlParse(rawYaml);
     skillYaml = validateSkillYaml(parsed);
     placeSkillContent(extractedPkgDir, communityBase, shortName, skillYaml.platforms);
@@ -6772,15 +6819,15 @@ function createInstallCommand() {
 
 // src/commands/install-constraints.ts
 init_dist3();
-import * as fs22 from "fs/promises";
-import * as path36 from "path";
+import * as fs23 from "fs/promises";
+import * as path37 from "path";
 import { Command as Command48 } from "commander";
 import semver3 from "semver";
 async function runInstallConstraints(options) {
   const { source, configPath, lockfilePath } = options;
   let rawBundle;
   try {
-    rawBundle = await fs22.readFile(source, "utf-8");
+    rawBundle = await fs23.readFile(source, "utf-8");
   } catch (err) {
     if (isNodeError(err) && err.code === "ENOENT") {
       return { ok: false, error: `Bundle file not found: ${source}` };
@@ -6823,7 +6870,7 @@ async function runInstallConstraints(options) {
   }
   let localConfig;
   try {
-    const raw = await fs22.readFile(configPath, "utf-8");
+    const raw = await fs23.readFile(configPath, "utf-8");
     localConfig = JSON.parse(raw);
   } catch (err) {
     return {
@@ -6971,7 +7018,7 @@ function isNodeError(err) {
   return err instanceof Error && "code" in err;
 }
 function resolveConfigPath(opts) {
-  if (opts.config) return path36.resolve(opts.config);
+  if (opts.config) return path37.resolve(opts.config);
   const found = findConfigFile();
   if (!found.ok) {
     logger.error(found.error.message);
@@ -7006,9 +7053,9 @@ function logInstallResult(val, opts) {
 }
 async function handleInstallConstraints(source, opts) {
   const configPath = resolveConfigPath(opts);
-  const projectRoot2 = path36.dirname(configPath);
-  const lockfilePath = path36.join(projectRoot2, ".harness", "constraints.lock.json");
-  const resolvedSource = path36.resolve(source);
+  const projectRoot3 = path37.dirname(configPath);
+  const lockfilePath = path37.join(projectRoot3, ".harness", "constraints.lock.json");
+  const resolvedSource = path37.resolve(source);
   if (opts.forceLocal && opts.forcePackage) {
     logger.error("Cannot use both --force-local and --force-package.");
     process.exit(1);
@@ -7039,8 +7086,8 @@ import { Command as Command53 } from "commander";
 // src/commands/integrations/add.ts
 init_dist3();
 import { Command as Command49 } from "commander";
-import * as fs23 from "fs";
-import * as path37 from "path";
+import * as fs24 from "fs";
+import * as path38 from "path";
 import chalk5 from "chalk";
 function buildMcpEntry(def) {
   const entry = { command: def.mcpConfig.command };
@@ -7049,14 +7096,14 @@ function buildMcpEntry(def) {
   return entry;
 }
 function writeMcpEntries(cwd, defName, mcpEntry) {
-  writeMcpEntry(path37.join(cwd, ".mcp.json"), defName, mcpEntry);
-  const geminiDir = path37.join(cwd, ".gemini");
-  if (fs23.existsSync(geminiDir)) {
-    writeMcpEntry(path37.join(geminiDir, "settings.json"), defName, mcpEntry);
+  writeMcpEntry(path38.join(cwd, ".mcp.json"), defName, mcpEntry);
+  const geminiDir = path38.join(cwd, ".gemini");
+  if (fs24.existsSync(geminiDir)) {
+    writeMcpEntry(path38.join(geminiDir, "settings.json"), defName, mcpEntry);
   }
 }
 function updateIntegrationsConfig(cwd, defName) {
-  const configPath = path37.join(cwd, "harness.config.json");
+  const configPath = path38.join(cwd, "harness.config.json");
   const integConfig = readIntegrationsConfig(configPath);
   if (!integConfig.enabled.includes(defName)) integConfig.enabled.push(defName);
   integConfig.dismissed = integConfig.dismissed.filter((d) => d !== defName);
@@ -7117,7 +7164,7 @@ function createAddIntegrationCommand() {
 
 // src/commands/integrations/list.ts
 import { Command as Command50 } from "commander";
-import * as path38 from "path";
+import * as path39 from "path";
 import chalk6 from "chalk";
 function printTier0Integrations(tier0, mcpServers) {
   console.log("  Tier 0 (zero-config):");
@@ -7141,8 +7188,8 @@ function printTier1Integrations(tier1, mcpServers, dismissed) {
 }
 async function runListIntegrations(globalOpts) {
   const cwd = process.cwd();
-  const mcpConfig = readMcpConfig(path38.join(cwd, ".mcp.json"));
-  const integConfig = readIntegrationsConfig(path38.join(cwd, "harness.config.json"));
+  const mcpConfig = readMcpConfig(path39.join(cwd, ".mcp.json"));
+  const integConfig = readIntegrationsConfig(path39.join(cwd, "harness.config.json"));
   const mcpServers = mcpConfig.mcpServers ?? {};
   if (globalOpts.json) {
     const entries = INTEGRATION_REGISTRY.map((i) => ({
@@ -7179,8 +7226,8 @@ function createListIntegrationsCommand() {
 // src/commands/integrations/remove.ts
 init_dist3();
 import { Command as Command51 } from "commander";
-import * as fs24 from "fs";
-import * as path39 from "path";
+import * as fs25 from "fs";
+import * as path40 from "path";
 function removeIntegration(cwd, name) {
   const def = INTEGRATION_REGISTRY.find((i) => i.name === name);
   if (!def) {
@@ -7191,14 +7238,14 @@ function removeIntegration(cwd, name) {
       )
     );
   }
-  const mcpPath = path39.join(cwd, ".mcp.json");
+  const mcpPath = path40.join(cwd, ".mcp.json");
   removeMcpEntry(mcpPath, def.name);
-  const geminiDir = path39.join(cwd, ".gemini");
-  if (fs24.existsSync(geminiDir)) {
-    const geminiPath = path39.join(geminiDir, "settings.json");
+  const geminiDir = path40.join(cwd, ".gemini");
+  if (fs25.existsSync(geminiDir)) {
+    const geminiPath = path40.join(geminiDir, "settings.json");
     removeMcpEntry(geminiPath, def.name);
   }
-  const configPath = path39.join(cwd, "harness.config.json");
+  const configPath = path40.join(cwd, "harness.config.json");
   const integConfig = readIntegrationsConfig(configPath);
   integConfig.enabled = integConfig.enabled.filter((e) => e !== def.name);
   writeIntegrationsConfig(configPath, integConfig);
@@ -7228,7 +7275,7 @@ function createRemoveIntegrationCommand() {
 // src/commands/integrations/dismiss.ts
 init_dist3();
 import { Command as Command52 } from "commander";
-import * as path40 from "path";
+import * as path41 from "path";
 function dismissIntegration(cwd, name) {
   const def = INTEGRATION_REGISTRY.find((i) => i.name === name);
   if (!def) {
@@ -7239,7 +7286,7 @@ function dismissIntegration(cwd, name) {
       )
     );
   }
-  const configPath = path40.join(cwd, "harness.config.json");
+  const configPath = path41.join(cwd, "harness.config.json");
   const integConfig = readIntegrationsConfig(configPath);
   if (!integConfig.dismissed.includes(def.name)) {
     integConfig.dismissed.push(def.name);
@@ -7334,10 +7381,10 @@ function printResult3(result, mode, _formatter) {
       list.push(f);
       byFile.set(f.target.file, list);
     }
-    for (const [file, fs50] of byFile) {
+    for (const [file, fs51] of byFile) {
       console.log(`
 ${file}`);
-      for (const f of fs50) {
+      for (const f of fs51) {
         console.log(`  ${f.code} [${f.tier}/${f.impact}/${f.confidence}] ${f.target.relative}`);
         console.log(`    ${f.message}`);
         if (verbose) console.log(`    source: ${f.cite.source}`);
@@ -7352,7 +7399,7 @@ ${file}`);
 
 // src/commands/knowledge-pipeline.ts
 import { Command as Command55 } from "commander";
-import * as path41 from "path";
+import * as path42 from "path";
 import chalk7 from "chalk";
 function resolveInferenceOptions(cfgKnowledge) {
   const patterns = cfgKnowledge?.domainPatterns;
@@ -7519,9 +7566,9 @@ function createKnowledgePipelineCommand() {
     const globalOpts = cmd.optsWithGlobals();
     const projectDir = process.cwd();
     try {
-      const graphDir = path41.join(projectDir, ".harness", "graph");
-      const fs50 = await import("fs/promises");
-      await fs50.mkdir(graphDir, { recursive: true });
+      const graphDir = path42.join(projectDir, ".harness", "graph");
+      const fs51 = await import("fs/promises");
+      await fs51.mkdir(graphDir, { recursive: true });
       const { GraphStore: GraphStore2, KnowledgePipelineRunner } = await import("./dist-DWBTZXR5.js");
       const store = new GraphStore2();
       try {
@@ -7566,9 +7613,9 @@ import { Command as Command57 } from "commander";
 // src/commands/learnings/prune.ts
 init_dist3();
 import { Command as Command56 } from "commander";
-import * as path42 from "path";
+import * as path43 from "path";
 async function handlePrune(opts) {
-  const projectPath = path42.resolve(opts.path);
+  const projectPath = path43.resolve(opts.path);
   const result = await pruneLearnings(projectPath, opts.stream);
   if (!result.ok) {
     logger.error(result.error.message);
@@ -7720,21 +7767,21 @@ function createLinterCommand() {
 
 // src/commands/maintenance.ts
 import { Command as Command61 } from "commander";
-import * as path45 from "path";
+import * as path46 from "path";
 import chalk8 from "chalk";
 import { TaskOutputStore as TaskOutputStore2 } from "@harness-engineering/orchestrator";
 
 // src/commands/maintenance-config.ts
-import * as path43 from "path";
-import * as fs25 from "fs";
+import * as path44 from "path";
+import * as fs26 from "fs";
 import {
   BUILT_IN_TASKS,
   WorkflowLoader,
   migrateAgentConfig
 } from "@harness-engineering/orchestrator";
 async function loadMaintenanceConfig(cwd) {
-  const workflowPath = path43.join(cwd, "harness.orchestrator.md");
-  if (!fs25.existsSync(workflowPath)) return null;
+  const workflowPath = path44.join(cwd, "harness.orchestrator.md");
+  if (!fs26.existsSync(workflowPath)) return null;
   const loader = new WorkflowLoader();
   const result = await loader.loadWorkflow(workflowPath);
   if (!result.ok) return null;
@@ -7742,8 +7789,8 @@ async function loadMaintenanceConfig(cwd) {
   return result.value.config.maintenance ?? null;
 }
 async function loadAgentBackends(cwd) {
-  const workflowPath = path43.join(cwd, "harness.orchestrator.md");
-  if (!fs25.existsSync(workflowPath)) return null;
+  const workflowPath = path44.join(cwd, "harness.orchestrator.md");
+  if (!fs26.existsSync(workflowPath)) return null;
   const loader = new WorkflowLoader();
   const result = await loader.loadWorkflow(workflowPath);
   if (!result.ok) return null;
@@ -7814,9 +7861,9 @@ function copyOptional(src, dst, keys) {
 }
 
 // src/commands/maintenance-run.ts
-import * as path44 from "path";
+import * as path45 from "path";
 import * as os6 from "os";
-import * as fs26 from "fs";
+import * as fs27 from "fs";
 import { execFile, execFileSync as execFileSync4 } from "child_process";
 import { promisify } from "util";
 import {
@@ -7909,7 +7956,7 @@ function createFixDispatcher(resolveBackend, git = realGit) {
 }
 function buildTaskRunner(cwd, config, mode, harnessEntry, resolveBackend = () => null) {
   const outputStore = new TaskOutputStore({
-    rootDir: path44.join(cwd, ".harness", "maintenance")
+    rootDir: path45.join(cwd, ".harness", "maintenance")
   });
   return new TaskRunner({
     config,
@@ -7924,7 +7971,7 @@ function buildTaskRunner(cwd, config, mode, harnessEntry, resolveBackend = () =>
 }
 async function loadRunHistory(cwd) {
   const reporter = new MaintenanceReporter({
-    persistDir: path44.join(cwd, ".harness", "maintenance")
+    persistDir: path45.join(cwd, ".harness", "maintenance")
   });
   await reporter.load();
   return reporter.getHistory(500, 0);
@@ -8032,16 +8079,16 @@ function renderTable(report) {
 var NO_BACKEND_FIX_WARNING = "--fix: no agent backend configured for maintenance dispatch \u2014 dispatch was skipped and nothing was fixed. Configure agent.backends in harness.orchestrator.md (and maintenance.aiBackend), or run maintenance via the orchestrator.";
 async function defaultRecord(cwd, results) {
   const reporter = new MaintenanceReporter({
-    persistDir: path44.join(cwd, ".harness", "maintenance")
+    persistDir: path45.join(cwd, ".harness", "maintenance")
   });
   await reporter.load();
   for (const r of results) await reporter.record(r);
 }
 function writeSummary(cwd, report) {
-  const dir = path44.join(cwd, ".harness", "maintenance");
-  fs26.mkdirSync(dir, { recursive: true });
-  fs26.writeFileSync(
-    path44.join(dir, "last-run-summary.json"),
+  const dir = path45.join(cwd, ".harness", "maintenance");
+  fs27.mkdirSync(dir, { recursive: true });
+  fs27.writeFileSync(
+    path45.join(dir, "last-run-summary.json"),
     JSON.stringify(report, null, 2),
     "utf-8"
   );
@@ -8168,7 +8215,7 @@ function createMaintenanceCommand() {
     "Inspect built-in + custom maintenance tasks and their persisted outputs"
   );
   command.command("list").description("List all resolved maintenance tasks (built-in + customTasks)").option("--json", "Emit machine-readable JSON", false).option("--path <path>", "Project root path", ".").action(async (opts) => {
-    const cwd = path45.resolve(opts.path);
+    const cwd = path46.resolve(opts.path);
     const config = await loadMaintenanceConfig(cwd);
     const tasks = mergeResolvedTasks(config);
     const rows = tasks.map((t) => ({
@@ -8189,7 +8236,7 @@ function createMaintenanceCommand() {
     process.exit(ExitCode.SUCCESS);
   });
   command.command("run [taskId...]").description("Run overdue (default) / selected maintenance tasks; report-first unless --fix").option("--all", "Run all sweep-eligible tasks (not just overdue)", false).option("--only <ids>", "Comma-separated task ids to run").option("--skip <ids>", "Comma-separated task ids to exclude").option("--fix", "Dispatch fixes per task type (default: report-only)", false).option("--concurrency <n>", "Max parallel tasks (report mode); --fix forces 1").option("--json", "Emit machine-readable consolidated report", false).option("--path <path>", "Project root path", ".").action(async (taskIds, opts, command2) => {
-    const cwd = path45.resolve(opts.path);
+    const cwd = path46.resolve(opts.path);
     const json = Boolean(command2.optsWithGlobals().json);
     const result = await runMaintenanceRun(cwd, {
       positional: taskIds,
@@ -8209,10 +8256,10 @@ async function runShow(taskId, opts) {
     console.error(`Invalid task id '${taskId}' (must match ^[a-z0-9][a-z0-9-]*$).`);
     process.exit(ExitCode.ERROR);
   }
-  const cwd = path45.resolve(opts.path ?? ".");
+  const cwd = path46.resolve(opts.path ?? ".");
   const limit = Math.max(1, parseInt(opts.limit ?? "5", 10) || 5);
   const store = new TaskOutputStore2({
-    rootDir: path45.join(cwd, ".harness", "maintenance")
+    rootDir: path46.join(cwd, ".harness", "maintenance")
   });
   const entries = await store.list(taskId, limit, 0);
   renderShow(taskId, entries, Boolean(opts.json));
@@ -8273,7 +8320,7 @@ function createMcpCommand() {
     parseBudget
   ).action(async (opts) => {
     const [{ startServer: startServer2, getToolDefinitions: getToolDefinitions2 }, { selectTier }] = await Promise.all([
-      import("./mcp-5V4LPMB3.js"),
+      import("./mcp-RIPEYDMU.js"),
       import("./tool-tiers-OKK5FE57.js")
     ]);
     if (opts.tools && opts.tools.length > 0) {
@@ -8296,8 +8343,8 @@ function createMcpCommand() {
 // src/commands/mcp-guard.ts
 init_dist3();
 import { Command as Command63 } from "commander";
-import * as fs27 from "fs";
-import * as path46 from "path";
+import * as fs28 from "fs";
+import * as path47 from "path";
 import chalk9 from "chalk";
 function extractNpmPackages(config) {
   const out = [];
@@ -8336,18 +8383,18 @@ function parseNpmSpec(spec) {
 }
 async function runMcpGuardCheck(options = {}) {
   const cwd = options.cwd ?? process.cwd();
-  const configPath = options.configPath ?? path46.join(cwd, ".mcp.json");
-  if (!fs27.existsSync(configPath)) {
+  const configPath = options.configPath ?? path47.join(cwd, ".mcp.json");
+  if (!fs28.existsSync(configPath)) {
     return { ok: true, checked: [] };
   }
   let config;
   try {
-    config = JSON.parse(fs27.readFileSync(configPath, "utf-8"));
+    config = JSON.parse(fs28.readFileSync(configPath, "utf-8"));
   } catch {
     return { ok: true, checked: [] };
   }
   const pkgs = extractNpmPackages(config);
-  const cacheDir = path46.join(cwd, ".harness", "cache", "osv");
+  const cacheDir = path47.join(cwd, ".harness", "cache", "osv");
   const warnLogger = {
     warn: (m, ctx) => logger.warn(ctx ? `${m} ${JSON.stringify(ctx)}` : m)
   };
@@ -8408,7 +8455,7 @@ function createMcpGuardCommand() {
     '\nUse "harness mcp-guard check" before launching MCP servers to block known malicious packages.'
   );
   command.command("check").description("Check every MCP/npx package in .mcp.json against OSV.dev advisories").option("--strict", "Fail closed on network errors (default: fail-open)", false).option("--json", "Emit machine-readable JSON", false).option("--path <path>", "Project root path", ".").action(async (opts) => {
-    const cwd = path46.resolve(opts.path);
+    const cwd = path47.resolve(opts.path);
     const result = await runMcpGuardCheck({ cwd, strict: opts.strict, json: opts.json });
     if (opts.json) {
       console.log(JSON.stringify(result, null, 2));
@@ -8419,10 +8466,10 @@ function createMcpGuardCommand() {
     process.exit(result.ok ? ExitCode.SUCCESS : 2);
   });
   command.command("cache").description("Manage the on-disk OSV advisory cache").command("clear").option("--path <path>", "Project root path", ".").action(async (opts) => {
-    const cwd = path46.resolve(opts.path);
-    const cacheDir = path46.join(cwd, ".harness", "cache", "osv");
+    const cwd = path47.resolve(opts.path);
+    const cacheDir = path47.join(cwd, ".harness", "cache", "osv");
     try {
-      fs27.rmSync(cacheDir, { recursive: true, force: true });
+      fs28.rmSync(cacheDir, { recursive: true, force: true });
       console.log(`Cleared ${cacheDir}`);
     } catch (err) {
       logger.error(`Failed to clear cache: ${err instanceof Error ? err.message : String(err)}`);
@@ -8438,8 +8485,8 @@ import { Command as Command65 } from "commander";
 
 // src/commands/migrate-backends.ts
 import { Command as Command64 } from "commander";
-import * as fs28 from "fs";
-import * as path47 from "path";
+import * as fs29 from "fs";
+import * as path48 from "path";
 import chalk10 from "chalk";
 import { parse as parseYaml2 } from "yaml";
 async function runMigrateBackends(opts = {}) {
@@ -8461,8 +8508,8 @@ async function runMigrateBackends(opts = {}) {
     };
   }
   const routing = readRoutingFromOrchestratorMd(mdPath);
-  const jsonPath = path47.join(path47.dirname(mdPath), "harness.config.json");
-  if (!fs28.existsSync(jsonPath)) {
+  const jsonPath = path48.join(path48.dirname(mdPath), "harness.config.json");
+  if (!fs29.existsSync(jsonPath)) {
     return {
       status: "error",
       message: `harness.config.json not found at ${jsonPath}. Run \`harness init\` first, then re-run this migration.`,
@@ -8471,7 +8518,7 @@ async function runMigrateBackends(opts = {}) {
   }
   let configRaw;
   try {
-    configRaw = fs28.readFileSync(jsonPath, "utf-8");
+    configRaw = fs29.readFileSync(jsonPath, "utf-8");
   } catch (err) {
     return {
       status: "error",
@@ -8518,7 +8565,7 @@ async function runMigrateBackends(opts = {}) {
     };
   }
   try {
-    fs28.writeFileSync(jsonPath, nextJson);
+    fs29.writeFileSync(jsonPath, nextJson);
   } catch (err) {
     return {
       status: "error",
@@ -8535,7 +8582,7 @@ async function runMigrateBackends(opts = {}) {
 function readRoutingFromOrchestratorMd(mdPath) {
   let raw;
   try {
-    raw = fs28.readFileSync(mdPath, "utf-8");
+    raw = fs29.readFileSync(mdPath, "utf-8");
   } catch {
     return null;
   }
@@ -8573,8 +8620,8 @@ function createBackendsSubcommand() {
 // src/commands/migrate.ts
 init_dist3();
 init_dist2();
-import * as fs29 from "fs";
-import * as path48 from "path";
+import * as fs30 from "fs";
+import * as path49 from "path";
 import * as readline from "readline";
 import { execFileSync as execFileSync5 } from "child_process";
 import chalk11 from "chalk";
@@ -8588,25 +8635,25 @@ function isGitRepo(cwd) {
 }
 function readJson2(p) {
   try {
-    return JSON.parse(fs29.readFileSync(p, "utf8"));
+    return JSON.parse(fs30.readFileSync(p, "utf8"));
   } catch {
     return null;
   }
 }
 function listDirs(p) {
-  if (!fs29.existsSync(p)) return [];
-  return fs29.readdirSync(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  if (!fs30.existsSync(p)) return [];
+  return fs30.readdirSync(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
 }
 function listFiles(p, predicate) {
-  if (!fs29.existsSync(p)) return [];
-  return fs29.readdirSync(p, { withFileTypes: true }).filter((e) => e.isFile() && predicate(e.name)).map((e) => e.name);
+  if (!fs30.existsSync(p)) return [];
+  return fs30.readdirSync(p, { withFileTypes: true }).filter((e) => e.isFile() && predicate(e.name)).map((e) => e.name);
 }
 function walk(dir, predicate) {
-  if (!fs29.existsSync(dir)) return [];
+  if (!fs30.existsSync(dir)) return [];
   const out = [];
-  for (const entry of fs29.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs30.readdirSync(dir, { withFileTypes: true })) {
     if (DEFAULT_SKIP_DIRS.has(entry.name)) continue;
-    const full = path48.join(dir, entry.name);
+    const full = path49.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...walk(full, predicate));
     else if (predicate(full)) out.push(full);
   }
@@ -8618,11 +8665,11 @@ function extractAutopilotTopic(state) {
 }
 function buildAutopilotMap(cwd) {
   const map = /* @__PURE__ */ new Map();
-  const sessionsDir = path48.join(cwd, ".harness", "sessions");
-  if (!fs29.existsSync(sessionsDir)) return map;
+  const sessionsDir = path49.join(cwd, ".harness", "sessions");
+  if (!fs30.existsSync(sessionsDir)) return map;
   for (const session of listDirs(sessionsDir)) {
     if (!session.startsWith("changes--")) continue;
-    const state = readJson2(path48.join(sessionsDir, session, "autopilot-state.json"));
+    const state = readJson2(path49.join(sessionsDir, session, "autopilot-state.json"));
     if (!state) continue;
     const topic = extractAutopilotTopic(state);
     if (!topic) continue;
@@ -8635,7 +8682,7 @@ function buildAutopilotMap(cwd) {
 function extractTopicFromHeader(planAbs, proposalTopics) {
   let text;
   try {
-    text = fs29.readFileSync(planAbs, "utf8").slice(0, 4e3);
+    text = fs30.readFileSync(planAbs, "utf8").slice(0, 4e3);
   } catch {
     return null;
   }
@@ -8660,8 +8707,8 @@ function extractTopicFromFilename(filename, proposalTopics) {
   return best;
 }
 function resolveDocsDir(cwd) {
-  const configPath = path48.join(cwd, "harness.config.json");
-  const configResult = fs29.existsSync(configPath) ? resolveConfig(configPath) : null;
+  const configPath = path49.join(cwd, "harness.config.json");
+  const configResult = fs30.existsSync(configPath) ? resolveConfig(configPath) : null;
   let docsDir;
   if (configResult?.ok) {
     docsDir = configResult.value.docsDir;
@@ -8673,16 +8720,16 @@ function resolveDocsDir(cwd) {
   } else {
     docsDir = "./docs";
   }
-  const docsAbs = path48.resolve(cwd, docsDir);
-  const relRaw = path48.relative(cwd, docsAbs).replaceAll("\\", "/");
+  const docsAbs = path49.resolve(cwd, docsDir);
+  const relRaw = path49.relative(cwd, docsAbs).replaceAll("\\", "/");
   return relRaw === "" ? "docs" : relRaw;
 }
 function collectAdrMoves(cwd, docsRel) {
   const moves = [];
-  const legacyAdrDir = path48.join(cwd, ".harness", "architecture");
-  if (!fs29.existsSync(legacyAdrDir)) return moves;
+  const legacyAdrDir = path49.join(cwd, ".harness", "architecture");
+  if (!fs30.existsSync(legacyAdrDir)) return moves;
   for (const topic of listDirs(legacyAdrDir)) {
-    const topicSrc = path48.join(legacyAdrDir, topic);
+    const topicSrc = path49.join(legacyAdrDir, topic);
     for (const file of listFiles(topicSrc, (n) => n.endsWith(".md"))) {
       moves.push({
         src: `.harness/architecture/${topic}/${file}`,
@@ -8694,9 +8741,9 @@ function collectAdrMoves(cwd, docsRel) {
 }
 function collectProposalTopics(cwd) {
   const topics = /* @__PURE__ */ new Set();
-  const changesDir = path48.join(cwd, "docs", "changes");
+  const changesDir = path49.join(cwd, "docs", "changes");
   for (const topic of listDirs(changesDir)) {
-    if (fs29.existsSync(path48.join(changesDir, topic, "proposal.md"))) {
+    if (fs30.existsSync(path49.join(changesDir, topic, "proposal.md"))) {
       topics.add(topic);
     }
   }
@@ -8723,12 +8770,12 @@ async function buildPlan(opts) {
     orphanPlans: [],
     proposalTopics: collectProposalTopics(cwd)
   };
-  const legacyPlanDir = path48.join(cwd, "docs", "plans");
-  if (!fs29.existsSync(legacyPlanDir)) return plan;
+  const legacyPlanDir = path49.join(cwd, "docs", "plans");
+  if (!fs30.existsSync(legacyPlanDir)) return plan;
   const autopilotMap = buildAutopilotMap(cwd);
   for (const file of listFiles(legacyPlanDir, (n) => n.endsWith(".md") && n !== "index.md")) {
     const planRel = `docs/plans/${file}`;
-    const planAbs = path48.join(legacyPlanDir, file);
+    const planAbs = path49.join(legacyPlanDir, file);
     const subdir = file.includes("VERIFICATION") ? "verifications" : "plans";
     const classified = classifyPlan(planRel, planAbs, file, autopilotMap, plan.proposalTopics);
     if (classified) {
@@ -8746,8 +8793,8 @@ async function buildPlan(opts) {
   return plan;
 }
 function gitMv(cwd, src, dest, useGit) {
-  const destAbs = path48.join(cwd, dest);
-  fs29.mkdirSync(path48.dirname(destAbs), { recursive: true });
+  const destAbs = path49.join(cwd, dest);
+  fs30.mkdirSync(path49.dirname(destAbs), { recursive: true });
   if (useGit) {
     try {
       execFileSync5("git", ["mv", src, dest], { cwd, stdio: "pipe" });
@@ -8755,7 +8802,7 @@ function gitMv(cwd, src, dest, useGit) {
     } catch {
     }
   }
-  fs29.renameSync(path48.join(cwd, src), destAbs);
+  fs30.renameSync(path49.join(cwd, src), destAbs);
 }
 function executeMigration(plan) {
   let moved = 0;
@@ -8787,13 +8834,13 @@ function updateReferences(plan) {
   let files = 0;
   let replacements = 0;
   const targets = [
-    ...walk(path48.join(plan.cwd, "docs"), (p) => p.endsWith(".md")),
-    ...walk(path48.join(plan.cwd, ".harness", "sessions"), (p) => p.endsWith(".json"))
+    ...walk(path49.join(plan.cwd, "docs"), (p) => p.endsWith(".md")),
+    ...walk(path49.join(plan.cwd, ".harness", "sessions"), (p) => p.endsWith(".json"))
   ];
   for (const target of targets) {
     let text;
     try {
-      text = fs29.readFileSync(target, "utf8");
+      text = fs30.readFileSync(target, "utf8");
     } catch {
       continue;
     }
@@ -8806,7 +8853,7 @@ function updateReferences(plan) {
       count += occurrences;
     }
     if (count > 0 && result !== text) {
-      fs29.writeFileSync(target, result);
+      fs30.writeFileSync(target, result);
       files++;
       replacements += count;
     }
@@ -8815,7 +8862,7 @@ function updateReferences(plan) {
 }
 async function prompt(question, def = "n") {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve48) => rl.question(question, resolve48));
+  const answer = await new Promise((resolve50) => rl.question(question, resolve50));
   rl.close();
   return (answer.trim() || def).toLowerCase();
 }
@@ -8865,7 +8912,7 @@ async function resolveOrphans(plan, opts) {
 }
 function bucketOrphans(plan, topic) {
   for (const src of plan.orphanPlans) {
-    const file = path48.basename(src);
+    const file = path49.basename(src);
     const isVerification = file.includes("VERIFICATION");
     const subdir = isVerification ? "verifications" : "plans";
     plan.planMoves.push({
@@ -8907,10 +8954,10 @@ function summarize(plan) {
   console.log("");
 }
 async function detectLegacyArtifacts(cwd) {
-  const adrLegacyDir = path48.join(cwd, ".harness", "architecture");
-  const adrLegacy = fs29.existsSync(adrLegacyDir) && listDirs(adrLegacyDir).length > 0;
-  const planLegacyDir = path48.join(cwd, "docs", "plans");
-  const planLegacy = fs29.existsSync(planLegacyDir) && listFiles(planLegacyDir, (n) => n.endsWith(".md") && n !== "index.md").length > 0;
+  const adrLegacyDir = path49.join(cwd, ".harness", "architecture");
+  const adrLegacy = fs30.existsSync(adrLegacyDir) && listDirs(adrLegacyDir).length > 0;
+  const planLegacyDir = path49.join(cwd, "docs", "plans");
+  const planLegacy = fs30.existsSync(planLegacyDir) && listFiles(planLegacyDir, (n) => n.endsWith(".md") && n !== "index.md").length > 0;
   return { adrLegacy, planLegacy };
 }
 async function confirmApply(opts) {
@@ -9002,7 +9049,9 @@ function createMigrateCommand() {
 }
 
 // src/commands/models.ts
+init_dist3();
 import { Command as Command66 } from "commander";
+import { resolve as resolve31 } from "path";
 import { defaultFetchModels } from "@harness-engineering/orchestrator";
 function errorResult(message, partial) {
   return {
@@ -9119,29 +9168,183 @@ function formatProbe(result) {
   }
   return lines.join("\n");
 }
-function createModelsCommand() {
-  const cmd = new Command66("models").description(
-    "Inspect and manage local LLM backends. Currently ships `probe`; LMLM phases add status/suggest/pool/proposals."
-  );
+function projectRoot() {
+  return resolve31(process.env["HARNESS_PROJECT_ROOT"] ?? process.cwd());
+}
+function summarizeModelProposal(p) {
+  const base = { id: p.id, status: p.status, proposedBy: p.proposedBy, createdAt: p.createdAt };
+  if (p.kind !== "model") return { ...base, kind: p.kind };
+  return {
+    ...base,
+    kind: "model",
+    action: p.model.action,
+    target: p.model.target.ollamaName,
+    replaces: p.model.replaces?.ollamaName,
+    scoreDelta: p.model.scoreDelta
+  };
+}
+async function runModelsProposals(status = "open") {
+  const opts = { kind: "model" };
+  if (status !== "all") opts.status = status;
+  const proposals = await listProposals(projectRoot(), opts);
+  return proposals.map(summarizeModelProposal);
+}
+async function runModelsApprove(id) {
+  const orchestratorUrl = process.env["HARNESS_ORCHESTRATOR_URL"] ?? "http://127.0.0.1:4577";
+  const token = process.env["HARNESS_ADMIN_TOKEN"];
+  if (!token) {
+    return {
+      ok: false,
+      error: "HARNESS_ADMIN_TOKEN is required to approve proposals (manage-proposals scope)."
+    };
+  }
+  try {
+    const res = await fetch(`${orchestratorUrl}/api/v1/proposals/${id}/approve`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${token}` }
+    });
+    return { ok: res.ok, status: res.status, body: await res.text() };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function runModelsReject(id, reason) {
+  const orchestratorUrl = process.env["HARNESS_ORCHESTRATOR_URL"] ?? "http://127.0.0.1:4577";
+  const token = process.env["HARNESS_ADMIN_TOKEN"];
+  if (!token) {
+    return {
+      ok: false,
+      error: "HARNESS_ADMIN_TOKEN is required to reject proposals (manage-proposals scope)."
+    };
+  }
+  try {
+    const res = await fetch(`${orchestratorUrl}/api/v1/proposals/${id}/reject`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+      body: JSON.stringify({ reason })
+    });
+    return { ok: res.ok, status: res.status, body: await res.text() };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function runModelsRefresh() {
+  const orchestratorUrl = process.env["HARNESS_ORCHESTRATOR_URL"] ?? "http://127.0.0.1:4577";
+  const token = process.env["HARNESS_ADMIN_TOKEN"];
+  if (!token) {
+    return {
+      ok: false,
+      error: "HARNESS_ADMIN_TOKEN is required to trigger a refresh (manage-proposals scope)."
+    };
+  }
+  try {
+    const res = await fetch(`${orchestratorUrl}/api/v1/local-models/refresh`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${token}` }
+    });
+    return buildRefreshResult(res, await res.text());
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function buildRefreshResult(res, body) {
+  const parsed = safeParseObject(body);
+  const emitted = parsed?.["emitted"];
+  const warnings = parsed?.["warnings"];
+  const error = parsed?.["error"];
+  return {
+    ok: res.ok,
+    status: res.status,
+    ...typeof emitted === "number" ? { emitted } : {},
+    ...Array.isArray(warnings) ? { warnings } : {},
+    ...res.ok ? {} : { error: typeof error === "string" ? error : `HTTP ${res.status}` },
+    body
+  };
+}
+function safeParseObject(body) {
+  try {
+    const v = JSON.parse(body);
+    return v !== null && typeof v === "object" ? v : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function refreshExitCode(result) {
+  return result.ok ? ExitCode.SUCCESS : ExitCode.ERROR;
+}
+function httpErrorLine(r) {
+  return r.error ?? `HTTP ${r.status ?? "?"}: ${r.body ?? ""}`;
+}
+function reportMutation(result) {
+  if (!result.ok) {
+    logger.error(httpErrorLine(result));
+    process.exit(ExitCode.ERROR);
+  }
+  console.log(result.body ?? "");
+}
+async function probeAction(options) {
+  const result = await runModelsProbe(options);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    const text = formatProbe(result);
+    if (result.status === "error" || result.status === "no-match") logger.error(text);
+    else logger.info(text);
+  }
+  process.exit(result.exitCode);
+}
+async function refreshAction() {
+  const result = await runModelsRefresh();
+  if (!result.ok) {
+    logger.error(httpErrorLine(result));
+  } else {
+    logger.info(`refresh: emitted ${result.emitted ?? 0} proposal(s)`);
+    for (const w of result.warnings ?? []) logger.warn(`  warning: ${w}`);
+  }
+  process.exitCode = refreshExitCode(result);
+}
+function addProbeCommand(cmd) {
   cmd.command("probe").description(
     "Probe a local backend's /v1/models endpoint and report which configured model is loaded."
   ).option(
     "--backend <name>",
     "Name of an entry in agent.backends. Defaults to the first local/pi entry."
-  ).option("--endpoint <url>", "Override the backend endpoint (bypasses harness.config.json).").option("--api-key <key>", "Override the API key.").option("--json", "Print machine-readable JSON instead of a human summary.", false).action(async (options) => {
-    const result = await runModelsProbe(options);
-    if (options.json) {
-      console.log(JSON.stringify(result, null, 2));
-    } else {
-      const text = formatProbe(result);
-      if (result.status === "error" || result.status === "no-match") {
-        logger.error(text);
-      } else {
-        logger.info(text);
-      }
-    }
-    process.exit(result.exitCode);
+  ).option("--endpoint <url>", "Override the backend endpoint (bypasses harness.config.json).").option("--api-key <key>", "Override the API key.").option("--json", "Print machine-readable JSON instead of a human summary.", false).action(probeAction);
+}
+function addProposalsCommand(cmd) {
+  cmd.command("proposals").description("List model proposals in the local review queue (defaults to pending).").option("--status <status>", "Filter by status (open | approved | rejected | all).", "open").action(async (options) => {
+    const rows = await runModelsProposals(options.status ?? "open");
+    console.log(JSON.stringify(rows, null, 2));
   });
+}
+function addRejectCommand(cmd) {
+  cmd.command("reject <id>").description(
+    "Reject a model proposal with a one-line reason (records the decision + fires the bus event). Requires the orchestrator to be running and HARNESS_ADMIN_TOKEN."
+  ).requiredOption("--reason <text>", "Why the proposal is being rejected").action(async (id, options) => {
+    reportMutation(await runModelsReject(id, options.reason));
+  });
+}
+function addApproveCommand(cmd) {
+  cmd.command("approve <id>").description(
+    "Approve a model proposal (drives the installer + pool update). Requires the orchestrator to be running and HARNESS_ADMIN_TOKEN."
+  ).action(async (id) => {
+    reportMutation(await runModelsApprove(id));
+  });
+}
+function addRefreshCommand(cmd) {
+  cmd.command("refresh").description(
+    "Force a background-scheduler refresh tick now (emits any model proposals). Exits non-zero on an O4 hard failure (HuggingFace unreachable AND no benchmark snapshot). Requires the orchestrator running + HARNESS_ADMIN_TOKEN."
+  ).action(refreshAction);
+}
+function createModelsCommand() {
+  const cmd = new Command66("models").description(
+    "Inspect and manage local LLM backends. Ships `probe`, model-proposal review (proposals/approve/reject), and `refresh` (force a scheduler tick)."
+  );
+  addProbeCommand(cmd);
+  addProposalsCommand(cmd);
+  addRejectCommand(cmd);
+  addApproveCommand(cmd);
+  addRefreshCommand(cmd);
   return cmd;
 }
 
@@ -9198,10 +9401,10 @@ function printResult4(result, mode, _formatter) {
       list.push(f);
       byFile.set(f.target.file, list);
     }
-    for (const [file, fs50] of byFile) {
+    for (const [file, fs51] of byFile) {
       console.log(`
 ${file}`);
-      for (const f of fs50) {
+      for (const f of fs51) {
         const line = f.target.line !== void 0 ? `:${f.target.line}` : "";
         console.log(
           `  ${f.code} [${f.tier}/${f.impact}/${f.confidence}] ${f.target.kind} ${f.target.identifier}${line}`
@@ -9227,7 +9430,7 @@ import { Command as Command69 } from "commander";
 init_dist3();
 import { Command as Command68 } from "commander";
 import { randomBytes } from "crypto";
-import { resolve as resolve30 } from "path";
+import { resolve as resolve32 } from "path";
 import { SinkRegistry, SinkConfigError, wrapAsEnvelope } from "@harness-engineering/orchestrator";
 function makeTestEvent(message) {
   return {
@@ -9237,8 +9440,8 @@ function makeTestEvent(message) {
     data: { message, triggeredAt: (/* @__PURE__ */ new Date()).toISOString() }
   };
 }
-async function runNotificationsTest(sinkId, opts, projectRoot2 = process.cwd()) {
-  const cfgResult = loadNotificationsConfig(projectRoot2);
+async function runNotificationsTest(sinkId, opts, projectRoot3 = process.cwd()) {
+  const cfgResult = loadNotificationsConfig(projectRoot3);
   if (!cfgResult.ok) {
     return { ok: false, error: `Config error: ${cfgResult.error.message}` };
   }
@@ -9279,8 +9482,8 @@ async function runNotificationsTest(sinkId, opts, projectRoot2 = process.cwd())
 function createNotificationsTestSubcommand() {
   return new Command68("test").description("Send a synthetic notification.test event through the named sink").argument("<sink-id>", "Sink id from harness.config.json `notifications.sinks[].id`").option("--message <text>", "Override the default test message").action(async (sinkId, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectRoot2 = typeof globalOpts["cwd"] === "string" ? resolve30(globalOpts["cwd"]) : process.cwd();
-    const result = await runNotificationsTest(sinkId, opts, projectRoot2);
+    const projectRoot3 = typeof globalOpts["cwd"] === "string" ? resolve32(globalOpts["cwd"]) : process.cwd();
+    const result = await runNotificationsTest(sinkId, opts, projectRoot3);
     if (globalOpts["json"]) {
       console.log(JSON.stringify(result, null, 2));
     } else if (result.ok) {
@@ -9303,12 +9506,12 @@ function createNotificationsCommand() {
 
 // src/commands/orchestrator.ts
 import { Command as Command70 } from "commander";
-import * as path49 from "path";
+import * as path50 from "path";
 import { Orchestrator, WorkflowLoader as WorkflowLoader2, launchTUI } from "@harness-engineering/orchestrator";
 function createOrchestratorCommand() {
   const orchestrator = new Command70("orchestrator");
   orchestrator.command("run").description("Run the orchestrator daemon").option("-w, --workflow <path>", "Path to harness.orchestrator.md", "harness.orchestrator.md").option("--headless", "Run without TUI (server-only mode for use with web dashboard)").action(async (opts) => {
-    const workflowPath = path49.resolve(process.cwd(), opts.workflow);
+    const workflowPath = path50.resolve(process.cwd(), opts.workflow);
     const loader = new WorkflowLoader2();
     const result = await loader.loadWorkflow(workflowPath);
     if (!result.ok) {
@@ -9343,12 +9546,12 @@ function createOrchestratorCommand() {
 // src/commands/perf.ts
 init_dist3();
 import { Command as Command71 } from "commander";
-import * as path50 from "path";
+import * as path51 from "path";
 function registerBenchCommand(perf) {
   perf.command("bench [glob]").description("Run benchmarks via vitest bench").action(async (glob2, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { BenchmarkRunner } = await import("./dist-MCTEX5QH.js");
+    const { BenchmarkRunner } = await import("./dist-BWFFVKEW.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob2);
     if (benchFiles.length === 0) {
@@ -9412,7 +9615,7 @@ async function runBaselinesShow(globalOpts) {
 }
 async function runBaselinesUpdate(globalOpts) {
   const cwd = process.cwd();
-  const { BenchmarkRunner } = await import("./dist-MCTEX5QH.js");
+  const { BenchmarkRunner } = await import("./dist-BWFFVKEW.js");
   const runner = new BenchmarkRunner();
   const manager = new BaselineManager(cwd);
   logger.info("Running benchmarks to update baselines...");
@@ -9453,9 +9656,9 @@ function registerReportCommand(perf) {
   perf.command("report").description("Full performance report with metrics, trends, and hotspots").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-MCTEX5QH.js");
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-BWFFVKEW.js");
     const analyzer = new EntropyAnalyzer2({
-      rootDir: path50.resolve(cwd),
+      rootDir: path51.resolve(cwd),
       analyze: { complexity: true, coupling: true }
     });
     const result = await analyzer.analyze();
@@ -9561,34 +9764,34 @@ function createListCommand2() {
 
 // src/commands/persona/generate.ts
 import { Command as Command73, Option } from "commander";
-import * as fs30 from "fs";
-import * as path51 from "path";
+import * as fs31 from "fs";
+import * as path52 from "path";
 function generatePersonaArtifacts(persona, outputDir, only, platform) {
   const slug = toKebabCase(persona.name);
   const generated = [];
   if (!only || only === "runtime") {
     const result = generateRuntime(persona);
     if (result.ok) {
-      const outPath = path51.join(outputDir, `${slug}.runtime.json`);
-      fs30.mkdirSync(path51.dirname(outPath), { recursive: true });
-      fs30.writeFileSync(outPath, result.value);
+      const outPath = path52.join(outputDir, `${slug}.runtime.json`);
+      fs31.mkdirSync(path52.dirname(outPath), { recursive: true });
+      fs31.writeFileSync(outPath, result.value);
       generated.push(outPath);
     }
   }
   if (!only || only === "agents-md") {
     const result = generateAgentsMd(persona);
     if (result.ok) {
-      const outPath = path51.join(outputDir, `${slug}.agents.md`);
-      fs30.writeFileSync(outPath, result.value);
+      const outPath = path52.join(outputDir, `${slug}.agents.md`);
+      fs31.writeFileSync(outPath, result.value);
       generated.push(outPath);
     }
   }
   if (!only || only === "ci") {
     const result = generateCIWorkflow(persona, platform);
     if (result.ok) {
-      const outPath = platform === "gitlab" ? path51.join(outputDir, `${slug}.gitlab-ci.yml`) : path51.join(outputDir, ".github", "workflows", `${slug}.yml`);
-      fs30.mkdirSync(path51.dirname(outPath), { recursive: true });
-      fs30.writeFileSync(outPath, result.value);
+      const outPath = platform === "gitlab" ? path52.join(outputDir, `${slug}.gitlab-ci.yml`) : path52.join(outputDir, ".github", "workflows", `${slug}.yml`);
+      fs31.mkdirSync(path52.dirname(outPath), { recursive: true });
+      fs31.writeFileSync(outPath, result.value);
       generated.push(outPath);
     }
   }
@@ -9599,14 +9802,14 @@ function createGenerateCommand3() {
     new Option("--platform <platform>", "CI platform for the ci artifact").choices(["github", "gitlab"]).default("github")
   ).action(async (name, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const personaResult = loadPersona(path51.join(resolvePersonasDir(), `${name}.yaml`));
+    const personaResult = loadPersona(path52.join(resolvePersonasDir(), `${name}.yaml`));
     if (!personaResult.ok) {
       logger.error(personaResult.error.message);
       process.exit(ExitCode.ERROR);
     }
     const generated = generatePersonaArtifacts(
       personaResult.value,
-      path51.resolve(opts.outputDir),
+      path52.resolve(opts.outputDir),
       opts.only,
       opts.platform
     );
@@ -9760,14 +9963,14 @@ function createPredictCommand() {
 init_dist2();
 import { execFileSync as execFileSync7 } from "child_process";
 import { readFileSync as readFileSync18 } from "fs";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 import { Command as Command77 } from "commander";
 import { gatherSignals } from "@harness-engineering/signals";
 
 // src/commands/review-ci.ts
 init_dist3();
 import { execFileSync as execFileSync6 } from "child_process";
-import { writeFileSync as writeFileSync18 } from "fs";
+import { writeFileSync as writeFileSync19 } from "fs";
 import { Command as Command76, Option as Option2 } from "commander";
 
 // src/commands/review-ci-local-adapter.ts
@@ -9940,7 +10143,7 @@ var defaultPostReview = (verdict) => {
     encoding: "utf-8"
   });
 };
-function emitReviewCi(result, opts, writeFile2 = (p, d) => writeFileSync18(p, d), log = (m) => process.stdout.write(m + "\n"), postReview = defaultPostReview) {
+function emitReviewCi(result, opts, writeFile2 = (p, d) => writeFileSync19(p, d), log = (m) => process.stdout.write(m + "\n"), postReview = defaultPostReview) {
   const serialized = JSON.stringify(result.verdict, null, 2);
   const jsonToStdout = opts.jsonPath === true;
   if (!jsonToStdout) log(result.terminalOutput);
@@ -10121,11 +10324,11 @@ var defaultPostBrief = (body) => {
     }
   );
 };
-var defaultReadFile = (path80) => readFileSync18(path80, "utf-8");
-function readReview(path80, readFile4 = defaultReadFile) {
-  if (!path80) return void 0;
+var defaultReadFile = (path81) => readFileSync18(path81, "utf-8");
+function readReview(path81, readFile4 = defaultReadFile) {
+  if (!path81) return void 0;
   try {
-    const parsed = JSON.parse(readFile4(path80));
+    const parsed = JSON.parse(readFile4(path81));
     return parsed?.verdict && typeof parsed.verdict === "object" ? parsed.verdict : void 0;
   } catch {
     return void 0;
@@ -10143,7 +10346,7 @@ var GRAPH_DIR = ".harness/graph";
 async function loadOutcomeStore(projectPath) {
   try {
     const store = new GraphStore();
-    const loaded = await store.load(join40(projectPath, GRAPH_DIR));
+    const loaded = await store.load(join41(projectPath, GRAPH_DIR));
     return loaded ? store : void 0;
   } catch {
     return void 0;
@@ -10240,31 +10443,44 @@ function createPreMergeBriefCommand() {
 // src/commands/proposals.ts
 init_dist3();
 import { Command as Command78 } from "commander";
-import { resolve as resolve34 } from "path";
-function projectRoot() {
-  return resolve34(process.env["HARNESS_PROJECT_ROOT"] ?? process.cwd());
+import { resolve as resolve36 } from "path";
+function projectRoot2() {
+  return resolve36(process.env["HARNESS_PROJECT_ROOT"] ?? process.cwd());
 }
 function summarizeProposal(p) {
-  return {
+  const base = {
     id: p.id,
-    kind: p.kind,
-    targetSkill: p.targetSkill,
-    name: p.content.name,
     status: p.status,
     proposedBy: p.proposedBy,
-    createdAt: p.createdAt,
-    gateLastRunAt: p.gate?.lastRunAt,
-    findings: p.gate?.findings?.length ?? 0
+    createdAt: p.createdAt
+  };
+  if (p.kind === "skill") {
+    return {
+      ...base,
+      kind: p.skillKind,
+      targetSkill: p.targetSkill,
+      name: p.content.name,
+      gateLastRunAt: p.gate?.lastRunAt,
+      findings: p.gate?.findings?.length ?? 0
+    };
+  }
+  return {
+    ...base,
+    kind: p.kind,
+    targetSkill: void 0,
+    name: p.model.target.ollamaName,
+    gateLastRunAt: void 0,
+    findings: 0
   };
 }
 async function runProposalsList(status) {
-  const opts = {};
+  const opts = { kind: "skill" };
   if (status) opts.status = status;
-  const proposals = await listProposals(projectRoot(), opts);
+  const proposals = await listProposals(projectRoot2(), opts);
   return proposals.map(summarizeProposal);
 }
 async function runProposalsShow(id) {
-  return getProposal(projectRoot(), id);
+  return getProposal(projectRoot2(), id);
 }
 async function runProposalsReject(id, reason) {
   const decision = {
@@ -10273,7 +10489,7 @@ async function runProposalsReject(id, reason) {
     action: "rejected",
     reason
   };
-  return updateProposal(projectRoot(), id, { status: "rejected", decision });
+  return updateProposal(projectRoot2(), id, { status: "rejected", decision });
 }
 var ALLOWED_STATUSES = [
   "open",
@@ -10349,8 +10565,8 @@ function createProposalsCommand() {
 }
 
 // src/commands/publish-analyses.ts
-import * as fs31 from "fs";
-import * as path52 from "path";
+import * as fs32 from "fs";
+import * as path53 from "path";
 import { Command as Command79 } from "commander";
 init_dist3();
 import {
@@ -10359,7 +10575,7 @@ import {
   savePublishedIndex
 } from "@harness-engineering/orchestrator";
 function bootstrapTrackerCommand(opts, verb) {
-  const projectPath = path52.resolve(opts.dir);
+  const projectPath = path53.resolve(opts.dir);
   const trackerConfig = loadTrackerSyncConfig(projectPath);
   if (!trackerConfig) {
     logger.error(`No tracker config found in harness.config.json. Cannot ${verb}.`);
@@ -10371,8 +10587,8 @@ function bootstrapTrackerCommand(opts, verb) {
     );
     return null;
   }
-  const projectEnvPath = path52.join(projectPath, ".env");
-  if (fs31.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
+  const projectEnvPath = path53.join(projectPath, ".env");
+  if (fs32.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
     __require("dotenv").config({ path: projectEnvPath });
   }
   const token = process.env.GITHUB_TOKEN;
@@ -10463,8 +10679,8 @@ async function runPublishAnalyses(opts) {
   const nameToExternalId = await buildNameToExternalIdMap(projectPath);
   if (!nameToExternalId) return process.exit(1);
   const { AnalysisArchive } = await import("@harness-engineering/orchestrator");
-  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-MCTEX5QH.js");
-  const archive = new AnalysisArchive(path52.join(projectPath, ".harness", "analyses"));
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-BWFFVKEW.js");
+  const archive = new AnalysisArchive(path53.join(projectPath, ".harness", "analyses"));
   const analyses = await archive.list();
   if (analyses.length === 0) {
     logger.info("No analyses found to publish.");
@@ -10506,8 +10722,8 @@ import { Command as Command81 } from "commander";
 
 // src/commands/pulse/run.ts
 init_dist3();
-import { readFileSync as readFileSync19, mkdirSync as mkdirSync15, writeFileSync as writeFileSync19 } from "fs";
-import { dirname as dirname18, join as join42, resolve as resolve36 } from "path";
+import { readFileSync as readFileSync19, mkdirSync as mkdirSync16, writeFileSync as writeFileSync20 } from "fs";
+import { dirname as dirname19, join as join43, resolve as resolve38 } from "path";
 import { Command as Command80 } from "commander";
 async function runPulseRunCommand(opts) {
   const startedAt = Date.now();
@@ -10539,9 +10755,9 @@ async function runPulseRunCommand(opts) {
   const report = assembleReport(result, productName, lookback);
   const now = /* @__PURE__ */ new Date();
   const ts = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}_${String(now.getHours()).padStart(2, "0")}-${String(now.getMinutes()).padStart(2, "0")}`;
-  const filePath = join42(opts.outputDir, `${ts}.md`);
-  mkdirSync15(dirname18(filePath), { recursive: true });
-  writeFileSync19(filePath, report);
+  const filePath = join43(opts.outputDir, `${ts}.md`);
+  mkdirSync16(dirname19(filePath), { recursive: true });
+  writeFileSync20(filePath, report);
   const headlines = extractHeadlines(report);
   return emit2(
     {
@@ -10583,8 +10799,8 @@ function createRunCommand2() {
     async (options) => {
       const nonInteractive = options.nonInteractive === true || !process.stdout.isTTY;
       const status = await runPulseRunCommand({
-        configPath: resolve36(process.cwd(), options.config),
-        outputDir: resolve36(process.cwd(), options.outputDir),
+        configPath: resolve38(process.cwd(), options.config),
+        outputDir: resolve38(process.cwd(), options.outputDir),
         nonInteractive,
         lookback: options.lookback
       });
@@ -10708,13 +10924,13 @@ import { Command as Command89 } from "commander";
 // src/commands/roadmap/migrate.ts
 init_dist3();
 import { Command as Command83 } from "commander";
-import * as fs33 from "fs";
-import * as path54 from "path";
+import * as fs34 from "fs";
+import * as path55 from "path";
 import chalk14 from "chalk";
 
 // src/commands/roadmap/migrate-lock.ts
-import * as fs32 from "fs";
-import * as path53 from "path";
+import * as fs33 from "fs";
+import * as path54 from "path";
 import * as os7 from "os";
 var LOCK_FILE_NAME = "migrate.lock";
 var STALE_LOCK_MS = 30 * 60 * 1e3;
@@ -10727,14 +10943,14 @@ function isPidAlive(pid) {
     return false;
   }
 }
-function acquireMigrateLock(projectRoot2) {
-  const harnessDir = path53.join(projectRoot2, ".harness");
-  const lockPath = path53.join(harnessDir, LOCK_FILE_NAME);
-  if (!fs32.existsSync(harnessDir)) fs32.mkdirSync(harnessDir, { recursive: true });
-  if (fs32.existsSync(lockPath)) {
+function acquireMigrateLock(projectRoot3) {
+  const harnessDir = path54.join(projectRoot3, ".harness");
+  const lockPath = path54.join(harnessDir, LOCK_FILE_NAME);
+  if (!fs33.existsSync(harnessDir)) fs33.mkdirSync(harnessDir, { recursive: true });
+  if (fs33.existsSync(lockPath)) {
     const existingRaw = (() => {
       try {
-        return fs32.readFileSync(lockPath, "utf-8");
+        return fs33.readFileSync(lockPath, "utf-8");
       } catch {
         return null;
       }
@@ -10764,11 +10980,11 @@ function acquireMigrateLock(projectRoot2) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     hostname: os7.hostname()
   };
-  fs32.writeFileSync(lockPath, JSON.stringify(payload, null, 2) + "\n");
+  fs33.writeFileSync(lockPath, JSON.stringify(payload, null, 2) + "\n");
   return {
     release: () => {
       try {
-        fs32.unlinkSync(lockPath);
+        fs33.unlinkSync(lockPath);
       } catch {
       }
     }
@@ -10924,11 +11140,11 @@ async function runRoadmapMigrate(opts) {
       if (!clientR.ok) return Err(new CLIError(clientR.error.message));
       client = clientR.value;
     }
-    const roadmapPath = path54.join(cwd, "docs", "roadmap.md");
-    if (!fs33.existsSync(roadmapPath)) {
+    const roadmapPath = path55.join(cwd, "docs", "roadmap.md");
+    if (!fs34.existsSync(roadmapPath)) {
       return Err(new CLIError(`docs/roadmap.md not found in ${cwd}`));
     }
-    const roadmapR = parseRoadmap(fs33.readFileSync(roadmapPath, "utf-8"));
+    const roadmapR = parseRoadmap(fs34.readFileSync(roadmapPath, "utf-8"));
     if (!roadmapR.ok) {
       return Err(new CLIError(`failed to parse docs/roadmap.md: ${roadmapR.error.message}`));
     }
@@ -10949,10 +11165,10 @@ async function runRoadmapMigrate(opts) {
     if (!isJson) printPlanSummary(plan, opts.dryRun);
     const deps = {
       client,
-      readFile: (p) => fs33.readFileSync(p, "utf-8"),
-      writeFile: (p, b) => fs33.writeFileSync(p, b),
-      renameFile: (from, to) => fs33.renameSync(from, to),
-      existsFile: (p) => fs33.existsSync(p)
+      readFile: (p) => fs34.readFileSync(p, "utf-8"),
+      writeFile: (p, b) => fs34.writeFileSync(p, b),
+      renameFile: (from, to) => fs34.renameSync(from, to),
+      existsFile: (p) => fs34.existsSync(p)
     };
     const reportR = await migrate_exports.runMigrationPlan(plan, deps, {
       projectRoot: cwd,
@@ -11010,7 +11226,7 @@ function featuresToRoadmap(features, project, nowIso) {
 }
 function readProjectName(configPath) {
   try {
-    const parsed = JSON.parse(fs33.readFileSync(configPath, "utf-8"));
+    const parsed = JSON.parse(fs34.readFileSync(configPath, "utf-8"));
     return typeof parsed.name === "string" && parsed.name.length > 0 ? parsed.name : "Roadmap";
   } catch {
     return "Roadmap";
@@ -11057,8 +11273,8 @@ async function runReverseMigrate(opts) {
   const lockResult = acquireMigrateLock(cwd);
   if (isRefusal(lockResult)) return Err(new CLIError(lockResult.message));
   try {
-    const roadmapPath = path54.join(cwd, "docs", "roadmap.md");
-    if (fs33.existsSync(roadmapPath)) {
+    const roadmapPath = path55.join(cwd, "docs", "roadmap.md");
+    if (fs34.existsSync(roadmapPath)) {
       return Err(
         new CLIError(`docs/roadmap.md already exists; refusing to overwrite (${roadmapPath})`)
       );
@@ -11078,7 +11294,7 @@ async function runReverseMigrate(opts) {
       return Err(new CLIError(`failed to fetch tracker features: ${fetchR.error.message}`));
     }
     const features = fetchR.value.features;
-    const configPath = path54.join(cwd, "harness.config.json");
+    const configPath = path55.join(cwd, "harness.config.json");
     const project = readProjectName(configPath);
     const nowIso = (/* @__PURE__ */ new Date()).toISOString();
     const markdown = serializeRoadmap(featuresToRoadmap(features, project, nowIso));
@@ -11096,19 +11312,19 @@ async function runReverseMigrate(opts) {
       emitReverseReport(report, features.length, isJson, true);
       return Ok(report);
     }
-    fs33.mkdirSync(path54.dirname(roadmapPath), { recursive: true });
-    fs33.writeFileSync(roadmapPath, markdown);
+    fs34.mkdirSync(path55.dirname(roadmapPath), { recursive: true });
+    fs34.writeFileSync(roadmapPath, markdown);
     report.archivedTo = roadmapPath;
-    if (fs33.existsSync(configPath)) {
-      const original = fs33.readFileSync(configPath, "utf-8");
-      const configBackupPath = path54.join(cwd, "harness.config.json.pre-migration");
-      fs33.writeFileSync(configBackupPath, original);
+    if (fs34.existsSync(configPath)) {
+      const original = fs34.readFileSync(configPath, "utf-8");
+      const configBackupPath = path55.join(cwd, "harness.config.json.pre-migration");
+      fs34.writeFileSync(configBackupPath, original);
       report.configBackup = configBackupPath;
       const parsed = JSON.parse(original);
       const roadmapSection = parsed.roadmap ?? {};
       roadmapSection.mode = "file-backed";
       parsed.roadmap = roadmapSection;
-      fs33.writeFileSync(configPath, JSON.stringify(parsed, null, 2) + "\n");
+      fs34.writeFileSync(configPath, JSON.stringify(parsed, null, 2) + "\n");
     }
     emitReverseReport(report, features.length, isJson, false);
     return Ok(report);
@@ -11153,23 +11369,23 @@ function createRoadmapMigrateCommand() {
 // src/commands/roadmap/shard.ts
 init_dist3();
 import { Command as Command84 } from "commander";
-import * as path55 from "path";
+import * as path56 from "path";
 
 // src/commands/roadmap/shard-io.ts
 import * as fsp from "fs/promises";
 function createNodeShardIO() {
   return {
-    readFile: (path80) => fsp.readFile(path80, "utf-8"),
-    writeFile: (path80, data) => fsp.writeFile(path80, data, "utf-8"),
+    readFile: (path81) => fsp.readFile(path81, "utf-8"),
+    writeFile: (path81, data) => fsp.writeFile(path81, data, "utf-8"),
     listDir: (dir) => fsp.readdir(dir),
-    deleteFile: (path80) => fsp.rm(path80),
+    deleteFile: (path81) => fsp.rm(path81),
     mkdirp: async (dir) => {
       await fsp.mkdir(dir, { recursive: true });
     },
-    rmrf: (path80) => fsp.rm(path80, { recursive: true, force: true }),
-    exists: async (path80) => {
+    rmrf: (path81) => fsp.rm(path81, { recursive: true, force: true }),
+    exists: async (path81) => {
       try {
-        await fsp.access(path80);
+        await fsp.access(path81);
         return true;
       } catch {
         return false;
@@ -11186,8 +11402,8 @@ async function runRoadmapShard(opts = {}) {
   const force = Boolean(opts.force);
   const format = opts.format === "json" ? "json" : "human";
   const assertRoundTrip = opts.assertRoundTrip ?? assertSemanticRoundTrip;
-  const roadmapPath = path55.join(cwd, "docs", "roadmap.md").replaceAll("\\", "/");
-  const shardDir = path55.join(cwd, "docs", "roadmap.d").replaceAll("\\", "/");
+  const roadmapPath = path56.join(cwd, "docs", "roadmap.md").replaceAll("\\", "/");
+  const shardDir = path56.join(cwd, "docs", "roadmap.d").replaceAll("\\", "/");
   if (!await io.exists(roadmapPath)) {
     return Err(new CLIError("docs/roadmap.md not found", ExitCode.ERROR));
   }
@@ -11279,14 +11495,14 @@ function createRoadmapShardCommand() {
 // src/commands/roadmap/unshard.ts
 init_dist3();
 import { Command as Command85 } from "commander";
-import * as path56 from "path";
+import * as path57 from "path";
 async function runRoadmapUnshard(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const io = opts.io ?? createNodeShardIO();
   const dryRun = Boolean(opts.dryRun);
   const format = opts.format === "json" ? "json" : "human";
-  const shardDir = path56.join(cwd, "docs", "roadmap.d");
-  const roadmapPath = path56.join(cwd, "docs", "roadmap.md");
+  const shardDir = path57.join(cwd, "docs", "roadmap.d");
+  const roadmapPath = path57.join(cwd, "docs", "roadmap.md");
   if (!await io.exists(shardDir)) {
     return Err(new CLIError("docs/roadmap.d not found; nothing to unshard", ExitCode.ERROR));
   }
@@ -11335,14 +11551,14 @@ function createRoadmapUnshardCommand() {
 // src/commands/roadmap/regen.ts
 init_dist3();
 import { Command as Command86 } from "commander";
-import * as path57 from "path";
+import * as path58 from "path";
 async function runRoadmapRegen(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const io = opts.io ?? createNodeShardIO();
   const dryRun = Boolean(opts.dryRun);
   const format = opts.format === "json" ? "json" : "human";
-  const shardDir = path57.join(cwd, "docs", "roadmap.d");
-  const roadmapPath = path57.join(cwd, "docs", "roadmap.md");
+  const shardDir = path58.join(cwd, "docs", "roadmap.d");
+  const roadmapPath = path58.join(cwd, "docs", "roadmap.md");
   if (!await io.exists(shardDir)) {
     return Err(new CLIError("docs/roadmap.d not found; project is not sharded", ExitCode.ERROR));
   }
@@ -11388,8 +11604,8 @@ function createRoadmapRegenCommand() {
 // src/commands/roadmap/reconcile.ts
 init_dist3();
 import { Command as Command87 } from "commander";
-import * as fs34 from "fs";
-import * as path58 from "path";
+import * as fs35 from "fs";
+import * as path59 from "path";
 async function runRoadmapReconcile(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   if (!opts.store && !roadmapSourceExists(cwd)) {
@@ -11467,8 +11683,8 @@ async function resolveAdapter(opts, cwd) {
       )
     );
   }
-  const envPath = path58.join(cwd, ".env");
-  if (fs34.existsSync(envPath) && !process.env.GITHUB_TOKEN) {
+  const envPath = path59.join(cwd, ".env");
+  if (fs35.existsSync(envPath) && !process.env.GITHUB_TOKEN) {
     const { config: loadDotenv } = await import("dotenv");
     loadDotenv({ path: envPath });
   }
@@ -11580,9 +11796,9 @@ function authHeader() {
   const tok = process.env["HARNESS_API_TOKEN"];
   return tok ? { Authorization: `Bearer ${tok}` } : {};
 }
-async function getJson(path80) {
+async function getJson(path81) {
   try {
-    const res = await fetch(`${orchestratorBase()}${path80}`, {
+    const res = await fetch(`${orchestratorBase()}${path81}`, {
       headers: { ...authHeader() }
     });
     const text = await res.text();
@@ -11597,9 +11813,9 @@ async function getJson(path80) {
     };
   }
 }
-async function postJson(path80, body) {
+async function postJson(path81, body) {
   try {
-    const res = await fetch(`${orchestratorBase()}${path80}`, {
+    const res = await fetch(`${orchestratorBase()}${path81}`, {
       method: "POST",
       headers: { "Content-Type": "application/json", ...authHeader() },
       body: JSON.stringify(body)
@@ -11804,8 +12020,8 @@ function createRoutingCommand() {
 // src/commands/scan-config.ts
 init_dist3();
 import { Command as Command94 } from "commander";
-import { existsSync as existsSync30, readFileSync as readFileSync22, writeFileSync as writeFileSync22 } from "fs";
-import { join as join49, relative as relative3 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync22, writeFileSync as writeFileSync23 } from "fs";
+import { join as join50, relative as relative4 } from "path";
 var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".gemini/settings.json", "skill.yaml"];
 function stripHighSeverityPatterns(content, injectionFindings) {
   const highLines = /* @__PURE__ */ new Set();
@@ -11831,14 +12047,14 @@ function applyFix(filePath, targetDir, content, injectionFindings) {
   if (!hasHighSeverity) return;
   const { cleaned, linesStripped } = stripHighSeverityPatterns(content, injectionFindings);
   if (linesStripped > 0) {
-    writeFileSync22(filePath, cleaned);
+    writeFileSync23(filePath, cleaned);
     logger.info(
-      `scan-config --fix: stripped ${linesStripped} high-severity line(s) from ${relative3(targetDir, filePath).replaceAll("\\", "/")}`
+      `scan-config --fix: stripped ${linesStripped} high-severity line(s) from ${relative4(targetDir, filePath).replaceAll("\\", "/")}`
     );
   }
 }
 function scanSingleFile(filePath, targetDir, scanner, options) {
-  if (!existsSync30(filePath)) return null;
+  if (!existsSync31(filePath)) return null;
   let content;
   try {
     content = readFileSync22(filePath, "utf8");
@@ -11853,7 +12069,7 @@ function scanSingleFile(filePath, targetDir, scanner, options) {
     applyFix(filePath, targetDir, content, injectionFindings);
   }
   return {
-    file: relative3(targetDir, filePath).replaceAll("\\", "/"),
+    file: relative4(targetDir, filePath).replaceAll("\\", "/"),
     findings,
     overallSeverity: computeOverallSeverity(findings)
   };
@@ -11862,7 +12078,7 @@ async function runScanConfig(targetDir, options) {
   const scanner = new SecurityScanner(parseSecurityConfig({}));
   const results = [];
   for (const configFile of CONFIG_FILES) {
-    const result = scanSingleFile(join49(targetDir, configFile), targetDir, scanner, options);
+    const result = scanSingleFile(join50(targetDir, configFile), targetDir, scanner, options);
     if (result) results.push(result);
   }
   return { exitCode: computeScanExitCode(results), results };
@@ -12040,10 +12256,10 @@ function printResult5(result, mode, _formatter) {
       list.push(f);
       byFile.set(f.target.file, list);
     }
-    for (const [file, fs50] of byFile) {
+    for (const [file, fs51] of byFile) {
       console.log(`
 ${file}`);
-      for (const f of fs50) {
+      for (const f of fs51) {
         console.log(
           `  ${f.code} [${f.tier}/${f.impact}/${f.confidence}] ${f.target.signal}:${f.target.line}`
         );
@@ -12060,23 +12276,23 @@ ${file}`);
 
 // src/commands/setup.ts
 import { Command as Command97 } from "commander";
-import * as fs37 from "fs";
+import * as fs38 from "fs";
 import * as os9 from "os";
-import * as path61 from "path";
+import * as path62 from "path";
 import chalk16 from "chalk";
 
 // src/utils/first-run.ts
-import * as fs35 from "fs";
+import * as fs36 from "fs";
 import * as os8 from "os";
-import * as path59 from "path";
-var HARNESS_DIR = path59.join(os8.homedir(), ".harness");
-var MARKER_FILE = path59.join(HARNESS_DIR, ".setup-complete");
+import * as path60 from "path";
+var HARNESS_DIR = path60.join(os8.homedir(), ".harness");
+var MARKER_FILE = path60.join(HARNESS_DIR, ".setup-complete");
 function isFirstRun() {
-  return !fs35.existsSync(MARKER_FILE);
+  return !fs36.existsSync(MARKER_FILE);
 }
 function markSetupComplete() {
-  fs35.mkdirSync(HARNESS_DIR, { recursive: true });
-  fs35.writeFileSync(MARKER_FILE, "", "utf-8");
+  fs36.mkdirSync(HARNESS_DIR, { recursive: true });
+  fs36.writeFileSync(MARKER_FILE, "", "utf-8");
 }
 function printFirstRunWelcome() {
   try {
@@ -12089,8 +12305,8 @@ function printFirstRunWelcome() {
 }
 
 // src/commands/telemetry-wizard.ts
-import * as fs36 from "fs";
-import * as path60 from "path";
+import * as fs37 from "fs";
+import * as path61 from "path";
 import readline2 from "readline";
 import chalk15 from "chalk";
 function prompt2(question) {
@@ -12098,10 +12314,10 @@ function prompt2(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve48) => {
+  return new Promise((resolve50) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve48(answer.trim().toLowerCase());
+      resolve50(answer.trim().toLowerCase());
     });
   });
 }
@@ -12110,10 +12326,10 @@ function promptRaw(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve48) => {
+  return new Promise((resolve50) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve48(answer.trim());
+      resolve50(answer.trim());
     });
   });
 }
@@ -12121,21 +12337,21 @@ function isNo(answer) {
   return answer === "n" || answer === "no";
 }
 function isTelemetryConfigured(cwd) {
-  const configPath = path60.join(cwd, "harness.config.json");
+  const configPath = path61.join(cwd, "harness.config.json");
   try {
-    const raw = JSON.parse(fs36.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs37.readFileSync(configPath, "utf-8"));
     return raw.telemetry !== void 0 && raw.adoption !== void 0;
   } catch {
     return false;
   }
 }
 function writeTelemetryConfig(cwd, result) {
-  const configPath = path60.join(cwd, "harness.config.json");
+  const configPath = path61.join(cwd, "harness.config.json");
   try {
-    const raw = JSON.parse(fs36.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs37.readFileSync(configPath, "utf-8"));
     raw.telemetry = { enabled: result.telemetryEnabled };
     raw.adoption = { enabled: result.adoptionEnabled };
-    fs36.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
+    fs37.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
   } catch (err) {
     console.warn(
       `\u26A0 Could not update ${configPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -12143,10 +12359,10 @@ function writeTelemetryConfig(cwd, result) {
   }
   const hasIdentity = result.identity.project || result.identity.team || result.identity.alias;
   if (hasIdentity) {
-    const harnessDir = path60.join(cwd, ".harness");
-    fs36.mkdirSync(harnessDir, { recursive: true });
-    const telemetryFile = path60.join(harnessDir, "telemetry.json");
-    fs36.writeFileSync(telemetryFile, JSON.stringify({ identity: result.identity }, null, 2) + "\n");
+    const harnessDir = path61.join(cwd, ".harness");
+    fs37.mkdirSync(harnessDir, { recursive: true });
+    const telemetryFile = path61.join(harnessDir, "telemetry.json");
+    fs37.writeFileSync(telemetryFile, JSON.stringify({ identity: result.identity }, null, 2) + "\n");
   }
 }
 async function promptIdentity() {
@@ -12192,8 +12408,8 @@ async function runTelemetryWizard() {
   return { telemetryEnabled, adoptionEnabled, identity };
 }
 async function ensureTelemetryConfigured(cwd) {
-  const configPath = path60.join(cwd, "harness.config.json");
-  if (!fs36.existsSync(configPath)) {
+  const configPath = path61.join(cwd, "harness.config.json");
+  if (!fs37.existsSync(configPath)) {
     return { status: "warn", message: "Not a harness project \u2014 skipped telemetry configuration" };
   }
   if (isTelemetryConfigured(cwd)) {
@@ -12239,7 +12455,7 @@ function runSlashCommandGeneration() {
   }
 }
 function detectClient(dirName) {
-  return fs37.existsSync(path61.join(os9.homedir(), dirName));
+  return fs38.existsSync(path62.join(os9.homedir(), dirName));
 }
 async function runMcpSetup(cwd) {
   const results = [];
@@ -12255,7 +12471,7 @@ async function runMcpSetup(cwd) {
     { name: "Cursor", dir: ".cursor", client: "cursor", configTarget: ".cursor/mcp.json" },
     {
       name: "OpenCode",
-      dir: path61.join(".config", "opencode"),
+      dir: path62.join(".config", "opencode"),
       client: "opencode",
       configTarget: "opencode.json"
     }
@@ -12287,7 +12503,7 @@ function formatStep(result) {
 }
 function configureTier0Integrations(cwd) {
   try {
-    const mcpPath = path61.join(cwd, ".mcp.json");
+    const mcpPath = path62.join(cwd, ".mcp.json");
     const config = readMcpConfig(mcpPath);
     const tier0 = INTEGRATION_REGISTRY.filter((i) => i.tier === 0);
     const added = [];
@@ -12296,9 +12512,9 @@ function configureTier0Integrations(cwd) {
       writeMcpEntry(mcpPath, integration.name, integration.mcpConfig);
       added.push(integration.displayName);
     }
-    const geminiDir = path61.join(cwd, ".gemini");
-    if (fs37.existsSync(geminiDir)) {
-      const geminiPath = path61.join(geminiDir, "settings.json");
+    const geminiDir = path62.join(cwd, ".gemini");
+    if (fs38.existsSync(geminiDir)) {
+      const geminiPath = path62.join(geminiDir, "settings.json");
       const geminiConfig = readMcpConfig(geminiPath);
       for (const integration of tier0) {
         if (!geminiConfig.mcpServers[integration.name]) {
@@ -12306,9 +12522,9 @@ function configureTier0Integrations(cwd) {
         }
       }
     }
-    const opencodePath = path61.join(cwd, "opencode.json");
-    const opencodeGlobalDir = path61.join(os9.homedir(), ".config", "opencode");
-    if (fs37.existsSync(opencodePath) || fs37.existsSync(opencodeGlobalDir)) {
+    const opencodePath = path62.join(cwd, "opencode.json");
+    const opencodeGlobalDir = path62.join(os9.homedir(), ".config", "opencode");
+    if (fs38.existsSync(opencodePath) || fs38.existsSync(opencodeGlobalDir)) {
       for (const integration of tier0) {
         writeOpencodeMcpEntry(opencodePath, integration.name, integration.mcpConfig);
       }
@@ -12326,14 +12542,14 @@ function configureTier0Integrations(cwd) {
   }
 }
 function ensureHooks(cwd) {
-  const configPath = path61.join(cwd, "harness.config.json");
-  if (!fs37.existsSync(configPath)) {
+  const configPath = path62.join(cwd, "harness.config.json");
+  if (!fs38.existsSync(configPath)) {
     return { status: "warn", message: "Not a harness project \u2014 skipped hook installation" };
   }
   let profile = "standard";
-  const profilePath = path61.join(cwd, ".harness", "hooks", "profile.json");
+  const profilePath = path62.join(cwd, ".harness", "hooks", "profile.json");
   try {
-    const data = JSON.parse(fs37.readFileSync(profilePath, "utf-8"));
+    const data = JSON.parse(fs38.readFileSync(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
       profile = data.profile;
     }
@@ -12428,14 +12644,14 @@ function createSetupCommand() {
 // src/commands/share.ts
 init_dist3();
 import { Command as Command98 } from "commander";
-import * as fs38 from "fs";
-import * as path62 from "path";
+import * as fs39 from "fs";
+import * as path63 from "path";
 import { parse as parseYaml3 } from "yaml";
 var MANIFEST_FILENAME = "constraints.yaml";
 async function runShareAction(projectPath, options) {
-  const rootDir = path62.resolve(projectPath);
-  const manifestPath = path62.join(rootDir, MANIFEST_FILENAME);
-  if (!fs38.existsSync(manifestPath)) {
+  const rootDir = path63.resolve(projectPath);
+  const manifestPath = path63.join(rootDir, MANIFEST_FILENAME);
+  if (!fs39.existsSync(manifestPath)) {
     logger.error(
       `No ${MANIFEST_FILENAME} found at ${manifestPath}.
 Create a constraints.yaml in your project root to define what to share.`
@@ -12444,7 +12660,7 @@ Create a constraints.yaml in your project root to define what to share.`
   }
   let parsed;
   try {
-    const raw = fs38.readFileSync(manifestPath, "utf-8");
+    const raw = fs39.readFileSync(manifestPath, "utf-8");
     parsed = parseYaml3(raw);
   } catch (err) {
     logger.error(
@@ -12458,7 +12674,7 @@ Create a constraints.yaml in your project root to define what to share.`
     process.exit(1);
   }
   const manifest = manifestResult.value;
-  const configResult = resolveConfig(path62.join(rootDir, "harness.config.json"));
+  const configResult = resolveConfig(path63.join(rootDir, "harness.config.json"));
   if (!configResult.ok) {
     logger.error(configResult.error.message);
     process.exit(1);
@@ -12476,8 +12692,8 @@ Create a constraints.yaml in your project root to define what to share.`
     );
     process.exit(1);
   }
-  const outputDir = path62.resolve(options.output);
-  const outputPath = path62.join(outputDir, `${manifest.name}.harness-constraints.json`);
+  const outputDir = path63.resolve(options.output);
+  const outputPath = path63.join(outputDir, `${manifest.name}.harness-constraints.json`);
   const writeResult = await writeConfig(outputPath, bundle);
   if (!writeResult.ok) {
     logger.error(`Failed to write bundle: ${writeResult.error.message}`);
@@ -12496,18 +12712,18 @@ import { Command as Command106 } from "commander";
 
 // src/commands/skill/list.ts
 import { Command as Command99 } from "commander";
-import * as fs39 from "fs";
-import * as path63 from "path";
+import * as fs40 from "fs";
+import * as path64 from "path";
 import { parse } from "yaml";
 function scanDirectory(dirPath, source) {
-  if (!fs39.existsSync(dirPath)) return [];
-  const entries = fs39.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  if (!fs40.existsSync(dirPath)) return [];
+  const entries = fs40.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   const skills = [];
   for (const name of entries) {
-    const yamlPath = path63.join(dirPath, name, "skill.yaml");
-    if (!fs39.existsSync(yamlPath)) continue;
+    const yamlPath = path64.join(dirPath, name, "skill.yaml");
+    if (!fs40.existsSync(yamlPath)) continue;
     try {
-      const raw = fs39.readFileSync(yamlPath, "utf-8");
+      const raw = fs40.readFileSync(yamlPath, "utf-8");
       const parsed = parse(raw);
       const result = SkillMetadataSchema.safeParse(parsed);
       if (result.success) {
@@ -12525,10 +12741,10 @@ function scanDirectory(dirPath, source) {
 }
 function collectCommunitySkills(seen, allSkills) {
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path63.dirname(globalDir);
-  const communityBase = path63.join(skillsDir, "community");
-  const communityPlatformDir = path63.join(communityBase, "claude-code");
-  const lockfilePath = path63.join(communityBase, "skills-lock.json");
+  const skillsDir = path64.dirname(globalDir);
+  const communityBase = path64.join(skillsDir, "community");
+  const communityPlatformDir = path64.join(communityBase, "claude-code");
+  const lockfilePath = path64.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const communitySkills = scanDirectory(communityPlatformDir, "community");
   for (const skill of communitySkills) {
@@ -12614,8 +12830,8 @@ function createListCommand3() {
 
 // src/commands/skill/run.ts
 import { Command as Command100 } from "commander";
-import * as fs40 from "fs";
-import * as path64 from "path";
+import * as fs41 from "fs";
+import * as path65 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/skill/complexity.ts
@@ -12711,10 +12927,10 @@ ${options.principles}`);
 
 // src/commands/skill/run.ts
 function loadSkillMetadata(skillDir) {
-  const yamlPath = path64.join(skillDir, "skill.yaml");
-  if (!fs40.existsSync(yamlPath)) return null;
+  const yamlPath = path65.join(skillDir, "skill.yaml");
+  if (!fs41.existsSync(yamlPath)) return null;
   try {
-    const result = SkillMetadataSchema.safeParse(parse2(fs40.readFileSync(yamlPath, "utf-8")));
+    const result = SkillMetadataSchema.safeParse(parse2(fs41.readFileSync(yamlPath, "utf-8")));
     return result.success ? result.data : null;
   } catch {
     return null;
@@ -12726,22 +12942,22 @@ function resolveComplexity(metadata, requested, projectPath) {
   return requested;
 }
 function loadPrinciples(projectPath) {
-  const principlesPath = path64.join(projectPath, "docs", "principles.md");
-  return fs40.existsSync(principlesPath) ? fs40.readFileSync(principlesPath, "utf-8") : void 0;
+  const principlesPath = path65.join(projectPath, "docs", "principles.md");
+  return fs41.existsSync(principlesPath) ? fs41.readFileSync(principlesPath, "utf-8") : void 0;
 }
 function readMostRecentFileInDir(dirPath) {
-  const files = fs40.readdirSync(dirPath).map((f) => ({ name: f, mtime: fs40.statSync(path64.join(dirPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
-  if (files.length > 0) return fs40.readFileSync(path64.join(dirPath, files[0].name), "utf-8");
+  const files = fs41.readdirSync(dirPath).map((f) => ({ name: f, mtime: fs41.statSync(path65.join(dirPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  if (files.length > 0) return fs41.readFileSync(path65.join(dirPath, files[0].name), "utf-8");
   return void 0;
 }
 function loadPriorState(metadata, projectPath) {
   if (!metadata?.state.persistent || metadata.state.files.length === 0) return void 0;
   for (const stateFilePath of metadata.state.files) {
-    const fullPath = path64.join(projectPath, stateFilePath);
-    if (!fs40.existsSync(fullPath)) continue;
-    const stat = fs40.statSync(fullPath);
+    const fullPath = path65.join(projectPath, stateFilePath);
+    if (!fs41.existsSync(fullPath)) continue;
+    const stat = fs41.statSync(fullPath);
     if (stat.isDirectory()) return readMostRecentFileInDir(fullPath);
-    return fs40.readFileSync(fullPath, "utf-8");
+    return fs41.readFileSync(fullPath, "utf-8");
   }
   return void 0;
 }
@@ -12761,7 +12977,7 @@ function resolvePhaseState(metadata, projectPath, phase) {
 }
 async function appendProjectState(content, metadata, projectPath, hasPathOpt) {
   if (!metadata?.state.persistent || !hasPathOpt) return content;
-  const { readHarnessState: readHarnessState2, isEmptyHarnessState } = await import("./state-events-YY5KBZTC.js");
+  const { readHarnessState: readHarnessState2, isEmptyHarnessState } = await import("./state-events-PBDNQPXT.js");
   const stateResult = await readHarnessState2(projectPath);
   if (!stateResult.ok || isEmptyHarnessState(stateResult.value)) return content;
   const stateContent = JSON.stringify(stateResult.value, null, 2);
@@ -12782,7 +12998,7 @@ async function runSkill(name, opts) {
     return;
   }
   const metadata = loadSkillMetadata(skillDir);
-  const projectPath = opts.path ? path64.resolve(opts.path) : process.cwd();
+  const projectPath = opts.path ? path65.resolve(opts.path) : process.cwd();
   const complexity = resolveComplexity(
     metadata,
     opts.complexity ?? "standard",
@@ -12809,14 +13025,14 @@ async function runSkill(name, opts) {
     ...stateWarning !== void 0 && { stateWarning },
     ...opts.party !== void 0 && { party: opts.party }
   });
-  const skillMdPath = path64.join(skillDir, "SKILL.md");
-  if (!fs40.existsSync(skillMdPath)) {
+  const skillMdPath = path65.join(skillDir, "SKILL.md");
+  if (!fs41.existsSync(skillMdPath)) {
     logger.error(`SKILL.md not found for skill: ${name}`);
     process.exit(ExitCode.ERROR);
     return;
   }
   const content = await appendProjectState(
-    fs40.readFileSync(skillMdPath, "utf-8"),
+    fs41.readFileSync(skillMdPath, "utf-8"),
     metadata,
     projectPath,
     !!opts.path
@@ -12835,8 +13051,8 @@ function createRunCommand3() {
 
 // src/commands/skill/validate.ts
 import { Command as Command101 } from "commander";
-import * as fs41 from "fs";
-import * as path65 from "path";
+import * as fs42 from "fs";
+import * as path66 from "path";
 import { parse as parse3 } from "yaml";
 var BEHAVIORAL_REQUIRED_SECTIONS = [
   "## When to Use",
@@ -12848,11 +13064,11 @@ var BEHAVIORAL_REQUIRED_SECTIONS = [
 ];
 var KNOWLEDGE_REQUIRED_SECTIONS = ["## Instructions"];
 function validateSkillMd(name, skillMdPath, skillType, errors) {
-  if (!fs41.existsSync(skillMdPath)) {
+  if (!fs42.existsSync(skillMdPath)) {
     errors.push(`${name}: missing SKILL.md`);
     return;
   }
-  const mdContent = fs41.readFileSync(skillMdPath, "utf-8");
+  const mdContent = fs42.readFileSync(skillMdPath, "utf-8");
   if (!mdContent.trim().startsWith("# ")) {
     errors.push(`${name}/SKILL.md: must start with an h1 heading`);
   }
@@ -12877,20 +13093,20 @@ function validateSkillMd(name, skillMdPath, skillType, errors) {
   }
 }
 function validateSkillEntry(name, skillsDir, errors) {
-  const skillDir = path65.join(skillsDir, name);
-  const yamlPath = path65.join(skillDir, "skill.yaml");
-  if (!fs41.existsSync(yamlPath)) {
+  const skillDir = path66.join(skillsDir, name);
+  const yamlPath = path66.join(skillDir, "skill.yaml");
+  if (!fs42.existsSync(yamlPath)) {
     errors.push(`${name}: missing skill.yaml`);
     return false;
   }
   try {
-    const raw = fs41.readFileSync(yamlPath, "utf-8");
+    const raw = fs42.readFileSync(yamlPath, "utf-8");
     const result = SkillMetadataSchema.safeParse(parse3(raw));
     if (!result.success) {
       errors.push(`${name}/skill.yaml: ${result.error.message}`);
       return false;
     }
-    validateSkillMd(name, path65.join(skillDir, "SKILL.md"), result.data.type, errors);
+    validateSkillMd(name, path66.join(skillDir, "SKILL.md"), result.data.type, errors);
     return true;
   } catch (e) {
     errors.push(`${name}: parse error \u2014 ${e instanceof Error ? e.message : String(e)}`);
@@ -12901,12 +13117,12 @@ function createValidateCommand2() {
   return new Command101("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    if (!fs41.existsSync(skillsDir)) {
+    if (!fs42.existsSync(skillsDir)) {
       logger.info("No skills directory found.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
-    const entries = fs41.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const entries = fs42.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     const errors = [];
     let validated = 0;
     for (const name of entries) {
@@ -12929,8 +13145,8 @@ function createValidateCommand2() {
 
 // src/commands/skill/info.ts
 import { Command as Command102 } from "commander";
-import * as fs42 from "fs";
-import * as path66 from "path";
+import * as fs43 from "fs";
+import * as path67 from "path";
 import { parse as parse4 } from "yaml";
 function loadSkillMetadata2(name) {
   const skillDir = resolveSkillDir(name);
@@ -12938,13 +13154,13 @@ function loadSkillMetadata2(name) {
     logger.error(`Skill not found: ${name}`);
     return { ok: false, exitCode: ExitCode.ERROR };
   }
-  const yamlPath = path66.join(skillDir, "skill.yaml");
-  if (!fs42.existsSync(yamlPath)) {
+  const yamlPath = path67.join(skillDir, "skill.yaml");
+  if (!fs43.existsSync(yamlPath)) {
     logger.error(`skill.yaml not found for skill: ${name}`);
     return { ok: false, exitCode: ExitCode.ERROR };
   }
   try {
-    const raw = fs42.readFileSync(yamlPath, "utf-8");
+    const raw = fs43.readFileSync(yamlPath, "utf-8");
     const parsed = parse4(raw);
     const result = SkillMetadataSchema.safeParse(parsed);
     if (!result.success) {
@@ -13042,8 +13258,8 @@ function createSearchCommand2() {
 
 // src/commands/skill/create.ts
 import { Command as Command104 } from "commander";
-import * as path67 from "path";
-import * as fs43 from "fs";
+import * as path68 from "path";
+import * as fs44 from "fs";
 import YAML from "yaml";
 var KEBAB_CASE_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 function buildReadme(name, description) {
@@ -13127,22 +13343,22 @@ function runCreate(name, opts) {
   if (!KEBAB_CASE_RE.test(name)) {
     throw new Error(`Invalid skill name "${name}". Must be kebab-case (e.g., my-skill).`);
   }
-  const baseDir = opts.outputDir ?? path67.join(process.cwd(), "agents", "skills", "claude-code");
-  const skillDir = path67.join(baseDir, name);
-  if (fs43.existsSync(skillDir)) {
+  const baseDir = opts.outputDir ?? path68.join(process.cwd(), "agents", "skills", "claude-code");
+  const skillDir = path68.join(baseDir, name);
+  if (fs44.existsSync(skillDir)) {
     throw new Error(`Skill directory already exists: ${skillDir}`);
   }
-  fs43.mkdirSync(skillDir, { recursive: true });
+  fs44.mkdirSync(skillDir, { recursive: true });
   const description = opts.description || `A community skill: ${name}`;
   const skillYaml = buildSkillYaml(name, opts);
-  const skillYamlPath = path67.join(skillDir, "skill.yaml");
-  fs43.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
+  const skillYamlPath = path68.join(skillDir, "skill.yaml");
+  fs44.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
   const skillMd = buildSkillMd(name, description);
-  const skillMdPath = path67.join(skillDir, "SKILL.md");
-  fs43.writeFileSync(skillMdPath, skillMd);
+  const skillMdPath = path68.join(skillDir, "SKILL.md");
+  fs44.writeFileSync(skillMdPath, skillMd);
   const readme = buildReadme(name, description);
-  const readmePath = path67.join(skillDir, "README.md");
-  fs43.writeFileSync(readmePath, readme);
+  const readmePath = path68.join(skillDir, "README.md");
+  fs44.writeFileSync(readmePath, readme);
   return {
     name,
     directory: skillDir,
@@ -13156,7 +13372,7 @@ function printCreateResult(name, result) {
   }
   logger.info(`
 Next steps:`);
-  logger.info(`  1. Edit ${path67.join(result.directory, "SKILL.md")} with your skill content`);
+  logger.info(`  1. Edit ${path68.join(result.directory, "SKILL.md")} with your skill content`);
   logger.info(`  2. Run: harness skill validate ${name}`);
   logger.info(`  3. Run: harness skills publish`);
 }
@@ -13185,25 +13401,25 @@ function createCreateCommand() {
 
 // src/commands/skill/publish.ts
 import { Command as Command105 } from "commander";
-import * as fs45 from "fs";
-import * as path69 from "path";
+import * as fs46 from "fs";
+import * as path70 from "path";
 import { execFileSync as execFileSync9 } from "child_process";
 
 // src/registry/validator.ts
-import * as fs44 from "fs";
-import * as path68 from "path";
+import * as fs45 from "fs";
+import * as path69 from "path";
 import { parse as parse5 } from "yaml";
 import semver4 from "semver";
 async function validateForPublish(skillDir, registryUrl) {
   const errors = [];
-  const skillYamlPath = path68.join(skillDir, "skill.yaml");
-  if (!fs44.existsSync(skillYamlPath)) {
+  const skillYamlPath = path69.join(skillDir, "skill.yaml");
+  if (!fs45.existsSync(skillYamlPath)) {
     errors.push("skill.yaml not found. Create one with: harness skill create <name>");
     return { valid: false, errors };
   }
   let skillMeta;
   try {
-    const raw = fs44.readFileSync(skillYamlPath, "utf-8");
+    const raw = fs45.readFileSync(skillYamlPath, "utf-8");
     const parsed = parse5(raw);
     const result = SkillMetadataSchema.safeParse(parsed);
     if (!result.success) {
@@ -13225,11 +13441,11 @@ async function validateForPublish(skillDir, registryUrl) {
   if (!skillMeta.triggers || skillMeta.triggers.length === 0) {
     errors.push("At least one trigger is required. Add triggers to skill.yaml.");
   }
-  const skillMdPath = path68.join(skillDir, "SKILL.md");
-  if (!fs44.existsSync(skillMdPath)) {
+  const skillMdPath = path69.join(skillDir, "SKILL.md");
+  if (!fs45.existsSync(skillMdPath)) {
     errors.push("SKILL.md not found. Create it with content describing your skill.");
   } else {
-    const content = fs44.readFileSync(skillMdPath, "utf-8");
+    const content = fs45.readFileSync(skillMdPath, "utf-8");
     if (!content.includes("## When to Use")) {
       errors.push('SKILL.md must contain a "## When to Use" section.');
     }
@@ -13309,11 +13525,11 @@ ${errorList}`);
   }
   const meta = validation.skillMeta;
   const pkg = derivePackageJson(meta);
-  const pkgPath = path69.join(skillDir, "package.json");
-  fs45.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-  const readmePath = path69.join(skillDir, "README.md");
-  if (!fs45.existsSync(readmePath)) {
-    const skillMdContent = fs45.readFileSync(path69.join(skillDir, "SKILL.md"), "utf-8");
+  const pkgPath = path70.join(skillDir, "package.json");
+  fs46.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  const readmePath = path70.join(skillDir, "README.md");
+  if (!fs46.existsSync(readmePath)) {
+    const skillMdContent = fs46.readFileSync(path70.join(skillDir, "SKILL.md"), "utf-8");
     const readme = `# ${pkg.name}
 
 ${meta.description}
@@ -13327,7 +13543,7 @@ harness install ${meta.name}
 ---
 
 ${skillMdContent}`;
-    fs45.writeFileSync(readmePath, readme);
+    fs46.writeFileSync(readmePath, readme);
   }
   if (opts.dryRun) {
     return {
@@ -13631,10 +13847,10 @@ function printResult6(result, mode, _formatter) {
       list.push(f);
       byFile.set(f.target.file, list);
     }
-    for (const [file, fs50] of byFile) {
+    for (const [file, fs51] of byFile) {
       console.log(`
 ${file}`);
-      for (const f of fs50) {
+      for (const f of fs51) {
         console.log(
           `  ${f.code} [${f.tier}/${f.impact}/${f.confidence}] ## ${f.target.section}:${f.target.line}`
         );
@@ -13760,7 +13976,7 @@ import { Command as Command114 } from "commander";
 
 // src/commands/state/show.ts
 import { Command as Command110 } from "commander";
-import * as path70 from "path";
+import * as path71 from "path";
 function printStateText(state, stream) {
   if (stream) console.log(`Stream:         ${stream}`);
   console.log(`Schema Version: ${state.schemaVersion}`);
@@ -13786,7 +14002,7 @@ function printStateProgress(progress) {
 function createShowCommand() {
   return new Command110("show").description("Show current project state").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const result = await readHarnessState(path70.resolve(opts.path), { stream: opts.stream });
+    const result = await readHarnessState(path71.resolve(opts.path), { stream: opts.stream });
     if (!result.ok) {
       logger.error(result.error.message);
       process.exit(ExitCode.ERROR);
@@ -13803,18 +14019,18 @@ function createShowCommand() {
 // src/commands/state/reset.ts
 init_dist3();
 import { Command as Command111 } from "commander";
-import * as path71 from "path";
+import * as path72 from "path";
 import * as readline3 from "readline";
 async function confirmReset() {
   const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve48) => {
-    rl.question("Reset project state? This cannot be undone. [y/N] ", resolve48);
+  const answer = await new Promise((resolve50) => {
+    rl.question("Reset project state? This cannot be undone. [y/N] ", resolve50);
   });
   rl.close();
   return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
 }
 async function runReset(opts) {
-  const projectPath = path71.resolve(opts.path);
+  const projectPath = path72.resolve(opts.path);
   if (!opts.yes && !await confirmReset()) {
     logger.info("Reset cancelled.");
     process.exit(ExitCode.SUCCESS);
@@ -13834,10 +14050,10 @@ function createResetCommand() {
 // src/commands/state/learn.ts
 init_dist3();
 import { Command as Command112 } from "commander";
-import * as path72 from "path";
+import * as path73 from "path";
 function createLearnCommand() {
   return new Command112("learn").description("Append a learning to .harness/learnings.md").argument("<message>", "The learning to record").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (message, opts, _cmd) => {
-    const projectPath = path72.resolve(opts.path);
+    const projectPath = path73.resolve(opts.path);
     const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -13852,9 +14068,9 @@ function createLearnCommand() {
 // src/commands/state/streams.ts
 init_dist3();
 import { Command as Command113 } from "commander";
-import * as path73 from "path";
+import * as path74 from "path";
 async function runListStreams(opts, globalOpts) {
-  const projectPath = path73.resolve(opts.path);
+  const projectPath = path74.resolve(opts.path);
   const indexResult = await loadStreamIndex(projectPath);
   const result = await listStreams(projectPath);
   if (!result.ok) {
@@ -13875,7 +14091,7 @@ async function runListStreams(opts, globalOpts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runCreateStream(name, opts) {
-  const result = await createStream(path73.resolve(opts.path), name, opts.branch);
+  const result = await createStream(path74.resolve(opts.path), name, opts.branch);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -13884,7 +14100,7 @@ async function runCreateStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runArchiveStream(name, opts) {
-  const result = await archiveStream(path73.resolve(opts.path), name);
+  const result = await archiveStream(path74.resolve(opts.path), name);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -13893,7 +14109,7 @@ async function runArchiveStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runActivateStream(name, opts) {
-  const result = await setActiveStream(path73.resolve(opts.path), name);
+  const result = await setActiveStream(path74.resolve(opts.path), name);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -13921,8 +14137,8 @@ function createStateCommand() {
 }
 
 // src/commands/sync-analyses.ts
-import * as fs46 from "fs";
-import * as path74 from "path";
+import * as fs47 from "fs";
+import * as path75 from "path";
 import { Command as Command115 } from "commander";
 init_dist3();
 function isValidRecord(record) {
@@ -13949,7 +14165,7 @@ function extractAnalysisFromComments(comments) {
   return null;
 }
 function bootstrapTrackerCommand2(opts, verb) {
-  const projectPath = path74.resolve(opts.dir);
+  const projectPath = path75.resolve(opts.dir);
   const trackerConfig = loadTrackerSyncConfig(projectPath);
   if (!trackerConfig) {
     logger.error(`No tracker config found in harness.config.json. Cannot ${verb}.`);
@@ -13961,8 +14177,8 @@ function bootstrapTrackerCommand2(opts, verb) {
     );
     return null;
   }
-  const projectEnvPath = path74.join(projectPath, ".env");
-  if (fs46.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
+  const projectEnvPath = path75.join(projectPath, ".env");
+  if (fs47.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
     __require("dotenv").config({ path: projectEnvPath });
   }
   const token = process.env.GITHUB_TOKEN;
@@ -14048,9 +14264,9 @@ async function runSyncAnalyses(opts) {
     return;
   }
   const { AnalysisArchive, loadPublishedIndex: loadPublishedIndex2, savePublishedIndex: savePublishedIndex2 } = await import("@harness-engineering/orchestrator");
-  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-MCTEX5QH.js");
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-BWFFVKEW.js");
   const adapter = new GitHubIssuesSyncAdapter2({ token, config: trackerConfig });
-  const archive = new AnalysisArchive(path74.join(projectPath, ".harness", "analyses"));
+  const archive = new AnalysisArchive(path75.join(projectPath, ".harness", "analyses"));
   const publishedIndex = loadPublishedIndex2(projectPath);
   const { syncedCount, skippedCount, warnCount } = await syncFeatureAnalyses(
     features,
@@ -14085,7 +14301,7 @@ function createSyncAnalysesCommand() {
 
 // src/commands/sync-main.ts
 import { Command as Command116 } from "commander";
-import * as path75 from "path";
+import * as path76 from "path";
 import {
   syncMain as defaultSyncMain
 } from "@harness-engineering/orchestrator";
@@ -14116,7 +14332,7 @@ function formatHuman2(r) {
 }
 function createSyncMainCommand() {
   return new Command116("sync-main").description("Fast-forward the local default branch from origin (no-op on conflict)").option("--json", "Emit a SyncMainResult JSON object", false).option("--path <path>", "Project root path", ".").action(async (opts) => {
-    const cwd = path75.resolve(opts.path ?? ".");
+    const cwd = path76.resolve(opts.path ?? ".");
     const exitCode = await runSyncMain({ cwd, json: Boolean(opts.json) });
     process.exit(exitCode);
   });
@@ -14132,8 +14348,8 @@ function registerClearCommand(taint) {
   taint.command("clear [sessionId]").description(
     "Clear session taint \u2014 removes taint file(s) and re-enables destructive operations"
   ).action((sessionId) => {
-    const projectRoot2 = getProjectRoot();
-    const count = clearTaint(projectRoot2, sessionId);
+    const projectRoot3 = getProjectRoot();
+    const count = clearTaint(projectRoot3, sessionId);
     if (count === 0) {
       if (sessionId) {
         logger.info(`No taint found for session "${sessionId}".`);
@@ -14151,8 +14367,8 @@ function registerClearCommand(taint) {
     }
   });
 }
-function printSingleSessionStatus(projectRoot2, sessionId) {
-  const result = checkTaint(projectRoot2, sessionId);
+function printSingleSessionStatus(projectRoot3, sessionId) {
+  const result = checkTaint(projectRoot3, sessionId);
   if (result.expired) {
     logger.info(`Session "${sessionId}": taint expired (cleared).`);
   } else if (result.tainted && result.state) {
@@ -14167,15 +14383,15 @@ function printSingleSessionStatus(projectRoot2, sessionId) {
     logger.info(`Session "${sessionId}": clean (no taint).`);
   }
 }
-function printAllSessionsStatus(projectRoot2) {
-  const sessions = listTaintedSessions(projectRoot2);
+function printAllSessionsStatus(projectRoot3) {
+  const sessions = listTaintedSessions(projectRoot3);
   if (sessions.length === 0) {
     logger.info("No active taint sessions.");
     return;
   }
   logger.info(`Active taint sessions (${sessions.length}):`);
   for (const id of sessions) {
-    const result = checkTaint(projectRoot2, id);
+    const result = checkTaint(projectRoot3, id);
     if (result.tainted && result.state) {
       const remaining = Math.max(
         0,
@@ -14187,11 +14403,11 @@ function printAllSessionsStatus(projectRoot2) {
 }
 function registerStatusCommand(taint) {
   taint.command("status [sessionId]").description("Show current taint status for a session or all sessions").action((sessionId) => {
-    const projectRoot2 = getProjectRoot();
+    const projectRoot3 = getProjectRoot();
     if (sessionId) {
-      printSingleSessionStatus(projectRoot2, sessionId);
+      printSingleSessionStatus(projectRoot3, sessionId);
     } else {
-      printAllSessionsStatus(projectRoot2);
+      printAllSessionsStatus(projectRoot3);
     }
   });
 }
@@ -14208,16 +14424,16 @@ import { Command as Command121 } from "commander";
 // src/commands/telemetry/identify.ts
 init_dist3();
 import { Command as Command118 } from "commander";
-import * as fs47 from "fs";
-import * as path76 from "path";
+import * as fs48 from "fs";
+import * as path77 from "path";
 function telemetryFilePath(cwd) {
-  return path76.join(cwd, ".harness", "telemetry.json");
+  return path77.join(cwd, ".harness", "telemetry.json");
 }
 function writeTelemetryFile(cwd, data) {
   const filePath = telemetryFilePath(cwd);
-  const dir = path76.dirname(filePath);
-  fs47.mkdirSync(dir, { recursive: true });
-  fs47.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  const dir = path77.dirname(filePath);
+  fs48.mkdirSync(dir, { recursive: true });
+  fs48.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 var IDENTITY_FIELDS = ["project", "team", "alias"];
 function applyIdentityFields(opts, identity) {
@@ -14334,17 +14550,17 @@ init_dist3();
 import { Command as Command120 } from "commander";
 
 // src/bin/command-telemetry.ts
-import { existsSync as existsSync43, readFileSync as readFileSync32, mkdirSync as mkdirSync22, appendFileSync, writeFileSync as writeFileSync28 } from "fs";
-import { join as join63, parse as parsePath, resolve as resolve45 } from "path";
+import { existsSync as existsSync44, readFileSync as readFileSync32, mkdirSync as mkdirSync23, appendFileSync, writeFileSync as writeFileSync29 } from "fs";
+import { join as join64, parse as parsePath, resolve as resolve47 } from "path";
 import { spawn as spawn2 } from "child_process";
 var POSTHOG_API_KEY = "phc_wNTdCMcfJXZPgdNeDociZW6vwoGGo4nb7vqEfWThFfsG";
 var EXCLUDED_COMMANDS = /* @__PURE__ */ new Set(["help", "completion"]);
 function findProjectRoot(cwd) {
-  let dir = resolve45(cwd);
+  let dir = resolve47(cwd);
   const { root } = parsePath(dir);
   while (dir !== root) {
-    if (existsSync43(join63(dir, "harness.config.json"))) return dir;
-    dir = resolve45(dir, "..");
+    if (existsSync44(join64(dir, "harness.config.json"))) return dir;
+    dir = resolve47(dir, "..");
   }
   return cwd;
 }
@@ -14353,8 +14569,8 @@ var startTime = 0;
 var recorded = false;
 function installCommandTelemetry(program, cwd) {
   if (typeof program.hook !== "function") return;
-  const projectRoot2 = findProjectRoot(cwd);
-  flushTelemetryBackground(projectRoot2);
+  const projectRoot3 = findProjectRoot(cwd);
+  flushTelemetryBackground(projectRoot3);
   program.hook("preAction", (_thisCommand, actionCommand) => {
     commandName = resolveCommandName(actionCommand);
     startTime = Date.now();
@@ -14364,7 +14580,7 @@ function installCommandTelemetry(program, cwd) {
     recorded = true;
     const duration = Date.now() - startTime;
     const outcome = code === 0 ? "completed" : "failed";
-    writeCommandRecordSync(projectRoot2, commandName, duration, outcome);
+    writeCommandRecordSync(projectRoot3, commandName, duration, outcome);
   });
 }
 function resolveCommandName(cmd) {
@@ -14381,8 +14597,8 @@ function resolveCommandName(cmd) {
 }
 function writeCommandRecordSync(cwd, command, duration, outcome) {
   try {
-    const metricsDir = join63(cwd, ".harness", "metrics");
-    mkdirSync22(metricsDir, { recursive: true });
+    const metricsDir = join64(cwd, ".harness", "metrics");
+    mkdirSync23(metricsDir, { recursive: true });
     const record = {
       skill: command,
       session: `cli-${Date.now()}`,
@@ -14391,14 +14607,14 @@ function writeCommandRecordSync(cwd, command, duration, outcome) {
       outcome,
       phasesReached: []
     };
-    const adoptionFile = join63(metricsDir, "adoption.jsonl");
+    const adoptionFile = join64(metricsDir, "adoption.jsonl");
     appendFileSync(adoptionFile, JSON.stringify(record) + "\n");
   } catch {
   }
 }
 function isTelemetryDisabledByConfig(cwd) {
-  const configPath = join63(cwd, "harness.config.json");
-  if (!existsSync43(configPath)) return false;
+  const configPath = join64(cwd, "harness.config.json");
+  if (!existsSync44(configPath)) return false;
   try {
     const config = JSON.parse(readFileSync32(configPath, "utf-8"));
     return config?.telemetry?.enabled === false;
@@ -14412,11 +14628,11 @@ function isTelemetryOptedOut(cwd) {
 }
 function flushTelemetryBackground(cwd) {
   try {
-    const adoptionFile = join63(cwd, ".harness", "metrics", "adoption.jsonl");
-    if (!existsSync43(adoptionFile)) return;
+    const adoptionFile = join64(cwd, ".harness", "metrics", "adoption.jsonl");
+    if (!existsSync44(adoptionFile)) return;
     if (isTelemetryOptedOut(cwd)) return;
-    const reporterPath = join63(cwd, ".harness", "hooks", "telemetry-reporter.js");
-    if (!existsSync43(reporterPath)) return;
+    const reporterPath = join64(cwd, ".harness", "hooks", "telemetry-reporter.js");
+    if (!existsSync44(reporterPath)) return;
     const child = spawn2(process.execPath, [reporterPath], {
       cwd,
       stdio: ["pipe", "ignore", "ignore"],
@@ -14548,10 +14764,10 @@ function printResult7(result, mode, _formatter) {
       list.push(f);
       byFile.set(f.target.file, list);
     }
-    for (const [file, fs50] of byFile) {
+    for (const [file, fs51] of byFile) {
       console.log(`
 ${file}`);
-      for (const f of fs50) {
+      for (const f of fs51) {
         const nestingStr = f.target.nesting.length > 0 ? f.target.nesting.join(" > ") + " > " : "";
         console.log(
           `  ${f.code} [${f.tier}/${f.impact}/${f.confidence}] ${f.target.framework}:${f.target.line}`
@@ -14723,15 +14939,15 @@ function createTraceabilityCommand() {
 }
 
 // src/commands/uninstall.ts
-import * as path77 from "path";
+import * as path78 from "path";
 import { Command as Command124 } from "commander";
 async function runUninstall(skillName, options) {
   const packageName = resolvePackageName(skillName);
   const shortName = extractSkillName(packageName);
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path77.dirname(globalDir);
-  const communityBase = path77.join(skillsDir, "community");
-  const lockfilePath = path77.join(communityBase, "skills-lock.json");
+  const skillsDir = path78.dirname(globalDir);
+  const communityBase = path78.join(skillsDir, "community");
+  const lockfilePath = path78.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const entry = lockfile.skills[packageName];
   if (!entry) {
@@ -14781,8 +14997,8 @@ function createUninstallCommand() {
 
 // src/commands/uninstall-constraints.ts
 init_dist3();
-import * as fs48 from "fs/promises";
-import * as path78 from "path";
+import * as fs49 from "fs/promises";
+import * as path79 from "path";
 import { Command as Command125 } from "commander";
 async function runUninstallConstraints(options) {
   const { packageName, configPath, lockfilePath } = options;
@@ -14803,7 +15019,7 @@ async function runUninstallConstraints(options) {
   }
   let localConfig;
   try {
-    const raw = await fs48.readFile(configPath, "utf-8");
+    const raw = await fs49.readFile(configPath, "utf-8");
     localConfig = JSON.parse(raw);
   } catch (err) {
     return {
@@ -14844,7 +15060,7 @@ function createUninstallConstraintsCommand() {
   cmd.description("Remove a previously installed constraints package").argument("<name>", "Name of the constraint package to uninstall").option("-c, --config <path>", "Path to harness.config.json").action(async (name, opts) => {
     let configPath;
     if (opts.config) {
-      configPath = path78.resolve(opts.config);
+      configPath = path79.resolve(opts.config);
     } else {
       const found = findConfigFile();
       if (!found.ok) {
@@ -14853,8 +15069,8 @@ function createUninstallConstraintsCommand() {
       }
       configPath = found.value;
     }
-    const projectRoot2 = path78.dirname(configPath);
-    const lockfilePath = path78.join(projectRoot2, ".harness", "constraints.lock.json");
+    const projectRoot3 = path79.dirname(configPath);
+    const lockfilePath = path79.join(projectRoot3, ".harness", "constraints.lock.json");
     const result = await runUninstallConstraints({
       packageName: name,
       configPath,
@@ -14882,8 +15098,8 @@ function createUninstallConstraintsCommand() {
 init_dist3();
 import { Command as Command126 } from "commander";
 import { execFile as execFile2, execFileSync as execFileSync10 } from "child_process";
-import { realpathSync, existsSync as existsSync44, readFileSync as readFileSync33 } from "fs";
-import { dirname as dirname24, join as join66 } from "path";
+import { realpathSync, existsSync as existsSync45, readFileSync as readFileSync33 } from "fs";
+import { dirname as dirname25, join as join67 } from "path";
 import { promisify as promisify2 } from "util";
 import readline4 from "readline";
 import chalk20 from "chalk";
@@ -14964,24 +15180,24 @@ function prompt3(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve48) => {
+  return new Promise((resolve50) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve48(answer.trim().toLowerCase());
+      resolve50(answer.trim().toLowerCase());
     });
   });
 }
 function findPackageDir(resolvedBin) {
-  let dir = dirname24(resolvedBin);
+  let dir = dirname25(resolvedBin);
   for (let i = 0; i < 6; i++) {
-    if (existsSync44(join66(dir, "package.json"))) {
+    if (existsSync45(join67(dir, "package.json"))) {
       try {
-        const pkg = JSON.parse(readFileSync33(join66(dir, "package.json"), "utf-8"));
+        const pkg = JSON.parse(readFileSync33(join67(dir, "package.json"), "utf-8"));
         if (pkg?.name === CLI_PACKAGE) return dir;
       } catch {
       }
     }
-    const parent = dirname24(dir);
+    const parent = dirname25(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -15021,7 +15237,7 @@ function findAllInstalls() {
     if (!packageDir) continue;
     let version = null;
     try {
-      const pkg = JSON.parse(readFileSync33(join66(packageDir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync33(join67(packageDir, "package.json"), "utf-8"));
       if (typeof pkg?.version === "string") version = pkg.version;
     } catch {
     }
@@ -15114,10 +15330,10 @@ async function ensureTelemetryIfNeeded() {
 }
 function refreshHooks() {
   const cwd = process.cwd();
-  const configPath = join66(cwd, "harness.config.json");
-  if (!existsSync44(configPath)) return;
+  const configPath = join67(cwd, "harness.config.json");
+  if (!existsSync45(configPath)) return;
   let profile = "standard";
-  const profilePath = join66(cwd, ".harness", "hooks", "profile.json");
+  const profilePath = join67(cwd, ".harness", "hooks", "profile.json");
   try {
     const data = JSON.parse(readFileSync33(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
@@ -15260,7 +15476,7 @@ function createUpdateCommand() {
 // src/commands/usage.ts
 import { Command as Command127 } from "commander";
 async function loadAndPriceRecords(cwd, includeClaudeSessions = false) {
-  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-MCTEX5QH.js");
+  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-BWFFVKEW.js");
   const records = readCostRecords(cwd);
   if (includeClaudeSessions) {
     const ccRecords = parseCCRecords();
@@ -15353,7 +15569,7 @@ function registerDailyCommand(usage) {
       else logger.info("No usage data found. Run some harness sessions first.");
       return;
     }
-    const { aggregateByDay } = await import("./dist-MCTEX5QH.js");
+    const { aggregateByDay } = await import("./dist-BWFFVKEW.js");
     const limited = aggregateByDay(records).slice(0, days);
     if (globalOpts.json) {
       console.log(
@@ -15382,7 +15598,7 @@ function registerSessionsCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-MCTEX5QH.js");
+    const { aggregateBySession } = await import("./dist-BWFFVKEW.js");
     const sessionData = aggregateBySession(records);
     const limited = sessionData.slice(0, limit);
     if (globalOpts.json) {
@@ -15462,7 +15678,7 @@ function registerSessionCommand(usage) {
       cwd,
       globalOpts.includeClaudeSessions
     );
-    const { aggregateBySession } = await import("./dist-MCTEX5QH.js");
+    const { aggregateBySession } = await import("./dist-BWFFVKEW.js");
     const sessionData = aggregateBySession(records);
     const match = sessionData.find((s) => s.sessionId === id);
     if (!match) {
@@ -15497,7 +15713,7 @@ function registerLatestCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-MCTEX5QH.js");
+    const { aggregateBySession } = await import("./dist-BWFFVKEW.js");
     const sessionData = aggregateBySession(records);
     const latest = sessionData[0];
     if (!latest) {
@@ -15539,8 +15755,8 @@ function createUsageCommand() {
 init_dist3();
 init_dist3();
 import { Command as Command128 } from "commander";
-import * as fs49 from "fs";
-import * as path79 from "path";
+import * as fs50 from "fs";
+import * as path80 from "path";
 import { execFileSync as execFileSync11 } from "child_process";
 async function runValidate(options) {
   const configResult = resolveConfig(options.configPath);
@@ -15548,7 +15764,7 @@ async function runValidate(options) {
     return configResult;
   }
   const config = configResult.value;
-  const cwd = options.cwd ?? (options.configPath ? path79.dirname(path79.resolve(options.configPath)) : process.cwd());
+  const cwd = options.cwd ?? (options.configPath ? path80.dirname(path80.resolve(options.configPath)) : process.cwd());
   const result = {
     valid: true,
     checks: {
@@ -15558,7 +15774,7 @@ async function runValidate(options) {
     },
     issues: []
   };
-  const agentsMapPath = path79.resolve(cwd, config.agentsMapPath);
+  const agentsMapPath = path80.resolve(cwd, config.agentsMapPath);
   const agentsResult = await validateAgentsMap(agentsMapPath);
   if (agentsResult.ok) {
     result.checks.agentsMap = true;
@@ -15655,9 +15871,9 @@ async function runValidate(options) {
       }
     });
   }
-  const gitattributesPath = path79.join(cwd, ".gitattributes");
-  if (fs49.existsSync(gitattributesPath)) {
-    const gitattributesContent = fs49.readFileSync(gitattributesPath, "utf-8");
+  const gitattributesPath = path80.join(cwd, ".gitattributes");
+  if (fs50.existsSync(gitattributesPath)) {
+    const gitattributesContent = fs50.readFileSync(gitattributesPath, "utf-8");
     let driverConfigured = false;
     try {
       const out = execFileSync11("git", ["config", "--get", "merge.ours.driver"], {
@@ -15681,10 +15897,10 @@ async function runValidate(options) {
     }
   }
   if (detectRoadmapStorageMode(cwd) === "sharded") {
-    const shardDir = path79.join(cwd, "docs", "roadmap.d");
+    const shardDir = path80.join(cwd, "docs", "roadmap.d");
     const regenerated = await regenerate(shardDir, createNodeRoadmapIO());
-    const aggregatePath = path79.join(cwd, "docs", "roadmap.md");
-    const committedAggregate = fs49.existsSync(aggregatePath) ? fs49.readFileSync(aggregatePath, "utf-8") : null;
+    const aggregatePath = path80.join(cwd, "docs", "roadmap.md");
+    const committedAggregate = fs50.existsSync(aggregatePath) ? fs50.readFileSync(aggregatePath, "utf-8") : null;
     const drift = checkRoadmapAggregateDrift({
       shardDirExists: true,
       committedAggregate,
@@ -15702,9 +15918,9 @@ async function runValidate(options) {
       result.checks.roadmapAggregateDrift = true;
     }
   }
-  const roadmapPath = path79.join(cwd, "docs", "roadmap.md");
-  if (fs49.existsSync(roadmapPath)) {
-    const parsed = parseRoadmap(fs49.readFileSync(roadmapPath, "utf-8"));
+  const roadmapPath = path80.join(cwd, "docs", "roadmap.md");
+  if (fs50.existsSync(roadmapPath)) {
+    const parsed = parseRoadmap(fs50.readFileSync(roadmapPath, "utf-8"));
     if (parsed.ok) {
       const findings = checkRoadmapHealth(parsed.value);
       result.checks.roadmapHealth = !findings.some((f) => f.severity === "error");
@@ -15846,11 +16062,11 @@ function resolveValidateMode(globalOpts) {
   return OutputMode.TEXT;
 }
 async function printCrossCheckWarnings(mode) {
-  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-OYKEDCST.js");
+  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-H2OUHTID.js");
   const cwd = process.cwd();
   const crossResult = await runCrossCheck2({
-    specsDir: path79.join(cwd, "docs", "specs"),
-    plansDir: path79.join(cwd, "docs", "plans"),
+    specsDir: path80.join(cwd, "docs", "specs"),
+    plansDir: path80.join(cwd, "docs", "plans"),
     projectPath: cwd
   });
   if (!crossResult.ok || crossResult.value.warnings === 0) return;