@harness-engineering/cli 4.0.0 → 4.1.0

package/dist/{chunk-6YXCZV33.js → chunk-ABRYIEWJ.js}

@@ -1,32 +1,32 @@
 import {
   generateRuntime
-} from "./chunk-S2RQPPL6.js";
+} from "./chunk-N4AI2WFH.js";
 import {
   generateAgentsMd
-} from "./chunk-IYWT3JJW.js";
+} from "./chunk-VG4G3R2V.js";
 import {
   generateCIWorkflow
-} from "./chunk-VTU3QOJT.js";
+} from "./chunk-P4NA5OQX.js";
 import {
   readHarnessState
-} from "./chunk-SPE7P4GL.js";
+} from "./chunk-YWRPQZL7.js";
 import {
   runCrossCheck
-} from "./chunk-VTUINXWR.js";
+} from "./chunk-GSYBGOY3.js";
 import {
   createGenerateAgentDefinitionsCommand,
   generateAgentDefinitions
-} from "./chunk-MYVTYFQD.js";
+} from "./chunk-XZNCONFG.js";
 import {
   toKebabCase
 } from "./chunk-KET4QQZB.js";
 import {
   createScanCommand,
   loadIngestOptions
-} from "./chunk-2N4OENGE.js";
+} from "./chunk-YYFSFSB3.js";
 import {
   TemplateEngine
-} from "./chunk-FZ4Q73HA.js";
+} from "./chunk-IGWJRAJT.js";
 import {
   generate,
   validate
@@ -37,7 +37,7 @@ import {
 import {
   listPersonas,
   loadPersona
-} from "./chunk-HXMAIVV2.js";
+} from "./chunk-NCMJXBEO.js";
 import {
   runPersona
 } from "./chunk-GISMXMVL.js";
@@ -51,7 +51,7 @@ import {
   OutputFormatter,
   OutputMode,
   createCheckPhaseGateCommand
-} from "./chunk-PHX45JYN.js";
+} from "./chunk-XW5XVVMI.js";
 import {
   appendFrameworkAgents,
   captureHealthSnapshot,
@@ -79,13 +79,13 @@ import {
   runSecurityCraft,
   runSpecCraft,
   runTestCraft
-} from "./chunk-ERILXQBP.js";
+} from "./chunk-Z4XWWNYX.js";
 import {
   VALID_PLATFORMS
 } from "./chunk-3ISINLYT.js";
 import {
   loadGraphStore
-} from "./chunk-CLI4K2CH.js";
+} from "./chunk-4U5LDFCY.js";
 import {
   loadOrRebuildIndex
 } from "./chunk-WBVCN35T.js";
@@ -108,7 +108,7 @@ import {
   BranchingConfigSchema,
   findConfigFile,
   resolveConfig
-} from "./chunk-XFHZ7GCI.js";
+} from "./chunk-Y5HPJMTM.js";
 import {
   logger
 } from "./chunk-EBJQ6N4M.js";
@@ -188,6 +188,7 @@ import {
   parseDiff,
   parseFileRegions,
   parseManifest,
+  parseReferencedIssues,
   parseRoadmap,
   parseSecurityConfig,
   pruneLearnings,
@@ -224,7 +225,7 @@ import {
   writeConfig,
   writeLockfile,
   writeRegeneratedRoadmap
-} from "./chunk-KLPX55TI.js";
+} from "./chunk-UACYZCW4.js";
 import {
   CLI_VERSION
 } from "./chunk-BM3PWGXQ.js";
