@harness-engineering/cli 2.7.0 → 2.8.0

package/dist/{chunk-HLPY3RHE.js → chunk-4BDOSCNY.js}

@@ -1,26 +1,26 @@
 import {
   generateRuntime
-} from "./chunk-S7GEONXL.js";
+} from "./chunk-5XL5QJ5B.js";
 import {
   generateAgentsMd
-} from "./chunk-OQE6ME2Z.js";
+} from "./chunk-7EQAZKJ5.js";
 import {
   generateCIWorkflow
-} from "./chunk-B3B64OPD.js";
+} from "./chunk-STESM73J.js";
 import {
   createGenerateAgentDefinitionsCommand,
   generateAgentDefinitions
-} from "./chunk-ZKA3TGYS.js";
+} from "./chunk-EEFRPEWT.js";
 import {
   toKebabCase
 } from "./chunk-KET4QQZB.js";
 import {
   createScanCommand,
   loadIngestOptions
-} from "./chunk-6UHDQP2N.js";
+} from "./chunk-2N4OENGE.js";
 import {
   TemplateEngine
-} from "./chunk-WOXR6I3R.js";
+} from "./chunk-UBZQE3JN.js";
 import {
   generate,
   validate
@@ -31,7 +31,7 @@ import {
 import {
   listPersonas,
   loadPersona
-} from "./chunk-XTIPZUPR.js";
+} from "./chunk-X4EFYVCZ.js";
 import {
   runPersona
 } from "./chunk-GISMXMVL.js";
@@ -46,19 +46,21 @@ import {
   OutputMode,
   createCheckPhaseGateCommand,
   findFiles
-} from "./chunk-OLTVDPA2.js";
+} from "./chunk-2SNRCAC3.js";
 import {
   appendFrameworkAgents,
   captureHealthSnapshot,
   createAdviseSkillsCommand,
   createGenerateSlashCommandsCommand,
   ensureHarnessGitignore,
+  findOrchestratorMd,
   generateSlashCommands,
   handleGetImpact,
   handleOrphanDeletion,
   isSnapshotFresh,
   loadCachedSnapshot,
   persistToolingConfig,
+  readBackendsFromOrchestratorMd,
   recommend,
   runAlignDesignSystem,
   runAudit,
@@ -72,13 +74,13 @@ import {
   runSecurityCraft,
   runSpecCraft,
   runTestCraft
-} from "./chunk-4EGPFB7V.js";
+} from "./chunk-CAQPSFPT.js";
 import {
   VALID_PLATFORMS
 } from "./chunk-3ISINLYT.js";
 import {
   loadGraphStore
-} from "./chunk-TIH53QXY.js";
+} from "./chunk-CLI4K2CH.js";
 import {
   loadOrRebuildIndex
 } from "./chunk-27AJKSQY.js";
@@ -97,7 +99,7 @@ import {
   BranchingConfigSchema,
   findConfigFile,
   resolveConfig
-} from "./chunk-B4OLYXZ4.js";
+} from "./chunk-B7KMTHN3.js";
 import {
   logger
 } from "./chunk-EBJQ6N4M.js";
@@ -189,9 +191,10 @@ import {
   validatePulseConfig,
   validateRoadmapMode,
   validateSolutionsDir,
+  validateStrategy,
   writeConfig,
   writeLockfile
-} from "./chunk-IY2TZLY5.js";
+} from "./chunk-GOHWCHCS.js";
 import {
   CLI_VERSION
 } from "./chunk-BM3PWGXQ.js";