@@ -237,7 +238,7 @@ import {
   detectDocDrift,
   generateSuggestions,
   validateDependencies
-} from "./chunk-N55WOGN3.js";
+} from "./chunk-YJYUJSWK.js";
 import {
   Err,
   INDEXED_FILE_KINDS,
@@ -250,7 +251,7 @@ import {
   DesignConstraintAdapter,
   GraphStore,
   init_dist as init_dist2
-} from "./chunk-PP6ZRL5T.js";
+} from "./chunk-WZJR6SOI.js";
 import {
   ArchConfigSchema,
   TimelineManager
@@ -261,7 +262,7 @@ import {
 } from "./chunk-KFQGP6VL.js";
 
 // src/index.ts
-import { Command as Command128 } from "commander";
+import { Command as Command130 } from "commander";
 
 // src/commands/add.ts
 init_dist3();
@@ -450,7 +451,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-IPVFYGY2.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-MCTEX5QH.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -486,7 +487,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-IPVFYGY2.js");
+    const { readAdoptionRecords } = await import("./dist-MCTEX5QH.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -564,7 +565,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-IPVFYGY2.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-MCTEX5QH.js");
     const records = readAdoptionRecords(cwd);
     const skillRecords = records.filter((r) => r.skill === name);
     if (skillRecords.length === 0) {
@@ -1995,10 +1996,24 @@ function createCheckHarnessStrengthCommand() {
 init_dist3();
 import { Command as Command15 } from "commander";
 import * as path9 from "path";
+function resolveConfiguredEntryPoints(configPath) {
+  const configResult = resolveConfig(configPath);
+  if (!configResult.ok) return void 0;
+  const config = configResult.value;
+  const fromPerformance = config.performance?.entryPoints;
+  if (Array.isArray(fromPerformance) && fromPerformance.length > 0) {
+    return fromPerformance.filter((e) => typeof e === "string");
+  }
+  const fromEntropy = config.entropy?.entryPoints;
+  if (Array.isArray(fromEntropy) && fromEntropy.length > 0) return fromEntropy;
+  return void 0;
+}
 async function runCheckPerf(cwd, options) {
   const runAll2 = !options.structural && !options.size && !options.coupling;
+  const entryPoints = resolveConfiguredEntryPoints(options.configPath);
   const analyzer = new EntropyAnalyzer({
     rootDir: path9.resolve(cwd),
+    ...entryPoints && { entryPoints },
     analyze: {
       complexity: runAll2 || !!options.structural,
       coupling: runAll2 || !!options.coupling,
@@ -2682,12 +2697,14 @@ async function runCleanup(options) {
   };
   const rootDir = path12.resolve(cwd, config.rootDir);
   const docsDir = path12.resolve(cwd, config.docsDir);
+  const driftEnabled = type === "all" || type === "drift";
+  const driftConfig = config.entropy?.drift;
   const entropyConfig = {
     rootDir,
     ...config.entropy?.entryPoints && { entryPoints: config.entropy.entryPoints },
     docPaths: [path12.join(docsDir, "**/*.md")],
     analyze: {
-      drift: type === "all" || type === "drift",
+      drift: driftEnabled ? driftConfig ?? true : false,
       deadCode: type === "all" || type === "dead-code",
       patterns: type === "all" || type === "patterns" ? { patterns: [] } : false
     },
@@ -4331,8 +4348,7 @@ function promptYesNo(message) {
     });
   });
 }
-function createDeliveriesCommand() {
-  const cmd = new Command32("deliveries").description("Inspect and manage webhook delivery queue");
+function registerListCommand(cmd) {
   cmd.command("list").description("List delivery queue entries (newest first; capped at 200 rows)").option("--status <status>", "Filter by status: pending|failed|delivered|dead").option("--subscription <id>", "Filter by subscription ID").action((opts) => {
     const queue = getQueue();
     try {
@@ -4345,6 +4361,8 @@ function createDeliveriesCommand() {
       queue.close();
     }
   });
+}
+function registerRetryCommand(cmd) {
   cmd.command("retry <id>").description("Re-enqueue a dead-lettered delivery by ID").action((id) => {
     const queue = getQueue();
     try {
@@ -4359,23 +4377,30 @@ function createDeliveriesCommand() {
       queue.close();
     }
   });
+}
+function buildPurgeOptions(opts) {
+  const purgeOpts = {};
+  if (opts.deadOnly) purgeOpts.deadOnly = true;
+  if (opts.olderThan !== void 0) purgeOpts.olderThanMs = Number(opts.olderThan);
+  if (opts.all) purgeOpts.all = true;
+  return purgeOpts;
+}
+function ttyPurgeConfirm(count) {
+  if (count === 0) {
+    console.log("No matching rows to delete.");
+    return false;
+  }
+  return promptYesNo(`Delete ${count} row(s)? [y/N] `);
+}
+function registerPurgeCommand(cmd) {
   cmd.command("purge").description("Delete delivery rows from the queue (requires at least one filter)").option("--dead-only", "Delete only dead-lettered rows").option("--older-than <ms>", "Delete delivered rows older than N milliseconds").option("--all", "Delete every row in the queue (use with caution)").action(async (opts) => {
     const queue = getQueue();
     try {
-      const purgeOpts = {};
-      if (opts.deadOnly) purgeOpts.deadOnly = true;
-      if (opts.olderThan !== void 0) purgeOpts.olderThanMs = Number(opts.olderThan);
-      if (opts.all) purgeOpts.all = true;
+      const purgeOpts = buildPurgeOptions(opts);
       const isTty = Boolean(process.stdout.isTTY);
       const runOpts = {};
       if (isTty) {
-        runOpts.confirm = (count) => {
-          if (count === 0) {
-            console.log("No matching rows to delete.");
-            return false;
-          }
-          return promptYesNo(`Delete ${count} row(s)? [y/N] `);
-        };
+        runOpts.confirm = ttyPurgeConfirm;
       }
       const result = await runDeliveriesPurge(queue, purgeOpts, runOpts);
       if (result === -1) {
@@ -4387,6 +4412,12 @@ function createDeliveriesCommand() {
       queue.close();
     }
   });
+}
+function createDeliveriesCommand() {
+  const cmd = new Command32("deliveries").description("Inspect and manage webhook delivery queue");
+  registerListCommand(cmd);
+  registerRetryCommand(cmd);
+  registerPurgeCommand(cmd);
   return cmd;
 }
 
@@ -4483,16 +4514,16 @@ async function readConnectorSyncStatus(graphDir) {
   return result;
 }
 async function runGraphStatus(projectPath) {
-  const { GraphStore: GraphStore2, loadGraphMetadata } = await import("./dist-OWHMNL4W.js");
+  const { GraphStore: GraphStore2, loadGraphMetadata } = await import("./dist-DWBTZXR5.js");
   const graphDir = path18.join(projectPath, ".harness", "graph");
   const metaResult = await loadGraphMetadata(graphDir);
   if (metaResult.status === "not_found") {
-    return { status: "no_graph", message: "No graph found. Run `harness scan` first." };
+    return { status: "no_graph", message: "No graph found. Run `harness graph scan` first." };
   }
   if (metaResult.status === "schema_mismatch") {
     return {
       status: "schema_mismatch",
-      message: `Graph schema version mismatch: file is v${metaResult.found}, CLI expects v${metaResult.expected}. Run \`harness scan\` to rebuild.`
+      message: `Graph schema version mismatch: file is v${metaResult.found}, CLI expects v${metaResult.expected}. Run \`harness graph scan\` to rebuild.`
     };
   }
   const meta = metaResult.metadata;
@@ -4535,11 +4566,11 @@ async function runGraphStatus(projectPath) {
 // src/commands/graph/export.ts
 import * as path19 from "path";
 async function runGraphExport(projectPath, format) {
-  const { GraphStore: GraphStore2 } = await import("./dist-OWHMNL4W.js");
+  const { GraphStore: GraphStore2 } = await import("./dist-DWBTZXR5.js");
   const graphDir = path19.join(projectPath, ".harness", "graph");
   const store = new GraphStore2();
   const loaded = await store.load(graphDir);
-  if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
+  if (!loaded) throw new Error("No graph found. Run `harness graph scan` first.");
   if (format === "json") {
     const nodes = store.findNodes({});
     const edges = store.getEdges({});
@@ -4568,11 +4599,11 @@ async function runGraphExport(projectPath, format) {
 import { Command as Command35 } from "commander";
 import * as path20 from "path";
 async function runQuery(projectPath, rootNodeId, opts) {
-  const { GraphStore: GraphStore2, ContextQL } = await import("./dist-OWHMNL4W.js");
+  const { GraphStore: GraphStore2, ContextQL } = await import("./dist-DWBTZXR5.js");
   const store = new GraphStore2();
   const graphDir = path20.join(projectPath, ".harness", "graph");
   const loaded = await store.load(graphDir);
-  if (!loaded) throw new Error("No graph found. Run `harness scan` first.");
+  if (!loaded) throw new Error("No graph found. Run `harness graph scan` first.");
   const params = {
     rootNodeIds: [rootNodeId],
     maxDepth: opts.depth ?? 3,
@@ -4673,7 +4704,7 @@ async function runIngest(projectPath, source, opts) {
     ConfluenceConnector,
     FigmaConnector,
     MiroConnector
-  } = await import("./dist-OWHMNL4W.js");
+  } = await import("./dist-DWBTZXR5.js");
   const graphDir = path21.join(projectPath, ".harness", "graph");
   const store = new GraphStore2();
   await store.load(graphDir);
@@ -4689,7 +4720,7 @@ async function runIngest(projectPath, source, opts) {
       path21.join(projectPath, "docs", "changes")
     );
     const gitResult = await new GitIngestor(store).ingest(projectPath);
-    const { createExtractionRunner } = await import("./dist-OWHMNL4W.js");
+    const { createExtractionRunner } = await import("./dist-DWBTZXR5.js");
     const extractedDir = path21.join(projectPath, ".harness", "knowledge", "extracted");
     const signalsResult = await createExtractionRunner().run(projectPath, store, extractedDir);
     const syncManager = new SyncManager(store, graphDir);
@@ -4739,7 +4770,7 @@ async function runIngest(projectPath, source, opts) {
       );
       break;
     case "business-signals": {
-      const { createExtractionRunner } = await import("./dist-OWHMNL4W.js");
+      const { createExtractionRunner } = await import("./dist-DWBTZXR5.js");
       const extractedDir = path21.join(projectPath, ".harness", "knowledge", "extracted");
       result = await createExtractionRunner().run(projectPath, store, extractedDir);
       break;
@@ -5451,7 +5482,7 @@ async function runImpactPreview(options) {
   const stagedFiles = getStagedFiles(projectPath);
   if (stagedFiles.length === 0) return "Impact Preview: no staged changes";
   if (!graphExists(projectPath)) {
-    return "Impact Preview: skipped (no graph \u2014 run `harness scan` to enable)";
+    return "Impact Preview: skipped (no graph \u2014 run `harness graph scan` to enable)";
   }
   const mode = options.detailed ? "detailed" : "summary";
   const acc = {
@@ -6131,7 +6162,7 @@ function createInsightsCommand() {
   return new Command46("insights").description("Composite project report \u2014 health, entropy, decay, attention, impact.").option("--json", "Emit JSON to stdout instead of pretty text").option("--skip <list>", `Comma-separated keys to skip (${INSIGHTS_KEYS.join(",")})`).action(async (opts) => {
     const cwd = process.cwd();
     const skip = parseSkip2(opts.skip);
-    const { composeInsights } = await import("./dist-IPVFYGY2.js");
+    const { composeInsights } = await import("./dist-MCTEX5QH.js");
     const report = await composeInsights(cwd, { skip });
     if (opts.json) {
       console.log(JSON.stringify(report, null, 2));
@@ -7323,6 +7354,166 @@ ${file}`);
 import { Command as Command55 } from "commander";
 import * as path41 from "path";
 import chalk7 from "chalk";
+function resolveInferenceOptions(cfgKnowledge) {
+  const patterns = cfgKnowledge?.domainPatterns;
+  const blocklist = cfgKnowledge?.domainBlocklist;
+  const hasPatterns = (patterns?.length ?? 0) > 0;
+  const hasBlocklist = (blocklist?.length ?? 0) > 0;
+  if (!hasPatterns && !hasBlocklist) {
+    return void 0;
+  }
+  return {
+    ...hasPatterns ? { extraPatterns: patterns } : {},
+    ...hasBlocklist ? { extraBlocklist: blocklist } : {}
+  };
+}
+function buildPipelineOptions(opts, projectDir, graphDir, inferenceOptions) {
+  const pipelineOpts = {
+    projectDir,
+    fix: Boolean(opts.fix),
+    ci: Boolean(opts.ci),
+    ...opts.domain ? { domain: opts.domain } : {},
+    graphDir,
+    analyzeImages: Boolean(opts.analyzeImages),
+    ...inferenceOptions ? { inferenceOptions } : {}
+  };
+  if (opts.imagePaths) {
+    pipelineOpts.imagePaths = opts.imagePaths.split(",").map((p) => p.trim());
+  }
+  return pipelineOpts;
+}
+async function createAnalysisProvider() {
+  try {
+    const intelligence = await import("@harness-engineering/intelligence");
+    const Provider = intelligence.AnthropicAnalysisProvider;
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      logger.error("ANTHROPIC_API_KEY environment variable is required for --analyze-images");
+      process.exit(1);
+    }
+    return new Provider({ apiKey });
+  } catch {
+    logger.error(
+      "Image analysis requires @harness-engineering/intelligence with ANTHROPIC_API_KEY set."
+    );
+    process.exit(1);
+  }
+}
+function printJsonResult(result) {
+  console.log(
+    JSON.stringify(
+      {
+        verdict: result.verdict,
+        driftScore: result.driftScore,
+        iterations: result.iterations,
+        findings: result.findings,
+        extraction: result.extraction,
+        errors: result.errors,
+        gaps: {
+          domains: result.gaps.domains.length,
+          totalEntries: result.gaps.totalEntries,
+          totalExtracted: result.gaps.totalExtracted,
+          totalGaps: result.gaps.totalGaps
+        },
+        remediations: result.remediations,
+        contradictions: {
+          count: result.contradictions.contradictions.length,
+          sourcePairCounts: result.contradictions.sourcePairCounts
+        },
+        coverage: {
+          overallScore: result.coverage.overallScore,
+          overallGrade: result.coverage.overallGrade,
+          domains: result.coverage.domains.length
+        },
+        ...result.materialization ? {
+          materialization: {
+            created: result.materialization.created.length,
+            skipped: result.materialization.skipped.length,
+            files: result.materialization.created.map((d) => d.filePath)
+          }
+        } : {}
+      },
+      null,
+      2
+    )
+  );
+}
+function printSummary(result) {
+  const verdictColor = result.verdict === "pass" ? chalk7.green("PASS") : result.verdict === "warn" ? chalk7.yellow("WARN") : chalk7.red("FAIL");
+  console.log("");
+  console.log(`KNOWLEDGE PIPELINE -- Verdict: ${verdictColor}`);
+  console.log("");
+  console.log(`  Drift Score: ${result.driftScore.toFixed(2)}`);
+  console.log(
+    `  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.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`
+  );
+  if (result.iterations > 1) {
+    console.log(`  Convergence: ${result.iterations} iterations`);
+  }
+  if (result.remediations.length > 0) {
+    console.log(`  Remediations: ${result.remediations.length} applied`);
+  }
+}
+function printIngestionErrors(result) {
+  if (result.errors.length === 0) {
+    return;
+  }
+  console.warn("");
+  console.warn(`  ${result.errors.length} ingestion warning(s):`);
+  for (const err of result.errors) {
+    console.warn(`    - ${err}`);
+  }
+}
+function printMaterialization(result) {
+  if (!result.materialization) {
+    return;
+  }
+  const mat = result.materialization;
+  console.log(
+    `  Materialization: ${mat.created.length} docs created, ${mat.skipped.length} skipped`
+  );
+  for (const doc of mat.created) {
+    console.log(`    ${chalk7.green("+")} ${doc.filePath}`);
+  }
+}
+function printContradictions(result, opts) {
+  if (!opts.checkContradictions && result.contradictions.contradictions.length === 0) {
+    return;
+  }
+  console.log("");
+  console.log(
+    `  Contradictions: ${result.contradictions.contradictions.length} detected across ${result.contradictions.totalChecked} knowledge nodes`
+  );
+  for (const c of result.contradictions.contradictions) {
+    console.log(`    ${chalk7.red("!")} ${c.description} [${c.conflictType}] (${c.severity})`);
+  }
+}
+function printCoverage(result, opts) {
+  if (!opts.coverage && result.coverage.domains.length === 0) {
+    return;
+  }
+  console.log("");
+  console.log(`  Coverage: ${result.coverage.overallGrade} (${result.coverage.overallScore}/100)`);
+  for (const d of result.coverage.domains) {
+    console.log(
+      `    ${d.domain}: ${d.grade} (${d.score}/100) \u2014 ${d.knowledgeEntries} knowledge, ${d.linkedEntities}/${d.codeEntities} code linked`
+    );
+  }
+}
+function printHumanResult(result, opts) {
+  printSummary(result);
+  printIngestionErrors(result);
+  printMaterialization(result);
+  printContradictions(result, opts);
+  printCoverage(result, opts);
+  console.log("");
+}
 function createKnowledgePipelineCommand() {
   return new Command55("knowledge-pipeline").description("Run knowledge extraction, drift detection, and gap analysis").option("--fix", "Enable convergence-based auto-remediation (default: detect-only)").option("--ci", "Non-interactive mode \u2014 apply safe fixes only, report everything else").option("--domain <name>", "Limit pipeline to a specific knowledge domain").option("--drift-check", "Exit 1 if unresolved drift exists (CI gate mode)").option("--analyze-images", "Enable vision model analysis of image files").option("--image-paths <paths>", "Comma-separated image file paths for analysis").option("--coverage", "Display per-domain coverage report").option("--check-contradictions", "Display cross-source contradiction report").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
@@ -7331,7 +7522,7 @@ function createKnowledgePipelineCommand() {
       const graphDir = path41.join(projectDir, ".harness", "graph");
       const fs50 = await import("fs/promises");
       await fs50.mkdir(graphDir, { recursive: true });
-      const { GraphStore: GraphStore2, KnowledgePipelineRunner } = await import("./dist-OWHMNL4W.js");
+      const { GraphStore: GraphStore2, KnowledgePipelineRunner } = await import("./dist-DWBTZXR5.js");
       const store = new GraphStore2();
       try {
         await store.load(graphDir);
@@ -7339,145 +7530,19 @@ function createKnowledgePipelineCommand() {
       }
       const cfgResult = resolveConfig();
       const cfgKnowledge = cfgResult.ok ? cfgResult.value.knowledge : void 0;
-      const inferenceOptions = cfgKnowledge && ((cfgKnowledge.domainPatterns?.length ?? 0) > 0 || (cfgKnowledge.domainBlocklist?.length ?? 0) > 0) ? {
-        ...(cfgKnowledge.domainPatterns?.length ?? 0) > 0 ? { extraPatterns: cfgKnowledge.domainPatterns } : {},
-        ...(cfgKnowledge.domainBlocklist?.length ?? 0) > 0 ? { extraBlocklist: cfgKnowledge.domainBlocklist } : {}
-      } : void 0;
-      const pipelineOpts = {
-        projectDir,
-        fix: Boolean(opts.fix),
-        ci: Boolean(opts.ci),
-        ...opts.domain ? { domain: opts.domain } : {},
-        graphDir,
-        analyzeImages: Boolean(opts.analyzeImages),
-        ...inferenceOptions ? { inferenceOptions } : {}
-      };
-      if (opts.imagePaths) {
-        pipelineOpts.imagePaths = opts.imagePaths.split(",").map((p) => p.trim());
-      }
+      const inferenceOptions = resolveInferenceOptions(cfgKnowledge);
+      const pipelineOpts = buildPipelineOptions(opts, projectDir, graphDir, inferenceOptions);
       if (opts.analyzeImages) {
-        try {
-          const intelligence = await import("@harness-engineering/intelligence");
-          const Provider = intelligence.AnthropicAnalysisProvider;
-          const apiKey = process.env.ANTHROPIC_API_KEY;
-          if (!apiKey) {
-            logger.error(
-              "ANTHROPIC_API_KEY environment variable is required for --analyze-images"
-            );
-            process.exit(1);
-          }
-          pipelineOpts.analysisProvider = new Provider({ apiKey });
-        } catch {
-          logger.error(
-            "Image analysis requires @harness-engineering/intelligence with ANTHROPIC_API_KEY set."
-          );
-          process.exit(1);
-        }
+        pipelineOpts.analysisProvider = await createAnalysisProvider();
       }
       const runner = new KnowledgePipelineRunner(store);
       const result = await runner.run(
         pipelineOpts
       );
       if (globalOpts.json) {
-        console.log(
-          JSON.stringify(
-            {
-              verdict: result.verdict,
-              driftScore: result.driftScore,
-              iterations: result.iterations,
-              findings: result.findings,
-              extraction: result.extraction,
-              errors: result.errors,
-              gaps: {
-                domains: result.gaps.domains.length,
-                totalEntries: result.gaps.totalEntries,
-                totalExtracted: result.gaps.totalExtracted,
-                totalGaps: result.gaps.totalGaps
-              },
-              remediations: result.remediations,
-              contradictions: {
-                count: result.contradictions.contradictions.length,
-                sourcePairCounts: result.contradictions.sourcePairCounts
-              },
-              coverage: {
-                overallScore: result.coverage.overallScore,
-                overallGrade: result.coverage.overallGrade,
-                domains: result.coverage.domains.length
-              },
-              ...result.materialization ? {
-                materialization: {
-                  created: result.materialization.created.length,
-                  skipped: result.materialization.skipped.length,
-                  files: result.materialization.created.map(
-                    (d) => d.filePath
-                  )
-                }
-              } : {}
-            },
-            null,
-            2
-          )
-        );
+        printJsonResult(result);
       } else {
-        const verdictColor = result.verdict === "pass" ? chalk7.green("PASS") : result.verdict === "warn" ? chalk7.yellow("WARN") : chalk7.red("FAIL");
-        console.log("");
-        console.log(`KNOWLEDGE PIPELINE -- Verdict: ${verdictColor}`);
-        console.log("");
-        console.log(`  Drift Score: ${result.driftScore.toFixed(2)}`);
-        console.log(
-          `  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.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`
-        );
-        if (result.iterations > 1) {
-          console.log(`  Convergence: ${result.iterations} iterations`);
-        }
-        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(
-            `  Materialization: ${mat.created.length} docs created, ${mat.skipped.length} skipped`
-          );
-          for (const doc of mat.created) {
-            console.log(`    ${chalk7.green("+")} ${doc.filePath}`);
-          }
-        }
-        if (opts.checkContradictions || result.contradictions.contradictions.length > 0) {
-          console.log("");
-          console.log(
-            `  Contradictions: ${result.contradictions.contradictions.length} detected across ${result.contradictions.totalChecked} knowledge nodes`
-          );
-          for (const c of result.contradictions.contradictions) {
-            console.log(
-              `    ${chalk7.red("!")} ${c.description} [${c.conflictType}] (${c.severity})`
-            );
-          }
-        }
-        if (opts.coverage || result.coverage.domains.length > 0) {
-          console.log("");
-          console.log(
-            `  Coverage: ${result.coverage.overallGrade} (${result.coverage.overallScore}/100)`
-          );
-          for (const d of result.coverage.domains) {
-            console.log(
-              `    ${d.domain}: ${d.grade} (${d.score}/100) \u2014 ${d.knowledgeEntries} knowledge, ${d.linkedEntities}/${d.codeEntities} code linked`
-            );
-          }
-        }
-        console.log("");
+        printHumanResult(result, opts);
       }
       const unresolvedDrift = result.findings.drifted + result.findings.stale + result.findings.contradicting;
       if (opts.driftCheck && unresolvedDrift > 0) {
@@ -8208,7 +8273,7 @@ function createMcpCommand() {
     parseBudget
   ).action(async (opts) => {
     const [{ startServer: startServer2, getToolDefinitions: getToolDefinitions2 }, { selectTier }] = await Promise.all([
-      import("./mcp-TCLNK7HG.js"),
+      import("./mcp-5V4LPMB3.js"),
       import("./tool-tiers-OKK5FE57.js")
     ]);
     if (opts.tools && opts.tools.length > 0) {
@@ -9283,7 +9348,7 @@ 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-IPVFYGY2.js");
+    const { BenchmarkRunner } = await import("./dist-MCTEX5QH.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob2);
     if (benchFiles.length === 0) {
@@ -9347,7 +9412,7 @@ async function runBaselinesShow(globalOpts) {
 }
 async function runBaselinesUpdate(globalOpts) {
   const cwd = process.cwd();
-  const { BenchmarkRunner } = await import("./dist-IPVFYGY2.js");
+  const { BenchmarkRunner } = await import("./dist-MCTEX5QH.js");
   const runner = new BenchmarkRunner();
   const manager = new BaselineManager(cwd);
   logger.info("Running benchmarks to update baselines...");
@@ -9388,7 +9453,7 @@ 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-IPVFYGY2.js");
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-MCTEX5QH.js");
     const analyzer = new EntropyAnalyzer2({
       rootDir: path50.resolve(cwd),
       analyze: { complexity: true, coupling: true }
@@ -9691,79 +9756,560 @@ function createPredictCommand() {
   return command;
 }
 
-// src/commands/proposals.ts
+// src/commands/pre-merge-brief.ts
+init_dist2();
+import { execFileSync as execFileSync7 } from "child_process";
+import { readFileSync as readFileSync18 } from "fs";
+import { join as join40 } from "path";
+import { Command as Command77 } from "commander";
+import { gatherSignals } from "@harness-engineering/signals";
+
+// src/commands/review-ci.ts
 init_dist3();
-import { Command as Command76 } from "commander";
-import { resolve as resolve34 } from "path";
-function projectRoot() {
-  return resolve34(process.env["HARNESS_PROJECT_ROOT"] ?? process.cwd());
-}
-function summarizeProposal(p) {
-  return {
-    id: p.id,
-    kind: p.kind,
-    targetSkill: p.targetSkill,
-    name: p.content.name,
-    status: p.status,
-    proposedBy: p.proposedBy,
-    createdAt: p.createdAt,
-    gateLastRunAt: p.gate?.lastRunAt,
-    findings: p.gate?.findings?.length ?? 0
-  };
-}
-async function runProposalsList(status) {
-  const opts = {};
-  if (status) opts.status = status;
-  const proposals = await listProposals(projectRoot(), opts);
-  return proposals.map(summarizeProposal);
-}
-async function runProposalsShow(id) {
-  return getProposal(projectRoot(), id);
+import { execFileSync as execFileSync6 } from "child_process";
+import { writeFileSync as writeFileSync18 } from "fs";
+import { Command as Command76, Option as Option2 } from "commander";
+
+// src/commands/review-ci-local-adapter.ts
+import { z } from "zod";
+import { OpenAICompatibleAnalysisProvider } from "@harness-engineering/intelligence";
+var FindingSchema = z.object({
+  id: z.string(),
+  file: z.string(),
+  lineRange: z.tuple([z.number(), z.number()]),
+  domain: z.enum(["compliance", "bug", "security", "architecture", "learnings"]),
+  severity: z.enum(["critical", "important", "suggestion"]),
+  title: z.string(),
+  rationale: z.string(),
+  suggestion: z.string().optional(),
+  evidence: z.array(z.string())
+});
+var LocalVerdictSchema = z.object({
+  assessment: z.enum(["approve", "comment", "request-changes"]),
+  findings: z.array(FindingSchema)
+});
+var MAX_SURFACED_ERROR_LEN = 200;
+function sanitizeProviderError(err) {
+  const raw = err instanceof Error ? err.message : String(err);
+  const redacted = raw.replace(/https?:\/\/\S+/gi, "[endpoint]").replace(/\b(bearer|authorization|api[-_]?key|token)\b\s*[:=]?\s*\S+/gi, "[redacted]").replace(/\s+/g, " ").trim();
+  const capped = redacted.length > MAX_SURFACED_ERROR_LEN ? redacted.slice(0, MAX_SURFACED_ERROR_LEN - 1) + "\u2026" : redacted;
+  return `local runner provider error: ${capped}`;
 }
-async function runProposalsReject(id, reason) {
-  const decision = {
-    decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    decidedBy: process.env["USER"] ?? "cli",
-    action: "rejected",
-    reason
+function createLocalInvoke() {
+  return async ({ endpoint, model, instruction, diff: diff2 }) => {
+    if (!/^https?:\/\//i.test(endpoint)) {
+      throw new Error(
+        `HARNESS_LOCAL_ENDPOINT must be an http(s) URL (got '${endpoint}'); e.g. http://localhost:1234/v1`
+      );
+    }
+    const provider = new OpenAICompatibleAnalysisProvider({
+      apiKey: process.env.HARNESS_LOCAL_API_KEY ?? "local",
+      baseUrl: endpoint,
+      defaultModel: model
+    });
+    try {
+      const { result } = await provider.analyze({
+        prompt: `${instruction}
+
+---
+DIFF UNDER REVIEW:
+${diff2}`,
+        responseSchema: LocalVerdictSchema,
+        model
+      });
+      return JSON.stringify(result);
+    } catch (err) {
+      throw new Error(sanitizeProviderError(err), { cause: err });
+    }
   };
-  return updateProposal(projectRoot(), id, { status: "rejected", decision });
-}
-var ALLOWED_STATUSES = [
-  "open",
-  "gate-running",
-  "gate-failed",
-  "approved",
-  "rejected",
-  "all"
-];
-function fail(message) {
-  console.error(message);
-  process.exitCode = 1;
-}
-async function actListCommand(opts) {
-  const raw = opts.status ?? "open";
-  if (!ALLOWED_STATUSES.includes(raw)) {
-    fail(`Error: unknown status "${raw}"`);
-    return;
-  }
-  const proposals = await runProposalsList(raw);
-  console.log(JSON.stringify(proposals, null, 2));
 }
-async function actShowCommand(id) {
-  const proposal = await runProposalsShow(id);
-  if (!proposal) {
-    fail(`No such proposal: ${id}`);
-    return;
+
+// src/commands/review-ci.ts
+var KNOWN_RUNNERS = Object.keys(RUNNER_PRESETS);
+var BLOCK_ON_LEVELS = [...CI_ASSESSMENTS, "none"];
+function assertKnownRunner(runner) {
+  if (runner === void 0) return;
+  if (!KNOWN_RUNNERS.includes(runner)) {
+    throw new Error(`unknown runner '${runner}' (expected: ${KNOWN_RUNNERS.join("|")})`);
   }
-  console.log(JSON.stringify(proposal, null, 2));
 }
-async function actRejectCommand(id, opts) {
+var defaultRunGit = (args) => execFileSync6("git", args, { encoding: "utf-8" }).toString().trim();
+function resolveDiffRange(opts) {
+  if (opts.range) return opts.range;
+  const runGit = opts.runGit ?? defaultRunGit;
+  let base = "main";
   try {
-    const updated = await runProposalsReject(id, opts.reason);
-    console.log(JSON.stringify(summarizeProposal(updated), null, 2));
-  } catch (err) {
-    fail(err instanceof Error ? err.message : String(err));
+    const ref = runGit(["symbolic-ref", "refs/remotes/origin/HEAD"]);
+    const m = ref.match(/origin\/(.+)$/);
+    if (m?.[1]) base = m[1];
+  } catch {
+  }
+  return `origin/${base}...HEAD`;
+}
+function splitDiffByFile(rawDiff) {
+  const sections = /* @__PURE__ */ new Map();
+  const headerRe = /^diff --git a\/(.+?) b\/(.+?)$/;
+  let currentPath = null;
+  let buffer = [];
+  const flush = () => {
+    if (currentPath !== null) sections.set(currentPath, buffer.join("\n"));
+  };
+  for (const line of rawDiff.split("\n")) {
+    const m = line.match(headerRe);
+    if (m?.[2]) {
+      flush();
+      currentPath = m[2];
+      buffer = [line];
+    } else if (currentPath !== null) {
+      buffer.push(line);
+    }
+  }
+  flush();
+  return sections;
+}
+function buildDiffInfo(rawDiff) {
+  const parsed = parseDiff(rawDiff);
+  if (!parsed.ok) throw new Error(`Failed to parse diff: ${parsed.error.message}`);
+  const files = parsed.value.files;
+  const perFile = splitDiffByFile(rawDiff);
+  return {
+    changedFiles: files.map((f) => f.path),
+    newFiles: files.filter((f) => f.status === "added").map((f) => f.path),
+    deletedFiles: files.filter((f) => f.status === "deleted").map((f) => f.path),
+    totalDiffLines: rawDiff ? rawDiff.split("\n").length : 0,
+    // On a path-key miss, fall back to '' (the file contributes no per-file diff)
+    // rather than the ENTIRE raw diff — substituting the whole diff would duplicate
+    // every file's content into one section, inflating the STDIN payload to the LLM
+    // (and risking core's execMaxStdoutBytes). With splitDiffByFile aligned to core's
+    // path extraction, ordinary paths never miss; this is the safe degenerate case.
+    fileDiffs: new Map(files.map((f) => [f.path, perFile.get(f.path) ?? ""]))
+  };
+}
+function defaultResolveRaw(range, _cwd, runGit) {
+  return runGit(["diff", range]);
+}
+function buildCallOpts(opts, cwd, diff2) {
+  const runner = opts.runner;
+  return {
+    projectRoot: cwd,
+    diff: diff2,
+    ...runner ? { runner } : {},
+    ...opts.blockOn ? { blockOn: opts.blockOn } : {},
+    ...runner === "local" ? { localInvoke: opts.localInvoke ?? createLocalInvoke() } : {}
+  };
+}
+async function runReviewCi(opts) {
+  assertKnownRunner(opts.runner);
+  const cwd = opts.cwd ?? process.cwd();
+  const runGit = opts.runGit ?? defaultRunGit;
+  const range = resolveDiffRange({
+    ...opts.diffRange ? { range: opts.diffRange } : {},
+    cwd,
+    runGit
+  });
+  const rawDiff = (opts.resolveRaw ?? defaultResolveRaw)(range, cwd, runGit);
+  const diff2 = buildDiffInfo(rawDiff);
+  const callOpts = buildCallOpts(opts, cwd, diff2);
+  return (opts.runCiReviewImpl ?? runCiReview)(callOpts);
+}
+function findingLine(f) {
+  const loc = f.lineRange ? `${f.file}:${f.lineRange[0]}` : f.file;
+  return `- \`${f.severity}\` **${loc}** \u2014 ${f.title}`;
+}
+function buildReviewBody(verdict) {
+  const findings = verdict.findings ?? [];
+  const blocking = verdict.blockingFindings ?? [];
+  const icon = verdict.assessment === "approve" ? "\u2705" : verdict.assessment === "request-changes" ? "\u{1F6D1}" : "\u{1F4AC}";
+  const out = [
+    `## ${icon} harness review-ci \u2014 ${verdict.assessment}`,
+    "",
+    `**Runner:** \`${verdict.runner}\`  \u2022  **Findings:** ${findings.length} (blocking: ${blocking.length})`
+  ];
+  if (verdict.skipped) out.push("", `> \u26A0\uFE0F ${verdict.skipReason ?? "A review tier was skipped."}`);
+  if (blocking.length) out.push("", "### Blocking", ...blocking.map(findingLine));
+  const nonBlocking = findings.filter((f) => !blocking.some((b) => b.id === f.id));
+  if (nonBlocking.length) out.push("", "### Other findings", ...nonBlocking.map(findingLine));
+  if (!findings.length) out.push("", "No findings. \u{1F389}");
+  out.push("", "<sub>Posted by `harness review-ci`. The CI exit code is authoritative.</sub>");
+  return out.join("\n");
+}
+var defaultPostReview = (verdict) => {
+  execFileSync6("gh", ["pr", "comment", "--body-file", "-"], {
+    input: buildReviewBody(verdict),
+    stdio: ["pipe", "pipe", "pipe"],
+    encoding: "utf-8"
+  });
+};
+function emitReviewCi(result, opts, writeFile2 = (p, d) => writeFileSync18(p, d), log = (m) => process.stdout.write(m + "\n"), postReview = defaultPostReview) {
+  const serialized = JSON.stringify(result.verdict, null, 2);
+  const jsonToStdout = opts.jsonPath === true;
+  if (!jsonToStdout) log(result.terminalOutput);
+  if (typeof opts.jsonPath === "string") writeFile2(opts.jsonPath, serialized);
+  else if (jsonToStdout) log(serialized);
+  if (opts.comment) {
+    try {
+      postReview(result.verdict);
+    } catch (err) {
+      logger.warn(
+        `review-ci: failed to post PR comment (${err instanceof Error ? err.message : String(err)}). The verdict above is authoritative; the exit code still reflects the gate.`
+      );
+    }
+  }
+}
+function createReviewCiCommand() {
+  return new Command76("review-ci").description("Run the tiered code-review gate (floor + optional LLM runner) for CI").addOption(
+    new Option2("--runner <runner>", `${KNOWN_RUNNERS.join(" | ")} (omit = floor-only)`).choices(
+      KNOWN_RUNNERS
+    )
+  ).addOption(
+    new Option2("--block-on <level>", BLOCK_ON_LEVELS.join(" | ")).choices(BLOCK_ON_LEVELS).default("request-changes")
+  ).option("--diff <range>", "git range (default: origin/<base>...HEAD)").option("--comment", "post the verdict as a comment on the current branch's PR via gh").option(
+    "--out <path>",
+    "write the verdict JSON artifact to a file (use the global --json to stream it to stdout instead)"
+  ).action(async (opts, cmd) => {
+    const result = await runReviewCi({
+      runner: opts.runner,
+      blockOn: opts.blockOn,
+      diffRange: opts.diff
+    });
+    const streamJson = cmd.optsWithGlobals().json === true;
+    emitReviewCi(result, {
+      jsonPath: typeof opts.out === "string" ? opts.out : streamJson ? true : void 0,
+      comment: opts.comment
+    });
+    process.exit(result.exitCode);
+  });
+}
+
+// src/commands/pre-merge-brief.ts
+var BRIEF_MARKER = "<!-- harness:pre-merge-brief -->";
+var UNAVAILABLE = "> _unavailable / not configured._";
+function renderDiffSummary(diff2) {
+  const out = ["## Diff summary", ""];
+  if (!diff2) {
+    out.push(UNAVAILABLE);
+    return out;
+  }
+  out.push(
+    `**Files changed:** ${diff2.changedFiles.length} (new: ${diff2.newFiles.length}, deleted: ${diff2.deletedFiles.length})  \u2022  **Diff lines:** ${diff2.totalDiffLines}`
+  );
+  return out;
+}
+function findingLine2(f) {
+  const loc = f.lineRange ? `${f.file}:${f.lineRange[0]}` : f.file;
+  return `- \`${f.severity}\` **${loc}** \u2014 ${f.title}`;
+}
+function renderPopulatedVerdict(verdict) {
+  const findings = verdict.findings ?? [];
+  const blocking = verdict.blockingFindings ?? [];
+  const out = [
+    `**Assessment:** \`${verdict.assessment}\`  \u2022  **Runner:** \`${verdict.runner}\`  \u2022  **Findings:** ${findings.length} (blocking: ${blocking.length})`
+  ];
+  if (verdict.skipped) {
+    out.push("", `> \u26A0\uFE0F ${verdict.skipReason ?? "A review tier was skipped."}`);
+  }
+  if (blocking.length) out.push("", "### Blocking", ...blocking.map(findingLine2));
+  const nonBlocking = findings.filter((f) => !blocking.some((b) => b.id === f.id));
+  if (nonBlocking.length) out.push("", "### Other findings", ...nonBlocking.map(findingLine2));
+  return out;
+}
+function renderReviewVerdict(verdict) {
+  if (!verdict) return ["## Review verdict", "", UNAVAILABLE];
+  return ["## Review verdict", "", ...renderPopulatedVerdict(verdict)];
+}
+function signalLine(s) {
+  const value = s.value === null ? "\u2014" : `${s.value}${s.unit ?? ""}`;
+  return `- \`${s.status}\` **${s.label}** \u2014 ${value}`;
+}
+function renderSignalStatus(signals) {
+  const out = ["## Signal status", ""];
+  if (!signals || signals.length === 0) {
+    out.push(UNAVAILABLE);
+    return out;
+  }
+  out.push(...signals.map(signalLine));
+  return out;
+}
+function renderOutcomeEval(outcome) {
+  const out = ["## Outcome evaluation", ""];
+  if (!outcome) {
+    out.push("> _not yet evaluated._");
+    return out;
+  }
+  out.push(
+    `**Verdict:** \`${outcome.verdict}\`  \u2022  **Confidence:** \`${outcome.confidence}\`  \u2022  **Authority:** \`${outcome.authority}\``,
+    "",
+    outcome.rationale
+  );
+  return out;
+}
+function blockingBullets(inputs) {
+  return (inputs.review?.blockingFindings ?? []).map(
+    (f) => `- \u{1F6D1} ${findingLine2(f).replace(/^- /, "")}`
+  );
+}
+function signalBullets(inputs) {
+  return (inputs.signals ?? []).filter((s) => s.status === "warn" || s.status === "alert").map((s) => `- \u{1F4CA} ${signalLine(s).replace(/^- /, "")}`);
+}
+function unmetBullets(inputs) {
+  const unmet = inputs.outcome?.verdict === "NOT_SATISFIED" ? inputs.outcome.unmetCriteria ?? [] : [];
+  return unmet.map((c) => `- \u{1F3AF} ${c}`);
+}
+function collectWorthYourEyesBullets(inputs) {
+  return [...blockingBullets(inputs), ...signalBullets(inputs), ...unmetBullets(inputs)];
+}
+function deriveWorthYourEyes(inputs) {
+  const bullets = collectWorthYourEyesBullets(inputs);
+  if (bullets.length === 0) {
+    return [
+      "## \u{1F440} Worth your eyes",
+      "",
+      "_Nothing flagged \u2014 no blocking findings, no warn/alert signals, no unmet criteria._"
+    ];
+  }
+  return ["## \u{1F440} Worth your eyes", "", ...bullets];
+}
+function buildBriefBody(inputs) {
+  const lines = [
+    BRIEF_MARKER,
+    "# \u{1F9ED} Pre-merge brief",
+    "",
+    ...renderDiffSummary(inputs.diff),
+    "",
+    ...renderReviewVerdict(inputs.review),
+    "",
+    ...renderSignalStatus(inputs.signals),
+    "",
+    ...renderOutcomeEval(inputs.outcome),
+    "",
+    ...deriveWorthYourEyes(inputs)
+  ];
+  return lines.join("\n");
+}
+function upsertComment(comments, body, patch, post) {
+  const marked = comments.find((c) => c.body.trimStart().startsWith(BRIEF_MARKER));
+  if (marked) {
+    patch(marked.id, body);
+  } else {
+    post(body);
+  }
+}
+var defaultPostBrief = (body) => {
+  const raw = execFileSync7("gh", ["pr", "view", "--json", "comments"], {
+    encoding: "utf-8"
+  }).toString();
+  const parsed = JSON.parse(raw);
+  const comments = (parsed.comments ?? []).filter(
+    (c) => typeof c.id === "number" && typeof c.body === "string"
+  ).map((c) => ({ id: c.id, body: c.body }));
+  upsertComment(
+    comments,
+    body,
+    (id, patchBody) => {
+      execFileSync7(
+        "gh",
+        ["api", "-X", "PATCH", `/repos/{owner}/{repo}/issues/comments/${id}`, "-F", "body=@-"],
+        { input: patchBody, stdio: ["pipe", "pipe", "pipe"], encoding: "utf-8" }
+      );
+    },
+    (postBody) => {
+      execFileSync7("gh", ["pr", "comment", "--body-file", "-"], {
+        input: postBody,
+        stdio: ["pipe", "pipe", "pipe"],
+        encoding: "utf-8"
+      });
+    }
+  );
+};
+var defaultReadFile = (path80) => readFileSync18(path80, "utf-8");
+function readReview(path80, readFile4 = defaultReadFile) {
+  if (!path80) return void 0;
+  try {
+    const parsed = JSON.parse(readFile4(path80));
+    return parsed?.verdict && typeof parsed.verdict === "object" ? parsed.verdict : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function gatherSignalsSafe(projectPath, gather = gatherSignals) {
+  try {
+    const result = await gather(projectPath);
+    return result.signals;
+  } catch {
+    return [];
+  }
+}
+var GRAPH_DIR = ".harness/graph";
+async function loadOutcomeStore(projectPath) {
+  try {
+    const store = new GraphStore();
+    const loaded = await store.load(join40(projectPath, GRAPH_DIR));
+    return loaded ? store : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function findOutcomeVerdict(store, headSha) {
+  if (!store || !headSha) return void 0;
+  try {
+    const nodes = store.findNodes({ type: "execution_outcome" });
+    const match = nodes.find((n) => {
+      const m2 = n.metadata ?? {};
+      return m2.commit === headSha || m2.headSha === headSha;
+    });
+    if (!match) return void 0;
+    const m = match.metadata;
+    return {
+      verdict: m.verdict,
+      confidence: m.confidence ?? "low",
+      rationale: m.rationale ?? "",
+      judgedAgainst: m.judgedAgainst ?? "success-criteria",
+      unmetCriteria: Array.isArray(m.unmetCriteria) ? m.unmetCriteria : [],
+      authority: m.authority ?? "advisory"
+    };
+  } catch {
+    return void 0;
+  }
+}
+function defaultResolveRaw2(range, _cwd, runGit) {
+  return runGit(["diff", range]);
+}
+async function runPreMergeBrief(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const runGit = opts.runGit ?? ((args) => execFileSync7("git", args, { encoding: "utf-8" }).toString().trim());
+  const range = resolveDiffRange({
+    ...opts.diffRange ? { range: opts.diffRange } : {},
+    cwd,
+    runGit
+  });
+  let diff2;
+  try {
+    const rawDiff = (opts.resolveRaw ?? defaultResolveRaw2)(range, cwd, runGit);
+    diff2 = rawDiff.trim() ? buildDiffInfo(rawDiff) : void 0;
+  } catch {
+    diff2 = void 0;
+  }
+  const review = readReview(opts.from, opts.readFile);
+  const signals = await gatherSignalsSafe(cwd, opts.gather);
+  const outcome = findOutcomeVerdict(opts.store, opts.headSha);
+  const body = buildBriefBody({ diff: diff2, review, signals, outcome });
+  const log = opts.log ?? ((m) => process.stdout.write(m + "\n"));
+  if (opts.comment) {
+    try {
+      (opts.postBrief ?? defaultPostBrief)(body);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      (opts.warn ?? ((m) => process.stderr.write(m + "\n")))(
+        `\u26A0\uFE0F pre-merge-brief: could not post sticky comment (${reason}); printing brief instead.`
+      );
+      log(body);
+    }
+  } else {
+    log(body);
+  }
+  return { body };
+}
+function createPreMergeBriefCommand() {
+  return new Command77("pre-merge-brief").description(
+    'Compose a senior-facing pre-merge PR brief (diff, review, signals, outcome, "worth your eyes")'
+  ).option("--from <path>", "review-ci --json verdict artifact").option("--comment", "upsert the brief as a sticky comment on the current branch's PR").option("--diff <range>", "git range (default: origin/<base>...HEAD)").option("--head <sha>", "head commit sha for the outcome lookup (default: git rev-parse HEAD)").action(async (opts) => {
+    const cwd = process.cwd();
+    const runGit = (args) => execFileSync7("git", args, { encoding: "utf-8" }).toString().trim();
+    let headSha = opts.head;
+    if (!headSha) {
+      try {
+        headSha = runGit(["rev-parse", "HEAD"]) || void 0;
+      } catch {
+        headSha = void 0;
+      }
+    }
+    const store = await loadOutcomeStore(cwd);
+    await runPreMergeBrief({
+      cwd,
+      from: opts.from,
+      comment: opts.comment,
+      diffRange: opts.diff,
+      headSha,
+      store,
+      runGit
+    });
+    process.exit(0);
+  });
+}
+
+// src/commands/proposals.ts
+init_dist3();
+import { Command as Command78 } from "commander";
+import { resolve as resolve34 } from "path";
+function projectRoot() {
+  return resolve34(process.env["HARNESS_PROJECT_ROOT"] ?? process.cwd());
+}
+function summarizeProposal(p) {
+  return {
+    id: p.id,
+    kind: p.kind,
+    targetSkill: p.targetSkill,
+    name: p.content.name,
+    status: p.status,
+    proposedBy: p.proposedBy,
+    createdAt: p.createdAt,
+    gateLastRunAt: p.gate?.lastRunAt,
+    findings: p.gate?.findings?.length ?? 0
+  };
+}
+async function runProposalsList(status) {
+  const opts = {};
+  if (status) opts.status = status;
+  const proposals = await listProposals(projectRoot(), opts);
+  return proposals.map(summarizeProposal);
+}
+async function runProposalsShow(id) {
+  return getProposal(projectRoot(), id);
+}
+async function runProposalsReject(id, reason) {
+  const decision = {
+    decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    decidedBy: process.env["USER"] ?? "cli",
+    action: "rejected",
+    reason
+  };
+  return updateProposal(projectRoot(), id, { status: "rejected", decision });
+}
+var ALLOWED_STATUSES = [
+  "open",
+  "gate-running",
+  "gate-failed",
+  "approved",
+  "rejected",
+  "all"
+];
+function fail(message) {
+  console.error(message);
+  process.exitCode = 1;
+}
+async function actListCommand(opts) {
+  const raw = opts.status ?? "open";
+  if (!ALLOWED_STATUSES.includes(raw)) {
+    fail(`Error: unknown status "${raw}"`);
+    return;
+  }
+  const proposals = await runProposalsList(raw);
+  console.log(JSON.stringify(proposals, null, 2));
+}
+async function actShowCommand(id) {
+  const proposal = await runProposalsShow(id);
+  if (!proposal) {
+    fail(`No such proposal: ${id}`);
+    return;
+  }
+  console.log(JSON.stringify(proposal, null, 2));
+}
+async function actRejectCommand(id, opts) {
+  try {
+    const updated = await runProposalsReject(id, opts.reason);
+    console.log(JSON.stringify(summarizeProposal(updated), null, 2));
+  } catch (err) {
+    fail(err instanceof Error ? err.message : String(err));
   }
 }
 async function actApproveCommand(id) {
@@ -9788,7 +10334,7 @@ async function actApproveCommand(id) {
   }
 }
 function createProposalsCommand() {
-  const cmd = new Command76("proposals").description("Skill-proposal review queue");
+  const cmd = new Command78("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(" | ")}`,
@@ -9805,7 +10351,7 @@ function createProposalsCommand() {
 // src/commands/publish-analyses.ts
 import * as fs31 from "fs";
 import * as path52 from "path";
-import { Command as Command77 } from "commander";
+import { Command as Command79 } from "commander";
 init_dist3();
 import {
   renderAnalysisComment,
@@ -9917,7 +10463,7 @@ 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-IPVFYGY2.js");
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-MCTEX5QH.js");
   const archive = new AnalysisArchive(path52.join(projectPath, ".harness", "analyses"));
   const analyses = await archive.list();
   if (analyses.length === 0) {
@@ -9940,7 +10486,7 @@ async function runPublishAnalyses(opts) {
   }
 }
 function createPublishAnalysesCommand() {
-  const command = new Command77("publish-analyses").description(
+  const command = new Command79("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 {
@@ -9956,18 +10502,18 @@ function createPublishAnalysesCommand() {
 }
 
 // src/commands/pulse/index.ts
-import { Command as Command79 } from "commander";
+import { Command as Command81 } from "commander";
 
 // src/commands/pulse/run.ts
 init_dist3();
-import { readFileSync as readFileSync18, mkdirSync as mkdirSync15, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname18, join as join41, resolve as resolve36 } from "path";
-import { Command as Command78 } from "commander";
+import { readFileSync as readFileSync19, mkdirSync as mkdirSync15, writeFileSync as writeFileSync19 } from "fs";
+import { dirname as dirname18, join as join42, resolve as resolve36 } from "path";
+import { Command as Command80 } 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(
       {
@@ -9993,9 +10539,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 = join41(opts.outputDir, `${ts}.md`);
+  const filePath = join42(opts.outputDir, `${ts}.md`);
   mkdirSync15(dirname18(filePath), { recursive: true });
-  writeFileSync18(filePath, report);
+  writeFileSync19(filePath, report);
   const headlines = extractHeadlines(report);
   return emit2(
     {
@@ -10027,7 +10573,7 @@ function emit2(status, nonInteractive) {
   return status;
 }
 function createRunCommand2() {
-  return new Command78("run").description("Run a pulse: query configured adapters, sanitize, assemble single-page report").option(
+  return new Command80("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(
@@ -10051,13 +10597,13 @@ function createRunCommand2() {
 
 // src/commands/pulse/index.ts
 function createPulseCommand() {
-  const command = new Command79("pulse").description("Pulse (read-side observability) commands");
+  const command = new Command81("pulse").description("Pulse (read-side observability) commands");
   command.addCommand(createRunCommand2());
   return command;
 }
 
 // src/commands/recommend.ts
-import { Command as Command80 } from "commander";
+import { Command as Command82 } from "commander";
 import chalk13 from "chalk";
 async function resolveSnapshot(cwd, noCache) {
   if (!noCache) {
@@ -10084,301 +10630,84 @@ async function runRecommend(options) {
   const { snapshot, usedCache } = await resolveSnapshot(cwd, options.noCache);
   const skills = buildSkillsRecord(cwd);
   const result = recommend(snapshot, skills, { top });
-  return {
-    ...result,
-    snapshotAge: usedCache ? "cached" : "fresh"
-  };
-}
-function formatRecommendation(rec) {
-  const lines = [];
-  if (rec.urgency === "critical") {
-    lines.push(`  ${chalk13.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(`     ${chalk13.dim("\u2192")} ${reason}`);
-  }
-  return lines.join("\n");
-}
-function printRecommendations(result) {
-  if (result.recommendations.length === 0) {
-    console.log("");
-    console.log("No recommendations. Codebase health looks good!");
-    console.log("");
-    return;
-  }
-  console.log("");
-  console.log(
-    `Recommended workflow (${result.recommendations.length} skill${result.recommendations.length === 1 ? "" : "s"}):`
-  );
-  console.log("");
-  for (const rec of result.recommendations) {
-    console.log(formatRecommendation(rec));
-    console.log("");
-  }
-  console.log(`Sequence reasoning: ${result.sequenceReasoning}`);
-  console.log("");
-}
-function createRecommendCommand() {
-  const command = new Command80("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 {
-      const top = parseInt(opts.top, 10);
-      if (isNaN(top) || top < 1) {
-        logger.error("--top must be a positive integer");
-        process.exit(1);
-      }
-      if (mode === OutputMode.TEXT) {
-        console.log("");
-        console.log("Analyzing codebase health...");
-      }
-      const result = await runRecommend({
-        noCache: opts.cache === false,
-        top
-      });
-      if (mode === OutputMode.JSON) {
-        console.log(JSON.stringify(result, null, 2));
-      } else {
-        printRecommendations(result);
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      if (mode === OutputMode.JSON) {
-        console.log(JSON.stringify({ error: message }));
-      } else {
-        logger.error(message);
-      }
-      process.exit(1);
-    }
-  });
-  return command;
-}
-
-// src/commands/review-ci.ts
-init_dist3();
-import { execFileSync as execFileSync6 } from "child_process";
-import { writeFileSync as writeFileSync19 } from "fs";
-import { Command as Command81, Option as Option2 } from "commander";
-
-// src/commands/review-ci-local-adapter.ts
-import { z } from "zod";
-import { OpenAICompatibleAnalysisProvider } from "@harness-engineering/intelligence";
-var FindingSchema = z.object({
-  id: z.string(),
-  file: z.string(),
-  lineRange: z.tuple([z.number(), z.number()]),
-  domain: z.enum(["compliance", "bug", "security", "architecture", "learnings"]),
-  severity: z.enum(["critical", "important", "suggestion"]),
-  title: z.string(),
-  rationale: z.string(),
-  suggestion: z.string().optional(),
-  evidence: z.array(z.string())
-});
-var LocalVerdictSchema = z.object({
-  assessment: z.enum(["approve", "comment", "request-changes"]),
-  findings: z.array(FindingSchema)
-});
-var MAX_SURFACED_ERROR_LEN = 200;
-function sanitizeProviderError(err) {
-  const raw = err instanceof Error ? err.message : String(err);
-  const redacted = raw.replace(/https?:\/\/\S+/gi, "[endpoint]").replace(/\b(bearer|authorization|api[-_]?key|token)\b\s*[:=]?\s*\S+/gi, "[redacted]").replace(/\s+/g, " ").trim();
-  const capped = redacted.length > MAX_SURFACED_ERROR_LEN ? redacted.slice(0, MAX_SURFACED_ERROR_LEN - 1) + "\u2026" : redacted;
-  return `local runner provider error: ${capped}`;
-}
-function createLocalInvoke() {
-  return async ({ endpoint, model, instruction, diff: diff2 }) => {
-    if (!/^https?:\/\//i.test(endpoint)) {
-      throw new Error(
-        `HARNESS_LOCAL_ENDPOINT must be an http(s) URL (got '${endpoint}'); e.g. http://localhost:1234/v1`
-      );
-    }
-    const provider = new OpenAICompatibleAnalysisProvider({
-      apiKey: process.env.HARNESS_LOCAL_API_KEY ?? "local",
-      baseUrl: endpoint,
-      defaultModel: model
-    });
-    try {
-      const { result } = await provider.analyze({
-        prompt: `${instruction}
-
----
-DIFF UNDER REVIEW:
-${diff2}`,
-        responseSchema: LocalVerdictSchema,
-        model
-      });
-      return JSON.stringify(result);
-    } catch (err) {
-      throw new Error(sanitizeProviderError(err), { cause: err });
-    }
-  };
-}
-
-// src/commands/review-ci.ts
-var KNOWN_RUNNERS = Object.keys(RUNNER_PRESETS);
-var BLOCK_ON_LEVELS = [...CI_ASSESSMENTS, "none"];
-function assertKnownRunner(runner) {
-  if (runner === void 0) return;
-  if (!KNOWN_RUNNERS.includes(runner)) {
-    throw new Error(`unknown runner '${runner}' (expected: ${KNOWN_RUNNERS.join("|")})`);
-  }
-}
-var defaultRunGit = (args) => execFileSync6("git", args, { encoding: "utf-8" }).toString().trim();
-function resolveDiffRange(opts) {
-  if (opts.range) return opts.range;
-  const runGit = opts.runGit ?? defaultRunGit;
-  let base = "main";
-  try {
-    const ref = runGit(["symbolic-ref", "refs/remotes/origin/HEAD"]);
-    const m = ref.match(/origin\/(.+)$/);
-    if (m?.[1]) base = m[1];
-  } catch {
-  }
-  return `origin/${base}...HEAD`;
-}
-function splitDiffByFile(rawDiff) {
-  const sections = /* @__PURE__ */ new Map();
-  const headerRe = /^diff --git a\/(.+?) b\/(.+?)$/;
-  let currentPath = null;
-  let buffer = [];
-  const flush = () => {
-    if (currentPath !== null) sections.set(currentPath, buffer.join("\n"));
-  };
-  for (const line of rawDiff.split("\n")) {
-    const m = line.match(headerRe);
-    if (m?.[2]) {
-      flush();
-      currentPath = m[2];
-      buffer = [line];
-    } else if (currentPath !== null) {
-      buffer.push(line);
-    }
-  }
-  flush();
-  return sections;
-}
-function buildDiffInfo(rawDiff) {
-  const parsed = parseDiff(rawDiff);
-  if (!parsed.ok) throw new Error(`Failed to parse diff: ${parsed.error.message}`);
-  const files = parsed.value.files;
-  const perFile = splitDiffByFile(rawDiff);
-  return {
-    changedFiles: files.map((f) => f.path),
-    newFiles: files.filter((f) => f.status === "added").map((f) => f.path),
-    deletedFiles: files.filter((f) => f.status === "deleted").map((f) => f.path),
-    totalDiffLines: rawDiff ? rawDiff.split("\n").length : 0,
-    // On a path-key miss, fall back to '' (the file contributes no per-file diff)
-    // rather than the ENTIRE raw diff — substituting the whole diff would duplicate
-    // every file's content into one section, inflating the STDIN payload to the LLM
-    // (and risking core's execMaxStdoutBytes). With splitDiffByFile aligned to core's
-    // path extraction, ordinary paths never miss; this is the safe degenerate case.
-    fileDiffs: new Map(files.map((f) => [f.path, perFile.get(f.path) ?? ""]))
-  };
-}
-function defaultResolveRaw(range, _cwd, runGit) {
-  return runGit(["diff", range]);
-}
-function buildCallOpts(opts, cwd, diff2) {
-  const runner = opts.runner;
-  return {
-    projectRoot: cwd,
-    diff: diff2,
-    ...runner ? { runner } : {},
-    ...opts.blockOn ? { blockOn: opts.blockOn } : {},
-    ...runner === "local" ? { localInvoke: opts.localInvoke ?? createLocalInvoke() } : {}
-  };
-}
-async function runReviewCi(opts) {
-  assertKnownRunner(opts.runner);
-  const cwd = opts.cwd ?? process.cwd();
-  const runGit = opts.runGit ?? defaultRunGit;
-  const range = resolveDiffRange({
-    ...opts.diffRange ? { range: opts.diffRange } : {},
-    cwd,
-    runGit
-  });
-  const rawDiff = (opts.resolveRaw ?? defaultResolveRaw)(range, cwd, runGit);
-  const diff2 = buildDiffInfo(rawDiff);
-  const callOpts = buildCallOpts(opts, cwd, diff2);
-  return (opts.runCiReviewImpl ?? runCiReview)(callOpts);
+  return {
+    ...result,
+    snapshotAge: usedCache ? "cached" : "fresh"
+  };
 }
-function findingLine(f) {
-  const loc = f.lineRange ? `${f.file}:${f.lineRange[0]}` : f.file;
-  return `- \`${f.severity}\` **${loc}** \u2014 ${f.title}`;
+function formatRecommendation(rec) {
+  const lines = [];
+  if (rec.urgency === "critical") {
+    lines.push(`  ${chalk13.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(`     ${chalk13.dim("\u2192")} ${reason}`);
+  }
+  return lines.join("\n");
 }
-function buildReviewBody(verdict) {
-  const findings = verdict.findings ?? [];
-  const blocking = verdict.blockingFindings ?? [];
-  const icon = verdict.assessment === "approve" ? "\u2705" : verdict.assessment === "request-changes" ? "\u{1F6D1}" : "\u{1F4AC}";
-  const out = [
-    `## ${icon} harness review-ci \u2014 ${verdict.assessment}`,
-    "",
-    `**Runner:** \`${verdict.runner}\`  \u2022  **Findings:** ${findings.length} (blocking: ${blocking.length})`
-  ];
-  if (verdict.skipped) out.push("", `> \u26A0\uFE0F ${verdict.skipReason ?? "A review tier was skipped."}`);
-  if (blocking.length) out.push("", "### Blocking", ...blocking.map(findingLine));
-  const nonBlocking = findings.filter((f) => !blocking.some((b) => b.id === f.id));
-  if (nonBlocking.length) out.push("", "### Other findings", ...nonBlocking.map(findingLine));
-  if (!findings.length) out.push("", "No findings. \u{1F389}");
-  out.push("", "<sub>Posted by `harness review-ci`. The CI exit code is authoritative.</sub>");
-  return out.join("\n");
+function printRecommendations(result) {
+  if (result.recommendations.length === 0) {
+    console.log("");
+    console.log("No recommendations. Codebase health looks good!");
+    console.log("");
+    return;
+  }
+  console.log("");
+  console.log(
+    `Recommended workflow (${result.recommendations.length} skill${result.recommendations.length === 1 ? "" : "s"}):`
+  );
+  console.log("");
+  for (const rec of result.recommendations) {
+    console.log(formatRecommendation(rec));
+    console.log("");
+  }
+  console.log(`Sequence reasoning: ${result.sequenceReasoning}`);
+  console.log("");
 }
-var defaultPostReview = (verdict) => {
-  execFileSync6("gh", ["pr", "comment", "--body-file", "-"], {
-    input: buildReviewBody(verdict),
-    stdio: ["pipe", "pipe", "pipe"],
-    encoding: "utf-8"
-  });
-};
-function emitReviewCi(result, opts, writeFile2 = (p, d) => writeFileSync19(p, d), log = (m) => process.stdout.write(m + "\n"), postReview = defaultPostReview) {
-  const serialized = JSON.stringify(result.verdict, null, 2);
-  const jsonToStdout = opts.jsonPath === true;
-  if (!jsonToStdout) log(result.terminalOutput);
-  if (typeof opts.jsonPath === "string") writeFile2(opts.jsonPath, serialized);
-  else if (jsonToStdout) log(serialized);
-  if (opts.comment) {
+function createRecommendCommand() {
+  const command = new Command82("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 {
-      postReview(result.verdict);
+      const top = parseInt(opts.top, 10);
+      if (isNaN(top) || top < 1) {
+        logger.error("--top must be a positive integer");
+        process.exit(1);
+      }
+      if (mode === OutputMode.TEXT) {
+        console.log("");
+        console.log("Analyzing codebase health...");
+      }
+      const result = await runRecommend({
+        noCache: opts.cache === false,
+        top
+      });
+      if (mode === OutputMode.JSON) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        printRecommendations(result);
+      }
     } catch (err) {
-      logger.warn(
-        `review-ci: failed to post PR comment (${err instanceof Error ? err.message : String(err)}). The verdict above is authoritative; the exit code still reflects the gate.`
-      );
+      const message = err instanceof Error ? err.message : String(err);
+      if (mode === OutputMode.JSON) {
+        console.log(JSON.stringify({ error: message }));
+      } else {
+        logger.error(message);
+      }
+      process.exit(1);
     }
-  }
-}
-function createReviewCiCommand() {
-  return new Command81("review-ci").description("Run the tiered code-review gate (floor + optional LLM runner) for CI").addOption(
-    new Option2("--runner <runner>", `${KNOWN_RUNNERS.join(" | ")} (omit = floor-only)`).choices(
-      KNOWN_RUNNERS
-    )
-  ).addOption(
-    new Option2("--block-on <level>", BLOCK_ON_LEVELS.join(" | ")).choices(BLOCK_ON_LEVELS).default("request-changes")
-  ).option("--diff <range>", "git range (default: origin/<base>...HEAD)").option("--comment", "post the verdict as a comment on the current branch's PR via gh").option(
-    "--out <path>",
-    "write the verdict JSON artifact to a file (use the global --json to stream it to stdout instead)"
-  ).action(async (opts, cmd) => {
-    const result = await runReviewCi({
-      runner: opts.runner,
-      blockOn: opts.blockOn,
-      diffRange: opts.diff
-    });
-    const streamJson = cmd.optsWithGlobals().json === true;
-    emitReviewCi(result, {
-      jsonPath: typeof opts.out === "string" ? opts.out : streamJson ? true : void 0,
-      comment: opts.comment
-    });
-    process.exit(result.exitCode);
   });
+  return command;
 }
 
 // src/commands/roadmap/index.ts
-import { Command as Command87 } from "commander";
+import { Command as Command89 } from "commander";
 
 // src/commands/roadmap/migrate.ts
 init_dist3();
-import { Command as Command82 } from "commander";
+import { Command as Command83 } from "commander";
 import * as fs33 from "fs";
 import * as path54 from "path";
 import chalk14 from "chalk";
@@ -10788,7 +11117,7 @@ async function runReverseMigrate(opts) {
   }
 }
 function createRoadmapMigrateCommand() {
-  return new Command82("migrate").description("Migrate the project roadmap to a different storage mode").requiredOption("--to <target>", 'Migration target: "file-less" or "file-backed"').option("--dry-run", "Print the migration plan without making any changes", false).option(
+  return new Command83("migrate").description("Migrate the project roadmap to a different storage mode").requiredOption("--to <target>", 'Migration target: "file-less" or "file-backed"').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"
@@ -10823,7 +11152,7 @@ function createRoadmapMigrateCommand() {
 
 // src/commands/roadmap/shard.ts
 init_dist3();
-import { Command as Command83 } from "commander";
+import { Command as Command84 } from "commander";
 import * as path55 from "path";
 
 // src/commands/roadmap/shard-io.ts
@@ -10922,7 +11251,7 @@ async function runRoadmapShard(opts = {}) {
   return Ok(report);
 }
 function createRoadmapShardCommand() {
-  return new Command83("shard").description("Migrate docs/roadmap.md to per-row shards under docs/roadmap.d").option("--cwd <dir>", "Project root (defaults to the current working directory)").option("--dry-run", "Report the migration plan without writing anything", false).option("--force", "Proceed even if docs/roadmap.d already exists", false).option(
+  return new Command84("shard").description("Migrate docs/roadmap.md to per-row shards under docs/roadmap.d").option("--cwd <dir>", "Project root (defaults to the current working directory)").option("--dry-run", "Report the migration plan without writing anything", false).option("--force", "Proceed even if docs/roadmap.d already exists", false).option(
     "--format <fmt>",
     'Output format: "human" (default) or "json" (single JSON object for CI consumers)',
     "human"
@@ -10949,7 +11278,7 @@ function createRoadmapShardCommand() {
 
 // src/commands/roadmap/unshard.ts
 init_dist3();
-import { Command as Command84 } from "commander";
+import { Command as Command85 } from "commander";
 import * as path56 from "path";
 async function runRoadmapUnshard(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
@@ -10981,7 +11310,7 @@ async function runRoadmapUnshard(opts = {}) {
   return Ok(report);
 }
 function createRoadmapUnshardCommand() {
-  return new Command84("unshard").description("Reassemble the aggregate from shards and remove docs/roadmap.d").option("--cwd <dir>", "Project root (defaults to the current working directory)").option("--dry-run", "Preview the reassembly without writing or deleting the shard dir", false).option(
+  return new Command85("unshard").description("Reassemble the aggregate from shards and remove docs/roadmap.d").option("--cwd <dir>", "Project root (defaults to the current working directory)").option("--dry-run", "Preview the reassembly without writing or deleting the shard dir", false).option(
     "--format <fmt>",
     'Output format: "human" (default) or "json" (single JSON object for CI consumers)',
     "human"
@@ -11005,7 +11334,7 @@ function createRoadmapUnshardCommand() {
 
 // src/commands/roadmap/regen.ts
 init_dist3();
-import { Command as Command85 } from "commander";
+import { Command as Command86 } from "commander";
 import * as path57 from "path";
 async function runRoadmapRegen(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
@@ -11034,7 +11363,7 @@ async function runRoadmapRegen(opts = {}) {
   return Ok(report);
 }
 function createRoadmapRegenCommand() {
-  return new Command85("regen").description("Regenerate the aggregate from the shard directory (docs/roadmap.d)").option("--cwd <dir>", "Project root (defaults to the current working directory)").option("--dry-run", "Report what would be regenerated without writing anything", false).option(
+  return new Command86("regen").description("Regenerate the aggregate from the shard directory (docs/roadmap.d)").option("--cwd <dir>", "Project root (defaults to the current working directory)").option("--dry-run", "Report what would be regenerated without writing anything", false).option(
     "--format <fmt>",
     'Output format: "human" (default) or "json" (single JSON object for CI consumers)',
     "human"
@@ -11058,7 +11387,7 @@ function createRoadmapRegenCommand() {
 
 // src/commands/roadmap/reconcile.ts
 init_dist3();
-import { Command as Command86 } from "commander";
+import { Command as Command87 } from "commander";
 import * as fs34 from "fs";
 import * as path58 from "path";
 async function runRoadmapReconcile(opts = {}) {
@@ -11163,8 +11492,35 @@ function logSummary(result) {
     `Reconciled ${markedDone.length} row(s) to done: ${markedDone.join(", ")} (already-done: ${alreadyDone.length}, unmatched: ${unmatched.length}).`
   );
 }
+function parseFromRefsFlag(raw) {
+  const refs = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (refs.length === 0) {
+    logger.error(
+      `--from-refs was provided ("${raw}") but contained no valid references; expected a comma-separated list of owner/repo#number`
+    );
+    process.exit(ExitCode.ERROR);
+  }
+  return refs;
+}
+function parseFromIssuesFlag(raw) {
+  const parsed = raw.split(",").map((s) => Number.parseInt(s.trim(), 10)).filter((n) => Number.isInteger(n));
+  if (parsed.length === 0) {
+    logger.error(
+      `--from-issues was provided ("${raw}") but contained no valid issue numbers; expected a comma-separated list of integers`
+    );
+    process.exit(ExitCode.ERROR);
+  }
+  return parsed;
+}
+function buildReconcileOptions(options) {
+  const opts = {};
+  if (options.cwd) opts.cwd = options.cwd;
+  if (options.fromRefs !== void 0) opts.fromRefs = parseFromRefsFlag(options.fromRefs);
+  if (options.fromIssues !== void 0) opts.fromIssues = parseFromIssuesFlag(options.fromIssues);
+  return opts;
+}
 function createRoadmapReconcileCommand() {
-  return new Command86("reconcile").description(
+  return new Command87("reconcile").description(
     "Flip roadmap rows whose linked GitHub issue is closed to done. Offline mode flips only issues closed as 'completed' (a 'not planned'/'wontfix' close is left untouched); the PR-merge auto-done workflow remains authoritative for cross-repo correctness."
   ).option("--cwd <dir>", "Project root (defaults to the current working directory)").option(
     "--from-issues <numbers>",
@@ -11173,29 +11529,7 @@ function createRoadmapReconcileCommand() {
     "--from-refs <refs>",
     "comma-separated owner/repo#number closing-issue references (preferred; cross-repo safe; skips the network fetch)"
   ).action(async (options) => {
-    const opts = {};
-    if (options.cwd) opts.cwd = options.cwd;
-    if (options.fromRefs !== void 0) {
-      const refs = options.fromRefs.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-      if (refs.length === 0) {
-        logger.error(
-          `--from-refs was provided ("${options.fromRefs}") but contained no valid references; expected a comma-separated list of owner/repo#number`
-        );
-        process.exit(ExitCode.ERROR);
-      }
-      opts.fromRefs = refs;
-    }
-    if (options.fromIssues !== void 0) {
-      const parsed = options.fromIssues.split(",").map((s) => Number.parseInt(s.trim(), 10)).filter((n) => Number.isInteger(n));
-      if (parsed.length === 0) {
-        logger.error(
-          `--from-issues was provided ("${options.fromIssues}") but contained no valid issue numbers; expected a comma-separated list of integers`
-        );
-        process.exit(ExitCode.ERROR);
-      }
-      opts.fromIssues = parsed;
-    }
-    const result = await runRoadmapReconcile(opts);
+    const result = await runRoadmapReconcile(buildReconcileOptions(options));
     if (!result.ok) {
       logger.error(result.error.message);
       process.exit(result.error.exitCode);
@@ -11203,22 +11537,40 @@ function createRoadmapReconcileCommand() {
   });
 }
 
+// src/commands/roadmap/referenced-issues.ts
+init_dist3();
+import { Command as Command88 } from "commander";
+function runReferencedIssues(text, print) {
+  for (const n of parseReferencedIssues(text)) print(String(n));
+}
+function createRoadmapReferencedIssuesCommand() {
+  return new Command88("referenced-issues").description(
+    "Parse issue references (#N, Closes/Fixes/Resolves #N, owner/repo#N) from stdin text (PR body + title) and print each issue number on its own line. Backstop for auto-done when a PR's closing keyword is malformed."
+  ).action(async () => {
+    const chunks = [];
+    for await (const c of process.stdin) chunks.push(c);
+    const text = Buffer.concat(chunks).toString("utf8");
+    runReferencedIssues(text, (line) => process.stdout.write(line + "\n"));
+  });
+}
+
 // src/commands/roadmap/index.ts
 function createRoadmapCommand() {
-  const roadmap = new Command87("roadmap").description("Roadmap management");
+  const roadmap = new Command89("roadmap").description("Roadmap management");
   roadmap.addCommand(createRoadmapMigrateCommand());
   roadmap.addCommand(createRoadmapShardCommand());
   roadmap.addCommand(createRoadmapUnshardCommand());
   roadmap.addCommand(createRoadmapRegenCommand());
   roadmap.addCommand(createRoadmapReconcileCommand());
+  roadmap.addCommand(createRoadmapReferencedIssuesCommand());
   return roadmap;
 }
 
 // src/commands/routing/index.ts
-import { Command as Command91 } from "commander";
+import { Command as Command93 } from "commander";
 
 // src/commands/routing/config.ts
-import { Command as Command88 } from "commander";
+import { Command as Command90 } from "commander";
 
 // src/commands/routing/http-client.ts
 function orchestratorBase() {
@@ -11283,7 +11635,7 @@ function renderHuman(data) {
   }
 }
 function createConfigCommand() {
-  return new Command88("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 Command90("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) {
@@ -11309,7 +11661,7 @@ function createConfigCommand() {
 }
 
 // src/commands/routing/trace.ts
-import { Command as Command89 } from "commander";
+import { Command as Command91 } from "commander";
 function buildUseCase(opts) {
   if (opts.skill) {
     return opts.mode ? { kind: "skill", skillName: opts.skill, cognitiveMode: opts.mode } : { kind: "skill", skillName: opts.skill };
@@ -11330,7 +11682,7 @@ function renderHuman2(r) {
   }
 }
 function createTraceCommand() {
-  return new Command89("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 Command91("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");
@@ -11362,7 +11714,7 @@ function createTraceCommand() {
 }
 
 // src/commands/routing/decisions.ts
-import { Command as Command90 } from "commander";
+import { Command as Command92 } from "commander";
 function summarizeUseCase(uc) {
   switch (uc.kind) {
     case "skill":
@@ -11410,7 +11762,7 @@ function buildQuery(opts) {
   return q ? `?${q}` : "";
 }
 function createDecisionsCommand() {
-  return new Command90("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 Command92("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}`);
@@ -11440,7 +11792,7 @@ function createDecisionsCommand() {
 
 // src/commands/routing/index.ts
 function createRoutingCommand() {
-  const cmd = new Command91("routing").description(
+  const cmd = new Command93("routing").description(
     "Inspect routing config, trace decisions, and read recent dispatches"
   );
   cmd.addCommand(createConfigCommand());
@@ -11451,9 +11803,9 @@ function createRoutingCommand() {
 
 // src/commands/scan-config.ts
 init_dist3();
-import { Command as Command92 } from "commander";
-import { existsSync as existsSync30, readFileSync as readFileSync21, writeFileSync as writeFileSync22 } from "fs";
-import { join as join48, relative as relative3 } from "path";
+import { Command as Command94 } from "commander";
+import { existsSync as existsSync30, readFileSync as readFileSync22, writeFileSync as writeFileSync22 } from "fs";
+import { join as join49, relative as relative3 } from "path";
 var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".gemini/settings.json", "skill.yaml"];
 function stripHighSeverityPatterns(content, injectionFindings) {
   const highLines = /* @__PURE__ */ new Set();
@@ -11489,7 +11841,7 @@ function scanSingleFile(filePath, targetDir, scanner, options) {
   if (!existsSync30(filePath)) return null;
   let content;
   try {
-    content = readFileSync21(filePath, "utf8");
+    content = readFileSync22(filePath, "utf8");
   } catch {
     return null;
   }
@@ -11510,7 +11862,7 @@ async function runScanConfig(targetDir, options) {
   const scanner = new SecurityScanner(parseSecurityConfig({}));
   const results = [];
   for (const configFile of CONFIG_FILES) {
-    const result = scanSingleFile(join48(targetDir, configFile), targetDir, scanner, options);
+    const result = scanSingleFile(join49(targetDir, configFile), targetDir, scanner, options);
     if (result) results.push(result);
   }
   return { exitCode: computeScanExitCode(results), results };
@@ -11540,7 +11892,7 @@ function formatTextOutput(result) {
   }
 }
 function createScanConfigCommand() {
-  const command = new Command92("scan-config").description(
+  const command = new Command94("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();
@@ -11558,7 +11910,7 @@ function createScanConfigCommand() {
 
 // src/commands/search.ts
 init_dist();
-import { Command as Command93 } from "commander";
+import { Command as Command95 } from "commander";
 function parseFileKinds(raw) {
   if (!raw) return void 0;
   const set = /* @__PURE__ */ new Set();
@@ -11579,7 +11931,7 @@ function fmtBytes(n) {
   return n.toFixed(0);
 }
 function createSearchCommand() {
-  return new Command93("search").description("Full-text search over archived + live session content.").argument(
+  return new Command95("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(
@@ -11639,9 +11991,9 @@ function createSearchCommand() {
 }
 
 // src/commands/security-craft.ts
-import { Command as Command94 } from "commander";
+import { Command as Command96 } from "commander";
 function createSecurityCraftCommand() {
-  return new Command94("security-craft").description(
+  return new Command96("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();
@@ -11707,7 +12059,7 @@ ${file}`);
 }
 
 // src/commands/setup.ts
-import { Command as Command95 } from "commander";
+import { Command as Command97 } from "commander";
 import * as fs37 from "fs";
 import * as os9 from "os";
 import * as path61 from "path";
@@ -12013,7 +12365,7 @@ async function detectLegacyLayout(cwd) {
 }
 async function runInitialGraphScan(cwd) {
   try {
-    const { runScan: runScan2 } = await import("./scan-P7YFKB77.js");
+    const { runScan: runScan2 } = await import("./scan-IYSVRPD2.js");
     const result = await runScan2(cwd);
     return {
       status: "pass",
@@ -12052,7 +12404,7 @@ async function runSetup(cwd) {
   return { steps, success };
 }
 function createSetupCommand() {
-  return new Command95("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
+  return new Command97("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
     const cwd = process.cwd();
     console.log("");
     console.log(`  ${chalk16.bold("harness setup")}`);
@@ -12075,7 +12427,7 @@ function createSetupCommand() {
 
 // src/commands/share.ts
 init_dist3();
-import { Command as Command96 } from "commander";
+import { Command as Command98 } from "commander";
 import * as fs38 from "fs";
 import * as path62 from "path";
 import { parse as parseYaml3 } from "yaml";
@@ -12134,16 +12486,16 @@ Create a constraints.yaml in your project root to define what to share.`
   logger.success(`Bundle written to ${outputPath}`);
 }
 function createShareCommand() {
-  return new Command96("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 Command98("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 Command104 } from "commander";
+import { Command as Command106 } from "commander";
 
 // src/commands/skill/list.ts
-import { Command as Command97 } from "commander";
+import { Command as Command99 } from "commander";
 import * as fs39 from "fs";
 import * as path63 from "path";
 import { parse } from "yaml";
@@ -12246,7 +12598,7 @@ function printSkillsVerbose(skills) {
   for (const s of skills) printSkillEntry(s);
 }
 function createListCommand3() {
-  return new Command97("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 Command99("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) {
@@ -12261,13 +12613,13 @@ function createListCommand3() {
 }
 
 // src/commands/skill/run.ts
-import { Command as Command98 } from "commander";
+import { Command as Command100 } from "commander";
 import * as fs40 from "fs";
 import * as path64 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/skill/complexity.ts
-import { execFileSync as execFileSync7 } from "child_process";
+import { execFileSync as execFileSync8 } from "child_process";
 function evaluateSignals(signals) {
   if (signals.fileCount >= 3) return "thorough";
   if (signals.newDir) return "thorough";
@@ -12279,17 +12631,17 @@ function evaluateSignals(signals) {
 }
 function detectComplexity(projectPath) {
   try {
-    const base = execFileSync7("git", ["merge-base", "HEAD", "main"], {
+    const base = execFileSync8("git", ["merge-base", "HEAD", "main"], {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const diffFiles = execFileSync7("git", ["diff", "--name-only", base], {
+    const diffFiles = execFileSync8("git", ["diff", "--name-only", base], {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim().split("\n").filter(Boolean);
-    const diffStat = execFileSync7("git", ["diff", "--stat", base], {
+    const diffStat = execFileSync8("git", ["diff", "--stat", base], {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -12409,7 +12761,7 @@ function resolvePhaseState(metadata, projectPath, phase) {
 }
 async function appendProjectState(content, metadata, projectPath, hasPathOpt) {
   if (!metadata?.state.persistent || !hasPathOpt) return content;
-  const { readHarnessState: readHarnessState2, isEmptyHarnessState } = await import("./state-events-F44CUUZG.js");
+  const { readHarnessState: readHarnessState2, isEmptyHarnessState } = await import("./state-events-YY5KBZTC.js");
   const stateResult = await readHarnessState2(projectPath);
   if (!stateResult.ok || isEmptyHarnessState(stateResult.value)) return content;
   const stateContent = JSON.stringify(stateResult.value, null, 2);
@@ -12475,14 +12827,14 @@ async function runSkill(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createRunCommand3() {
-  return new Command98("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 Command100("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 Command99 } from "commander";
+import { Command as Command101 } from "commander";
 import * as fs41 from "fs";
 import * as path65 from "path";
 import { parse as parse3 } from "yaml";
@@ -12546,7 +12898,7 @@ function validateSkillEntry(name, skillsDir, errors) {
   }
 }
 function createValidateCommand2() {
-  return new Command99("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
+  return new Command101("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
     if (!fs41.existsSync(skillsDir)) {
@@ -12576,7 +12928,7 @@ function createValidateCommand2() {
 }
 
 // src/commands/skill/info.ts
-import { Command as Command100 } from "commander";
+import { Command as Command102 } from "commander";
 import * as fs42 from "fs";
 import * as path66 from "path";
 import { parse as parse4 } from "yaml";
@@ -12621,7 +12973,7 @@ function printSkillInfo(skill) {
   console.log(`Persistent:  ${skill.state.persistent}`);
 }
 function createInfoCommand() {
-  return new Command100("info").description("Show metadata for a skill").argument("<name>", "Skill name (e.g., harness-tdd)").action(async (name, _opts, cmd) => {
+  return new Command102("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) {
@@ -12638,7 +12990,7 @@ function createInfoCommand() {
 }
 
 // src/commands/skill/search.ts
-import { Command as Command101 } from "commander";
+import { Command as Command103 } from "commander";
 async function runSearch(query, opts) {
   const results = await searchNpmRegistry(query, opts.registry);
   return results.filter((r) => {
@@ -12683,13 +13035,13 @@ async function runSearchAction(query, opts, globalOpts) {
   }
 }
 function createSearchCommand2() {
-  return new Command101("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 Command103("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 Command102 } from "commander";
+import { Command as Command104 } from "commander";
 import * as path67 from "path";
 import * as fs43 from "fs";
 import YAML from "yaml";
@@ -12809,7 +13161,7 @@ Next steps:`);
   logger.info(`  3. Run: harness skills publish`);
 }
 function createCreateCommand() {
-  return new Command102("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 Command104("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, {
@@ -12832,10 +13184,10 @@ function createCreateCommand() {
 }
 
 // src/commands/skill/publish.ts
-import { Command as Command103 } from "commander";
+import { Command as Command105 } from "commander";
 import * as fs45 from "fs";
 import * as path69 from "path";
-import { execFileSync as execFileSync8 } from "child_process";
+import { execFileSync as execFileSync9 } from "child_process";
 
 // src/registry/validator.ts
 import * as fs44 from "fs";
@@ -12989,7 +13341,7 @@ ${skillMdContent}`;
   if (opts.registry) {
     publishArgs.push("--registry", opts.registry);
   }
-  execFileSync8("npm", publishArgs, {
+  execFileSync9("npm", publishArgs, {
     cwd: skillDir,
     stdio: "pipe",
     timeout: 6e4
@@ -13001,7 +13353,7 @@ ${skillMdContent}`;
   };
 }
 function createPublishCommand() {
-  return new Command103("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 Command105("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 {
@@ -13026,7 +13378,7 @@ function createPublishCommand() {
 
 // src/commands/skill/index.ts
 function createSkillCommand() {
-  const command = new Command104("skill").description("Skill management commands");
+  const command = new Command106("skill").description("Skill management commands");
   command.addCommand(createListCommand3());
   command.addCommand(createRunCommand3());
   command.addCommand(createValidateCommand2());
@@ -13039,7 +13391,7 @@ function createSkillCommand() {
 
 // src/commands/snapshot.ts
 init_dist3();
-import { Command as Command105 } from "commander";
+import { Command as Command107 } from "commander";
 import { execSync as execSync5 } from "child_process";
 import chalk17 from "chalk";
 function getCommitHash3(cwd) {
@@ -13208,7 +13560,7 @@ function registerTrendsCommand(parent) {
     }
   });
 }
-function registerListCommand(parent) {
+function registerListCommand2(parent) {
   parent.command("list").description("List all captured architecture snapshots").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : OutputMode.TEXT;
@@ -13221,17 +13573,17 @@ function registerListCommand(parent) {
   });
 }
 function createSnapshotCommand() {
-  const command = new Command105("snapshot").description("Architecture timeline snapshot commands");
+  const command = new Command107("snapshot").description("Architecture timeline snapshot commands");
   registerCaptureCommand(command);
   registerTrendsCommand(command);
-  registerListCommand(command);
+  registerListCommand2(command);
   return command;
 }
 
 // src/commands/spec-craft.ts
-import { Command as Command106 } from "commander";
+import { Command as Command108 } from "commander";
 function createSpecCraftCommand() {
-  return new Command106("spec-craft").description(
+  return new Command108("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();
@@ -13299,7 +13651,7 @@ ${file}`);
 
 // src/commands/stale-constraints.ts
 init_dist3();
-import { Command as Command107 } from "commander";
+import { Command as Command109 } from "commander";
 import chalk18 from "chalk";
 var CATEGORIES = [
   "circular-deps",
@@ -13386,7 +13738,7 @@ async function runStaleConstraintsCommand(options) {
   );
 }
 function createStaleConstraintsCommand() {
-  return new Command107("stale-constraints").description(
+  return new Command109("stale-constraints").description(
     "Detect architectural constraints not violated within a window (candidates for removal)"
   ).option(
     "--window <days>",
@@ -13404,10 +13756,10 @@ function createStaleConstraintsCommand() {
 }
 
 // src/commands/state/index.ts
-import { Command as Command112 } from "commander";
+import { Command as Command114 } from "commander";
 
 // src/commands/state/show.ts
-import { Command as Command108 } from "commander";
+import { Command as Command110 } from "commander";
 import * as path70 from "path";
 function printStateText(state, stream) {
   if (stream) console.log(`Stream:         ${stream}`);
@@ -13432,7 +13784,7 @@ function printStateProgress(progress) {
   }
 }
 function createShowCommand() {
-  return new Command108("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 Command110("show").description("Show current project state").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const result = await readHarnessState(path70.resolve(opts.path), { stream: opts.stream });
     if (!result.ok) {
@@ -13450,7 +13802,7 @@ function createShowCommand() {
 
 // src/commands/state/reset.ts
 init_dist3();
-import { Command as Command109 } from "commander";
+import { Command as Command111 } from "commander";
 import * as path71 from "path";
 import * as readline3 from "readline";
 async function confirmReset() {
@@ -13476,15 +13828,15 @@ async function runReset(opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createResetCommand() {
-  return new Command109("reset").description("Reset project state (truncates the event log to a fresh default)").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 Command111("reset").description("Reset project state (truncates the event log to a fresh default)").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 Command110 } from "commander";
+import { Command as Command112 } from "commander";
 import * as path72 from "path";
 function createLearnCommand() {
-  return new Command110("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) => {
+  return new Command112("learn").description("Append a learning to .harness/learnings.md").argument("<message>", "The learning to record").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (message, opts, _cmd) => {
     const projectPath = path72.resolve(opts.path);
     const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
     if (!result.ok) {
@@ -13499,7 +13851,7 @@ function createLearnCommand() {
 
 // src/commands/state/streams.ts
 init_dist3();
-import { Command as Command111 } from "commander";
+import { Command as Command113 } from "commander";
 import * as path73 from "path";
 async function runListStreams(opts, globalOpts) {
   const projectPath = path73.resolve(opts.path);
@@ -13550,7 +13902,7 @@ async function runActivateStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createStreamsCommand() {
-  const command = new Command111("streams").description("Manage state streams");
+  const command = new Command113("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));
@@ -13560,7 +13912,7 @@ function createStreamsCommand() {
 
 // src/commands/state/index.ts
 function createStateCommand() {
-  const command = new Command112("state").description("Project state management commands");
+  const command = new Command114("state").description("Project state management commands");
   command.addCommand(createShowCommand());
   command.addCommand(createResetCommand());
   command.addCommand(createLearnCommand());
@@ -13571,7 +13923,7 @@ function createStateCommand() {
 // src/commands/sync-analyses.ts
 import * as fs46 from "fs";
 import * as path74 from "path";
-import { Command as Command113 } from "commander";
+import { Command as Command115 } 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);
@@ -13696,7 +14048,7 @@ async function runSyncAnalyses(opts) {
     return;
   }
   const { AnalysisArchive, loadPublishedIndex: loadPublishedIndex2, savePublishedIndex: savePublishedIndex2 } = await import("@harness-engineering/orchestrator");
-  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-IPVFYGY2.js");
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-MCTEX5QH.js");
   const adapter = new GitHubIssuesSyncAdapter2({ token, config: trackerConfig });
   const archive = new AnalysisArchive(path74.join(projectPath, ".harness", "analyses"));
   const publishedIndex = loadPublishedIndex2(projectPath);
@@ -13718,7 +14070,7 @@ async function runSyncAnalyses(opts) {
   }
 }
 function createSyncAnalysesCommand() {
-  const command = new Command113("sync-analyses").description(
+  const command = new Command115("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 {
@@ -13732,7 +14084,7 @@ function createSyncAnalysesCommand() {
 }
 
 // src/commands/sync-main.ts
-import { Command as Command114 } from "commander";
+import { Command as Command116 } from "commander";
 import * as path75 from "path";
 import {
   syncMain as defaultSyncMain
@@ -13763,7 +14115,7 @@ function formatHuman2(r) {
   }
 }
 function createSyncMainCommand() {
-  return new Command114("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) => {
+  return new Command116("sync-main").description("Fast-forward the local default branch from origin (no-op on conflict)").option("--json", "Emit a SyncMainResult JSON object", false).option("--path <path>", "Project root path", ".").action(async (opts) => {
     const cwd = path75.resolve(opts.path ?? ".");
     const exitCode = await runSyncMain({ cwd, json: Boolean(opts.json) });
     process.exit(exitCode);
@@ -13772,7 +14124,7 @@ function createSyncMainCommand() {
 
 // src/commands/taint.ts
 init_dist3();
-import { Command as Command115 } from "commander";
+import { Command as Command117 } from "commander";
 function getProjectRoot() {
   return process.cwd();
 }
@@ -13844,18 +14196,18 @@ function registerStatusCommand(taint) {
   });
 }
 function createTaintCommand() {
-  const taint = new Command115("taint").description("Manage sentinel session taint state");
+  const taint = new Command117("taint").description("Manage sentinel session taint state");
   registerClearCommand(taint);
   registerStatusCommand(taint);
   return taint;
 }
 
 // src/commands/telemetry/index.ts
-import { Command as Command119 } from "commander";
+import { Command as Command121 } from "commander";
 
 // src/commands/telemetry/identify.ts
 init_dist3();
-import { Command as Command116 } from "commander";
+import { Command as Command118 } from "commander";
 import * as fs47 from "fs";
 import * as path76 from "path";
 function telemetryFilePath(cwd) {
@@ -13879,7 +14231,7 @@ function printIdentity(identity) {
   }
 }
 function createIdentifyCommand() {
-  const cmd = new Command116("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 Command118("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: {} });
@@ -13904,7 +14256,7 @@ function createIdentifyCommand() {
 
 // src/commands/telemetry/status.ts
 init_dist3();
-import { Command as Command117 } from "commander";
+import { Command as Command119 } from "commander";
 function gatherEnvOverrides() {
   const overrides = {};
   if (process.env.DO_NOT_TRACK) overrides.DO_NOT_TRACK = process.env.DO_NOT_TRACK;
@@ -13946,7 +14298,7 @@ function printHumanStatus(result) {
   printEnvOverrides(result.envOverrides);
 }
 function createStatusCommand() {
-  const cmd = new Command117("status").description("Show current telemetry consent state, install ID, and identity").option("--json", "Output as JSON").action((opts) => {
+  const cmd = new Command119("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);
@@ -13979,11 +14331,11 @@ function createStatusCommand() {
 
 // src/commands/telemetry/test.ts
 init_dist3();
-import { Command as Command118 } from "commander";
+import { Command as Command120 } from "commander";
 
 // src/bin/command-telemetry.ts
-import { existsSync as existsSync43, readFileSync as readFileSync31, mkdirSync as mkdirSync22, appendFileSync, writeFileSync as writeFileSync28 } from "fs";
-import { join as join62, parse as parsePath, resolve as resolve45 } from "path";
+import { existsSync as existsSync43, readFileSync as readFileSync32, mkdirSync as mkdirSync22, appendFileSync, writeFileSync as writeFileSync28 } from "fs";
+import { join as join63, parse as parsePath, resolve as resolve45 } from "path";
 import { spawn as spawn2 } from "child_process";
 var POSTHOG_API_KEY = "phc_wNTdCMcfJXZPgdNeDociZW6vwoGGo4nb7vqEfWThFfsG";
 var EXCLUDED_COMMANDS = /* @__PURE__ */ new Set(["help", "completion"]);
@@ -13991,7 +14343,7 @@ function findProjectRoot(cwd) {
   let dir = resolve45(cwd);
   const { root } = parsePath(dir);
   while (dir !== root) {
-    if (existsSync43(join62(dir, "harness.config.json"))) return dir;
+    if (existsSync43(join63(dir, "harness.config.json"))) return dir;
     dir = resolve45(dir, "..");
   }
   return cwd;
@@ -14029,7 +14381,7 @@ function resolveCommandName(cmd) {
 }
 function writeCommandRecordSync(cwd, command, duration, outcome) {
   try {
-    const metricsDir = join62(cwd, ".harness", "metrics");
+    const metricsDir = join63(cwd, ".harness", "metrics");
     mkdirSync22(metricsDir, { recursive: true });
     const record = {
       skill: command,
@@ -14039,16 +14391,16 @@ function writeCommandRecordSync(cwd, command, duration, outcome) {
       outcome,
       phasesReached: []
     };
-    const adoptionFile = join62(metricsDir, "adoption.jsonl");
+    const adoptionFile = join63(metricsDir, "adoption.jsonl");
     appendFileSync(adoptionFile, JSON.stringify(record) + "\n");
   } catch {
   }
 }
 function isTelemetryDisabledByConfig(cwd) {
-  const configPath = join62(cwd, "harness.config.json");
+  const configPath = join63(cwd, "harness.config.json");
   if (!existsSync43(configPath)) return false;
   try {
-    const config = JSON.parse(readFileSync31(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync32(configPath, "utf-8"));
     return config?.telemetry?.enabled === false;
   } catch {
     return false;
@@ -14060,10 +14412,10 @@ function isTelemetryOptedOut(cwd) {
 }
 function flushTelemetryBackground(cwd) {
   try {
-    const adoptionFile = join62(cwd, ".harness", "metrics", "adoption.jsonl");
+    const adoptionFile = join63(cwd, ".harness", "metrics", "adoption.jsonl");
     if (!existsSync43(adoptionFile)) return;
     if (isTelemetryOptedOut(cwd)) return;
-    const reporterPath = join62(cwd, ".harness", "hooks", "telemetry-reporter.js");
+    const reporterPath = join63(cwd, ".harness", "hooks", "telemetry-reporter.js");
     if (!existsSync43(reporterPath)) return;
     const child = spawn2(process.execPath, [reporterPath], {
       cwd,
@@ -14101,7 +14453,7 @@ function reportTestSuccess(status, distinctId, identity) {
   if (identity.team) logger.info(`  team:        ${identity.team}`);
 }
 function createTestCommand() {
-  return new Command118("test").description("Send a test event to PostHog and verify connectivity").action(async () => {
+  return new Command120("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) {
@@ -14138,7 +14490,7 @@ function createTestCommand() {
 
 // src/commands/telemetry/index.ts
 function createTelemetryCommand() {
-  const command = new Command119("telemetry").description("Telemetry identity and status management");
+  const command = new Command121("telemetry").description("Telemetry identity and status management");
   command.addCommand(createIdentifyCommand());
   command.addCommand(createStatusCommand());
   command.addCommand(createTestCommand());
@@ -14146,9 +14498,9 @@ function createTelemetryCommand() {
 }
 
 // src/commands/test-craft.ts
-import { Command as Command120 } from "commander";
+import { Command as Command122 } from "commander";
 function createTestCraftCommand() {
-  return new Command120("test-craft").description(
+  return new Command122("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();
@@ -14218,7 +14570,7 @@ ${file}`);
 }
 
 // src/commands/traceability.ts
-import { Command as Command121 } from "commander";
+import { Command as Command123 } from "commander";
 import chalk19 from "chalk";
 function confidenceLabel(maxConfidence) {
   if (maxConfidence >= 0.8) return "explicit";
@@ -14260,9 +14612,11 @@ function buildFilterOptions(options) {
 }
 function handleNoStore2(mode) {
   if (mode === OutputMode.JSON) {
-    console.log(JSON.stringify({ error: "No knowledge graph found. Run `harness scan` first." }));
+    console.log(
+      JSON.stringify({ error: "No knowledge graph found. Run `harness graph scan` first." })
+    );
   } else {
-    logger.error("No knowledge graph found. Run `harness scan` first.");
+    logger.error("No knowledge graph found. Run `harness graph scan` first.");
   }
   process.exit(ExitCode.ERROR);
 }
@@ -14271,11 +14625,13 @@ function handleEmptyResults(mode) {
     console.log(
       JSON.stringify({
         results: [],
-        message: "No requirements found in graph. Run `harness scan` to ingest spec requirements."
+        message: "No requirements found in graph. Run `harness graph scan` to ingest spec requirements."
       })
     );
   } else if (mode !== OutputMode.QUIET) {
-    logger.info("No requirements found in graph. Run `harness scan` to ingest spec requirements.");
+    logger.info(
+      "No requirements found in graph. Run `harness graph scan` to ingest spec requirements."
+    );
   }
   process.exit(ExitCode.SUCCESS);
 }
@@ -14339,7 +14695,7 @@ async function runTraceability(options) {
   const projectPath = process.cwd();
   const store = await loadGraphStore(projectPath);
   if (!store) handleNoStore2(mode);
-  const graphModule = await import("./dist-OWHMNL4W.js");
+  const graphModule = await import("./dist-DWBTZXR5.js");
   const filterOptions = buildFilterOptions(options);
   const results = graphModule.queryTraceability(store, filterOptions);
   if (results.length === 0) handleEmptyResults(mode);
@@ -14354,7 +14710,7 @@ async function runTraceability(options) {
   process.exit(ExitCode.SUCCESS);
 }
 function createTraceabilityCommand() {
-  return new Command121("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 Command123("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,
@@ -14368,7 +14724,7 @@ function createTraceabilityCommand() {
 
 // src/commands/uninstall.ts
 import * as path77 from "path";
-import { Command as Command122 } from "commander";
+import { Command as Command124 } from "commander";
 async function runUninstall(skillName, options) {
   const packageName = resolvePackageName(skillName);
   const shortName = extractSkillName(packageName);
@@ -14405,7 +14761,7 @@ async function runUninstall(skillName, options) {
   return result;
 }
 function createUninstallCommand() {
-  const cmd = new Command122("uninstall");
+  const cmd = new Command124("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);
@@ -14427,7 +14783,7 @@ function createUninstallCommand() {
 init_dist3();
 import * as fs48 from "fs/promises";
 import * as path78 from "path";
-import { Command as Command123 } from "commander";
+import { Command as Command125 } from "commander";
 async function runUninstallConstraints(options) {
   const { packageName, configPath, lockfilePath } = options;
   const lockfileResult = await readLockfile(lockfilePath);
@@ -14484,7 +14840,7 @@ async function runUninstallConstraints(options) {
   };
 }
 function createUninstallConstraintsCommand() {
-  const cmd = new Command123("uninstall-constraints");
+  const cmd = new Command125("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) {
@@ -14524,10 +14880,10 @@ function createUninstallConstraintsCommand() {
 
 // src/commands/update.ts
 init_dist3();
-import { Command as Command124 } from "commander";
-import { execFile as execFile2, execFileSync as execFileSync9 } from "child_process";
-import { realpathSync, existsSync as existsSync44, readFileSync as readFileSync32 } from "fs";
-import { dirname as dirname24, join as join65 } from "path";
+import { Command as Command126 } from "commander";
+import { execFile as execFile2, execFileSync as execFileSync10 } from "child_process";
+import { realpathSync, existsSync as existsSync44, readFileSync as readFileSync33 } from "fs";
+import { dirname as dirname24, join as join66 } from "path";
 import { promisify as promisify2 } from "util";
 import readline4 from "readline";
 import chalk20 from "chalk";
@@ -14567,7 +14923,7 @@ async function getLatestVersionAsync(pkg) {
 function getInstalledVersions(pm, packages) {
   const versions = {};
   try {
-    const output = execFileSync9(pm, ["list", "-g", "--json"], {
+    const output = execFileSync10(pm, ["list", "-g", "--json"], {
       encoding: "utf-8",
       timeout: 15e3
     });
@@ -14588,7 +14944,7 @@ function getInstalledVersions(pm, packages) {
 }
 function getInstalledPackages(pm) {
   try {
-    const output = execFileSync9(pm, ["list", "-g", "--json"], {
+    const output = execFileSync10(pm, ["list", "-g", "--json"], {
       encoding: "utf-8",
       timeout: 15e3
     });
@@ -14618,9 +14974,9 @@ function prompt3(question) {
 function findPackageDir(resolvedBin) {
   let dir = dirname24(resolvedBin);
   for (let i = 0; i < 6; i++) {
-    if (existsSync44(join65(dir, "package.json"))) {
+    if (existsSync44(join66(dir, "package.json"))) {
       try {
-        const pkg = JSON.parse(readFileSync32(join65(dir, "package.json"), "utf-8"));
+        const pkg = JSON.parse(readFileSync33(join66(dir, "package.json"), "utf-8"));
         if (pkg?.name === CLI_PACKAGE) return dir;
       } catch {
       }
@@ -14643,7 +14999,7 @@ function findAllInstalls() {
   const args = isWindows ? ["harness"] : ["-a", "harness"];
   let output;
   try {
-    const raw = execFileSync9(cmd, args, { encoding: "utf-8", timeout: 5e3 });
+    const raw = execFileSync10(cmd, args, { encoding: "utf-8", timeout: 5e3 });
     if (typeof raw !== "string") return [];
     output = raw;
   } catch {
@@ -14665,7 +15021,7 @@ function findAllInstalls() {
     if (!packageDir) continue;
     let version = null;
     try {
-      const pkg = JSON.parse(readFileSync32(join65(packageDir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync33(join66(packageDir, "package.json"), "utf-8"));
       if (typeof pkg?.version === "string") version = pkg.version;
     } catch {
     }
@@ -14720,7 +15076,7 @@ async function offerCleanupOfOtherInstalls(activeDir) {
     }
     try {
       logger.info(`Uninstalling: ${cmd.display}`);
-      execFileSync9(cmd.bin, cmd.args, { stdio: "inherit", timeout: 12e4 });
+      execFileSync10(cmd.bin, cmd.args, { stdio: "inherit", timeout: 12e4 });
     } catch {
       logger.warn(`Uninstall failed for ${cmd.install.binPath}.`);
       console.log(`  Run manually: ${chalk20.cyan(cmd.display)}`);
@@ -14758,12 +15114,12 @@ async function ensureTelemetryIfNeeded() {
 }
 function refreshHooks() {
   const cwd = process.cwd();
-  const configPath = join65(cwd, "harness.config.json");
+  const configPath = join66(cwd, "harness.config.json");
   if (!existsSync44(configPath)) return;
   let profile = "standard";
-  const profilePath = join65(cwd, ".harness", "hooks", "profile.json");
+  const profilePath = join66(cwd, ".harness", "hooks", "profile.json");
   try {
-    const data = JSON.parse(readFileSync32(profilePath, "utf-8"));
+    const data = JSON.parse(readFileSync33(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
       profile = data.profile;
     }
@@ -14780,7 +15136,7 @@ function refreshHooks() {
 function runLocalGraphScan() {
   try {
     logger.info("Scanning codebase to rebuild knowledge graph...");
-    execFileSync9("harness", ["graph", "scan", "."], { stdio: "inherit" });
+    execFileSync10("harness", ["graph", "scan", "."], { stdio: "inherit" });
   } catch {
     logger.warn("Graph scan failed. Run manually:");
     console.log(`  ${chalk20.cyan("harness graph scan .")}`);
@@ -14795,7 +15151,7 @@ async function offerRegeneration() {
   const scopeAnswer = await prompt3("Generate for (G)lobal or (l)ocal project? (G/l) ");
   const isGlobal = scopeAnswer !== "l" && scopeAnswer !== "local";
   try {
-    execFileSync9("harness", ["generate", ...isGlobal ? ["--global"] : []], {
+    execFileSync10("harness", ["generate", ...isGlobal ? ["--global"] : []], {
       stdio: "inherit"
     });
   } catch {
@@ -14875,7 +15231,7 @@ async function runUpdateAction(opts, globalOpts) {
   }
   try {
     logger.info("Updating packages...");
-    execFileSync9(pm, ["install", "-g", ...installPkgs], { stdio: "inherit", timeout: 12e4 });
+    execFileSync10(pm, ["install", "-g", ...installPkgs], { stdio: "inherit", timeout: 12e4 });
     console.log("");
     logger.success("Update complete");
     invalidateCheckState();
@@ -14892,7 +15248,7 @@ async function runUpdateAction(opts, globalOpts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createUpdateCommand() {
-  return new Command124("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 Command126("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) => {
@@ -14902,9 +15258,9 @@ function createUpdateCommand() {
 }
 
 // src/commands/usage.ts
-import { Command as Command125 } from "commander";
+import { Command as Command127 } from "commander";
 async function loadAndPriceRecords(cwd, includeClaudeSessions = false) {
-  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-IPVFYGY2.js");
+  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-MCTEX5QH.js");
   const records = readCostRecords(cwd);
   if (includeClaudeSessions) {
     const ccRecords = parseCCRecords();
@@ -14997,7 +15353,7 @@ function registerDailyCommand(usage) {
       else logger.info("No usage data found. Run some harness sessions first.");
       return;
     }
-    const { aggregateByDay } = await import("./dist-IPVFYGY2.js");
+    const { aggregateByDay } = await import("./dist-MCTEX5QH.js");
     const limited = aggregateByDay(records).slice(0, days);
     if (globalOpts.json) {
       console.log(
@@ -15026,7 +15382,7 @@ function registerSessionsCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-IPVFYGY2.js");
+    const { aggregateBySession } = await import("./dist-MCTEX5QH.js");
     const sessionData = aggregateBySession(records);
     const limited = sessionData.slice(0, limit);
     if (globalOpts.json) {
@@ -15106,7 +15462,7 @@ function registerSessionCommand(usage) {
       cwd,
       globalOpts.includeClaudeSessions
     );
-    const { aggregateBySession } = await import("./dist-IPVFYGY2.js");
+    const { aggregateBySession } = await import("./dist-MCTEX5QH.js");
     const sessionData = aggregateBySession(records);
     const match = sessionData.find((s) => s.sessionId === id);
     if (!match) {
@@ -15141,7 +15497,7 @@ function registerLatestCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-IPVFYGY2.js");
+    const { aggregateBySession } = await import("./dist-MCTEX5QH.js");
     const sessionData = aggregateBySession(records);
     const latest = sessionData[0];
     if (!latest) {
@@ -15167,7 +15523,7 @@ function registerLatestCommand(usage) {
   });
 }
 function createUsageCommand() {
-  const usage = new Command125("usage").description("Token usage and cost tracking");
+  const usage = new Command127("usage").description("Token usage and cost tracking");
   usage.option(
     "--include-claude-sessions",
     "Include Claude Code session data from ~/.claude/projects/"
@@ -15182,10 +15538,10 @@ function createUsageCommand() {
 // src/commands/validate.ts
 init_dist3();
 init_dist3();
-import { Command as Command126 } from "commander";
+import { Command as Command128 } from "commander";
 import * as fs49 from "fs";
 import * as path79 from "path";
-import { execFileSync as execFileSync10 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 async function runValidate(options) {
   const configResult = resolveConfig(options.configPath);
   if (!configResult.ok) {
@@ -15304,7 +15660,7 @@ async function runValidate(options) {
     const gitattributesContent = fs49.readFileSync(gitattributesPath, "utf-8");
     let driverConfigured = false;
     try {
-      const out = execFileSync10("git", ["config", "--get", "merge.ours.driver"], {
+      const out = execFileSync11("git", ["config", "--get", "merge.ours.driver"], {
         cwd,
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "ignore"]
@@ -15490,7 +15846,7 @@ function resolveValidateMode(globalOpts) {
   return OutputMode.TEXT;
 }
 async function printCrossCheckWarnings(mode) {
-  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-M2ZM6RFY.js");
+  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-OYKEDCST.js");
   const cwd = process.cwd();
   const crossResult = await runCrossCheck2({
     specsDir: path79.join(cwd, "docs", "specs"),
@@ -15506,7 +15862,7 @@ async function printCrossCheckWarnings(mode) {
   ${crossResult.value.warnings} warnings`);
 }
 function createValidateCommand3() {
-  const command = new Command126("validate").description("Run all validation checks").option("--cross-check", "Run cross-artifact consistency validation").option(
+  const command = new Command128("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()));
@@ -15555,7 +15911,7 @@ Agent configs checked via ${engineLabel}${note}`);
 
 // src/commands/verify.ts
 init_dist3();
-import { Command as Command127 } from "commander";
+import { Command as Command129 } from "commander";
 import { execSync as execSync6 } from "child_process";
 function loadBranchingConfig(configPath) {
   const shouldLoad = configPath !== void 0 || findConfigFile().ok;
@@ -15618,7 +15974,7 @@ async function runVerify(options) {
   process.exit(ExitCode.VALIDATION_FAILED);
 }
 function createVerifyCommand() {
-  return new Command127("verify").description(
+  return new Command129("verify").description(
     "Verify project conventions (currently: branch naming). Works with or without a harness.config.json."
   ).option(
     "--branch <name>",
@@ -15669,7 +16025,6 @@ var commandCreators = [
   createGraphCommand,
   createHooksCommand,
   createImpactPreviewCommand,
-  createIngestCommand,
   createInitCommand3,
   createInsightsCommand,
   createInstallCommand,
@@ -15690,15 +16045,14 @@ var commandCreators = [
   createPerfCommand,
   createPersonaCommand,
   createPredictCommand,
+  createPreMergeBriefCommand,
   createProposalsCommand,
   createPublishAnalysesCommand,
   createPulseCommand,
-  createQueryCommand,
   createRecommendCommand,
   createReviewCiCommand,
   createRoadmapCommand,
   createRoutingCommand,
-  createScanCommand,
   createScanConfigCommand,
   createSearchCommand,
   createSecurityCraftCommand,
@@ -15724,13 +16078,35 @@ var commandCreators = [
   createVerifyCommand
 ];
 
+// src/commands/graph/deprecated-aliases.ts
+var DEPRECATED_GRAPH_ALIASES = [
+  { factory: createScanCommand, canonical: "harness graph scan" },
+  { factory: createQueryCommand, canonical: "harness graph query" },
+  { factory: createIngestCommand, canonical: "harness graph ingest" }
+];
+function registerDeprecatedGraphAliases(program) {
+  for (const { factory, canonical } of DEPRECATED_GRAPH_ALIASES) {
+    const alias = factory();
+    alias.hook("preAction", (thisCommand) => {
+      const globalOpts = thisCommand.optsWithGlobals();
+      if (globalOpts.quiet) return;
+      process.stderr.write(
+        `\u26A0 "harness ${alias.name()}" is deprecated and will be removed in the next major release. Use "${canonical}" instead.
+`
+      );
+    });
+    program.addCommand(alias, { hidden: true });
+  }
+}
+
 // src/index.ts
 function createProgram() {
-  const program = new Command128();
+  const program = new Command130();
   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());
   }
+  registerDeprecatedGraphAliases(program);
   return program;
 }