@@ -204,20 +207,20 @@ import {
   detectDocDrift,
   generateSuggestions,
   validateDependencies
-} from "./chunk-W3PDVZ4I.js";
+} from "./chunk-N55WOGN3.js";
 import {
   Err,
   INDEXED_FILE_KINDS,
   INSIGHTS_KEYS,
   Ok,
   init_dist
-} from "./chunk-OH3NXXUY.js";
+} from "./chunk-BDGTZRZ6.js";
 import {
   DEFAULT_SKIP_DIRS,
   DesignConstraintAdapter,
   GraphStore,
   init_dist as init_dist2
-} from "./chunk-H2ZJOJ7A.js";
+} from "./chunk-PP6ZRL5T.js";
 import {
   ArchConfigSchema,
   TimelineManager
@@ -228,7 +231,7 @@ import {
 } from "./chunk-KFQGP6VL.js";
 
 // src/index.ts
-import { Command as Command118 } from "commander";
+import { Command as Command120 } from "commander";
 
 // src/commands/add.ts
 init_dist3();
@@ -417,7 +420,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-XIJWWQ5N.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-JCFK263L.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -453,7 +456,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-XIJWWQ5N.js");
+    const { readAdoptionRecords } = await import("./dist-JCFK263L.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -531,7 +534,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-XIJWWQ5N.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-JCFK263L.js");
     const records = readAdoptionRecords(cwd);
     const skillRecords = records.filter((r) => r.skill === name);
     if (skillRecords.length === 0) {
@@ -846,6 +849,9 @@ function createAlignDesignSystemCommand() {
   ).option(
     "--design-strictness <level>",
     "Override design.strictness: strict | standard | permissive"
+  ).option(
+    "--revert",
+    "Inverse-apply the most-recent batch recorded at .harness/align/last-batch.json. Skips files edited externally since the apply."
   ).action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const outputMode = resolveOutputMode(globalOpts);
@@ -856,6 +862,7 @@ function createAlignDesignSystemCommand() {
     if (opts.files !== void 0) input.files = opts.files;
     if (opts.mode !== void 0) input.mode = opts.mode;
     if (opts.designStrictness !== void 0) input.designStrictness = opts.designStrictness;
+    if (opts.revert === true) input.revert = true;
     let result;
     try {
       result = await runAlignDesignSystem(input);
@@ -882,7 +889,11 @@ function printAlignResult(result, mode, _formatter) {
   const verbose = mode === OutputMode.VERBOSE;
   const { summary, outcomes, meta } = result;
   if (outcomes.length === 0) {
-    console.log("No drift findings to align.");
+    if (meta.revert === true) {
+      console.log("No batch to revert (.harness/align/last-batch.json missing or empty).");
+    } else {
+      console.log("No drift findings to align.");
+    }
     return;
   }
   const byFile = /* @__PURE__ */ new Map();
@@ -912,8 +923,9 @@ ${file}`);
     }
   }
   console.log("");
+  const action = meta.revert === true ? "reverted" : "applied";
   console.log(
-    `Summary: ${summary.applied} applied, ${summary.suggestions} suggestions, ${summary.skipped} skipped, ${summary.failed} failed (${summary.filesModified} files modified, ${summary.durationMs}ms)`
+    `Summary: ${summary.applied} ${action}, ${summary.suggestions} suggestions, ${summary.skipped} skipped, ${summary.failed} failed (${summary.filesModified} files modified, ${summary.durationMs}ms)`
   );
   if (meta.dryRun) {
     console.log("(dry-run \u2014 no files written)");
@@ -1124,7 +1136,7 @@ function runBackfillSkillProvenance(projectRoot2) {
 }
 function createBackfillSkillProvenanceCommand() {
   const cmd = new Command8("backfill-skill-provenance").description(
-    "Stamp `provenance: user-authored` on every catalog skill missing the field (Hermes Phase 4 one-shot)"
+    "Stamp `provenance: user-authored` on every catalog skill missing the field (one-shot migration)"
   ).option("--root <path>", "Project root containing agents/skills/", process.cwd()).action((opts) => {
     const result = runBackfillSkillProvenance(opts.root);
     console.log(JSON.stringify(result, null, 2));
@@ -1652,9 +1664,9 @@ ${name} (${count} finding${count === 1 ? "" : "s"})`);
 }
 function printAnatomyFindings(findings, verbose) {
   const byFile = groupByFile(findings, (f) => f.file);
-  for (const [file, fs47] of byFile) {
+  for (const [file, fs48] of byFile) {
     console.log(`  ${file}`);
-    for (const f of fs47) {
+    for (const f of fs48) {
       const line = f.line !== null && f.line !== void 0 ? `:${f.line}` : "";
       console.log(`    ${f.code} [${f.severity}]    line${line}: ${f.message}`);
       if (verbose) {
@@ -1665,9 +1677,9 @@ function printAnatomyFindings(findings, verbose) {
 }
 function printCraftFindings(findings, verbose) {
   const byFile = groupByFile(findings, (f) => f.target.file);
-  for (const [file, fs47] of byFile) {
+  for (const [file, fs48] of byFile) {
     console.log(`  ${file}`);
-    for (const f of fs47) {
+    for (const f of fs48) {
       const line = f.target.line !== void 0 ? `:${f.target.line}` : "";
       const sev = craftTierToSeverity(f.tier);
       console.log(
@@ -1681,9 +1693,9 @@ function printCraftFindings(findings, verbose) {
 }
 function printDriftFindings(findings, verbose) {
   const byFile = groupByFile(findings, (f) => f.file);
-  for (const [file, fs47] of byFile) {
+  for (const [file, fs48] of byFile) {
     console.log(`  ${file}`);
-    for (const f of fs47) {
+    for (const f of fs48) {
       const line = f.line !== null && f.line !== void 0 ? `:${f.line}` : "";
       console.log(`    ${f.code} [${f.severity}]    line${line}: ${f.message}`);
       if (verbose) {
@@ -1694,9 +1706,9 @@ function printDriftFindings(findings, verbose) {
 }
 function printBrandFindings(findings, verbose) {
   const byFile = groupByFile(findings, (f) => f.file);
-  for (const [file, fs47] of byFile) {
+  for (const [file, fs48] of byFile) {
     console.log(`  ${file}`);
-    for (const f of fs47) {
+    for (const f of fs48) {
       const line = f.line !== null && f.line !== void 0 ? `:${f.line}` : "";
       console.log(`    ${f.code} [${f.severity}]    line${line}: ${f.message}`);
       if (verbose) {
@@ -2015,10 +2027,10 @@ async function runCheckSecurity(cwd, options) {
   const projectRoot2 = path9.resolve(cwd);
   let configData = {};
   try {
-    const fs47 = await import("fs");
+    const fs48 = await import("fs");
     const configPath = path9.join(projectRoot2, "harness.config.json");
-    if (fs47.existsSync(configPath)) {
-      const raw = fs47.readFileSync(configPath, "utf-8");
+    if (fs48.existsSync(configPath)) {
+      const raw = fs48.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       configData = parsed.security ?? {};
     }
@@ -2786,10 +2798,10 @@ ${dryRun ? "Would remove" : "Removed"} ${totalRemoved} stale entry(ies) across t
 function createCleanupSessionsCommand() {
   const command = new Command21("cleanup-sessions").description(
     "Remove stale entries from .harness/. Default: only .harness/sessions/ (no write in 24h)."
-  ).option("--dry-run", "List stale entries without deleting them", false).option("--path <path>", "Project root path", ".").option("--all", "Hermes Phase 2: sweep every registered .harness/ target").option(
+  ).option("--dry-run", "List stale entries without deleting them", false).option("--path <path>", "Project root path", ".").option("--all", "Sweep every registered .harness/ target").option(
     "--include <list>",
-    "Hermes Phase 2: comma-separated target names (mutually-exclusive with --exclude/--all)"
-  ).option("--exclude <list>", "Hermes Phase 2: comma-separated target names to skip").action(async (opts, cmd) => {
+    "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 = path12.resolve(opts.path);
     const asJson = Boolean(globalOpts.json);
@@ -2979,10 +2991,10 @@ function printResult2(result, mode, _formatter) {
       list.push(f);
       bySurface.set(f.target.surface, list);
     }
-    for (const [surface, fs47] of bySurface) {
+    for (const [surface, fs48] of bySurface) {
       console.log(`
 [${surface}]`);
-      for (const f of fs47) {
+      for (const f of fs48) {
         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)}"`);
@@ -4210,11 +4222,11 @@ import { Command as Command35 } from "commander";
 // src/commands/graph/status.ts
 import * as path16 from "path";
 async function readConnectorSyncStatus(graphDir) {
-  const fs47 = await import("fs/promises");
+  const fs48 = await import("fs/promises");
   const result = {};
   try {
     const syncMetaPath = path16.join(graphDir, "sync-metadata.json");
-    const syncMeta = JSON.parse(await fs47.readFile(syncMetaPath, "utf-8"));
+    const syncMeta = JSON.parse(await fs48.readFile(syncMetaPath, "utf-8"));
     for (const [name, data] of Object.entries(syncMeta.connectors ?? {})) {
       result[name] = data.lastSyncTimestamp;
     }
@@ -4223,7 +4235,7 @@ async function readConnectorSyncStatus(graphDir) {
   return result;
 }
 async function runGraphStatus(projectPath) {
-  const { GraphStore: GraphStore2, loadGraphMetadata } = await import("./dist-R3TOOPJ7.js");
+  const { GraphStore: GraphStore2, loadGraphMetadata } = await import("./dist-OWHMNL4W.js");
   const graphDir = path16.join(projectPath, ".harness", "graph");
   const metaResult = await loadGraphMetadata(graphDir);
   if (metaResult.status === "not_found") {
@@ -4275,7 +4287,7 @@ async function runGraphStatus(projectPath) {
 // src/commands/graph/export.ts
 import * as path17 from "path";
 async function runGraphExport(projectPath, format) {
-  const { GraphStore: GraphStore2 } = await import("./dist-R3TOOPJ7.js");
+  const { GraphStore: GraphStore2 } = await import("./dist-OWHMNL4W.js");
   const graphDir = path17.join(projectPath, ".harness", "graph");
   const store = new GraphStore2();
   const loaded = await store.load(graphDir);
@@ -4311,7 +4323,7 @@ import * as path20 from "path";
 import { Command as Command33 } from "commander";
 import * as path18 from "path";
 async function runQuery(projectPath, rootNodeId, opts) {
-  const { GraphStore: GraphStore2, ContextQL } = await import("./dist-R3TOOPJ7.js");
+  const { GraphStore: GraphStore2, ContextQL } = await import("./dist-OWHMNL4W.js");
   const store = new GraphStore2();
   const graphDir = path18.join(projectPath, ".harness", "graph");
   const loaded = await store.load(graphDir);
@@ -4364,15 +4376,22 @@ import { Command as Command34 } from "commander";
 import * as path19 from "path";
 async function loadConnectorConfig(projectPath, source) {
   try {
-    const fs47 = await import("fs/promises");
+    const fs48 = await import("fs/promises");
     const configPath = path19.join(projectPath, "harness.config.json");
-    const config = JSON.parse(await fs47.readFile(configPath, "utf-8"));
+    const config = JSON.parse(await fs48.readFile(configPath, "utf-8"));
     const connector = config.graph?.connectors?.[source];
     return connector ?? {};
   } catch {
     return {};
   }
 }
+async function ingestBusinessKnowledge(bk, projectPath) {
+  return mergeResults(
+    await bk.ingest(path19.join(projectPath, "docs", "knowledge")),
+    await bk.ingestSolutions(path19.join(projectPath, "docs", "solutions")),
+    await bk.ingestStrategy(path19.join(projectPath, "STRATEGY.md"))
+  );
+}
 function mergeResults(...results) {
   return results.reduce(
     (acc, r) => ({
@@ -4399,6 +4418,7 @@ async function runIngest(projectPath, source, opts) {
     CodeIngestor,
     TopologicalLinker,
     KnowledgeIngestor,
+    BusinessKnowledgeIngestor,
     GitIngestor,
     RequirementIngestor,
     SyncManager,
@@ -4408,7 +4428,7 @@ async function runIngest(projectPath, source, opts) {
     ConfluenceConnector,
     FigmaConnector,
     MiroConnector
-  } = await import("./dist-R3TOOPJ7.js");
+  } = await import("./dist-OWHMNL4W.js");
   const graphDir = path19.join(projectPath, ".harness", "graph");
   const store = new GraphStore2();
   await store.load(graphDir);
@@ -4418,11 +4438,13 @@ async function runIngest(projectPath, source, opts) {
     const codeResult = await new CodeIngestor(store, ingestOptions).ingest(projectPath);
     new TopologicalLinker(store).link();
     const knowledgeResult = await new KnowledgeIngestor(store).ingestAll(projectPath);
+    const bkInst = new BusinessKnowledgeIngestor(store);
+    const bkResult = await ingestBusinessKnowledge(bkInst, projectPath);
     const reqResult = await new RequirementIngestor(store).ingestSpecs(
       path19.join(projectPath, "docs", "changes")
     );
     const gitResult = await new GitIngestor(store).ingest(projectPath);
-    const { createExtractionRunner } = await import("./dist-R3TOOPJ7.js");
+    const { createExtractionRunner } = await import("./dist-OWHMNL4W.js");
     const extractedDir = path19.join(projectPath, ".harness", "knowledge", "extracted");
     const signalsResult = await createExtractionRunner().run(projectPath, store, extractedDir);
     const syncManager = new SyncManager(store, graphDir);
@@ -4443,6 +4465,7 @@ async function runIngest(projectPath, source, opts) {
     const merged = mergeResults(
       codeResult,
       knowledgeResult,
+      bkResult,
       reqResult,
       gitResult,
       signalsResult,
@@ -4456,9 +4479,12 @@ async function runIngest(projectPath, source, opts) {
       result = await new CodeIngestor(store, ingestOptions).ingest(projectPath);
       new TopologicalLinker(store).link();
       break;
-    case "knowledge":
-      result = await new KnowledgeIngestor(store).ingestAll(projectPath);
+    case "knowledge": {
+      const knowledge = await new KnowledgeIngestor(store).ingestAll(projectPath);
+      const bk = await ingestBusinessKnowledge(new BusinessKnowledgeIngestor(store), projectPath);
+      result = mergeResults(knowledge, bk);
       break;
+    }
     case "git":
       result = await new GitIngestor(store).ingest(projectPath);
       break;
@@ -4468,7 +4494,7 @@ async function runIngest(projectPath, source, opts) {
       );
       break;
     case "business-signals": {
-      const { createExtractionRunner } = await import("./dist-R3TOOPJ7.js");
+      const { createExtractionRunner } = await import("./dist-OWHMNL4W.js");
       const extractedDir = path19.join(projectPath, ".harness", "knowledge", "extracted");
       result = await createExtractionRunner().run(projectPath, store, extractedDir);
       break;
@@ -4504,35 +4530,41 @@ async function runIngest(projectPath, source, opts) {
   await store.save(graphDir);
   return result;
 }
+function printIngestSummary(result, label) {
+  console.log(
+    `Ingested (${label}): +${result.nodesAdded} nodes, +${result.edgesAdded} edges (${result.durationMs}ms)`
+  );
+  if (result.errors.length === 0) return;
+  console.warn(`  ${result.errors.length} parse/skip warning(s):`);
+  for (const err of result.errors) console.warn(`    - ${err}`);
+}
+async function handleIngestAction(opts, cmd) {
+  if (!opts.source && !opts.all) {
+    console.error("Error: --source or --all is required");
+    process.exit(1);
+  }
+  const globalOpts = cmd.optsWithGlobals();
+  const projectPath = path19.resolve(globalOpts.config ? path19.dirname(globalOpts.config) : ".");
+  try {
+    const runOpts = {};
+    if (opts.full !== void 0) runOpts.full = opts.full;
+    if (opts.all !== void 0) runOpts.all = opts.all;
+    const result = await runIngest(projectPath, opts.source ?? "", runOpts);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(result));
+    } else {
+      printIngestSummary(result, opts.all ? "all" : opts.source ?? "");
+    }
+  } catch (err) {
+    console.error("Ingest failed:", err instanceof Error ? err.message : err);
+    process.exit(2);
+  }
+}
 function createIngestCommand() {
   return new Command34("ingest").description("Ingest data into the knowledge graph").option(
     "--source <name>",
     "Source to ingest (code, knowledge, git, requirements, business-signals, jira, slack, ci, confluence, figma, miro)"
-  ).option("--all", "Run all sources (code, knowledge, git, and configured connectors)").option("--full", "Force full re-ingestion").action(async (opts, cmd) => {
-    if (!opts.source && !opts.all) {
-      console.error("Error: --source or --all is required");
-      process.exit(1);
-    }
-    const globalOpts = cmd.optsWithGlobals();
-    const projectPath = path19.resolve(globalOpts.config ? path19.dirname(globalOpts.config) : ".");
-    try {
-      const result = await runIngest(projectPath, opts.source ?? "", {
-        full: opts.full,
-        all: opts.all
-      });
-      if (globalOpts.json) {
-        console.log(JSON.stringify(result));
-      } else {
-        const label = opts.all ? "all" : opts.source;
-        console.log(
-          `Ingested (${label}): +${result.nodesAdded} nodes, +${result.edgesAdded} edges (${result.durationMs}ms)`
-        );
-      }
-    } catch (err) {
-      console.error("Ingest failed:", err instanceof Error ? err.message : err);
-      process.exit(2);
-    }
-  });
+  ).option("--all", "Run all sources (code, knowledge, git, and configured connectors)").option("--full", "Force full re-ingestion").action(handleIngestAction);
 }
 
 // src/commands/graph/index.ts
@@ -5356,6 +5388,7 @@ var ALL_MCP_TOOLS = [
   "run_design_pipeline",
   // craft-pipeline #1 — naming-craft LLM-judgment ceiling skill
   "naming_craft",
+  "naming_craft_finalize",
   // craft-pipeline #6 — spec-craft LLM-judgment ceiling skill
   "spec_craft",
   // craft-pipeline #5 — copy-craft LLM-judgment ceiling skill (6 surfaces)
@@ -5365,7 +5398,19 @@ var ALL_MCP_TOOLS = [
   // craft-pipeline #9 — knowledge-craft LLM-judgment ceiling skill (docs/knowledge/ entries)
   "knowledge_craft",
   // craft-pipeline #10 — security-craft LLM-judgment ceiling skill (AST-driven, conservative-confidence)
-  "security_craft"
+  "security_craft",
+  // strategic-anchor — STRATEGY.md read/validate/write so projects can call
+  // these via MCP without needing @harness-engineering/core in node_modules
+  "validate_strategy",
+  "read_strategy",
+  "write_strategy",
+  // strategic-anchor — pulse config writer + STRATEGY.md seed extractor
+  "write_pulse_config",
+  "seed_pulse_from_strategy",
+  // strategic-anchor — compound lock acquire/release (server holds the handle;
+  // skill threads a token between calls)
+  "acquire_compound_lock",
+  "release_compound_lock"
 ];
 async function runCursorToolPicker() {
   try {
@@ -5738,12 +5783,10 @@ function renderPretty(report) {
   }
 }
 function createInsightsCommand() {
-  return new Command44("insights").description(
-    "Composite project report \u2014 health, entropy, decay, attention, impact (Hermes Phase 1)."
-  ).option("--json", "Emit JSON to stdout instead of pretty text").option("--skip <list>", `Comma-separated keys to skip (${INSIGHTS_KEYS.join(",")})`).action(async (opts) => {
+  return new Command44("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-XIJWWQ5N.js");
+    const { composeInsights } = await import("./dist-JCFK263L.js");
     const report = await composeInsights(cwd, { skip });
     if (opts.json) {
       console.log(JSON.stringify(report, null, 2));
@@ -6915,10 +6958,10 @@ function printResult3(result, mode, _formatter) {
       list.push(f);
       byFile.set(f.target.file, list);
     }
-    for (const [file, fs47] of byFile) {
+    for (const [file, fs48] of byFile) {
       console.log(`
 ${file}`);
-      for (const f of fs47) {
+      for (const f of fs48) {
         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}`);
@@ -6941,9 +6984,9 @@ function createKnowledgePipelineCommand() {
     const projectDir = process.cwd();
     try {
       const graphDir = path39.join(projectDir, ".harness", "graph");
-      const fs47 = await import("fs/promises");
-      await fs47.mkdir(graphDir, { recursive: true });
-      const { GraphStore: GraphStore2, KnowledgePipelineRunner } = await import("./dist-R3TOOPJ7.js");
+      const fs48 = await import("fs/promises");
+      await fs48.mkdir(graphDir, { recursive: true });
+      const { GraphStore: GraphStore2, KnowledgePipelineRunner } = await import("./dist-OWHMNL4W.js");
       const store = new GraphStore2();
       try {
         await store.load(graphDir);
@@ -6999,6 +7042,7 @@ function createKnowledgePipelineCommand() {
               iterations: result.iterations,
               findings: result.findings,
               extraction: result.extraction,
+              errors: result.errors,
               gaps: {
                 domains: result.gaps.domains.length,
                 totalEntries: result.gaps.totalEntries,
@@ -7039,7 +7083,7 @@ function createKnowledgePipelineCommand() {
           `  Findings: ${result.findings.new} new, ${result.findings.stale} stale, ${result.findings.drifted} drifted, ${result.findings.contradicting} contradicting`
         );
         console.log(
-          `  Extraction: ${result.extraction.codeSignals} code signals, ${result.extraction.diagrams} diagrams, ${result.extraction.linkerFacts} linker facts, ${result.extraction.businessKnowledge} business knowledge, ${result.extraction.images} images`
+          `  Extraction: ${result.extraction.codeSignals} code signals, ${result.extraction.diagrams} diagrams, ${result.extraction.linkerFacts} linker facts, ${result.extraction.businessKnowledge} business knowledge, ${result.extraction.decisions} decisions, ${result.extraction.images} images`
         );
         console.log(
           `  Gaps: ${result.gaps.domains.length} domains \u2014 ${result.gaps.totalEntries} documented / ${result.gaps.totalExtracted} extracted / ${result.gaps.totalGaps} undocumented`
@@ -7050,6 +7094,13 @@ function createKnowledgePipelineCommand() {
         if (result.remediations.length > 0) {
           console.log(`  Remediations: ${result.remediations.length} applied`);
         }
+        if (result.errors.length > 0) {
+          console.warn("");
+          console.warn(`  ${result.errors.length} ingestion warning(s):`);
+          for (const err of result.errors) {
+            console.warn(`    - ${err}`);
+          }
+        }
         if (result.materialization) {
           const mat = result.materialization;
           console.log(
@@ -7351,7 +7402,7 @@ function printListTable(rows) {
 }
 function createMaintenanceCommand() {
   const command = new Command59("maintenance").description(
-    "Hermes Phase 2 \u2014 inspect built-in + custom maintenance tasks and their persisted outputs"
+    "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 = path41.resolve(opts.path);
@@ -7445,7 +7496,7 @@ function createMcpCommand() {
     parseBudget
   ).action(async (opts) => {
     const [{ startServer: startServer2, getToolDefinitions: getToolDefinitions2 }, { selectTier }] = await Promise.all([
-      import("./mcp-NEAPIDTT.js"),
+      import("./mcp-JBIBINO2.js"),
       import("./tool-tiers-B7JC2XC3.js")
     ]);
     if (opts.tools && opts.tools.length > 0) {
@@ -7606,14 +7657,150 @@ function createMcpGuardCommand() {
 }
 
 // src/commands/migrate.ts
-init_dist3();
-init_dist2();
+import { Command as Command63 } from "commander";
+
+// src/commands/migrate-backends.ts
 import { Command as Command62 } from "commander";
 import * as fs27 from "fs";
 import * as path43 from "path";
+import chalk9 from "chalk";
+import { parse as parseYaml2 } from "yaml";
+async function runMigrateBackends(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const mdPath = findOrchestratorMd(cwd);
+  if (mdPath === null) {
+    return {
+      status: "noop",
+      message: "No harness.orchestrator.md found \u2014 nothing to migrate.",
+      exitCode: ExitCode.SUCCESS
+    };
+  }
+  const backends = readBackendsFromOrchestratorMd(cwd);
+  if (backends === null) {
+    return {
+      status: "noop",
+      message: `Found ${mdPath} but no agent.backends to migrate.`,
+      exitCode: ExitCode.SUCCESS
+    };
+  }
+  const routing = readRoutingFromOrchestratorMd(mdPath);
+  const jsonPath = path43.join(path43.dirname(mdPath), "harness.config.json");
+  if (!fs27.existsSync(jsonPath)) {
+    return {
+      status: "error",
+      message: `harness.config.json not found at ${jsonPath}. Run \`harness init\` first, then re-run this migration.`,
+      exitCode: ExitCode.ERROR
+    };
+  }
+  let configRaw;
+  try {
+    configRaw = fs27.readFileSync(jsonPath, "utf-8");
+  } catch (err) {
+    return {
+      status: "error",
+      message: `Failed to read ${jsonPath}: ${err instanceof Error ? err.message : String(err)}`,
+      exitCode: ExitCode.ERROR
+    };
+  }
+  let configObj;
+  try {
+    configObj = JSON.parse(configRaw);
+  } catch (err) {
+    return {
+      status: "error",
+      message: `${jsonPath} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`,
+      exitCode: ExitCode.ERROR
+    };
+  }
+  const agent = configObj.agent ?? {};
+  const existingBackends = agent.backends;
+  if (existingBackends !== void 0 && !opts.force) {
+    return {
+      status: "error",
+      message: `${jsonPath} already declares agent.backends. Re-run with --force to overwrite, or merge manually.`,
+      exitCode: ExitCode.ERROR
+    };
+  }
+  const nextAgent = { ...agent, backends };
+  if (routing !== null) nextAgent.routing = routing;
+  const nextConfig = { ...configObj, agent: nextAgent };
+  const nextJson = JSON.stringify(nextConfig, null, 2) + "\n";
+  if (opts.dryRun) {
+    logger.info(chalk9.bold("--- dry run ---"));
+    logger.info(`Would write ${Object.keys(backends).length} backend(s) to ${jsonPath}:`);
+    for (const name of Object.keys(backends)) {
+      logger.info(`  \u2022 ${name}`);
+    }
+    if (routing !== null) {
+      logger.info("Would also copy agent.routing.");
+    }
+    return {
+      status: "ok",
+      message: "(dry-run) migration plan above \u2014 re-run without --dry-run to apply.",
+      exitCode: ExitCode.SUCCESS
+    };
+  }
+  try {
+    fs27.writeFileSync(jsonPath, nextJson);
+  } catch (err) {
+    return {
+      status: "error",
+      message: `Failed to write ${jsonPath}: ${err instanceof Error ? err.message : String(err)}`,
+      exitCode: ExitCode.ERROR
+    };
+  }
+  return {
+    status: "ok",
+    message: `Migrated ${Object.keys(backends).length} backend(s)${routing !== null ? " + routing" : ""} from ${mdPath} to ${jsonPath}. You can leave the entries in harness.orchestrator.md (orchestrator still reads them) or remove them once the orchestrator config picks up the JSON source.`,
+    exitCode: ExitCode.SUCCESS
+  };
+}
+function readRoutingFromOrchestratorMd(mdPath) {
+  let raw;
+  try {
+    raw = fs27.readFileSync(mdPath, "utf-8");
+  } catch {
+    return null;
+  }
+  const parts = raw.split("---");
+  if (parts.length < 3) return null;
+  let parsed;
+  try {
+    parsed = parseYaml2(parts[1].trim());
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object") return null;
+  const agent = parsed.agent;
+  if (agent === null || typeof agent !== "object") return null;
+  const routing = agent.routing;
+  return routing ?? null;
+}
+function createBackendsSubcommand() {
+  return new Command62("backends").description(
+    "Copy agent.backends (and routing) from harness.orchestrator.md into harness.config.json."
+  ).option("--dry-run", "Show what would change without writing", false).option("--force", "Overwrite existing agent.backends in harness.config.json", false).action(async (options) => {
+    const result = await runMigrateBackends({
+      dryRun: options.dryRun ?? false,
+      force: options.force ?? false
+    });
+    if (result.status === "error") {
+      logger.error(result.message);
+      process.exit(result.exitCode);
+    }
+    logger.info(result.message);
+    process.exit(result.exitCode);
+  });
+}
+
+// src/commands/migrate.ts
+init_dist3();
+init_dist2();
+import * as fs28 from "fs";
+import * as path44 from "path";
 import * as readline from "readline";
 import { execFileSync as execFileSync4 } from "child_process";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 function isGitRepo(cwd) {
   try {
     execFileSync4("git", ["rev-parse", "--is-inside-work-tree"], { cwd, stdio: "pipe" });
@@ -7624,25 +7811,25 @@ function isGitRepo(cwd) {
 }
 function readJson2(p) {
   try {
-    return JSON.parse(fs27.readFileSync(p, "utf8"));
+    return JSON.parse(fs28.readFileSync(p, "utf8"));
   } catch {
     return null;
   }
 }
 function listDirs(p) {
-  if (!fs27.existsSync(p)) return [];
-  return fs27.readdirSync(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  if (!fs28.existsSync(p)) return [];
+  return fs28.readdirSync(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
 }
 function listFiles(p, predicate) {
-  if (!fs27.existsSync(p)) return [];
-  return fs27.readdirSync(p, { withFileTypes: true }).filter((e) => e.isFile() && predicate(e.name)).map((e) => e.name);
+  if (!fs28.existsSync(p)) return [];
+  return fs28.readdirSync(p, { withFileTypes: true }).filter((e) => e.isFile() && predicate(e.name)).map((e) => e.name);
 }
 function walk(dir, predicate) {
-  if (!fs27.existsSync(dir)) return [];
+  if (!fs28.existsSync(dir)) return [];
   const out = [];
-  for (const entry of fs27.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs28.readdirSync(dir, { withFileTypes: true })) {
     if (DEFAULT_SKIP_DIRS.has(entry.name)) continue;
-    const full = path43.join(dir, entry.name);
+    const full = path44.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...walk(full, predicate));
     else if (predicate(full)) out.push(full);
   }
@@ -7654,11 +7841,11 @@ function extractAutopilotTopic(state) {
 }
 function buildAutopilotMap(cwd) {
   const map = /* @__PURE__ */ new Map();
-  const sessionsDir = path43.join(cwd, ".harness", "sessions");
-  if (!fs27.existsSync(sessionsDir)) return map;
+  const sessionsDir = path44.join(cwd, ".harness", "sessions");
+  if (!fs28.existsSync(sessionsDir)) return map;
   for (const session of listDirs(sessionsDir)) {
     if (!session.startsWith("changes--")) continue;
-    const state = readJson2(path43.join(sessionsDir, session, "autopilot-state.json"));
+    const state = readJson2(path44.join(sessionsDir, session, "autopilot-state.json"));
     if (!state) continue;
     const topic = extractAutopilotTopic(state);
     if (!topic) continue;
@@ -7671,7 +7858,7 @@ function buildAutopilotMap(cwd) {
 function extractTopicFromHeader(planAbs, proposalTopics) {
   let text;
   try {
-    text = fs27.readFileSync(planAbs, "utf8").slice(0, 4e3);
+    text = fs28.readFileSync(planAbs, "utf8").slice(0, 4e3);
   } catch {
     return null;
   }
@@ -7696,8 +7883,8 @@ function extractTopicFromFilename(filename, proposalTopics) {
   return best;
 }
 function resolveDocsDir(cwd) {
-  const configPath = path43.join(cwd, "harness.config.json");
-  const configResult = fs27.existsSync(configPath) ? resolveConfig(configPath) : null;
+  const configPath = path44.join(cwd, "harness.config.json");
+  const configResult = fs28.existsSync(configPath) ? resolveConfig(configPath) : null;
   let docsDir;
   if (configResult?.ok) {
     docsDir = configResult.value.docsDir;
@@ -7709,16 +7896,16 @@ function resolveDocsDir(cwd) {
   } else {
     docsDir = "./docs";
   }
-  const docsAbs = path43.resolve(cwd, docsDir);
-  const relRaw = path43.relative(cwd, docsAbs).replaceAll("\\", "/");
+  const docsAbs = path44.resolve(cwd, docsDir);
+  const relRaw = path44.relative(cwd, docsAbs).replaceAll("\\", "/");
   return relRaw === "" ? "docs" : relRaw;
 }
 function collectAdrMoves(cwd, docsRel) {
   const moves = [];
-  const legacyAdrDir = path43.join(cwd, ".harness", "architecture");
-  if (!fs27.existsSync(legacyAdrDir)) return moves;
+  const legacyAdrDir = path44.join(cwd, ".harness", "architecture");
+  if (!fs28.existsSync(legacyAdrDir)) return moves;
   for (const topic of listDirs(legacyAdrDir)) {
-    const topicSrc = path43.join(legacyAdrDir, topic);
+    const topicSrc = path44.join(legacyAdrDir, topic);
     for (const file of listFiles(topicSrc, (n) => n.endsWith(".md"))) {
       moves.push({
         src: `.harness/architecture/${topic}/${file}`,
@@ -7730,9 +7917,9 @@ function collectAdrMoves(cwd, docsRel) {
 }
 function collectProposalTopics(cwd) {
   const topics = /* @__PURE__ */ new Set();
-  const changesDir = path43.join(cwd, "docs", "changes");
+  const changesDir = path44.join(cwd, "docs", "changes");
   for (const topic of listDirs(changesDir)) {
-    if (fs27.existsSync(path43.join(changesDir, topic, "proposal.md"))) {
+    if (fs28.existsSync(path44.join(changesDir, topic, "proposal.md"))) {
       topics.add(topic);
     }
   }
@@ -7759,12 +7946,12 @@ async function buildPlan(opts) {
     orphanPlans: [],
     proposalTopics: collectProposalTopics(cwd)
   };
-  const legacyPlanDir = path43.join(cwd, "docs", "plans");
-  if (!fs27.existsSync(legacyPlanDir)) return plan;
+  const legacyPlanDir = path44.join(cwd, "docs", "plans");
+  if (!fs28.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 = path43.join(legacyPlanDir, file);
+    const planAbs = path44.join(legacyPlanDir, file);
     const subdir = file.includes("VERIFICATION") ? "verifications" : "plans";
     const classified = classifyPlan(planRel, planAbs, file, autopilotMap, plan.proposalTopics);
     if (classified) {
@@ -7782,8 +7969,8 @@ async function buildPlan(opts) {
   return plan;
 }
 function gitMv(cwd, src, dest, useGit) {
-  const destAbs = path43.join(cwd, dest);
-  fs27.mkdirSync(path43.dirname(destAbs), { recursive: true });
+  const destAbs = path44.join(cwd, dest);
+  fs28.mkdirSync(path44.dirname(destAbs), { recursive: true });
   if (useGit) {
     try {
       execFileSync4("git", ["mv", src, dest], { cwd, stdio: "pipe" });
@@ -7791,7 +7978,7 @@ function gitMv(cwd, src, dest, useGit) {
     } catch {
     }
   }
-  fs27.renameSync(path43.join(cwd, src), destAbs);
+  fs28.renameSync(path44.join(cwd, src), destAbs);
 }
 function executeMigration(plan) {
   let moved = 0;
@@ -7823,13 +8010,13 @@ function updateReferences(plan) {
   let files = 0;
   let replacements = 0;
   const targets = [
-    ...walk(path43.join(plan.cwd, "docs"), (p) => p.endsWith(".md")),
-    ...walk(path43.join(plan.cwd, ".harness", "sessions"), (p) => p.endsWith(".json"))
+    ...walk(path44.join(plan.cwd, "docs"), (p) => p.endsWith(".md")),
+    ...walk(path44.join(plan.cwd, ".harness", "sessions"), (p) => p.endsWith(".json"))
   ];
   for (const target of targets) {
     let text;
     try {
-      text = fs27.readFileSync(target, "utf8");
+      text = fs28.readFileSync(target, "utf8");
     } catch {
       continue;
     }
@@ -7842,7 +8029,7 @@ function updateReferences(plan) {
       count += occurrences;
     }
     if (count > 0 && result !== text) {
-      fs27.writeFileSync(target, result);
+      fs28.writeFileSync(target, result);
       files++;
       replacements += count;
     }
@@ -7901,7 +8088,7 @@ async function resolveOrphans(plan, opts) {
 }
 function bucketOrphans(plan, topic) {
   for (const src of plan.orphanPlans) {
-    const file = path43.basename(src);
+    const file = path44.basename(src);
     const isVerification = file.includes("VERIFICATION");
     const subdir = isVerification ? "verifications" : "plans";
     plan.planMoves.push({
@@ -7916,7 +8103,7 @@ function bucketOrphans(plan, topic) {
 }
 function summarize(plan) {
   console.log("");
-  console.log(chalk9.bold("  Migration plan"));
+  console.log(chalk10.bold("  Migration plan"));
   console.log("");
   if (plan.adrMoves.length === 0 && plan.planMoves.length === 0 && plan.orphanPlans.length === 0) {
     logger.success("  Nothing to migrate. Layout is already up to date.");
@@ -7935,7 +8122,7 @@ function summarize(plan) {
     logger.info(
       `  Plan moves: ${plan.planMoves.length} file(s) \u2014 docs/plans/ \u2192 docs/changes/<topic>/{plans,verifications}/`
     );
-    for (const [via, n] of Object.entries(byVia)) console.log(chalk9.dim(`    via ${via}: ${n}`));
+    for (const [via, n] of Object.entries(byVia)) console.log(chalk10.dim(`    via ${via}: ${n}`));
   }
   if (plan.orphanPlans.length > 0) {
     logger.warn(`  Orphan plans: ${plan.orphanPlans.length} (no proposal match \u2014 needs decision)`);
@@ -7943,10 +8130,10 @@ function summarize(plan) {
   console.log("");
 }
 async function detectLegacyArtifacts(cwd) {
-  const adrLegacyDir = path43.join(cwd, ".harness", "architecture");
-  const adrLegacy = fs27.existsSync(adrLegacyDir) && listDirs(adrLegacyDir).length > 0;
-  const planLegacyDir = path43.join(cwd, "docs", "plans");
-  const planLegacy = fs27.existsSync(planLegacyDir) && listFiles(planLegacyDir, (n) => n.endsWith(".md") && n !== "index.md").length > 0;
+  const adrLegacyDir = path44.join(cwd, ".harness", "architecture");
+  const adrLegacy = fs28.existsSync(adrLegacyDir) && listDirs(adrLegacyDir).length > 0;
+  const planLegacyDir = path44.join(cwd, "docs", "plans");
+  const planLegacy = fs28.existsSync(planLegacyDir) && listFiles(planLegacyDir, (n) => n.endsWith(".md") && n !== "index.md").length > 0;
   return { adrLegacy, planLegacy };
 }
 async function confirmApply(opts) {
@@ -8014,7 +8201,7 @@ async function runMigrate(opts) {
   });
 }
 function createMigrateCommand() {
-  return new Command62("migrate").description("Migrate legacy harness artifact locations to current layout").option("--dry-run", "Show the migration plan without moving files", false).option("--yes", "Skip confirmation prompt", false).option(
+  const cmd = new Command63("migrate").description("Migrate legacy harness artifact locations to current layout").option("--dry-run", "Show the migration plan without moving files", false).option("--yes", "Skip confirmation prompt", false).option(
     "--skip-references",
     "Do not update path references in docs/sessions after moves",
     false
@@ -8033,12 +8220,158 @@ function createMigrateCommand() {
     }
     process.exit(result.value.movesFailed === 0 ? ExitCode.SUCCESS : ExitCode.ERROR);
   });
+  cmd.addCommand(createBackendsSubcommand());
+  return cmd;
+}
+
+// src/commands/models.ts
+import { Command as Command64 } from "commander";
+import { defaultFetchModels } from "@harness-engineering/orchestrator";
+function errorResult(message, partial) {
+  return {
+    status: "error",
+    endpoint: "",
+    configured: [],
+    detected: [],
+    resolved: null,
+    error: message,
+    exitCode: ExitCode.ERROR,
+    ...partial
+  };
+}
+function pickConfiguredList(model) {
+  if (typeof model === "string") return [model];
+  if (Array.isArray(model)) return model.filter((m) => typeof m === "string");
+  return [];
+}
+function locateBackend(opts) {
+  const resolved = resolveConfig(opts.configPath);
+  if (!resolved.ok) {
+    return errorResult(`Could not load harness.config.json: ${resolved.error.message}`);
+  }
+  const backends = resolved.value.agent?.backends;
+  const name = opts.backend ?? defaultLocalBackend(backends);
+  if (name === null) {
+    return errorResult(
+      'No local backend in agent.backends. Declare one with type "local" or "pi", or pass --endpoint <url>.'
+    );
+  }
+  const def = backends?.[name];
+  if (def === void 0) {
+    return errorResult(`agent.backends["${name}"] not found.`);
+  }
+  return { name, def };
+}
+function resolveProbeContext(opts) {
+  if (opts.endpoint !== void 0) {
+    return {
+      endpoint: opts.endpoint,
+      configured: [],
+      apiKey: opts.apiKey ?? "local",
+      backendLabel: opts.backend
+    };
+  }
+  const located = locateBackend(opts);
+  if ("status" in located) return located;
+  const ep = located.def.endpoint;
+  if (typeof ep !== "string") {
+    return errorResult(`agent.backends["${located.name}"]: missing or invalid 'endpoint'.`);
+  }
+  const explicitKey = typeof located.def.apiKey === "string" ? located.def.apiKey : void 0;
+  return {
+    endpoint: ep,
+    configured: pickConfiguredList(located.def.model),
+    apiKey: opts.apiKey ?? explicitKey ?? "local",
+    backendLabel: located.name
+  };
+}
+async function runModelsProbe(opts) {
+  const ctx = resolveProbeContext(opts);
+  if ("status" in ctx) return ctx;
+  let detected;
+  try {
+    detected = await defaultFetchModels(ctx.endpoint, ctx.apiKey);
+  } catch (err) {
+    return {
+      status: "error",
+      ...ctx.backendLabel !== void 0 ? { backend: ctx.backendLabel } : {},
+      endpoint: ctx.endpoint,
+      configured: ctx.configured,
+      detected: [],
+      resolved: null,
+      error: err instanceof Error ? err.message : String(err),
+      exitCode: ExitCode.ERROR
+    };
+  }
+  const match = ctx.configured.find((id) => detected.includes(id)) ?? null;
+  return {
+    status: match !== null ? "ok" : "no-match",
+    ...ctx.backendLabel !== void 0 ? { backend: ctx.backendLabel } : {},
+    endpoint: ctx.endpoint,
+    configured: ctx.configured,
+    detected,
+    resolved: match,
+    exitCode: match !== null ? ExitCode.SUCCESS : ExitCode.ERROR
+  };
+}
+function defaultLocalBackend(backends) {
+  if (backends === void 0) return null;
+  for (const [name, def] of Object.entries(backends)) {
+    const t = def.type;
+    if (t === "local" || t === "pi") return name;
+  }
+  return null;
+}
+function formatProbe(result) {
+  if (result.status === "error") {
+    return `error probing ${result.endpoint || "(no endpoint)"}: ${result.error}`;
+  }
+  const lines = [];
+  lines.push(
+    `endpoint: ${result.endpoint}${result.backend !== void 0 ? ` (agent.backends["${result.backend}"])` : ""}`
+  );
+  lines.push(`configured: [${result.configured.join(", ")}]`);
+  lines.push(`detected:   [${result.detected.join(", ")}]`);
+  if (result.resolved !== null) {
+    lines.push(`resolved:   ${result.resolved}`);
+  } else {
+    lines.push("resolved:   (no configured model is loaded)");
+    lines.push(
+      "hint: load one of the configured models or update agent.backends.<name>.model to include a detected id."
+    );
+  }
+  return lines.join("\n");
+}
+function createModelsCommand() {
+  const cmd = new Command64("models").description(
+    "Inspect and manage local LLM backends. Currently ships `probe`; LMLM phases add status/suggest/pool/proposals."
+  );
+  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);
+  });
+  return cmd;
 }
 
 // src/commands/naming-craft.ts
-import { Command as Command63 } from "commander";
+import { Command as Command65 } from "commander";
 function createNamingCraftCommand() {
-  return new Command63("naming-craft").description(
+  return new Command65("naming-craft").description(
     "LLM-judgment critique of identifier names (variables, functions, types, files). First craft-pipeline ceiling skill; uses curated rubric catalog from Martin/Beck/Karlton."
   ).option("-f, --files <files...>", "Optional file/glob scope").option(
     "-k, --kinds <kinds...>",
@@ -8088,10 +8421,10 @@ function printResult4(result, mode, _formatter) {
       list.push(f);
       byFile.set(f.target.file, list);
     }
-    for (const [file, fs47] of byFile) {
+    for (const [file, fs48] of byFile) {
       console.log(`
 ${file}`);
-      for (const f of fs47) {
+      for (const f of fs48) {
         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}`
@@ -8111,11 +8444,11 @@ ${file}`);
 }
 
 // src/commands/notifications/index.ts
-import { Command as Command65 } from "commander";
+import { Command as Command67 } from "commander";
 
 // src/commands/notifications/test.ts
 init_dist3();
-import { Command as Command64 } from "commander";
+import { Command as Command66 } from "commander";
 import { randomBytes } from "crypto";
 import { resolve as resolve28 } from "path";
 import { SinkRegistry, SinkConfigError, wrapAsEnvelope } from "@harness-engineering/orchestrator";
@@ -8167,7 +8500,7 @@ async function runNotificationsTest(sinkId, opts, projectRoot2 = process.cwd())
   return { ok: false, error: result.error };
 }
 function createNotificationsTestSubcommand() {
-  return new Command64("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) => {
+  return new Command66("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" ? resolve28(globalOpts["cwd"]) : process.cwd();
     const result = await runNotificationsTest(sinkId, opts, projectRoot2);
@@ -8184,7 +8517,7 @@ function createNotificationsTestSubcommand() {
 
 // src/commands/notifications/index.ts
 function createNotificationsCommand() {
-  const cmd = new Command65("notifications").description(
+  const cmd = new Command67("notifications").description(
     "Manage notification sinks (Slack and others)"
   );
   cmd.addCommand(createNotificationsTestSubcommand());
@@ -8192,13 +8525,13 @@ function createNotificationsCommand() {
 }
 
 // src/commands/orchestrator.ts
-import { Command as Command66 } from "commander";
-import * as path44 from "path";
+import { Command as Command68 } from "commander";
+import * as path45 from "path";
 import { Orchestrator, WorkflowLoader as WorkflowLoader2, launchTUI } from "@harness-engineering/orchestrator";
 function createOrchestratorCommand() {
-  const orchestrator = new Command66("orchestrator");
+  const orchestrator = new Command68("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 = path44.resolve(process.cwd(), opts.workflow);
+    const workflowPath = path45.resolve(process.cwd(), opts.workflow);
     const loader = new WorkflowLoader2();
     const result = await loader.loadWorkflow(workflowPath);
     if (!result.ok) {
@@ -8232,13 +8565,13 @@ function createOrchestratorCommand() {
 
 // src/commands/perf.ts
 init_dist3();
-import { Command as Command67 } from "commander";
-import * as path45 from "path";
+import { Command as Command69 } from "commander";
+import * as path46 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-XIJWWQ5N.js");
+    const { BenchmarkRunner } = await import("./dist-JCFK263L.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob2);
     if (benchFiles.length === 0) {
@@ -8302,7 +8635,7 @@ async function runBaselinesShow(globalOpts) {
 }
 async function runBaselinesUpdate(globalOpts) {
   const cwd = process.cwd();
-  const { BenchmarkRunner } = await import("./dist-XIJWWQ5N.js");
+  const { BenchmarkRunner } = await import("./dist-JCFK263L.js");
   const runner = new BenchmarkRunner();
   const manager = new BaselineManager(cwd);
   logger.info("Running benchmarks to update baselines...");
@@ -8343,9 +8676,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-XIJWWQ5N.js");
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-JCFK263L.js");
     const analyzer = new EntropyAnalyzer2({
-      rootDir: path45.resolve(cwd),
+      rootDir: path46.resolve(cwd),
       analyze: { complexity: true, coupling: true }
     });
     const result = await analyzer.analyze();
@@ -8404,7 +8737,7 @@ function registerCriticalPathsCommand(perf) {
   });
 }
 function createPerfCommand() {
-  const perf = new Command67("perf").description("Performance benchmark and baseline management");
+  const perf = new Command69("perf").description("Performance benchmark and baseline management");
   registerBenchCommand(perf);
   registerBaselinesCommands(perf);
   registerReportCommand(perf);
@@ -8413,10 +8746,10 @@ function createPerfCommand() {
 }
 
 // src/commands/persona/index.ts
-import { Command as Command70 } from "commander";
+import { Command as Command72 } from "commander";
 
 // src/commands/persona/list.ts
-import { Command as Command68 } from "commander";
+import { Command as Command70 } from "commander";
 function printPersonaList(personas) {
   if (personas.length === 0) {
     logger.info("No personas found.");
@@ -8430,7 +8763,7 @@ function printPersonaList(personas) {
   }
 }
 function createListCommand2() {
-  return new Command68("list").description("List available agent personas").action(async (_opts, cmd) => {
+  return new Command70("list").description("List available agent personas").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const personasDir = resolvePersonasDir();
     const result = listPersonas(personasDir);
@@ -8450,51 +8783,51 @@ function createListCommand2() {
 }
 
 // src/commands/persona/generate.ts
-import { Command as Command69 } from "commander";
-import * as fs28 from "fs";
-import * as path46 from "path";
+import { Command as Command71 } from "commander";
+import * as fs29 from "fs";
+import * as path47 from "path";
 function generatePersonaArtifacts(persona, outputDir, only) {
   const slug = toKebabCase(persona.name);
   const generated = [];
   if (!only || only === "runtime") {
     const result = generateRuntime(persona);
     if (result.ok) {
-      const outPath = path46.join(outputDir, `${slug}.runtime.json`);
-      fs28.mkdirSync(path46.dirname(outPath), { recursive: true });
-      fs28.writeFileSync(outPath, result.value);
+      const outPath = path47.join(outputDir, `${slug}.runtime.json`);
+      fs29.mkdirSync(path47.dirname(outPath), { recursive: true });
+      fs29.writeFileSync(outPath, result.value);
       generated.push(outPath);
     }
   }
   if (!only || only === "agents-md") {
     const result = generateAgentsMd(persona);
     if (result.ok) {
-      const outPath = path46.join(outputDir, `${slug}.agents.md`);
-      fs28.writeFileSync(outPath, result.value);
+      const outPath = path47.join(outputDir, `${slug}.agents.md`);
+      fs29.writeFileSync(outPath, result.value);
       generated.push(outPath);
     }
   }
   if (!only || only === "ci") {
     const result = generateCIWorkflow(persona, "github");
     if (result.ok) {
-      const outPath = path46.join(outputDir, ".github", "workflows", `${slug}.yml`);
-      fs28.mkdirSync(path46.dirname(outPath), { recursive: true });
-      fs28.writeFileSync(outPath, result.value);
+      const outPath = path47.join(outputDir, ".github", "workflows", `${slug}.yml`);
+      fs29.mkdirSync(path47.dirname(outPath), { recursive: true });
+      fs29.writeFileSync(outPath, result.value);
       generated.push(outPath);
     }
   }
   return generated;
 }
 function createGenerateCommand3() {
-  return new Command69("generate").description("Generate artifacts from a persona config").argument("<name>", "Persona name (e.g., architecture-enforcer)").option("--output-dir <dir>", "Output directory", ".").option("--only <type>", "Generate only: ci, agents-md, runtime").action(async (name, opts, cmd) => {
+  return new Command71("generate").description("Generate artifacts from a persona config").argument("<name>", "Persona name (e.g., architecture-enforcer)").option("--output-dir <dir>", "Output directory", ".").option("--only <type>", "Generate only: ci, agents-md, runtime").action(async (name, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const personaResult = loadPersona(path46.join(resolvePersonasDir(), `${name}.yaml`));
+    const personaResult = loadPersona(path47.join(resolvePersonasDir(), `${name}.yaml`));
     if (!personaResult.ok) {
       logger.error(personaResult.error.message);
       process.exit(ExitCode.ERROR);
     }
     const generated = generatePersonaArtifacts(
       personaResult.value,
-      path46.resolve(opts.outputDir),
+      path47.resolve(opts.outputDir),
       opts.only
     );
     if (!globalOpts.quiet) {
@@ -8507,7 +8840,7 @@ function createGenerateCommand3() {
 
 // src/commands/persona/index.ts
 function createPersonaCommand() {
-  const command = new Command70("persona").description("Agent persona management commands");
+  const command = new Command72("persona").description("Agent persona management commands");
   command.addCommand(createListCommand2());
   command.addCommand(createGenerateCommand3());
   return command;
@@ -8515,8 +8848,8 @@ function createPersonaCommand() {
 
 // src/commands/predict.ts
 init_dist3();
-import { Command as Command71 } from "commander";
-import chalk10 from "chalk";
+import { Command as Command73 } from "commander";
+import chalk11 from "chalk";
 var CATEGORY_ORDER = [
   "circular-deps",
   "layer-violations",
@@ -8537,11 +8870,11 @@ function crossingLabel(weeks) {
 function severityPrefix(severity) {
   switch (severity) {
     case "critical":
-      return chalk10.red("[critical]");
+      return chalk11.red("[critical]");
     case "warning":
-      return chalk10.yellow("[warning]");
+      return chalk11.yellow("[warning]");
     case "info":
-      return chalk10.blue("[info]");
+      return chalk11.blue("[info]");
   }
 }
 function printCategoryTable(result) {
@@ -8621,7 +8954,7 @@ function handlePredictError(err, mode) {
   process.exit(ExitCode.ERROR);
 }
 function createPredictCommand() {
-  const command = new Command71("predict").description("Predict which architectural constraints will break and when").option("--category <name>", "Filter to a single metric category").option("--no-roadmap", "Baseline only \u2014 skip roadmap spec impact").option("--horizon <weeks>", "Forecast horizon in weeks (default: 12)", "12").action(async (opts, cmd) => {
+  const command = new Command73("predict").description("Predict which architectural constraints will break and when").option("--category <name>", "Filter to a single metric category").option("--no-roadmap", "Baseline only \u2014 skip roadmap spec impact").option("--horizon <weeks>", "Forecast horizon in weeks (default: 12)", "12").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : OutputMode.TEXT;
     try {
@@ -8645,7 +8978,7 @@ function createPredictCommand() {
 
 // src/commands/proposals.ts
 init_dist3();
-import { Command as Command72 } from "commander";
+import { Command as Command74 } from "commander";
 import { resolve as resolve32 } from "path";
 function projectRoot() {
   return resolve32(process.env["HARNESS_PROJECT_ROOT"] ?? process.cwd());
@@ -8740,7 +9073,7 @@ async function actApproveCommand(id) {
   }
 }
 function createProposalsCommand() {
-  const cmd = new Command72("proposals").description("Skill-proposal review queue (Hermes Phase 4)");
+  const cmd = new Command74("proposals").description("Skill-proposal review queue");
   cmd.command("list").description("List skill proposals in the local queue").option(
     "--status <status>",
     `Filter by status \u2014 one of ${ALLOWED_STATUSES.join(" | ")}`,
@@ -8755,9 +9088,9 @@ function createProposalsCommand() {
 }
 
 // src/commands/publish-analyses.ts
-import * as fs29 from "fs";
-import * as path47 from "path";
-import { Command as Command73 } from "commander";
+import * as fs30 from "fs";
+import * as path48 from "path";
+import { Command as Command75 } from "commander";
 init_dist3();
 import {
   renderAnalysisComment,
@@ -8765,7 +9098,7 @@ import {
   savePublishedIndex
 } from "@harness-engineering/orchestrator";
 function bootstrapTrackerCommand(opts, verb) {
-  const projectPath = path47.resolve(opts.dir);
+  const projectPath = path48.resolve(opts.dir);
   const trackerConfig = loadTrackerSyncConfig(projectPath);
   if (!trackerConfig) {
     logger.error(`No tracker config found in harness.config.json. Cannot ${verb}.`);
@@ -8777,8 +9110,8 @@ function bootstrapTrackerCommand(opts, verb) {
     );
     return null;
   }
-  const projectEnvPath = path47.join(projectPath, ".env");
-  if (fs29.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
+  const projectEnvPath = path48.join(projectPath, ".env");
+  if (fs30.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
     __require("dotenv").config({ path: projectEnvPath });
   }
   const token = process.env.GITHUB_TOKEN;
@@ -8814,13 +9147,13 @@ async function buildNameToExternalIdMap(projectPath) {
     }
     return fileLessMap;
   }
-  const roadmapFile = path47.join(projectPath, "docs", "roadmap.md");
-  if (!fs29.existsSync(roadmapFile)) {
+  const roadmapFile = path48.join(projectPath, "docs", "roadmap.md");
+  if (!fs30.existsSync(roadmapFile)) {
     logger.error("No docs/roadmap.md found. Cannot map issue hashes to external IDs.");
     return null;
   }
   const { parseRoadmap: parseRoadmap2 } = (init_dist3(), __toCommonJS(dist_exports));
-  const roadmapParsed = parseRoadmap2(fs29.readFileSync(roadmapFile, "utf-8"));
+  const roadmapParsed = parseRoadmap2(fs30.readFileSync(roadmapFile, "utf-8"));
   if (!roadmapParsed.ok) {
     logger.error("Failed to parse docs/roadmap.md");
     return null;
@@ -8870,8 +9203,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-XIJWWQ5N.js");
-  const archive = new AnalysisArchive(path47.join(projectPath, ".harness", "analyses"));
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-JCFK263L.js");
+  const archive = new AnalysisArchive(path48.join(projectPath, ".harness", "analyses"));
   const analyses = await archive.list();
   if (analyses.length === 0) {
     logger.info("No analyses found to publish.");
@@ -8893,7 +9226,7 @@ async function runPublishAnalyses(opts) {
   }
 }
 function createPublishAnalysesCommand() {
-  const command = new Command73("publish-analyses").description(
+  const command = new Command75("publish-analyses").description(
     "Publishes locally generated intelligence analyses to the external issue tracker (e.g., GitHub)"
   ).option("-d, --dir <path>", "Workspace directory", process.cwd()).action(async (opts) => {
     try {
@@ -8909,18 +9242,18 @@ function createPublishAnalysesCommand() {
 }
 
 // src/commands/pulse/index.ts
-import { Command as Command75 } from "commander";
+import { Command as Command77 } from "commander";
 
 // src/commands/pulse/run.ts
 init_dist3();
-import { readFileSync as readFileSync18, mkdirSync as mkdirSync13, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname17, join as join38, resolve as resolve34 } from "path";
-import { Command as Command74 } from "commander";
+import { readFileSync as readFileSync19, mkdirSync as mkdirSync13, writeFileSync as writeFileSync16 } from "fs";
+import { dirname as dirname18, join as join39, resolve as resolve34 } from "path";
+import { Command as Command76 } from "commander";
 async function runPulseRunCommand(opts) {
   const startedAt = Date.now();
   let raw;
   try {
-    raw = JSON.parse(readFileSync18(opts.configPath, "utf-8"));
+    raw = JSON.parse(readFileSync19(opts.configPath, "utf-8"));
   } catch (err) {
     return emit2(
       {
@@ -8946,9 +9279,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 = join38(opts.outputDir, `${ts}.md`);
-  mkdirSync13(dirname17(filePath), { recursive: true });
-  writeFileSync15(filePath, report);
+  const filePath = join39(opts.outputDir, `${ts}.md`);
+  mkdirSync13(dirname18(filePath), { recursive: true });
+  writeFileSync16(filePath, report);
   const headlines = extractHeadlines(report);
   return emit2(
     {
@@ -8980,7 +9313,7 @@ function emit2(status, nonInteractive) {
   return status;
 }
 function createRunCommand2() {
-  return new Command74("run").description("Run a pulse: query configured adapters, sanitize, assemble single-page report").option(
+  return new Command76("run").description("Run a pulse: query configured adapters, sanitize, assemble single-page report").option(
     "--lookback <window>",
     "Lookback window (e.g. 24h, 7d). Defaults to pulse.lookbackDefault."
   ).option(
@@ -9004,14 +9337,14 @@ function createRunCommand2() {
 
 // src/commands/pulse/index.ts
 function createPulseCommand() {
-  const command = new Command75("pulse").description("Pulse (read-side observability) commands");
+  const command = new Command77("pulse").description("Pulse (read-side observability) commands");
   command.addCommand(createRunCommand2());
   return command;
 }
 
 // src/commands/recommend.ts
-import { Command as Command76 } from "commander";
-import chalk11 from "chalk";
+import { Command as Command78 } from "commander";
+import chalk12 from "chalk";
 async function resolveSnapshot(cwd, noCache) {
   if (!noCache) {
     const cached = loadCachedSnapshot(cwd);
@@ -9045,12 +9378,12 @@ async function runRecommend(options) {
 function formatRecommendation(rec) {
   const lines = [];
   if (rec.urgency === "critical") {
-    lines.push(`  ${chalk11.red("[CRITICAL]")} ${rec.sequence}. ${rec.skillName}`);
+    lines.push(`  ${chalk12.red("[CRITICAL]")} ${rec.sequence}. ${rec.skillName}`);
   } else {
     lines.push(`  ${rec.sequence}. ${rec.skillName} (${rec.score.toFixed(2)})`);
   }
   for (const reason of rec.reasons) {
-    lines.push(`     ${chalk11.dim("\u2192")} ${reason}`);
+    lines.push(`     ${chalk12.dim("\u2192")} ${reason}`);
   }
   return lines.join("\n");
 }
@@ -9074,7 +9407,7 @@ function printRecommendations(result) {
   console.log("");
 }
 function createRecommendCommand() {
-  const command = new Command76("recommend").description("Recommend skills based on codebase health analysis").option("--no-cache", "Force fresh health snapshot").option("--top <n>", "Max recommendations (default 5)", "5").action(async (opts, cmd) => {
+  const command = new Command78("recommend").description("Recommend skills based on codebase health analysis").option("--no-cache", "Force fresh health snapshot").option("--top <n>", "Max recommendations (default 5)", "5").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : OutputMode.TEXT;
     try {
@@ -9110,18 +9443,18 @@ function createRecommendCommand() {
 }
 
 // src/commands/roadmap/index.ts
-import { Command as Command78 } from "commander";
+import { Command as Command80 } from "commander";
 
 // src/commands/roadmap/migrate.ts
 init_dist3();
-import { Command as Command77 } from "commander";
-import * as fs31 from "fs";
-import * as path49 from "path";
-import chalk12 from "chalk";
+import { Command as Command79 } from "commander";
+import * as fs32 from "fs";
+import * as path50 from "path";
+import chalk13 from "chalk";
 
 // src/commands/roadmap/migrate-lock.ts
-import * as fs30 from "fs";
-import * as path48 from "path";
+import * as fs31 from "fs";
+import * as path49 from "path";
 import * as os6 from "os";
 var LOCK_FILE_NAME = "migrate.lock";
 var STALE_LOCK_MS = 30 * 60 * 1e3;
@@ -9135,13 +9468,13 @@ function isPidAlive(pid) {
   }
 }
 function acquireMigrateLock(projectRoot2) {
-  const harnessDir = path48.join(projectRoot2, ".harness");
-  const lockPath = path48.join(harnessDir, LOCK_FILE_NAME);
-  if (!fs30.existsSync(harnessDir)) fs30.mkdirSync(harnessDir, { recursive: true });
-  if (fs30.existsSync(lockPath)) {
+  const harnessDir = path49.join(projectRoot2, ".harness");
+  const lockPath = path49.join(harnessDir, LOCK_FILE_NAME);
+  if (!fs31.existsSync(harnessDir)) fs31.mkdirSync(harnessDir, { recursive: true });
+  if (fs31.existsSync(lockPath)) {
     const existingRaw = (() => {
       try {
-        return fs30.readFileSync(lockPath, "utf-8");
+        return fs31.readFileSync(lockPath, "utf-8");
       } catch {
         return null;
       }
@@ -9171,11 +9504,11 @@ function acquireMigrateLock(projectRoot2) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     hostname: os6.hostname()
   };
-  fs30.writeFileSync(lockPath, JSON.stringify(payload, null, 2) + "\n");
+  fs31.writeFileSync(lockPath, JSON.stringify(payload, null, 2) + "\n");
   return {
     release: () => {
       try {
-        fs30.unlinkSync(lockPath);
+        fs31.unlinkSync(lockPath);
       } catch {
       }
     }
@@ -9206,7 +9539,7 @@ function reportToExitCode(report) {
   return MigrateExitCode.GENERIC_FAILURE;
 }
 function printPlanSummary(plan, dryRun) {
-  const banner = dryRun ? chalk12.cyan("DRY RUN ") : "";
+  const banner = dryRun ? chalk13.cyan("DRY RUN ") : "";
   console.log(`${banner}Migration plan:`);
   console.log(`  Would create: ${plan.toCreate.length}`);
   for (const e of plan.toCreate) console.log(`    - ${e.name}`);
@@ -9335,11 +9668,11 @@ async function runRoadmapMigrate(opts) {
       if (!clientR.ok) return Err(new CLIError(clientR.error.message));
       client = clientR.value;
     }
-    const roadmapPath = path49.join(cwd, "docs", "roadmap.md");
-    if (!fs31.existsSync(roadmapPath)) {
+    const roadmapPath = path50.join(cwd, "docs", "roadmap.md");
+    if (!fs32.existsSync(roadmapPath)) {
       return Err(new CLIError(`docs/roadmap.md not found in ${cwd}`));
     }
-    const roadmapR = parseRoadmap(fs31.readFileSync(roadmapPath, "utf-8"));
+    const roadmapR = parseRoadmap(fs32.readFileSync(roadmapPath, "utf-8"));
     if (!roadmapR.ok) {
       return Err(new CLIError(`failed to parse docs/roadmap.md: ${roadmapR.error.message}`));
     }
@@ -9360,10 +9693,10 @@ async function runRoadmapMigrate(opts) {
     if (!isJson) printPlanSummary(plan, opts.dryRun);
     const deps = {
       client,
-      readFile: (p) => fs31.readFileSync(p, "utf-8"),
-      writeFile: (p, b) => fs31.writeFileSync(p, b),
-      renameFile: (from, to) => fs31.renameSync(from, to),
-      existsFile: (p) => fs31.existsSync(p)
+      readFile: (p) => fs32.readFileSync(p, "utf-8"),
+      writeFile: (p, b) => fs32.writeFileSync(p, b),
+      renameFile: (from, to) => fs32.renameSync(from, to),
+      existsFile: (p) => fs32.existsSync(p)
     };
     const reportR = await migrate_exports.runMigrationPlan(plan, deps, {
       projectRoot: cwd,
@@ -9384,7 +9717,7 @@ async function runRoadmapMigrate(opts) {
   }
 }
 function createRoadmapMigrateCommand() {
-  return new Command77("migrate").description("Migrate the project roadmap to a different storage mode").requiredOption("--to <target>", 'Migration target (only "file-less" supported today)').option("--dry-run", "Print the migration plan without making any changes", false).option(
+  return new Command79("migrate").description("Migrate the project roadmap to a different storage mode").requiredOption("--to <target>", 'Migration target (only "file-less" supported today)').option("--dry-run", "Print the migration plan without making any changes", false).option(
     "--format <fmt>",
     'Output format: "human" (default) or "json" (single JSON object for CI consumers)',
     "human"
@@ -9419,16 +9752,16 @@ function createRoadmapMigrateCommand() {
 
 // src/commands/roadmap/index.ts
 function createRoadmapCommand() {
-  const roadmap = new Command78("roadmap").description("Roadmap management");
+  const roadmap = new Command80("roadmap").description("Roadmap management");
   roadmap.addCommand(createRoadmapMigrateCommand());
   return roadmap;
 }
 
 // src/commands/routing/index.ts
-import { Command as Command82 } from "commander";
+import { Command as Command84 } from "commander";
 
 // src/commands/routing/config.ts
-import { Command as Command79 } from "commander";
+import { Command as Command81 } from "commander";
 
 // src/commands/routing/http-client.ts
 function orchestratorBase() {
@@ -9438,9 +9771,9 @@ function authHeader() {
   const tok = process.env["HARNESS_API_TOKEN"];
   return tok ? { Authorization: `Bearer ${tok}` } : {};
 }
-async function getJson(path71) {
+async function getJson(path72) {
   try {
-    const res = await fetch(`${orchestratorBase()}${path71}`, {
+    const res = await fetch(`${orchestratorBase()}${path72}`, {
       headers: { ...authHeader() }
     });
     const text = await res.text();
@@ -9455,9 +9788,9 @@ async function getJson(path71) {
     };
   }
 }
-async function postJson(path71, body) {
+async function postJson(path72, body) {
   try {
-    const res = await fetch(`${orchestratorBase()}${path71}`, {
+    const res = await fetch(`${orchestratorBase()}${path72}`, {
       method: "POST",
       headers: { "Content-Type": "application/json", ...authHeader() },
       body: JSON.stringify(body)
@@ -9493,7 +9826,7 @@ function renderHuman(data) {
   }
 }
 function createConfigCommand() {
-  return new Command79("config").description("Print active routing config and resolved fallback chains").option("--json", "Emit JSON to stdout instead of human-readable text").action(async (opts) => {
+  return new Command81("config").description("Print active routing config and resolved fallback chains").option("--json", "Emit JSON to stdout instead of human-readable text").action(async (opts) => {
     const r = await getJson("/api/v1/routing/config");
     if (!r.ok) {
       if (r.status === 0) {
@@ -9519,7 +9852,7 @@ function createConfigCommand() {
 }
 
 // src/commands/routing/trace.ts
-import { Command as Command80 } from "commander";
+import { Command as Command82 } from "commander";
 function buildUseCase(opts) {
   if (opts.skill) {
     return opts.mode ? { kind: "skill", skillName: opts.skill, cognitiveMode: opts.mode } : { kind: "skill", skillName: opts.skill };
@@ -9540,7 +9873,7 @@ function renderHuman2(r) {
   }
 }
 function createTraceCommand() {
-  return new Command80("trace").description("Dry-run a routing decision without dispatching (Spec B F7)").option("--skill <name>", "Skill name to trace").option("--mode <m>", "Cognitive mode to trace (or attach to --skill per spec D12)").option("--json", "Emit JSON to stdout instead of human-readable text").action(async (opts) => {
+  return new Command82("trace").description("Dry-run a routing decision without dispatching (Spec B F7)").option("--skill <name>", "Skill name to trace").option("--mode <m>", "Cognitive mode to trace (or attach to --skill per spec D12)").option("--json", "Emit JSON to stdout instead of human-readable text").action(async (opts) => {
     const useCase = buildUseCase(opts);
     if (!useCase) {
       logger.error("Either --skill <name> or --mode <m> is required");
@@ -9572,7 +9905,7 @@ function createTraceCommand() {
 }
 
 // src/commands/routing/decisions.ts
-import { Command as Command81 } from "commander";
+import { Command as Command83 } from "commander";
 function summarizeUseCase(uc) {
   switch (uc.kind) {
     case "skill":
@@ -9620,7 +9953,7 @@ function buildQuery(opts) {
   return q ? `?${q}` : "";
 }
 function createDecisionsCommand() {
-  return new Command81("decisions").description("List recent routing decisions from the orchestrator ring buffer (Spec B F8)").option("--skill <name>", "Filter by useCase.skillName").option("--mode <m>", "Filter by useCase.cognitiveMode").option("--backend <name>", "Filter by chosen backendName").option("--last <N>", "Limit to the N most recent decisions").option("--json", "Emit JSON to stdout instead of human-readable text").action(
+  return new Command83("decisions").description("List recent routing decisions from the orchestrator ring buffer (Spec B F8)").option("--skill <name>", "Filter by useCase.skillName").option("--mode <m>", "Filter by useCase.cognitiveMode").option("--backend <name>", "Filter by chosen backendName").option("--last <N>", "Limit to the N most recent decisions").option("--json", "Emit JSON to stdout instead of human-readable text").action(
     async (opts) => {
       const query = buildQuery(opts);
       const r = await getJson(`/api/v1/routing/decisions${query}`);
@@ -9650,7 +9983,7 @@ function createDecisionsCommand() {
 
 // src/commands/routing/index.ts
 function createRoutingCommand() {
-  const cmd = new Command82("routing").description(
+  const cmd = new Command84("routing").description(
     "Inspect routing config, trace decisions, and read recent dispatches"
   );
   cmd.addCommand(createConfigCommand());
@@ -9661,9 +9994,9 @@ function createRoutingCommand() {
 
 // src/commands/scan-config.ts
 init_dist3();
-import { Command as Command83 } from "commander";
-import { existsSync as existsSync28, readFileSync as readFileSync21, writeFileSync as writeFileSync18 } from "fs";
-import { join as join41, relative as relative3 } from "path";
+import { Command as Command85 } from "commander";
+import { existsSync as existsSync29, readFileSync as readFileSync22, writeFileSync as writeFileSync19 } from "fs";
+import { join as join42, relative as relative3 } from "path";
 var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".gemini/settings.json", "skill.yaml"];
 function stripHighSeverityPatterns(content, injectionFindings) {
   const highLines = /* @__PURE__ */ new Set();
@@ -9689,17 +10022,17 @@ function applyFix(filePath, targetDir, content, injectionFindings) {
   if (!hasHighSeverity) return;
   const { cleaned, linesStripped } = stripHighSeverityPatterns(content, injectionFindings);
   if (linesStripped > 0) {
-    writeFileSync18(filePath, cleaned);
+    writeFileSync19(filePath, cleaned);
     logger.info(
       `scan-config --fix: stripped ${linesStripped} high-severity line(s) from ${relative3(targetDir, filePath).replaceAll("\\", "/")}`
     );
   }
 }
 function scanSingleFile(filePath, targetDir, scanner, options) {
-  if (!existsSync28(filePath)) return null;
+  if (!existsSync29(filePath)) return null;
   let content;
   try {
-    content = readFileSync21(filePath, "utf8");
+    content = readFileSync22(filePath, "utf8");
   } catch {
     return null;
   }
@@ -9720,7 +10053,7 @@ async function runScanConfig(targetDir, options) {
   const scanner = new SecurityScanner(parseSecurityConfig({}));
   const results = [];
   for (const configFile of CONFIG_FILES) {
-    const result = scanSingleFile(join41(targetDir, configFile), targetDir, scanner, options);
+    const result = scanSingleFile(join42(targetDir, configFile), targetDir, scanner, options);
     if (result) results.push(result);
   }
   return { exitCode: computeScanExitCode(results), results };
@@ -9750,7 +10083,7 @@ function formatTextOutput(result) {
   }
 }
 function createScanConfigCommand() {
-  const command = new Command83("scan-config").description(
+  const command = new Command85("scan-config").description(
     "Scan CLAUDE.md, AGENTS.md, .gemini/settings.json, and skill.yaml for prompt injection patterns"
   ).option("--path <dir>", "Target directory to scan (default: cwd)").option("--fix", "Strip high-severity patterns from files in-place").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
@@ -9768,7 +10101,7 @@ function createScanConfigCommand() {
 
 // src/commands/search.ts
 init_dist();
-import { Command as Command84 } from "commander";
+import { Command as Command86 } from "commander";
 function parseFileKinds(raw) {
   if (!raw) return void 0;
   const set = /* @__PURE__ */ new Set();
@@ -9789,7 +10122,7 @@ function fmtBytes(n) {
   return n.toFixed(0);
 }
 function createSearchCommand() {
-  return new Command84("search").description("Full-text search over archived + live session content (Hermes Phase 1).").argument(
+  return new Command86("search").description("Full-text search over archived + live session content.").argument(
     "<query>",
     "FTS5 query (bare words AND-joined; quotes/AND/OR/NOT/column: for advanced syntax)"
   ).option("-n, --limit <n>", "Max results", "20").option("--archived-only", "Skip live sessions, only search archived ones").option("--json", "Emit JSON to stdout instead of pretty text").option(
@@ -9849,9 +10182,9 @@ function createSearchCommand() {
 }
 
 // src/commands/security-craft.ts
-import { Command as Command85 } from "commander";
+import { Command as Command87 } from "commander";
 function createSecurityCraftCommand() {
-  return new Command85("security-craft").description(
+  return new Command87("security-craft").description(
     "LLM-judgment critique of security posture (TS/JS source). Sixth non-design craft-pipeline ceiling skill (the final sub-project). AST-driven signal detection fires only on files with security-relevant constructs; conservative confidence defaults manage the FP risk inherent in judgment-based security."
   ).option("-f, --files <files...>", "Optional file scope (overrides discovery)").option("-p, --packages <names...>", "Restrict to specific packages under packages/").option("--max-files <n>", "Cap source-file count (default: 100)").option("--max-signals-per-file <n>", "Cap per-file signal critique (default: 10)").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
@@ -9898,10 +10231,10 @@ function printResult5(result, mode, _formatter) {
       list.push(f);
       byFile.set(f.target.file, list);
     }
-    for (const [file, fs47] of byFile) {
+    for (const [file, fs48] of byFile) {
       console.log(`
 ${file}`);
-      for (const f of fs47) {
+      for (const f of fs48) {
         console.log(
           `  ${f.code} [${f.tier}/${f.impact}/${f.confidence}] ${f.target.signal}:${f.target.line}`
         );
@@ -9917,24 +10250,24 @@ ${file}`);
 }
 
 // src/commands/setup.ts
-import { Command as Command86 } from "commander";
-import * as fs34 from "fs";
+import { Command as Command88 } from "commander";
+import * as fs35 from "fs";
 import * as os8 from "os";
-import * as path52 from "path";
-import chalk14 from "chalk";
+import * as path53 from "path";
+import chalk15 from "chalk";
 
 // src/utils/first-run.ts
-import * as fs32 from "fs";
+import * as fs33 from "fs";
 import * as os7 from "os";
-import * as path50 from "path";
-var HARNESS_DIR = path50.join(os7.homedir(), ".harness");
-var MARKER_FILE = path50.join(HARNESS_DIR, ".setup-complete");
+import * as path51 from "path";
+var HARNESS_DIR = path51.join(os7.homedir(), ".harness");
+var MARKER_FILE = path51.join(HARNESS_DIR, ".setup-complete");
 function isFirstRun() {
-  return !fs32.existsSync(MARKER_FILE);
+  return !fs33.existsSync(MARKER_FILE);
 }
 function markSetupComplete() {
-  fs32.mkdirSync(HARNESS_DIR, { recursive: true });
-  fs32.writeFileSync(MARKER_FILE, "", "utf-8");
+  fs33.mkdirSync(HARNESS_DIR, { recursive: true });
+  fs33.writeFileSync(MARKER_FILE, "", "utf-8");
 }
 function printFirstRunWelcome() {
   try {
@@ -9947,10 +10280,10 @@ function printFirstRunWelcome() {
 }
 
 // src/commands/telemetry-wizard.ts
-import * as fs33 from "fs";
-import * as path51 from "path";
+import * as fs34 from "fs";
+import * as path52 from "path";
 import readline2 from "readline";
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 function prompt2(question) {
   const rl = readline2.createInterface({
     input: process.stdin,
@@ -9979,21 +10312,21 @@ function isNo(answer) {
   return answer === "n" || answer === "no";
 }
 function isTelemetryConfigured(cwd) {
-  const configPath = path51.join(cwd, "harness.config.json");
+  const configPath = path52.join(cwd, "harness.config.json");
   try {
-    const raw = JSON.parse(fs33.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs34.readFileSync(configPath, "utf-8"));
     return raw.telemetry !== void 0 && raw.adoption !== void 0;
   } catch {
     return false;
   }
 }
 function writeTelemetryConfig(cwd, result) {
-  const configPath = path51.join(cwd, "harness.config.json");
+  const configPath = path52.join(cwd, "harness.config.json");
   try {
-    const raw = JSON.parse(fs33.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs34.readFileSync(configPath, "utf-8"));
     raw.telemetry = { enabled: result.telemetryEnabled };
     raw.adoption = { enabled: result.adoptionEnabled };
-    fs33.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
+    fs34.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
   } catch (err) {
     console.warn(
       `\u26A0 Could not update ${configPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -10001,15 +10334,15 @@ function writeTelemetryConfig(cwd, result) {
   }
   const hasIdentity = result.identity.project || result.identity.team || result.identity.alias;
   if (hasIdentity) {
-    const harnessDir = path51.join(cwd, ".harness");
-    fs33.mkdirSync(harnessDir, { recursive: true });
-    const telemetryFile = path51.join(harnessDir, "telemetry.json");
-    fs33.writeFileSync(telemetryFile, JSON.stringify({ identity: result.identity }, null, 2) + "\n");
+    const harnessDir = path52.join(cwd, ".harness");
+    fs34.mkdirSync(harnessDir, { recursive: true });
+    const telemetryFile = path52.join(harnessDir, "telemetry.json");
+    fs34.writeFileSync(telemetryFile, JSON.stringify({ identity: result.identity }, null, 2) + "\n");
   }
 }
 async function promptIdentity() {
   console.log(
-    `  ${chalk13.cyan("Identity")} (optional) \u2014 tag telemetry with project/team/alias for filtering.`
+    `  ${chalk14.cyan("Identity")} (optional) \u2014 tag telemetry with project/team/alias for filtering.`
   );
   console.log("  Leave blank to keep anonymous.");
   const answer = await prompt2("  Set identity fields? (y/N) ");
@@ -10027,20 +10360,20 @@ async function promptIdentity() {
 async function runTelemetryWizard() {
   if (!process.stdin.isTTY) return null;
   console.log("");
-  console.log(`  ${chalk13.bold("Telemetry Configuration")}`);
+  console.log(`  ${chalk14.bold("Telemetry Configuration")}`);
   console.log("");
   console.log("  Harness can collect anonymous usage data to help improve the tool.");
   console.log("  You can change these settings anytime in harness.config.json.");
   console.log("");
   console.log(
-    `  ${chalk13.cyan("Anonymous telemetry")} \u2014 error rates, command usage, performance metrics.`
+    `  ${chalk14.cyan("Anonymous telemetry")} \u2014 error rates, command usage, performance metrics.`
   );
   console.log("  No code, file contents, or personally identifiable info is sent.");
   const telemetryAnswer = await prompt2("  Enable anonymous telemetry? (Y/n) ");
   const telemetryEnabled = !isNo(telemetryAnswer);
   console.log("");
   console.log(
-    `  ${chalk13.cyan("Adoption tracking")} \u2014 which skills are used, how often, and success rates.`
+    `  ${chalk14.cyan("Adoption tracking")} \u2014 which skills are used, how often, and success rates.`
   );
   console.log("  Stored locally in .harness/adoption/. Never sent externally.");
   const adoptionAnswer = await prompt2("  Enable local adoption tracking? (Y/n) ");
@@ -10050,8 +10383,8 @@ async function runTelemetryWizard() {
   return { telemetryEnabled, adoptionEnabled, identity };
 }
 async function ensureTelemetryConfigured(cwd) {
-  const configPath = path51.join(cwd, "harness.config.json");
-  if (!fs33.existsSync(configPath)) {
+  const configPath = path52.join(cwd, "harness.config.json");
+  if (!fs34.existsSync(configPath)) {
     return { status: "warn", message: "Not a harness project \u2014 skipped telemetry configuration" };
   }
   if (isTelemetryConfigured(cwd)) {
@@ -10097,7 +10430,7 @@ function runSlashCommandGeneration() {
   }
 }
 function detectClient(dirName) {
-  return fs34.existsSync(path52.join(os8.homedir(), dirName));
+  return fs35.existsSync(path53.join(os8.homedir(), dirName));
 }
 async function runMcpSetup(cwd) {
   const results = [];
@@ -10113,7 +10446,7 @@ async function runMcpSetup(cwd) {
     { name: "Cursor", dir: ".cursor", client: "cursor", configTarget: ".cursor/mcp.json" },
     {
       name: "OpenCode",
-      dir: path52.join(".config", "opencode"),
+      dir: path53.join(".config", "opencode"),
       client: "opencode",
       configTarget: "opencode.json"
     }
@@ -10140,12 +10473,12 @@ async function runMcpSetup(cwd) {
   return results;
 }
 function formatStep(result) {
-  const icon = result.status === "pass" ? chalk14.green("\u2713") : result.status === "warn" ? chalk14.yellow("\u26A0") : chalk14.red("\u2717");
+  const icon = result.status === "pass" ? chalk15.green("\u2713") : result.status === "warn" ? chalk15.yellow("\u26A0") : chalk15.red("\u2717");
   return `  ${icon} ${result.message}`;
 }
 function configureTier0Integrations(cwd) {
   try {
-    const mcpPath = path52.join(cwd, ".mcp.json");
+    const mcpPath = path53.join(cwd, ".mcp.json");
     const config = readMcpConfig(mcpPath);
     const tier0 = INTEGRATION_REGISTRY.filter((i) => i.tier === 0);
     const added = [];
@@ -10154,9 +10487,9 @@ function configureTier0Integrations(cwd) {
       writeMcpEntry(mcpPath, integration.name, integration.mcpConfig);
       added.push(integration.displayName);
     }
-    const geminiDir = path52.join(cwd, ".gemini");
-    if (fs34.existsSync(geminiDir)) {
-      const geminiPath = path52.join(geminiDir, "settings.json");
+    const geminiDir = path53.join(cwd, ".gemini");
+    if (fs35.existsSync(geminiDir)) {
+      const geminiPath = path53.join(geminiDir, "settings.json");
       const geminiConfig = readMcpConfig(geminiPath);
       for (const integration of tier0) {
         if (!geminiConfig.mcpServers[integration.name]) {
@@ -10164,9 +10497,9 @@ function configureTier0Integrations(cwd) {
         }
       }
     }
-    const opencodePath = path52.join(cwd, "opencode.json");
-    const opencodeGlobalDir = path52.join(os8.homedir(), ".config", "opencode");
-    if (fs34.existsSync(opencodePath) || fs34.existsSync(opencodeGlobalDir)) {
+    const opencodePath = path53.join(cwd, "opencode.json");
+    const opencodeGlobalDir = path53.join(os8.homedir(), ".config", "opencode");
+    if (fs35.existsSync(opencodePath) || fs35.existsSync(opencodeGlobalDir)) {
       for (const integration of tier0) {
         writeOpencodeMcpEntry(opencodePath, integration.name, integration.mcpConfig);
       }
@@ -10184,14 +10517,14 @@ function configureTier0Integrations(cwd) {
   }
 }
 function ensureHooks(cwd) {
-  const configPath = path52.join(cwd, "harness.config.json");
-  if (!fs34.existsSync(configPath)) {
+  const configPath = path53.join(cwd, "harness.config.json");
+  if (!fs35.existsSync(configPath)) {
     return { status: "warn", message: "Not a harness project \u2014 skipped hook installation" };
   }
   let profile = "standard";
-  const profilePath = path52.join(cwd, ".harness", "hooks", "profile.json");
+  const profilePath = path53.join(cwd, ".harness", "hooks", "profile.json");
   try {
-    const data = JSON.parse(fs34.readFileSync(profilePath, "utf-8"));
+    const data = JSON.parse(fs35.readFileSync(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
       profile = data.profile;
     }
@@ -10223,7 +10556,7 @@ async function detectLegacyLayout(cwd) {
 }
 async function runInitialGraphScan(cwd) {
   try {
-    const { runScan: runScan2 } = await import("./scan-LYKLM4EQ.js");
+    const { runScan: runScan2 } = await import("./scan-P7YFKB77.js");
     const result = await runScan2(cwd);
     return {
       status: "pass",
@@ -10262,10 +10595,10 @@ async function runSetup(cwd) {
   return { steps, success };
 }
 function createSetupCommand() {
-  return new Command86("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
+  return new Command88("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
     const cwd = process.cwd();
     console.log("");
-    console.log(`  ${chalk14.bold("harness setup")}`);
+    console.log(`  ${chalk15.bold("harness setup")}`);
     console.log("");
     const { steps, success } = await runSetup(cwd);
     for (const step of steps) {
@@ -10285,15 +10618,15 @@ function createSetupCommand() {
 
 // src/commands/share.ts
 init_dist3();
-import { Command as Command87 } from "commander";
-import * as fs35 from "fs";
-import * as path53 from "path";
-import { parse as parseYaml2 } from "yaml";
+import { Command as Command89 } from "commander";
+import * as fs36 from "fs";
+import * as path54 from "path";
+import { parse as parseYaml3 } from "yaml";
 var MANIFEST_FILENAME = "constraints.yaml";
 async function runShareAction(projectPath, options) {
-  const rootDir = path53.resolve(projectPath);
-  const manifestPath = path53.join(rootDir, MANIFEST_FILENAME);
-  if (!fs35.existsSync(manifestPath)) {
+  const rootDir = path54.resolve(projectPath);
+  const manifestPath = path54.join(rootDir, MANIFEST_FILENAME);
+  if (!fs36.existsSync(manifestPath)) {
     logger.error(
       `No ${MANIFEST_FILENAME} found at ${manifestPath}.
 Create a constraints.yaml in your project root to define what to share.`
@@ -10302,8 +10635,8 @@ Create a constraints.yaml in your project root to define what to share.`
   }
   let parsed;
   try {
-    const raw = fs35.readFileSync(manifestPath, "utf-8");
-    parsed = parseYaml2(raw);
+    const raw = fs36.readFileSync(manifestPath, "utf-8");
+    parsed = parseYaml3(raw);
   } catch (err) {
     logger.error(
       `Failed to read ${MANIFEST_FILENAME}: ${err instanceof Error ? err.message : String(err)}`
@@ -10316,7 +10649,7 @@ Create a constraints.yaml in your project root to define what to share.`
     process.exit(1);
   }
   const manifest = manifestResult.value;
-  const configResult = resolveConfig(path53.join(rootDir, "harness.config.json"));
+  const configResult = resolveConfig(path54.join(rootDir, "harness.config.json"));
   if (!configResult.ok) {
     logger.error(configResult.error.message);
     process.exit(1);
@@ -10334,8 +10667,8 @@ Create a constraints.yaml in your project root to define what to share.`
     );
     process.exit(1);
   }
-  const outputDir = path53.resolve(options.output);
-  const outputPath = path53.join(outputDir, `${manifest.name}.harness-constraints.json`);
+  const outputDir = path54.resolve(options.output);
+  const outputPath = path54.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}`);
@@ -10344,28 +10677,28 @@ Create a constraints.yaml in your project root to define what to share.`
   logger.success(`Bundle written to ${outputPath}`);
 }
 function createShareCommand() {
-  return new Command87("share").description("Extract and publish a constraints bundle from constraints.yaml").argument("[path]", "Path to the project root", ".").option("-o, --output <dir>", "Output directory for the bundle", ".").action(async (projectPath, options) => {
+  return new Command89("share").description("Extract and publish a constraints bundle from constraints.yaml").argument("[path]", "Path to the project root", ".").option("-o, --output <dir>", "Output directory for the bundle", ".").action(async (projectPath, options) => {
     await runShareAction(projectPath, options);
   });
 }
 
 // src/commands/skill/index.ts
-import { Command as Command95 } from "commander";
+import { Command as Command97 } from "commander";
 
 // src/commands/skill/list.ts
-import { Command as Command88 } from "commander";
-import * as fs36 from "fs";
-import * as path54 from "path";
+import { Command as Command90 } from "commander";
+import * as fs37 from "fs";
+import * as path55 from "path";
 import { parse } from "yaml";
 function scanDirectory(dirPath, source) {
-  if (!fs36.existsSync(dirPath)) return [];
-  const entries = fs36.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  if (!fs37.existsSync(dirPath)) return [];
+  const entries = fs37.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   const skills = [];
   for (const name of entries) {
-    const yamlPath = path54.join(dirPath, name, "skill.yaml");
-    if (!fs36.existsSync(yamlPath)) continue;
+    const yamlPath = path55.join(dirPath, name, "skill.yaml");
+    if (!fs37.existsSync(yamlPath)) continue;
     try {
-      const raw = fs36.readFileSync(yamlPath, "utf-8");
+      const raw = fs37.readFileSync(yamlPath, "utf-8");
       const parsed = parse(raw);
       const result = SkillMetadataSchema.safeParse(parsed);
       if (result.success) {
@@ -10383,10 +10716,10 @@ function scanDirectory(dirPath, source) {
 }
 function collectCommunitySkills(seen, allSkills) {
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path54.dirname(globalDir);
-  const communityBase = path54.join(skillsDir, "community");
-  const communityPlatformDir = path54.join(communityBase, "claude-code");
-  const lockfilePath = path54.join(communityBase, "skills-lock.json");
+  const skillsDir = path55.dirname(globalDir);
+  const communityBase = path55.join(skillsDir, "community");
+  const communityPlatformDir = path55.join(communityBase, "claude-code");
+  const lockfilePath = path55.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const communitySkills = scanDirectory(communityPlatformDir, "community");
   for (const skill of communitySkills) {
@@ -10456,7 +10789,7 @@ function printSkillsVerbose(skills) {
   for (const s of skills) printSkillEntry(s);
 }
 function createListCommand3() {
-  return new Command88("list").description("List available skills").option("--installed", "Show only community-installed skills").option("--local", "Show only project-local skills").option("--all", "Show all skills (default)").action(async (opts, cmd) => {
+  return new Command90("list").description("List available skills").option("--installed", "Show only community-installed skills").option("--local", "Show only project-local skills").option("--all", "Show all skills (default)").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skills = collectSkills({ filter: resolveFilter(opts) });
     if (globalOpts.json) {
@@ -10471,9 +10804,9 @@ function createListCommand3() {
 }
 
 // src/commands/skill/run.ts
-import { Command as Command89 } from "commander";
-import * as fs37 from "fs";
-import * as path55 from "path";
+import { Command as Command91 } from "commander";
+import * as fs38 from "fs";
+import * as path56 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/skill/complexity.ts
@@ -10569,10 +10902,10 @@ ${options.principles}`);
 
 // src/commands/skill/run.ts
 function loadSkillMetadata(skillDir) {
-  const yamlPath = path55.join(skillDir, "skill.yaml");
-  if (!fs37.existsSync(yamlPath)) return null;
+  const yamlPath = path56.join(skillDir, "skill.yaml");
+  if (!fs38.existsSync(yamlPath)) return null;
   try {
-    const result = SkillMetadataSchema.safeParse(parse2(fs37.readFileSync(yamlPath, "utf-8")));
+    const result = SkillMetadataSchema.safeParse(parse2(fs38.readFileSync(yamlPath, "utf-8")));
     return result.success ? result.data : null;
   } catch {
     return null;
@@ -10584,22 +10917,22 @@ function resolveComplexity(metadata, requested, projectPath) {
   return requested;
 }
 function loadPrinciples(projectPath) {
-  const principlesPath = path55.join(projectPath, "docs", "principles.md");
-  return fs37.existsSync(principlesPath) ? fs37.readFileSync(principlesPath, "utf-8") : void 0;
+  const principlesPath = path56.join(projectPath, "docs", "principles.md");
+  return fs38.existsSync(principlesPath) ? fs38.readFileSync(principlesPath, "utf-8") : void 0;
 }
 function readMostRecentFileInDir(dirPath) {
-  const files = fs37.readdirSync(dirPath).map((f) => ({ name: f, mtime: fs37.statSync(path55.join(dirPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
-  if (files.length > 0) return fs37.readFileSync(path55.join(dirPath, files[0].name), "utf-8");
+  const files = fs38.readdirSync(dirPath).map((f) => ({ name: f, mtime: fs38.statSync(path56.join(dirPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  if (files.length > 0) return fs38.readFileSync(path56.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 = path55.join(projectPath, stateFilePath);
-    if (!fs37.existsSync(fullPath)) continue;
-    const stat = fs37.statSync(fullPath);
+    const fullPath = path56.join(projectPath, stateFilePath);
+    if (!fs38.existsSync(fullPath)) continue;
+    const stat = fs38.statSync(fullPath);
     if (stat.isDirectory()) return readMostRecentFileInDir(fullPath);
-    return fs37.readFileSync(fullPath, "utf-8");
+    return fs38.readFileSync(fullPath, "utf-8");
   }
   return void 0;
 }
@@ -10619,9 +10952,9 @@ function resolvePhaseState(metadata, projectPath, phase) {
 }
 function appendProjectState(content, metadata, projectPath, hasPathOpt) {
   if (!metadata?.state.persistent || !hasPathOpt) return content;
-  const stateFile = path55.join(projectPath, ".harness", "state.json");
-  if (!fs37.existsSync(stateFile)) return content;
-  const stateContent = fs37.readFileSync(stateFile, "utf-8");
+  const stateFile = path56.join(projectPath, ".harness", "state.json");
+  if (!fs38.existsSync(stateFile)) return content;
+  const stateContent = fs38.readFileSync(stateFile, "utf-8");
   return content + `
 
 ---
@@ -10633,14 +10966,14 @@ ${stateContent}
 }
 async function runSkill(name, opts) {
   const skillsDir = resolveSkillsDir();
-  const skillDir = path55.join(skillsDir, name);
-  if (!fs37.existsSync(skillDir)) {
+  const skillDir = path56.join(skillsDir, name);
+  if (!fs38.existsSync(skillDir)) {
     logger.error(`Skill not found: ${name}`);
     process.exit(ExitCode.ERROR);
     return;
   }
   const metadata = loadSkillMetadata(skillDir);
-  const projectPath = opts.path ? path55.resolve(opts.path) : process.cwd();
+  const projectPath = opts.path ? path56.resolve(opts.path) : process.cwd();
   const complexity = resolveComplexity(
     metadata,
     opts.complexity ?? "standard",
@@ -10667,14 +11000,14 @@ async function runSkill(name, opts) {
     ...stateWarning !== void 0 && { stateWarning },
     ...opts.party !== void 0 && { party: opts.party }
   });
-  const skillMdPath = path55.join(skillDir, "SKILL.md");
-  if (!fs37.existsSync(skillMdPath)) {
+  const skillMdPath = path56.join(skillDir, "SKILL.md");
+  if (!fs38.existsSync(skillMdPath)) {
     logger.error(`SKILL.md not found for skill: ${name}`);
     process.exit(ExitCode.ERROR);
     return;
   }
   const content = appendProjectState(
-    fs37.readFileSync(skillMdPath, "utf-8"),
+    fs38.readFileSync(skillMdPath, "utf-8"),
     metadata,
     projectPath,
     !!opts.path
@@ -10685,16 +11018,16 @@ async function runSkill(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createRunCommand3() {
-  return new Command89("run").description("Run a skill (outputs SKILL.md content with context preamble)").argument("<name>", "Skill name (e.g., harness-tdd)").option("--path <path>", "Project root path for context injection").option("--complexity <level>", "Rigor level: fast, standard, thorough", "standard").option("--phase <name>", "Start at a specific phase (for re-entry)").option("--party", "Enable multi-perspective evaluation").option(
+  return new Command91("run").description("Run a skill (outputs SKILL.md content with context preamble)").argument("<name>", "Skill name (e.g., harness-tdd)").option("--path <path>", "Project root path for context injection").option("--complexity <level>", "Rigor level: fast, standard, thorough", "standard").option("--phase <name>", "Start at a specific phase (for re-entry)").option("--party", "Enable multi-perspective evaluation").option(
     "--backend <name>",
     "Spec B: one-shot routing override forwarded to the orchestrator as HARNESS_BACKEND_OVERRIDE"
   ).action(async (name, opts) => runSkill(name, opts));
 }
 
 // src/commands/skill/validate.ts
-import { Command as Command90 } from "commander";
-import * as fs38 from "fs";
-import * as path56 from "path";
+import { Command as Command92 } from "commander";
+import * as fs39 from "fs";
+import * as path57 from "path";
 import { parse as parse3 } from "yaml";
 var BEHAVIORAL_REQUIRED_SECTIONS = [
   "## When to Use",
@@ -10706,11 +11039,11 @@ var BEHAVIORAL_REQUIRED_SECTIONS = [
 ];
 var KNOWLEDGE_REQUIRED_SECTIONS = ["## Instructions"];
 function validateSkillMd(name, skillMdPath, skillType, errors) {
-  if (!fs38.existsSync(skillMdPath)) {
+  if (!fs39.existsSync(skillMdPath)) {
     errors.push(`${name}: missing SKILL.md`);
     return;
   }
-  const mdContent = fs38.readFileSync(skillMdPath, "utf-8");
+  const mdContent = fs39.readFileSync(skillMdPath, "utf-8");
   if (!mdContent.trim().startsWith("# ")) {
     errors.push(`${name}/SKILL.md: must start with an h1 heading`);
   }
@@ -10735,20 +11068,20 @@ function validateSkillMd(name, skillMdPath, skillType, errors) {
   }
 }
 function validateSkillEntry(name, skillsDir, errors) {
-  const skillDir = path56.join(skillsDir, name);
-  const yamlPath = path56.join(skillDir, "skill.yaml");
-  if (!fs38.existsSync(yamlPath)) {
+  const skillDir = path57.join(skillsDir, name);
+  const yamlPath = path57.join(skillDir, "skill.yaml");
+  if (!fs39.existsSync(yamlPath)) {
     errors.push(`${name}: missing skill.yaml`);
     return false;
   }
   try {
-    const raw = fs38.readFileSync(yamlPath, "utf-8");
+    const raw = fs39.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, path56.join(skillDir, "SKILL.md"), result.data.type, errors);
+    validateSkillMd(name, path57.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)}`);
@@ -10756,15 +11089,15 @@ function validateSkillEntry(name, skillsDir, errors) {
   }
 }
 function createValidateCommand2() {
-  return new Command90("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
+  return new Command92("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    if (!fs38.existsSync(skillsDir)) {
+    if (!fs39.existsSync(skillsDir)) {
       logger.info("No skills directory found.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
-    const entries = fs38.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const entries = fs39.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     const errors = [];
     let validated = 0;
     for (const name of entries) {
@@ -10786,24 +11119,24 @@ function createValidateCommand2() {
 }
 
 // src/commands/skill/info.ts
-import { Command as Command91 } from "commander";
-import * as fs39 from "fs";
-import * as path57 from "path";
+import { Command as Command93 } from "commander";
+import * as fs40 from "fs";
+import * as path58 from "path";
 import { parse as parse4 } from "yaml";
 function loadSkillMetadata2(name) {
   const skillsDir = resolveSkillsDir();
-  const skillDir = path57.join(skillsDir, name);
-  if (!fs39.existsSync(skillDir)) {
+  const skillDir = path58.join(skillsDir, name);
+  if (!fs40.existsSync(skillDir)) {
     logger.error(`Skill not found: ${name}`);
     return { ok: false, exitCode: ExitCode.ERROR };
   }
-  const yamlPath = path57.join(skillDir, "skill.yaml");
-  if (!fs39.existsSync(yamlPath)) {
+  const yamlPath = path58.join(skillDir, "skill.yaml");
+  if (!fs40.existsSync(yamlPath)) {
     logger.error(`skill.yaml not found for skill: ${name}`);
     return { ok: false, exitCode: ExitCode.ERROR };
   }
   try {
-    const raw = fs39.readFileSync(yamlPath, "utf-8");
+    const raw = fs40.readFileSync(yamlPath, "utf-8");
     const parsed = parse4(raw);
     const result = SkillMetadataSchema.safeParse(parsed);
     if (!result.success) {
@@ -10832,7 +11165,7 @@ function printSkillInfo(skill) {
   console.log(`Persistent:  ${skill.state.persistent}`);
 }
 function createInfoCommand() {
-  return new Command91("info").description("Show metadata for a skill").argument("<name>", "Skill name (e.g., harness-tdd)").action(async (name, _opts, cmd) => {
+  return new Command93("info").description("Show metadata for a skill").argument("<name>", "Skill name (e.g., harness-tdd)").action(async (name, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const loaded = loadSkillMetadata2(name);
     if (!loaded.ok) {
@@ -10849,7 +11182,7 @@ function createInfoCommand() {
 }
 
 // src/commands/skill/search.ts
-import { Command as Command92 } from "commander";
+import { Command as Command94 } from "commander";
 async function runSearch(query, opts) {
   const results = await searchNpmRegistry(query, opts.registry);
   return results.filter((r) => {
@@ -10894,15 +11227,15 @@ async function runSearchAction(query, opts, globalOpts) {
   }
 }
 function createSearchCommand2() {
-  return new Command92("search").description("Search for community skills on the @harness-skills registry").argument("<query>", "Search query").option("--platform <platform>", "Filter by platform (e.g., claude-code)").option("--trigger <trigger>", "Filter by trigger type (e.g., manual, automatic)").option("--registry <url>", "Use a custom npm registry URL").action(async (query, opts, cmd) => {
+  return new Command94("search").description("Search for community skills on the @harness-skills registry").argument("<query>", "Search query").option("--platform <platform>", "Filter by platform (e.g., claude-code)").option("--trigger <trigger>", "Filter by trigger type (e.g., manual, automatic)").option("--registry <url>", "Use a custom npm registry URL").action(async (query, opts, cmd) => {
     await runSearchAction(query, opts, cmd.optsWithGlobals());
   });
 }
 
 // src/commands/skill/create.ts
-import { Command as Command93 } from "commander";
-import * as path58 from "path";
-import * as fs40 from "fs";
+import { Command as Command95 } from "commander";
+import * as path59 from "path";
+import * as fs41 from "fs";
 import YAML from "yaml";
 var KEBAB_CASE_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 function buildReadme(name, description) {
@@ -10986,22 +11319,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 ?? path58.join(process.cwd(), "agents", "skills", "claude-code");
-  const skillDir = path58.join(baseDir, name);
-  if (fs40.existsSync(skillDir)) {
+  const baseDir = opts.outputDir ?? path59.join(process.cwd(), "agents", "skills", "claude-code");
+  const skillDir = path59.join(baseDir, name);
+  if (fs41.existsSync(skillDir)) {
     throw new Error(`Skill directory already exists: ${skillDir}`);
   }
-  fs40.mkdirSync(skillDir, { recursive: true });
+  fs41.mkdirSync(skillDir, { recursive: true });
   const description = opts.description || `A community skill: ${name}`;
   const skillYaml = buildSkillYaml(name, opts);
-  const skillYamlPath = path58.join(skillDir, "skill.yaml");
-  fs40.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
+  const skillYamlPath = path59.join(skillDir, "skill.yaml");
+  fs41.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
   const skillMd = buildSkillMd(name, description);
-  const skillMdPath = path58.join(skillDir, "SKILL.md");
-  fs40.writeFileSync(skillMdPath, skillMd);
+  const skillMdPath = path59.join(skillDir, "SKILL.md");
+  fs41.writeFileSync(skillMdPath, skillMd);
   const readme = buildReadme(name, description);
-  const readmePath = path58.join(skillDir, "README.md");
-  fs40.writeFileSync(readmePath, readme);
+  const readmePath = path59.join(skillDir, "README.md");
+  fs41.writeFileSync(readmePath, readme);
   return {
     name,
     directory: skillDir,
@@ -11015,12 +11348,12 @@ function printCreateResult(name, result) {
   }
   logger.info(`
 Next steps:`);
-  logger.info(`  1. Edit ${path58.join(result.directory, "SKILL.md")} with your skill content`);
+  logger.info(`  1. Edit ${path59.join(result.directory, "SKILL.md")} with your skill content`);
   logger.info(`  2. Run: harness skill validate ${name}`);
   logger.info(`  3. Run: harness skills publish`);
 }
 function createCreateCommand() {
-  return new Command93("create").description("Scaffold a new community skill").argument("<name>", "Skill name (kebab-case)").option("--description <desc>", "Skill description").option("--type <type>", "Skill type: rigid or flexible", "flexible").option("--platforms <platforms>", "Comma-separated platforms (default: claude-code)").option("--triggers <triggers>", "Comma-separated triggers (default: manual)").option("--output-dir <dir>", "Output directory (default: agents/skills/claude-code/)").action(async (name, opts, cmd) => {
+  return new Command95("create").description("Scaffold a new community skill").argument("<name>", "Skill name (kebab-case)").option("--description <desc>", "Skill description").option("--type <type>", "Skill type: rigid or flexible", "flexible").option("--platforms <platforms>", "Comma-separated platforms (default: claude-code)").option("--triggers <triggers>", "Comma-separated triggers (default: manual)").option("--output-dir <dir>", "Output directory (default: agents/skills/claude-code/)").action(async (name, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     try {
       const result = runCreate(name, {
@@ -11043,26 +11376,26 @@ function createCreateCommand() {
 }
 
 // src/commands/skill/publish.ts
-import { Command as Command94 } from "commander";
-import * as fs42 from "fs";
-import * as path60 from "path";
+import { Command as Command96 } from "commander";
+import * as fs43 from "fs";
+import * as path61 from "path";
 import { execFileSync as execFileSync6 } from "child_process";
 
 // src/registry/validator.ts
-import * as fs41 from "fs";
-import * as path59 from "path";
+import * as fs42 from "fs";
+import * as path60 from "path";
 import { parse as parse5 } from "yaml";
 import semver4 from "semver";
 async function validateForPublish(skillDir, registryUrl) {
   const errors = [];
-  const skillYamlPath = path59.join(skillDir, "skill.yaml");
-  if (!fs41.existsSync(skillYamlPath)) {
+  const skillYamlPath = path60.join(skillDir, "skill.yaml");
+  if (!fs42.existsSync(skillYamlPath)) {
     errors.push("skill.yaml not found. Create one with: harness skill create <name>");
     return { valid: false, errors };
   }
   let skillMeta;
   try {
-    const raw = fs41.readFileSync(skillYamlPath, "utf-8");
+    const raw = fs42.readFileSync(skillYamlPath, "utf-8");
     const parsed = parse5(raw);
     const result = SkillMetadataSchema.safeParse(parsed);
     if (!result.success) {
@@ -11084,11 +11417,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 = path59.join(skillDir, "SKILL.md");
-  if (!fs41.existsSync(skillMdPath)) {
+  const skillMdPath = path60.join(skillDir, "SKILL.md");
+  if (!fs42.existsSync(skillMdPath)) {
     errors.push("SKILL.md not found. Create it with content describing your skill.");
   } else {
-    const content = fs41.readFileSync(skillMdPath, "utf-8");
+    const content = fs42.readFileSync(skillMdPath, "utf-8");
     if (!content.includes("## When to Use")) {
       errors.push('SKILL.md must contain a "## When to Use" section.');
     }
@@ -11168,11 +11501,11 @@ ${errorList}`);
   }
   const meta = validation.skillMeta;
   const pkg = derivePackageJson(meta);
-  const pkgPath = path60.join(skillDir, "package.json");
-  fs42.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-  const readmePath = path60.join(skillDir, "README.md");
-  if (!fs42.existsSync(readmePath)) {
-    const skillMdContent = fs42.readFileSync(path60.join(skillDir, "SKILL.md"), "utf-8");
+  const pkgPath = path61.join(skillDir, "package.json");
+  fs43.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  const readmePath = path61.join(skillDir, "README.md");
+  if (!fs43.existsSync(readmePath)) {
+    const skillMdContent = fs43.readFileSync(path61.join(skillDir, "SKILL.md"), "utf-8");
     const readme = `# ${pkg.name}
 
 ${meta.description}
@@ -11186,7 +11519,7 @@ harness install ${meta.name}
 ---
 
 ${skillMdContent}`;
-    fs42.writeFileSync(readmePath, readme);
+    fs43.writeFileSync(readmePath, readme);
   }
   if (opts.dryRun) {
     return {
@@ -11212,7 +11545,7 @@ ${skillMdContent}`;
   };
 }
 function createPublishCommand() {
-  return new Command94("publish").description("Validate and publish a skill to @harness-skills on npm").option("--dry-run", "Run validation and generate package.json without publishing").option("--dir <dir>", "Skill directory (default: current directory)").option("--registry <url>", "Use a custom npm registry URL").action(async (opts, cmd) => {
+  return new Command96("publish").description("Validate and publish a skill to @harness-skills on npm").option("--dry-run", "Run validation and generate package.json without publishing").option("--dir <dir>", "Skill directory (default: current directory)").option("--registry <url>", "Use a custom npm registry URL").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillDir = opts.dir || process.cwd();
     try {
@@ -11237,7 +11570,7 @@ function createPublishCommand() {
 
 // src/commands/skill/index.ts
 function createSkillCommand() {
-  const command = new Command95("skill").description("Skill management commands");
+  const command = new Command97("skill").description("Skill management commands");
   command.addCommand(createListCommand3());
   command.addCommand(createRunCommand3());
   command.addCommand(createValidateCommand2());
@@ -11250,9 +11583,9 @@ function createSkillCommand() {
 
 // src/commands/snapshot.ts
 init_dist3();
-import { Command as Command96 } from "commander";
+import { Command as Command98 } from "commander";
 import { execSync as execSync5 } from "child_process";
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 function getCommitHash3(cwd) {
   try {
     return execSync5("git rev-parse --short HEAD", { cwd, encoding: "utf-8" }).toString().trim();
@@ -11277,9 +11610,9 @@ function formatDelta(delta) {
 function directionSymbol(direction) {
   switch (direction) {
     case "improving":
-      return chalk15.green("improving");
+      return chalk16.green("improving");
     case "declining":
-      return chalk15.red("declining");
+      return chalk16.red("declining");
     case "stable":
       return "=";
   }
@@ -11432,7 +11765,7 @@ function registerListCommand(parent) {
   });
 }
 function createSnapshotCommand() {
-  const command = new Command96("snapshot").description("Architecture timeline snapshot commands");
+  const command = new Command98("snapshot").description("Architecture timeline snapshot commands");
   registerCaptureCommand(command);
   registerTrendsCommand(command);
   registerListCommand(command);
@@ -11440,9 +11773,9 @@ function createSnapshotCommand() {
 }
 
 // src/commands/spec-craft.ts
-import { Command as Command97 } from "commander";
+import { Command as Command99 } from "commander";
 function createSpecCraftCommand() {
-  return new Command97("spec-craft").description(
+  return new Command99("spec-craft").description(
     "LLM-judgment critique of spec quality (proposals + ADRs). Second craft-pipeline ceiling skill; 7 seed rubrics from the spec-quality canon. Per-section critique."
   ).option("-f, --files <files...>", "Optional spec file/glob scope").option("-k, --kinds <kinds...>", "Restrict to proposal / adr (default: both)").option("-s, --sections <names...>", "Restrict to specific canonical section names").option("--max-files <n>", "Cap doc count (default: 50)").option("--max-sections-per-file <n>", "Cap per-doc section critique (default: 10)").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
@@ -11490,10 +11823,10 @@ function printResult6(result, mode, _formatter) {
       list.push(f);
       byFile.set(f.target.file, list);
     }
-    for (const [file, fs47] of byFile) {
+    for (const [file, fs48] of byFile) {
       console.log(`
 ${file}`);
-      for (const f of fs47) {
+      for (const f of fs48) {
         console.log(
           `  ${f.code} [${f.tier}/${f.impact}/${f.confidence}] ## ${f.target.section}:${f.target.line}`
         );
@@ -11509,12 +11842,12 @@ ${file}`);
 }
 
 // src/commands/state/index.ts
-import { Command as Command102 } from "commander";
+import { Command as Command104 } from "commander";
 
 // src/commands/state/show.ts
 init_dist3();
-import { Command as Command98 } from "commander";
-import * as path61 from "path";
+import { Command as Command100 } from "commander";
+import * as path62 from "path";
 function printStateText(state, stream) {
   if (stream) console.log(`Stream:         ${stream}`);
   console.log(`Schema Version: ${state.schemaVersion}`);
@@ -11538,9 +11871,9 @@ function printStateProgress(progress) {
   }
 }
 function createShowCommand() {
-  return new Command98("show").description("Show current project state").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (opts, cmd) => {
+  return new Command100("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 loadState(path61.resolve(opts.path), opts.stream);
+    const result = await loadState(path62.resolve(opts.path), opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
       process.exit(ExitCode.ERROR);
@@ -11556,9 +11889,9 @@ function createShowCommand() {
 
 // src/commands/state/reset.ts
 init_dist3();
-import { Command as Command99 } from "commander";
-import * as fs43 from "fs";
-import * as path62 from "path";
+import { Command as Command101 } from "commander";
+import * as fs44 from "fs";
+import * as path63 from "path";
 import * as readline3 from "readline";
 async function resolveStatePath(projectPath, stream) {
   if (stream) {
@@ -11567,9 +11900,9 @@ async function resolveStatePath(projectPath, stream) {
       logger.error(streamResult.error.message);
       process.exit(ExitCode.ERROR);
     }
-    return path62.join(streamResult.value, "state.json");
+    return path63.join(streamResult.value, "state.json");
   }
-  return path62.join(projectPath, ".harness", "state.json");
+  return path63.join(projectPath, ".harness", "state.json");
 }
 async function confirmReset() {
   const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
@@ -11580,9 +11913,9 @@ async function confirmReset() {
   return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
 }
 async function runReset(opts) {
-  const projectPath = path62.resolve(opts.path);
+  const projectPath = path63.resolve(opts.path);
   const statePath = await resolveStatePath(projectPath, opts.stream);
-  if (!fs43.existsSync(statePath)) {
+  if (!fs44.existsSync(statePath)) {
     logger.info("No state file found. Nothing to reset.");
     process.exit(ExitCode.SUCCESS);
   }
@@ -11591,7 +11924,7 @@ async function runReset(opts) {
     process.exit(ExitCode.SUCCESS);
   }
   try {
-    fs43.unlinkSync(statePath);
+    fs44.unlinkSync(statePath);
     logger.success("Project state reset.");
   } catch (e) {
     logger.error(`Failed to reset state: ${e instanceof Error ? e.message : String(e)}`);
@@ -11600,16 +11933,16 @@ async function runReset(opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createResetCommand() {
-  return new Command99("reset").description("Reset project state (deletes .harness/state.json)").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").option("--yes", "Skip confirmation prompt").action(async (opts) => runReset(opts));
+  return new Command101("reset").description("Reset project state (deletes .harness/state.json)").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").option("--yes", "Skip confirmation prompt").action(async (opts) => runReset(opts));
 }
 
 // src/commands/state/learn.ts
 init_dist3();
-import { Command as Command100 } from "commander";
-import * as path63 from "path";
+import { Command as Command102 } from "commander";
+import * as path64 from "path";
 function createLearnCommand() {
-  return new Command100("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 = path63.resolve(opts.path);
+  return new Command102("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 = path64.resolve(opts.path);
     const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -11623,10 +11956,10 @@ function createLearnCommand() {
 
 // src/commands/state/streams.ts
 init_dist3();
-import { Command as Command101 } from "commander";
-import * as path64 from "path";
+import { Command as Command103 } from "commander";
+import * as path65 from "path";
 async function runListStreams(opts, globalOpts) {
-  const projectPath = path64.resolve(opts.path);
+  const projectPath = path65.resolve(opts.path);
   const indexResult = await loadStreamIndex(projectPath);
   const result = await listStreams(projectPath);
   if (!result.ok) {
@@ -11647,7 +11980,7 @@ async function runListStreams(opts, globalOpts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runCreateStream(name, opts) {
-  const result = await createStream(path64.resolve(opts.path), name, opts.branch);
+  const result = await createStream(path65.resolve(opts.path), name, opts.branch);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -11656,7 +11989,7 @@ async function runCreateStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runArchiveStream(name, opts) {
-  const result = await archiveStream(path64.resolve(opts.path), name);
+  const result = await archiveStream(path65.resolve(opts.path), name);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -11665,7 +11998,7 @@ async function runArchiveStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runActivateStream(name, opts) {
-  const result = await setActiveStream(path64.resolve(opts.path), name);
+  const result = await setActiveStream(path65.resolve(opts.path), name);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -11674,7 +12007,7 @@ async function runActivateStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createStreamsCommand() {
-  const command = new Command101("streams").description("Manage state streams");
+  const command = new Command103("streams").description("Manage state streams");
   command.command("list").description("List all known streams").option("--path <path>", "Project root path", ".").action(async (opts, cmd) => runListStreams(opts, cmd.optsWithGlobals()));
   command.command("create <name>").description("Create a new stream").option("--path <path>", "Project root path", ".").option("--branch <branch>", "Associate with a git branch").action(async (name, opts) => runCreateStream(name, opts));
   command.command("archive <name>").description("Archive a stream").option("--path <path>", "Project root path", ".").action(async (name, opts) => runArchiveStream(name, opts));
@@ -11684,7 +12017,7 @@ function createStreamsCommand() {
 
 // src/commands/state/index.ts
 function createStateCommand() {
-  const command = new Command102("state").description("Project state management commands");
+  const command = new Command104("state").description("Project state management commands");
   command.addCommand(createShowCommand());
   command.addCommand(createResetCommand());
   command.addCommand(createLearnCommand());
@@ -11693,9 +12026,9 @@ function createStateCommand() {
 }
 
 // src/commands/sync-analyses.ts
-import * as fs44 from "fs";
-import * as path65 from "path";
-import { Command as Command103 } from "commander";
+import * as fs45 from "fs";
+import * as path66 from "path";
+import { Command as Command105 } from "commander";
 init_dist3();
 function isValidRecord(record) {
   return typeof record.issueId === "string" && !!record.issueId && typeof record.identifier === "string" && !!record.identifier && typeof record.analyzedAt === "string" && !/[/\\]/.test(record.issueId);
@@ -11721,7 +12054,7 @@ function extractAnalysisFromComments(comments) {
   return null;
 }
 function bootstrapTrackerCommand2(opts, verb) {
-  const projectPath = path65.resolve(opts.dir);
+  const projectPath = path66.resolve(opts.dir);
   const trackerConfig = loadTrackerSyncConfig(projectPath);
   if (!trackerConfig) {
     logger.error(`No tracker config found in harness.config.json. Cannot ${verb}.`);
@@ -11733,8 +12066,8 @@ function bootstrapTrackerCommand2(opts, verb) {
     );
     return null;
   }
-  const projectEnvPath = path65.join(projectPath, ".env");
-  if (fs44.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
+  const projectEnvPath = path66.join(projectPath, ".env");
+  if (fs45.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
     __require("dotenv").config({ path: projectEnvPath });
   }
   const token = process.env.GITHUB_TOKEN;
@@ -11764,13 +12097,13 @@ async function loadRoadmapFeatures(projectPath) {
     }
     return r.value.features.filter((f) => !!f.externalId).map((f) => ({ name: f.name, externalId: f.externalId }));
   }
-  const roadmapFile = path65.join(projectPath, "docs", "roadmap.md");
-  if (!fs44.existsSync(roadmapFile)) {
+  const roadmapFile = path66.join(projectPath, "docs", "roadmap.md");
+  if (!fs45.existsSync(roadmapFile)) {
     logger.error("No docs/roadmap.md found. Cannot discover features with externalIds.");
     return null;
   }
   const { parseRoadmap: parseRoadmap2 } = (init_dist3(), __toCommonJS(dist_exports));
-  const roadmapParsed = parseRoadmap2(fs44.readFileSync(roadmapFile, "utf-8"));
+  const roadmapParsed = parseRoadmap2(fs45.readFileSync(roadmapFile, "utf-8"));
   if (!roadmapParsed.ok) {
     logger.error("Failed to parse docs/roadmap.md");
     return null;
@@ -11821,9 +12154,9 @@ async function runSyncAnalyses(opts) {
     return;
   }
   const { AnalysisArchive, loadPublishedIndex: loadPublishedIndex2, savePublishedIndex: savePublishedIndex2 } = await import("@harness-engineering/orchestrator");
-  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-XIJWWQ5N.js");
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-JCFK263L.js");
   const adapter = new GitHubIssuesSyncAdapter2({ token, config: trackerConfig });
-  const archive = new AnalysisArchive(path65.join(projectPath, ".harness", "analyses"));
+  const archive = new AnalysisArchive(path66.join(projectPath, ".harness", "analyses"));
   const publishedIndex = loadPublishedIndex2(projectPath);
   const { syncedCount, skippedCount, warnCount } = await syncFeatureAnalyses(
     features,
@@ -11843,7 +12176,7 @@ async function runSyncAnalyses(opts) {
   }
 }
 function createSyncAnalysesCommand() {
-  const command = new Command103("sync-analyses").description(
+  const command = new Command105("sync-analyses").description(
     "Pull published intelligence analyses from the external issue tracker into the local .harness/analyses/ directory"
   ).option("-d, --dir <path>", "Workspace directory", process.cwd()).action(async (opts) => {
     try {
@@ -11857,8 +12190,8 @@ function createSyncAnalysesCommand() {
 }
 
 // src/commands/sync-main.ts
-import { Command as Command104 } from "commander";
-import * as path66 from "path";
+import { Command as Command106 } from "commander";
+import * as path67 from "path";
 import {
   syncMain as defaultSyncMain
 } from "@harness-engineering/orchestrator";
@@ -11888,8 +12221,8 @@ function formatHuman2(r) {
   }
 }
 function createSyncMainCommand() {
-  return new Command104("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 = path66.resolve(opts.path ?? ".");
+  return new Command106("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 = path67.resolve(opts.path ?? ".");
     const exitCode = await runSyncMain({ cwd, json: Boolean(opts.json) });
     process.exit(exitCode);
   });
@@ -11897,7 +12230,7 @@ function createSyncMainCommand() {
 
 // src/commands/taint.ts
 init_dist3();
-import { Command as Command105 } from "commander";
+import { Command as Command107 } from "commander";
 function getProjectRoot() {
   return process.cwd();
 }
@@ -11969,28 +12302,28 @@ function registerStatusCommand(taint) {
   });
 }
 function createTaintCommand() {
-  const taint = new Command105("taint").description("Manage sentinel session taint state");
+  const taint = new Command107("taint").description("Manage sentinel session taint state");
   registerClearCommand(taint);
   registerStatusCommand(taint);
   return taint;
 }
 
 // src/commands/telemetry/index.ts
-import { Command as Command109 } from "commander";
+import { Command as Command111 } from "commander";
 
 // src/commands/telemetry/identify.ts
 init_dist3();
-import { Command as Command106 } from "commander";
-import * as fs45 from "fs";
-import * as path67 from "path";
+import { Command as Command108 } from "commander";
+import * as fs46 from "fs";
+import * as path68 from "path";
 function telemetryFilePath(cwd) {
-  return path67.join(cwd, ".harness", "telemetry.json");
+  return path68.join(cwd, ".harness", "telemetry.json");
 }
 function writeTelemetryFile(cwd, data) {
   const filePath = telemetryFilePath(cwd);
-  const dir = path67.dirname(filePath);
-  fs45.mkdirSync(dir, { recursive: true });
-  fs45.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  const dir = path68.dirname(filePath);
+  fs46.mkdirSync(dir, { recursive: true });
+  fs46.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 var IDENTITY_FIELDS = ["project", "team", "alias"];
 function applyIdentityFields(opts, identity) {
@@ -12004,7 +12337,7 @@ function printIdentity(identity) {
   }
 }
 function createIdentifyCommand() {
-  const cmd = new Command106("identify").description("Set or clear telemetry identity fields in .harness/telemetry.json").option("--project <name>", "Project name").option("--team <name>", "Team name").option("--alias <name>", "User alias").option("--clear", "Remove all identity fields").action((opts) => {
+  const cmd = new Command108("identify").description("Set or clear telemetry identity fields in .harness/telemetry.json").option("--project <name>", "Project name").option("--team <name>", "Team name").option("--alias <name>", "User alias").option("--clear", "Remove all identity fields").action((opts) => {
     const cwd = process.cwd();
     if (opts.clear) {
       writeTelemetryFile(cwd, { identity: {} });
@@ -12029,7 +12362,7 @@ function createIdentifyCommand() {
 
 // src/commands/telemetry/status.ts
 init_dist3();
-import { Command as Command107 } from "commander";
+import { Command as Command109 } from "commander";
 function gatherEnvOverrides() {
   const overrides = {};
   if (process.env.DO_NOT_TRACK) overrides.DO_NOT_TRACK = process.env.DO_NOT_TRACK;
@@ -12071,7 +12404,7 @@ function printHumanStatus(result) {
   printEnvOverrides(result.envOverrides);
 }
 function createStatusCommand() {
-  const cmd = new Command107("status").description("Show current telemetry consent state, install ID, and identity").option("--json", "Output as JSON").action((opts) => {
+  const cmd = new Command109("status").description("Show current telemetry consent state, install ID, and identity").option("--json", "Output as JSON").action((opts) => {
     const cwd = process.cwd();
     const envOverrides = gatherEnvOverrides();
     const consent = resolveConsent(cwd, void 0);
@@ -12104,11 +12437,11 @@ function createStatusCommand() {
 
 // src/commands/telemetry/test.ts
 init_dist3();
-import { Command as Command108 } from "commander";
+import { Command as Command110 } from "commander";
 
 // src/bin/command-telemetry.ts
-import { existsSync as existsSync42, readFileSync as readFileSync32, mkdirSync as mkdirSync19, appendFileSync, writeFileSync as writeFileSync24 } from "fs";
-import { join as join56, parse as parsePath, resolve as resolve43 } from "path";
+import { existsSync as existsSync43, readFileSync as readFileSync33, mkdirSync as mkdirSync19, appendFileSync, writeFileSync as writeFileSync25 } from "fs";
+import { join as join57, parse as parsePath, resolve as resolve43 } from "path";
 import { spawn as spawn2 } from "child_process";
 var POSTHOG_API_KEY = "phc_wNTdCMcfJXZPgdNeDociZW6vwoGGo4nb7vqEfWThFfsG";
 var EXCLUDED_COMMANDS = /* @__PURE__ */ new Set(["help", "completion"]);
@@ -12116,7 +12449,7 @@ function findProjectRoot(cwd) {
   let dir = resolve43(cwd);
   const { root } = parsePath(dir);
   while (dir !== root) {
-    if (existsSync42(join56(dir, "harness.config.json"))) return dir;
+    if (existsSync43(join57(dir, "harness.config.json"))) return dir;
     dir = resolve43(dir, "..");
   }
   return cwd;
@@ -12154,7 +12487,7 @@ function resolveCommandName(cmd) {
 }
 function writeCommandRecordSync(cwd, command, duration, outcome) {
   try {
-    const metricsDir = join56(cwd, ".harness", "metrics");
+    const metricsDir = join57(cwd, ".harness", "metrics");
     mkdirSync19(metricsDir, { recursive: true });
     const record = {
       skill: command,
@@ -12164,16 +12497,16 @@ function writeCommandRecordSync(cwd, command, duration, outcome) {
       outcome,
       phasesReached: []
     };
-    const adoptionFile = join56(metricsDir, "adoption.jsonl");
+    const adoptionFile = join57(metricsDir, "adoption.jsonl");
     appendFileSync(adoptionFile, JSON.stringify(record) + "\n");
   } catch {
   }
 }
 function isTelemetryDisabledByConfig(cwd) {
-  const configPath = join56(cwd, "harness.config.json");
-  if (!existsSync42(configPath)) return false;
+  const configPath = join57(cwd, "harness.config.json");
+  if (!existsSync43(configPath)) return false;
   try {
-    const config = JSON.parse(readFileSync32(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync33(configPath, "utf-8"));
     return config?.telemetry?.enabled === false;
   } catch {
     return false;
@@ -12185,11 +12518,11 @@ function isTelemetryOptedOut(cwd) {
 }
 function flushTelemetryBackground(cwd) {
   try {
-    const adoptionFile = join56(cwd, ".harness", "metrics", "adoption.jsonl");
-    if (!existsSync42(adoptionFile)) return;
+    const adoptionFile = join57(cwd, ".harness", "metrics", "adoption.jsonl");
+    if (!existsSync43(adoptionFile)) return;
     if (isTelemetryOptedOut(cwd)) return;
-    const reporterPath = join56(cwd, ".harness", "hooks", "telemetry-reporter.js");
-    if (!existsSync42(reporterPath)) return;
+    const reporterPath = join57(cwd, ".harness", "hooks", "telemetry-reporter.js");
+    if (!existsSync43(reporterPath)) return;
     const child = spawn2(process.execPath, [reporterPath], {
       cwd,
       stdio: ["pipe", "ignore", "ignore"],
@@ -12226,7 +12559,7 @@ function reportTestSuccess(status, distinctId, identity) {
   if (identity.team) logger.info(`  team:        ${identity.team}`);
 }
 function createTestCommand() {
-  return new Command108("test").description("Send a test event to PostHog and verify connectivity").action(async () => {
+  return new Command110("test").description("Send a test event to PostHog and verify connectivity").action(async () => {
     const cwd = process.cwd();
     const consent = resolveConsent(cwd, void 0);
     if (!consent.allowed) {
@@ -12263,7 +12596,7 @@ function createTestCommand() {
 
 // src/commands/telemetry/index.ts
 function createTelemetryCommand() {
-  const command = new Command109("telemetry").description("Telemetry identity and status management");
+  const command = new Command111("telemetry").description("Telemetry identity and status management");
   command.addCommand(createIdentifyCommand());
   command.addCommand(createStatusCommand());
   command.addCommand(createTestCommand());
@@ -12271,9 +12604,9 @@ function createTelemetryCommand() {
 }
 
 // src/commands/test-craft.ts
-import { Command as Command110 } from "commander";
+import { Command as Command112 } from "commander";
 function createTestCraftCommand() {
-  return new Command110("test-craft").description(
+  return new Command112("test-craft").description(
     "LLM-judgment critique of test quality across vitest/jest/mocha/playwright. Fourth craft-pipeline ceiling skill. Per-test critique with best-effort source pairing."
   ).option("-f, --files <files...>", "Optional test file/glob scope").option("--frameworks <names...>", "Restrict to: vitest / jest / mocha / playwright").option("--max-files <n>", "Cap test file count (default: 100)").option("--max-tests-per-file <n>", "Cap per-file test critique (default: 20)").option("--no-source-pair", "Skip source-pairing resolution").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
@@ -12321,10 +12654,10 @@ function printResult7(result, mode, _formatter) {
       list.push(f);
       byFile.set(f.target.file, list);
     }
-    for (const [file, fs47] of byFile) {
+    for (const [file, fs48] of byFile) {
       console.log(`
 ${file}`);
-      for (const f of fs47) {
+      for (const f of fs48) {
         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}`
@@ -12343,8 +12676,8 @@ ${file}`);
 }
 
 // src/commands/traceability.ts
-import { Command as Command111 } from "commander";
-import chalk16 from "chalk";
+import { Command as Command113 } from "commander";
+import chalk17 from "chalk";
 function confidenceLabel(maxConfidence) {
   if (maxConfidence >= 0.8) return "explicit";
   if (maxConfidence > 0) return "inferred";
@@ -12353,13 +12686,13 @@ function confidenceLabel(maxConfidence) {
 function statusIcon(status) {
   switch (status) {
     case "full":
-      return chalk16.green("\u2713 full");
+      return chalk17.green("\u2713 full");
     case "code-only":
-      return chalk16.yellow("\u25D0 code-only");
+      return chalk17.yellow("\u25D0 code-only");
     case "test-only":
-      return chalk16.yellow("\u25D0 test-only");
+      return chalk17.yellow("\u25D0 test-only");
     case "none":
-      return chalk16.red("\u2717 none");
+      return chalk17.red("\u2717 none");
     default:
       return status;
   }
@@ -12406,14 +12739,14 @@ function handleEmptyResults(mode) {
 }
 function printResultTable(result, mode) {
   const specLabel = result.specPath || result.featureName || "Unknown";
-  console.log(`  ${chalk16.cyan(specLabel)} ${chalk16.dim(`(${result.summary.total} requirements)`)}`);
+  console.log(`  ${chalk17.cyan(specLabel)} ${chalk17.dim(`(${result.summary.total} requirements)`)}`);
   console.log("");
   const numWidth = 4;
   const nameWidth = mode === OutputMode.VERBOSE ? 44 : 36;
   const codeWidth = 6;
   const testWidth = 7;
   const confWidth = 12;
-  const header = chalk16.dim(
+  const header = chalk17.dim(
     `  ${pad("#", numWidth)}${pad("Requirement", nameWidth)}${pad("Code", codeWidth)}${pad("Tests", testWidth)}${pad("Confidence", confWidth)}Status`
   );
   console.log(header);
@@ -12442,10 +12775,10 @@ function printRequirementRows(requirements, mode, cols) {
     );
     if (mode === OutputMode.VERBOSE) {
       for (const f of req.codeFiles) {
-        console.log(chalk16.dim(`        code: ${f.path} (${f.method})`));
+        console.log(chalk17.dim(`        code: ${f.path} (${f.method})`));
       }
       for (const f of req.testFiles) {
-        console.log(chalk16.dim(`        test: ${f.path} (${f.method})`));
+        console.log(chalk17.dim(`        test: ${f.path} (${f.method})`));
       }
     }
   }
@@ -12456,7 +12789,7 @@ function printCoverageSummary(summary) {
   const codePct = s.total > 0 ? Math.round(s.withCode / s.total * 100) : 0;
   const testPct = s.total > 0 ? Math.round(s.withTests / s.total * 100) : 0;
   console.log(
-    `  ${chalk16.bold("Coverage:")} ${fullyPct}% fully traced (${s.fullyTraced}/${s.total}), ${codePct}% with code (${s.withCode}/${s.total}), ${testPct}% with tests (${s.withTests}/${s.total})`
+    `  ${chalk17.bold("Coverage:")} ${fullyPct}% fully traced (${s.fullyTraced}/${s.total}), ${codePct}% with code (${s.withCode}/${s.total}), ${testPct}% with tests (${s.withTests}/${s.total})`
   );
 }
 async function runTraceability(options) {
@@ -12464,7 +12797,7 @@ async function runTraceability(options) {
   const projectPath = process.cwd();
   const store = await loadGraphStore(projectPath);
   if (!store) handleNoStore(mode);
-  const graphModule = await import("./dist-R3TOOPJ7.js");
+  const graphModule = await import("./dist-OWHMNL4W.js");
   const filterOptions = buildFilterOptions(options);
   const results = graphModule.queryTraceability(store, filterOptions);
   if (results.length === 0) handleEmptyResults(mode);
@@ -12472,14 +12805,14 @@ async function runTraceability(options) {
     console.log(JSON.stringify(results, null, 2));
   } else {
     console.log("");
-    console.log(chalk16.bold("Spec-to-Implementation Traceability"));
+    console.log(chalk17.bold("Spec-to-Implementation Traceability"));
     console.log("");
     for (const result of results) printResultTable(result, mode);
   }
   process.exit(ExitCode.SUCCESS);
 }
 function createTraceabilityCommand() {
-  return new Command111("traceability").description("Show spec-to-implementation traceability from the knowledge graph").option("--spec <path>", "Filter by spec file path").option("--feature <name>", "Filter by feature name").action(async (opts, cmd) => {
+  return new Command113("traceability").description("Show spec-to-implementation traceability from the knowledge graph").option("--spec <path>", "Filter by spec file path").option("--feature <name>", "Filter by feature name").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     await runTraceability({
       spec: opts.spec,
@@ -12492,15 +12825,15 @@ function createTraceabilityCommand() {
 }
 
 // src/commands/uninstall.ts
-import * as path68 from "path";
-import { Command as Command112 } from "commander";
+import * as path69 from "path";
+import { Command as Command114 } from "commander";
 async function runUninstall(skillName, options) {
   const packageName = resolvePackageName(skillName);
   const shortName = extractSkillName(packageName);
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path68.dirname(globalDir);
-  const communityBase = path68.join(skillsDir, "community");
-  const lockfilePath = path68.join(communityBase, "skills-lock.json");
+  const skillsDir = path69.dirname(globalDir);
+  const communityBase = path69.join(skillsDir, "community");
+  const lockfilePath = path69.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const entry = lockfile.skills[packageName];
   if (!entry) {
@@ -12530,7 +12863,7 @@ async function runUninstall(skillName, options) {
   return result;
 }
 function createUninstallCommand() {
-  const cmd = new Command112("uninstall");
+  const cmd = new Command114("uninstall");
   cmd.description("Uninstall a community skill").argument("<skill>", "Skill name or @harness-skills/scoped package name").option("--force", "Remove even if other skills depend on this one").action(async (skill, opts) => {
     try {
       const result = await runUninstall(skill, opts);
@@ -12550,9 +12883,9 @@ function createUninstallCommand() {
 
 // src/commands/uninstall-constraints.ts
 init_dist3();
-import * as fs46 from "fs/promises";
-import * as path69 from "path";
-import { Command as Command113 } from "commander";
+import * as fs47 from "fs/promises";
+import * as path70 from "path";
+import { Command as Command115 } from "commander";
 async function runUninstallConstraints(options) {
   const { packageName, configPath, lockfilePath } = options;
   const lockfileResult = await readLockfile(lockfilePath);
@@ -12572,7 +12905,7 @@ async function runUninstallConstraints(options) {
   }
   let localConfig;
   try {
-    const raw = await fs46.readFile(configPath, "utf-8");
+    const raw = await fs47.readFile(configPath, "utf-8");
     localConfig = JSON.parse(raw);
   } catch (err) {
     return {
@@ -12609,11 +12942,11 @@ async function runUninstallConstraints(options) {
   };
 }
 function createUninstallConstraintsCommand() {
-  const cmd = new Command113("uninstall-constraints");
+  const cmd = new Command115("uninstall-constraints");
   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 = path69.resolve(opts.config);
+      configPath = path70.resolve(opts.config);
     } else {
       const found = findConfigFile();
       if (!found.ok) {
@@ -12622,8 +12955,8 @@ function createUninstallConstraintsCommand() {
       }
       configPath = found.value;
     }
-    const projectRoot2 = path69.dirname(configPath);
-    const lockfilePath = path69.join(projectRoot2, ".harness", "constraints.lock.json");
+    const projectRoot2 = path70.dirname(configPath);
+    const lockfilePath = path70.join(projectRoot2, ".harness", "constraints.lock.json");
     const result = await runUninstallConstraints({
       packageName: name,
       configPath,
@@ -12649,13 +12982,13 @@ function createUninstallConstraintsCommand() {
 
 // src/commands/update.ts
 init_dist3();
-import { Command as Command114 } from "commander";
+import { Command as Command116 } from "commander";
 import { execFile, execFileSync as execFileSync7 } from "child_process";
-import { realpathSync, existsSync as existsSync43, readFileSync as readFileSync33 } from "fs";
-import { dirname as dirname22, join as join59 } from "path";
+import { realpathSync, existsSync as existsSync44, readFileSync as readFileSync34 } from "fs";
+import { dirname as dirname23, join as join60 } from "path";
 import { promisify } from "util";
 import readline4 from "readline";
-import chalk17 from "chalk";
+import chalk18 from "chalk";
 var CLI_PACKAGE = "@harness-engineering/cli";
 function detectPackageManagerFromPath(resolvedPath) {
   const normalizedBin = resolvedPath.replace(/\\/g, "/");
@@ -12741,16 +13074,16 @@ function prompt3(question) {
   });
 }
 function findPackageDir(resolvedBin) {
-  let dir = dirname22(resolvedBin);
+  let dir = dirname23(resolvedBin);
   for (let i = 0; i < 6; i++) {
-    if (existsSync43(join59(dir, "package.json"))) {
+    if (existsSync44(join60(dir, "package.json"))) {
       try {
-        const pkg = JSON.parse(readFileSync33(join59(dir, "package.json"), "utf-8"));
+        const pkg = JSON.parse(readFileSync34(join60(dir, "package.json"), "utf-8"));
         if (pkg?.name === CLI_PACKAGE) return dir;
       } catch {
       }
     }
-    const parent = dirname22(dir);
+    const parent = dirname23(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -12790,7 +13123,7 @@ function findAllInstalls() {
     if (!packageDir) continue;
     let version = null;
     try {
-      const pkg = JSON.parse(readFileSync33(join59(packageDir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync34(join60(packageDir, "package.json"), "utf-8"));
       if (typeof pkg?.version === "string") version = pkg.version;
     } catch {
     }
@@ -12824,7 +13157,7 @@ async function offerCleanupOfOtherInstalls(activeDir) {
     `Found ${installs.length} harness installs on PATH. Only the active one was updated.`
   );
   for (const install of installs) {
-    const tag = install.packageDir === activeDir ? chalk17.green(" (active, just updated)") : chalk17.yellow(" (stale)");
+    const tag = install.packageDir === activeDir ? chalk18.green(" (active, just updated)") : chalk18.yellow(" (stale)");
     const versionStr = install.version ? `v${install.version}` : "unknown";
     console.log(`  ${install.binPath} -> ${versionStr}${tag}`);
   }
@@ -12832,7 +13165,7 @@ async function offerCleanupOfOtherInstalls(activeDir) {
   const commands = others.map((install) => buildUninstallCommand(install));
   console.log("Cleanup commands:");
   for (const { display } of commands) {
-    console.log(`  ${chalk17.cyan(display)}`);
+    console.log(`  ${chalk18.cyan(display)}`);
   }
   console.log("");
   const answer = await prompt3(`Run these now to remove stale installs? (y/N) `);
@@ -12840,7 +13173,7 @@ async function offerCleanupOfOtherInstalls(activeDir) {
   for (const cmd of commands) {
     if (!cmd.runnable) {
       logger.warn(`Skipped ${cmd.install.binPath} (no automatic uninstall for this layout).`);
-      console.log(`  Run manually: ${chalk17.cyan(cmd.display)}`);
+      console.log(`  Run manually: ${chalk18.cyan(cmd.display)}`);
       continue;
     }
     try {
@@ -12848,7 +13181,7 @@ async function offerCleanupOfOtherInstalls(activeDir) {
       execFileSync7(cmd.bin, cmd.args, { stdio: "inherit", timeout: 12e4 });
     } catch {
       logger.warn(`Uninstall failed for ${cmd.install.binPath}.`);
-      console.log(`  Run manually: ${chalk17.cyan(cmd.display)}`);
+      console.log(`  Run manually: ${chalk18.cyan(cmd.display)}`);
     }
   }
 }
@@ -12883,12 +13216,12 @@ async function ensureTelemetryIfNeeded() {
 }
 function refreshHooks() {
   const cwd = process.cwd();
-  const configPath = join59(cwd, "harness.config.json");
-  if (!existsSync43(configPath)) return;
+  const configPath = join60(cwd, "harness.config.json");
+  if (!existsSync44(configPath)) return;
   let profile = "standard";
-  const profilePath = join59(cwd, ".harness", "hooks", "profile.json");
+  const profilePath = join60(cwd, ".harness", "hooks", "profile.json");
   try {
-    const data = JSON.parse(readFileSync33(profilePath, "utf-8"));
+    const data = JSON.parse(readFileSync34(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
       profile = data.profile;
     }
@@ -12908,7 +13241,7 @@ function runLocalGraphScan() {
     execFileSync7("harness", ["graph", "scan", "."], { stdio: "inherit" });
   } catch {
     logger.warn("Graph scan failed. Run manually:");
-    console.log(`  ${chalk17.cyan("harness graph scan .")}`);
+    console.log(`  ${chalk18.cyan("harness graph scan .")}`);
   }
 }
 async function offerRegeneration() {
@@ -12925,7 +13258,7 @@ async function offerRegeneration() {
     });
   } catch {
     logger.warn("Generation failed. Run manually:");
-    console.log(`  ${chalk17.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
+    console.log(`  ${chalk18.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
   }
   if (!isGlobal) {
     runLocalGraphScan();
@@ -12989,8 +13322,8 @@ async function runUpdateAction(opts, globalOpts) {
     console.log("");
     for (const { pkg, current, latest } of outdated) {
       const shortName = pkg.replace("@harness-engineering/", "");
-      const currentStr = current ? chalk17.dim(`v${current}`) : chalk17.dim("not installed");
-      logger.info(`${shortName}: ${currentStr} \u2192 ${chalk17.green(`v${latest}`)}`);
+      const currentStr = current ? chalk18.dim(`v${current}`) : chalk18.dim("not installed");
+      logger.info(`${shortName}: ${currentStr} \u2192 ${chalk18.green(`v${latest}`)}`);
     }
     console.log("");
   }
@@ -13007,7 +13340,7 @@ async function runUpdateAction(opts, globalOpts) {
   } catch {
     console.log("");
     logger.error("Update failed. You can try manually:");
-    console.log(`  ${chalk17.cyan(installCmd)}`);
+    console.log(`  ${chalk18.cyan(installCmd)}`);
     process.exit(ExitCode.ERROR);
   }
   refreshHooks();
@@ -13017,7 +13350,7 @@ async function runUpdateAction(opts, globalOpts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createUpdateCommand() {
-  return new Command114("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").option("--force", "Force update even if versions match").option(
+  return new Command116("update").description("Update all @harness-engineering packages to the latest version").option("--version <semver>", "Pin @harness-engineering/cli to a specific version").option("--force", "Force update even if versions match").option(
     "--regenerate",
     "Only regenerate slash commands and agent definitions (skip package updates)"
   ).action(async (opts, cmd) => {
@@ -13027,9 +13360,9 @@ function createUpdateCommand() {
 }
 
 // src/commands/usage.ts
-import { Command as Command115 } from "commander";
+import { Command as Command117 } from "commander";
 async function loadAndPriceRecords(cwd, includeClaudeSessions = false) {
-  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-XIJWWQ5N.js");
+  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-JCFK263L.js");
   const records = readCostRecords(cwd);
   if (includeClaudeSessions) {
     const ccRecords = parseCCRecords();
@@ -13122,7 +13455,7 @@ function registerDailyCommand(usage) {
       else logger.info("No usage data found. Run some harness sessions first.");
       return;
     }
-    const { aggregateByDay } = await import("./dist-XIJWWQ5N.js");
+    const { aggregateByDay } = await import("./dist-JCFK263L.js");
     const limited = aggregateByDay(records).slice(0, days);
     if (globalOpts.json) {
       console.log(
@@ -13151,7 +13484,7 @@ function registerSessionsCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-XIJWWQ5N.js");
+    const { aggregateBySession } = await import("./dist-JCFK263L.js");
     const sessionData = aggregateBySession(records);
     const limited = sessionData.slice(0, limit);
     if (globalOpts.json) {
@@ -13231,7 +13564,7 @@ function registerSessionCommand(usage) {
       cwd,
       globalOpts.includeClaudeSessions
     );
-    const { aggregateBySession } = await import("./dist-XIJWWQ5N.js");
+    const { aggregateBySession } = await import("./dist-JCFK263L.js");
     const sessionData = aggregateBySession(records);
     const match = sessionData.find((s) => s.sessionId === id);
     if (!match) {
@@ -13266,7 +13599,7 @@ function registerLatestCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-XIJWWQ5N.js");
+    const { aggregateBySession } = await import("./dist-JCFK263L.js");
     const sessionData = aggregateBySession(records);
     const latest = sessionData[0];
     if (!latest) {
@@ -13292,7 +13625,7 @@ function registerLatestCommand(usage) {
   });
 }
 function createUsageCommand() {
-  const usage = new Command115("usage").description("Token usage and cost tracking");
+  const usage = new Command117("usage").description("Token usage and cost tracking");
   usage.option(
     "--include-claude-sessions",
     "Include Claude Code session data from ~/.claude/projects/"
@@ -13307,15 +13640,15 @@ function createUsageCommand() {
 // src/commands/validate.ts
 init_dist3();
 init_dist3();
-import { Command as Command116 } from "commander";
-import * as path70 from "path";
+import { Command as Command118 } from "commander";
+import * as path71 from "path";
 async function runValidate(options) {
   const configResult = resolveConfig(options.configPath);
   if (!configResult.ok) {
     return configResult;
   }
   const config = configResult.value;
-  const cwd = options.cwd ?? (options.configPath ? path70.dirname(path70.resolve(options.configPath)) : process.cwd());
+  const cwd = options.cwd ?? (options.configPath ? path71.dirname(path71.resolve(options.configPath)) : process.cwd());
   const result = {
     valid: true,
     checks: {
@@ -13325,7 +13658,7 @@ async function runValidate(options) {
     },
     issues: []
   };
-  const agentsMapPath = path70.resolve(cwd, config.agentsMapPath);
+  const agentsMapPath = path71.resolve(cwd, config.agentsMapPath);
   const agentsResult = await validateAgentsMap(agentsMapPath);
   if (agentsResult.ok) {
     result.checks.agentsMap = true;
@@ -13376,6 +13709,22 @@ async function runValidate(options) {
       }
     });
   }
+  const strategyResult = await validateStrategy(cwd);
+  if (strategyResult.ok) {
+    result.checks.strategyConfig = true;
+  } else {
+    result.valid = false;
+    result.checks.strategyConfig = false;
+    result.issues.push({
+      check: "strategyConfig",
+      file: "STRATEGY.md",
+      severity: "error",
+      message: strategyResult.error.message,
+      ...strategyResult.error.suggestions?.[0] !== void 0 && {
+        suggestion: strategyResult.error.suggestions[0]
+      }
+    });
+  }
   const solutionsResult = await validateSolutionsDir(cwd);
   if (solutionsResult.ok) {
     result.checks.solutionsDir = true;
@@ -13531,11 +13880,11 @@ function resolveValidateMode(globalOpts) {
   return OutputMode.TEXT;
 }
 async function printCrossCheckWarnings(mode) {
-  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-SNE3SQOB.js");
+  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-F7GEBRDH.js");
   const cwd = process.cwd();
   const crossResult = await runCrossCheck2({
-    specsDir: path70.join(cwd, "docs", "specs"),
-    plansDir: path70.join(cwd, "docs", "plans"),
+    specsDir: path71.join(cwd, "docs", "specs"),
+    plansDir: path71.join(cwd, "docs", "plans"),
     projectPath: cwd
   });
   if (!crossResult.ok || crossResult.value.warnings === 0) return;
@@ -13547,7 +13896,7 @@ async function printCrossCheckWarnings(mode) {
   ${crossResult.value.warnings} warnings`);
 }
 function createValidateCommand3() {
-  const command = new Command116("validate").description("Run all validation checks").option("--cross-check", "Run cross-artifact consistency validation").option(
+  const command = new Command118("validate").description("Run all validation checks").option("--cross-check", "Run cross-artifact consistency validation").option(
     "--agent-configs",
     "Validate agent configs (CLAUDE.md, hooks, skills) via agnix or built-in fallback rules"
   ).option("--strict", "Treat warnings as errors (applies to --agent-configs)").option("--agnix-bin <path>", "Override the agnix binary path discovered on PATH").action(async (opts, cmd) => runValidateAction(opts, cmd.optsWithGlobals()));
@@ -13596,7 +13945,7 @@ Agent configs checked via ${engineLabel}${note}`);
 
 // src/commands/verify.ts
 init_dist3();
-import { Command as Command117 } from "commander";
+import { Command as Command119 } from "commander";
 import { execSync as execSync6 } from "child_process";
 function loadBranchingConfig(configPath) {
   const shouldLoad = configPath !== void 0 || findConfigFile().ok;
@@ -13659,7 +14008,7 @@ async function runVerify(options) {
   process.exit(ExitCode.VALIDATION_FAILED);
 }
 function createVerifyCommand() {
-  return new Command117("verify").description(
+  return new Command119("verify").description(
     "Verify project conventions (currently: branch naming). Works with or without a harness.config.json."
   ).option(
     "--branch <name>",
@@ -13722,6 +14071,7 @@ var commandCreators = [
   createMcpCommand,
   createMcpGuardCommand,
   createMigrateCommand,
+  createModelsCommand,
   createNamingCraftCommand,
   createNotificationsCommand,
   createOrchestratorCommand,
@@ -13762,7 +14112,7 @@ var commandCreators = [
 
 // src/index.ts
 function createProgram() {
-  const program = new Command118();
+  const program = new Command120();
   program.name("harness").description("CLI for Harness Engineering toolkit").version(CLI_VERSION).option("-c, --config <path>", "Path to config file").option("--json", "Output as JSON").option("--verbose", "Verbose output").option("--quiet", "Minimal output");
   for (const creator of commandCreators) {
     program.addCommand(creator());