@harness-engineering/cli 4.3.3 → 6.0.0

package/dist/{chunk-YVI7ZV73.js → chunk-VGDZAWCJ.js}

@@ -1,22 +1,22 @@
 import {
   generateRuntime
-} from "./chunk-574JCBYH.js";
+} from "./chunk-TM4KFUWP.js";
 import {
   generateAgentsMd
-} from "./chunk-TKPAOB2T.js";
+} from "./chunk-VRA64HYI.js";
 import {
   generateCIWorkflow
-} from "./chunk-GTHL3TRZ.js";
+} from "./chunk-XF6RE3JQ.js";
 import {
   readHarnessState
-} from "./chunk-NEMB36N4.js";
+} from "./chunk-MEIUXTFY.js";
 import {
   runCrossCheck
-} from "./chunk-MIZQY35D.js";
+} from "./chunk-D7QXGI6E.js";
 import {
   createGenerateAgentDefinitionsCommand,
   generateAgentDefinitions
-} from "./chunk-CMU4DNLY.js";
+} from "./chunk-IXGYIQSR.js";
 import {
   toKebabCase
 } from "./chunk-KET4QQZB.js";
@@ -26,7 +26,7 @@ import {
 } from "./chunk-YYFSFSB3.js";
 import {
   TemplateEngine
-} from "./chunk-6NEJPS7W.js";
+} from "./chunk-JJLOWMGC.js";
 import {
   generate,
   validate
@@ -37,7 +37,7 @@ import {
 import {
   listPersonas,
   loadPersona
-} from "./chunk-73QZ43DF.js";
+} from "./chunk-KPBGAB35.js";
 import {
   runPersona
 } from "./chunk-GISMXMVL.js";
@@ -51,7 +51,7 @@ import {
   OutputFormatter,
   OutputMode,
   createCheckPhaseGateCommand
-} from "./chunk-LP764MGR.js";
+} from "./chunk-6Y6M3AZA.js";
 import {
   appendFrameworkAgents,
   captureHealthSnapshot,
@@ -79,7 +79,7 @@ import {
   runSecurityCraft,
   runSpecCraft,
   runTestCraft
-} from "./chunk-F3GNBRGL.js";
+} from "./chunk-EFWRZHZ7.js";
 import {
   VALID_PLATFORMS
 } from "./chunk-3ISINLYT.js";
@@ -108,7 +108,7 @@ import {
   BranchingConfigSchema,
   findConfigFile,
   resolveConfig
-} from "./chunk-LTYVAKWK.js";
+} from "./chunk-IOJGLIEQ.js";
 import {
   logger
 } from "./chunk-EBJQ6N4M.js";
@@ -146,6 +146,7 @@ import {
   checkRoadmapAggregateDrift,
   checkRoadmapHealth,
   checkTaint,
+  classifyRevert,
   clearTaint,
   computeHotspots,
   computeOverallSeverity,
@@ -225,7 +226,7 @@ import {
   writeConfig,
   writeLockfile,
   writeRegeneratedRoadmap
-} from "./chunk-CRHQYBDA.js";
+} from "./chunk-CTMHHMHQ.js";
 import {
   CLI_VERSION
 } from "./chunk-BM3PWGXQ.js";
@@ -238,14 +239,14 @@ import {
   detectDocDrift,
   generateSuggestions,
   validateDependencies
-} from "./chunk-7RH2NTLA.js";
+} from "./chunk-NZ5AXKRA.js";
 import {
   Err,
   INDEXED_FILE_KINDS,
   INSIGHTS_KEYS,
   Ok,
   init_dist
-} from "./chunk-VJDSB7CI.js";
+} from "./chunk-LHWBQD7F.js";
 import {
   DEFAULT_SKIP_DIRS,
   DesignConstraintAdapter,
@@ -262,7 +263,7 @@ import {
 } from "./chunk-KFQGP6VL.js";
 
 // src/index.ts
-import { Command as Command130 } from "commander";
+import { Command as Command133 } from "commander";
 
 // src/commands/add.ts
 init_dist3();
@@ -453,7 +454,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-BWFFVKEW.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-4CZLCE33.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -489,7 +490,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-BWFFVKEW.js");
+    const { readAdoptionRecords } = await import("./dist-4CZLCE33.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -567,7 +568,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-BWFFVKEW.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-4CZLCE33.js");
     const records = readAdoptionRecords(cwd);
     const skillRecords = records.filter((r) => r.skill === name);
     if (skillRecords.length === 0) {
@@ -601,7 +602,7 @@ function registerRetrospectiveCommand(adoption) {
   adoption.command("retrospective").description("Generate a catalog retrospective from adoption telemetry").option("--inactive-days <n>", "Inactivity threshold in days (default: 90)", "90").option("--top <n>", "Rows per ranked section (default: 10)", "10").option("--out <path>", "Output file path (default: docs/retrospectives/YYYY-MM-DD.md)").option("--no-write", "Print the report to stdout instead of writing a file").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { readAdoptionRecords, getCatalogRetrospectiveReport, renderRetrospectiveMarkdown } = await import("./dist-BWFFVKEW.js");
+    const { readAdoptionRecords, getCatalogRetrospectiveReport, renderRetrospectiveMarkdown } = await import("./dist-4CZLCE33.js");
     const records = readAdoptionRecords(cwd);
     const catalogSkills = discoverCatalogSkills(cwd);
     const report = getCatalogRetrospectiveReport(records, {
@@ -5248,16 +5249,9 @@ function createRemoveCommand() {
 import { Command as Command41 } from "commander";
 import * as fs13 from "fs";
 import * as path27 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-var __dirname3 = path27.dirname(fileURLToPath3(import.meta.url));
 var ALIASES = {
   sentinel: ["sentinel-pre", "sentinel-post"]
 };
-function hookSourceDir() {
-  const d = path27.resolve(__dirname3, "..", "..", "hooks");
-  if (fs13.existsSync(d)) return d;
-  throw new Error(`Hook scripts not found: ${d}`);
-}
 function readJson(p) {
   return fs13.existsSync(p) ? JSON.parse(fs13.readFileSync(p, "utf-8")) : {};
 }
@@ -5271,7 +5265,7 @@ function registerHook(s, ev, matcher, name) {
 function addHooks(hookName, projectDir) {
   const names = ALIASES[hookName] ?? [hookName];
   const result = { added: [], alreadyInstalled: [], notFound: [] };
-  const srcDir = hookSourceDir();
+  const srcDir = resolveHookSourceDir();
   const destDir = path27.join(projectDir, ".harness", "hooks");
   fs13.mkdirSync(destDir, { recursive: true });
   const claudeDir = path27.join(projectDir, ".claude");
@@ -6209,7 +6203,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-BWFFVKEW.js");
+    const { composeInsights } = await import("./dist-4CZLCE33.js");
     const report = await composeInsights(cwd, { skip });
     if (opts.json) {
       console.log(JSON.stringify(report, null, 2));
@@ -7944,10 +7938,10 @@ function reportDispatcher() {
 function realGit(args, cwd) {
   return execFileSync4("git", args, { cwd, encoding: "utf-8" }).toString().trim();
 }
-function createFixDispatcher(resolveBackend, git = realGit) {
+function createFixDispatcher(resolveBackend, git2 = realGit) {
   return createAgentDispatcher({
     resolveBackend,
-    git,
+    git: git2,
     logger: {
       info: (message) => logger.info(message),
       warn: (message) => logger.warn(message)
@@ -8320,7 +8314,7 @@ function createMcpCommand() {
     parseBudget
   ).action(async (opts) => {
     const [{ startServer: startServer2, getToolDefinitions: getToolDefinitions2 }, { selectTier }] = await Promise.all([
-      import("./mcp-VSSIWTII.js"),
+      import("./mcp-XX6EIBLL.js"),
       import("./tool-tiers-OKK5FE57.js")
     ]);
     if (opts.tools && opts.tools.length > 0) {
@@ -8862,7 +8856,7 @@ function updateReferences(plan) {
 }
 async function prompt(question, def = "n") {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve50) => rl.question(question, resolve50));
+  const answer = await new Promise((resolve49) => rl.question(question, resolve49));
   rl.close();
   return (answer.trim() || def).toLowerCase();
 }
@@ -9051,7 +9045,7 @@ function createMigrateCommand() {
 // src/commands/models.ts
 init_dist3();
 import { Command as Command66 } from "commander";
-import { resolve as resolve31 } from "path";
+import { resolve as resolve30 } from "path";
 import { defaultFetchModels } from "@harness-engineering/orchestrator";
 function errorResult(message, partial) {
   return {
@@ -9169,7 +9163,7 @@ function formatProbe(result) {
   return lines.join("\n");
 }
 function projectRoot() {
-  return resolve31(process.env["HARNESS_PROJECT_ROOT"] ?? process.cwd());
+  return resolve30(process.env["HARNESS_PROJECT_ROOT"] ?? process.cwd());
 }
 function summarizeModelProposal(p) {
   const base = { id: p.id, status: p.status, proposedBy: p.proposedBy, createdAt: p.createdAt };
@@ -9430,7 +9424,7 @@ import { Command as Command69 } from "commander";
 init_dist3();
 import { Command as Command68 } from "commander";
 import { randomBytes } from "crypto";
-import { resolve as resolve32 } from "path";
+import { resolve as resolve31 } from "path";
 import { SinkRegistry, SinkConfigError, wrapAsEnvelope } from "@harness-engineering/orchestrator";
 function makeTestEvent(message) {
   return {
@@ -9482,7 +9476,7 @@ async function runNotificationsTest(sinkId, opts, projectRoot3 = process.cwd())
 function createNotificationsTestSubcommand() {
   return new Command68("test").description("Send a synthetic notification.test event through the named sink").argument("<sink-id>", "Sink id from harness.config.json `notifications.sinks[].id`").option("--message <text>", "Override the default test message").action(async (sinkId, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const projectRoot3 = typeof globalOpts["cwd"] === "string" ? resolve32(globalOpts["cwd"]) : process.cwd();
+    const projectRoot3 = typeof globalOpts["cwd"] === "string" ? resolve31(globalOpts["cwd"]) : process.cwd();
     const result = await runNotificationsTest(sinkId, opts, projectRoot3);
     if (globalOpts["json"]) {
       console.log(JSON.stringify(result, null, 2));
@@ -9507,7 +9501,12 @@ function createNotificationsCommand() {
 // src/commands/orchestrator.ts
 import { Command as Command70 } from "commander";
 import * as path50 from "path";
-import { Orchestrator, WorkflowLoader as WorkflowLoader2, launchTUI } from "@harness-engineering/orchestrator";
+import {
+  Orchestrator,
+  WorkflowLoader as WorkflowLoader2,
+  launchTUI,
+  discoverCandidates
+} from "@harness-engineering/orchestrator";
 function createOrchestratorCommand() {
   const orchestrator = new Command70("orchestrator");
   orchestrator.command("run").description("Run the orchestrator daemon").option("-w, --workflow <path>", "Path to harness.orchestrator.md", "harness.orchestrator.md").option("--headless", "Run without TUI (server-only mode for use with web dashboard)").action(async (opts) => {
@@ -9520,7 +9519,7 @@ function createOrchestratorCommand() {
     }
     const { config, promptTemplate, warnings } = result.value;
     for (const w of warnings) logger.warn(w);
-    const daemon = new Orchestrator(config, promptTemplate);
+    const daemon = new Orchestrator(config, promptTemplate, { discoverCandidates });
     const shutdown = () => {
       daemon.stop();
       process.exit(ExitCode.SUCCESS);
@@ -9551,7 +9550,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-BWFFVKEW.js");
+    const { BenchmarkRunner } = await import("./dist-4CZLCE33.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob2);
     if (benchFiles.length === 0) {
@@ -9615,7 +9614,7 @@ async function runBaselinesShow(globalOpts) {
 }
 async function runBaselinesUpdate(globalOpts) {
   const cwd = process.cwd();
-  const { BenchmarkRunner } = await import("./dist-BWFFVKEW.js");
+  const { BenchmarkRunner } = await import("./dist-4CZLCE33.js");
   const runner = new BenchmarkRunner();
   const manager = new BaselineManager(cwd);
   logger.info("Running benchmarks to update baselines...");
@@ -9656,7 +9655,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-BWFFVKEW.js");
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-4CZLCE33.js");
     const analyzer = new EntropyAnalyzer2({
       rootDir: path51.resolve(cwd),
       analyze: { complexity: true, coupling: true }
@@ -10443,9 +10442,9 @@ function createPreMergeBriefCommand() {
 // src/commands/proposals.ts
 init_dist3();
 import { Command as Command78 } from "commander";
-import { resolve as resolve36 } from "path";
+import { resolve as resolve35 } from "path";
 function projectRoot2() {
-  return resolve36(process.env["HARNESS_PROJECT_ROOT"] ?? process.cwd());
+  return resolve35(process.env["HARNESS_PROJECT_ROOT"] ?? process.cwd());
 }
 function summarizeProposal(p) {
   const base = {
@@ -10679,7 +10678,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-BWFFVKEW.js");
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-4CZLCE33.js");
   const archive = new AnalysisArchive(path53.join(projectPath, ".harness", "analyses"));
   const analyses = await archive.list();
   if (analyses.length === 0) {
@@ -10723,7 +10722,7 @@ import { Command as Command81 } from "commander";
 // src/commands/pulse/run.ts
 init_dist3();
 import { readFileSync as readFileSync19, mkdirSync as mkdirSync16, writeFileSync as writeFileSync20 } from "fs";
-import { dirname as dirname19, join as join43, resolve as resolve38 } from "path";
+import { dirname as dirname18, join as join43, resolve as resolve37 } from "path";
 import { Command as Command80 } from "commander";
 async function runPulseRunCommand(opts) {
   const startedAt = Date.now();
@@ -10756,7 +10755,7 @@ async function runPulseRunCommand(opts) {
   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 = join43(opts.outputDir, `${ts}.md`);
-  mkdirSync16(dirname19(filePath), { recursive: true });
+  mkdirSync16(dirname18(filePath), { recursive: true });
   writeFileSync20(filePath, report);
   const headlines = extractHeadlines(report);
   return emit2(
@@ -10799,8 +10798,8 @@ function createRunCommand2() {
     async (options) => {
       const nonInteractive = options.nonInteractive === true || !process.stdout.isTTY;
       const status = await runPulseRunCommand({
-        configPath: resolve38(process.cwd(), options.config),
-        outputDir: resolve38(process.cwd(), options.outputDir),
+        configPath: resolve37(process.cwd(), options.config),
+        outputDir: resolve37(process.cwd(), options.outputDir),
         nonInteractive,
         lookback: options.lookback
       });
@@ -11782,11 +11781,435 @@ function createRoadmapCommand() {
   return roadmap;
 }
 
+// src/commands/rollback.ts
+init_dist3();
+import { execFileSync as execFileSync10 } from "child_process";
+import { Command as Command90, Option as Option3, InvalidArgumentError } from "commander";
+
+// src/rollback/compose.ts
+var ROLLBACK_LABEL = "harness:rollback";
+function buildRevertBody(d, originalTitle, reason) {
+  const lines = [
+    `## Automated rollback proposal`,
+    ``,
+    `**Trigger:** ${d.trigger}`,
+    `**Target PR:** #${d.targetPr} \u2014 ${originalTitle}`,
+    `**Revert-ready:** ${d.revertReady}`,
+    d.blastRadius !== void 0 ? `**Blast radius:** ${d.blastRadius}` : void 0,
+    // #4: surface the human-provided --reason when present (help text promises it).
+    reason && reason.trim() !== "" ? `**Reason:** ${reason.trim()}` : void 0,
+    ``,
+    `### Classification`,
+    ...d.reasons.map((r) => `- ${r}`)
+  ];
+  if (d.migrationWarnings.length > 0) {
+    lines.push(
+      ``,
+      `### Migration / irreversibility warnings`,
+      ...d.migrationWarnings.map((w) => `- ${w}`)
+    );
+  }
+  if (d.dependentMerges.length > 0) {
+    lines.push(
+      ``,
+      `### Dependent later merges`,
+      `- ${d.dependentMerges.map((n) => `#${n}`).join(", ")}`
+    );
+  }
+  return lines.filter((l) => l !== void 0).join("\n");
+}
+async function composeRevertPr(decision, originalTitle, opts) {
+  if (!decision.revertReady) return { action: decision.action };
+  const body = buildRevertBody(decision, originalTitle, opts.reason);
+  if (opts.dryRun) {
+    const print = opts.print ?? ((s) => process.stdout.write(`${s}
+`));
+    print(body);
+    return { action: "proposed" };
+  }
+  const existing = await opts.gh.findOpenRevertPr(decision.targetPr, ROLLBACK_LABEL);
+  if (existing !== null) {
+    return { action: "skipped", ...existing.url ? { prUrl: existing.url } : {} };
+  }
+  const prUrl = await opts.gh.openPr({
+    title: `revert: ${originalTitle} (automated rollback)`,
+    body,
+    label: ROLLBACK_LABEL,
+    targetPr: decision.targetPr
+  });
+  return { action: "proposed", prUrl };
+}
+
+// src/rollback/breadcrumb.ts
+import { appendFileSync, mkdirSync as mkdirSync19 } from "fs";
+import { dirname as dirname20, join as join50 } from "path";
+var ROLLBACK_EVENTS_FILE = join50(".harness", "signals", "rollback-events.jsonl");
+async function appendRollbackEvent(event, opts = {}) {
+  const root = opts.root ?? process.cwd();
+  const ts = (opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))();
+  const file = join50(root, ROLLBACK_EVENTS_FILE);
+  mkdirSync19(dirname20(file), { recursive: true });
+  appendFileSync(file, `${JSON.stringify({ ...event, ts })}
+`, "utf-8");
+}
+async function linkRollbackEventToGraph(event, opts = {}) {
+  const root = opts.root ?? process.cwd();
+  try {
+    const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-STFGYKZH.js");
+    const store = await loadGraphStore2(root);
+    if (!store) return;
+    const ts = (opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))();
+    const nodeId = `rollback_event:${event.targetPr}:${ts}`;
+    store.addNode({
+      id: nodeId,
+      type: "learning",
+      name: `rollback ${event.action} for PR #${event.targetPr}`,
+      metadata: { kind: "rollback_event", ...event, ts },
+      lastModified: ts
+    });
+    const outcomes = store.findNodes({ type: "execution_outcome" });
+    const target = outcomes.find(
+      (n) => n.metadata.pr === event.targetPr
+    );
+    if (target) {
+      store.addEdge({ from: nodeId, to: target.id, type: "references" });
+    }
+    await store.save(join50(root, ".harness", "graph"));
+  } catch {
+  }
+}
+
+// src/rollback/io.ts
+import { execFileSync as execFileSync8 } from "child_process";
+var git = (args) => execFileSync8("git", args, { encoding: "utf-8" }).toString();
+var nodeGitSeam = {
+  run: (args) => git(args).trim(),
+  tryMergeTree: (args) => {
+    try {
+      const stdout = execFileSync8("git", args, {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }).toString();
+      return { status: 0, stdout };
+    } catch (err) {
+      const e = err;
+      return { status: e?.status ?? 1, stdout: e?.stdout?.toString?.() ?? "" };
+    }
+  }
+};
+var gh = (args) => execFileSync8("gh", args, { encoding: "utf-8" }).toString();
+function parseConflictPaths(stdout) {
+  const lines = stdout.split("\n");
+  const paths = /* @__PURE__ */ new Set();
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0 || line.trim() === "") break;
+    const tab = line.indexOf("	");
+    if (tab === -1) continue;
+    const path81 = line.slice(tab + 1).trim();
+    if (path81) paths.add(path81);
+  }
+  return [...paths];
+}
+async function computeRevertDryRun(mergeSha, gitSeam = nodeGitSeam) {
+  const revList = gitSeam.run(["rev-list", "--parents", "-n", "1", mergeSha]);
+  const parents = revList.trim().split(/\s+/).slice(1);
+  if (parents.length === 0) {
+    throw new Error(`cannot revert ${mergeSha}: commit has no parent (root commit)`);
+  }
+  const parent = parents[0];
+  const { status, stdout } = gitSeam.tryMergeTree([
+    "merge-tree",
+    "--write-tree",
+    "--merge-base",
+    mergeSha,
+    "HEAD",
+    parent
+  ]);
+  if (status === 0) return { clean: true, conflictPaths: [] };
+  if (status === 1) return { clean: false, conflictPaths: parseConflictPaths(stdout) };
+  throw new Error(
+    `git merge-tree failed for ${mergeSha} (exit ${status})${stdout ? `: ${stdout.trim()}` : ""}`
+  );
+}
+async function revertDryRun(mergeSha) {
+  return computeRevertDryRun(mergeSha, nodeGitSeam);
+}
+async function resolveTarget(pr) {
+  const raw = gh(["pr", "view", String(pr), "--json", "mergeCommit,files,title"]);
+  const parsed = JSON.parse(raw);
+  return {
+    mergeSha: parsed.mergeCommit?.oid ?? "",
+    changedFiles: (parsed.files ?? []).map((f) => f.path),
+    title: parsed.title ?? `PR #${pr}`
+  };
+}
+async function listLaterMerges(pr) {
+  const targetRaw = gh(["pr", "view", String(pr), "--json", "mergedAt"]);
+  const targetMergedAt = JSON.parse(targetRaw).mergedAt;
+  if (!targetMergedAt) return [];
+  const raw = gh([
+    "pr",
+    "list",
+    "--state",
+    "merged",
+    "--limit",
+    "100",
+    "--json",
+    "number,files,mergedAt"
+  ]);
+  const list = JSON.parse(raw);
+  return list.filter((p) => p.number !== pr && p.mergedAt > targetMergedAt).map((p) => ({ pr: p.number, changedFiles: (p.files ?? []).map((f) => f.path) }));
+}
+function createNodeRollbackIO() {
+  return { revertDryRun, resolveTarget, listLaterMerges };
+}
+
+// src/rollback/sweep.ts
+import { execFileSync as execFileSync9 } from "child_process";
+import { SignalTimelineStore } from "@harness-engineering/signals";
+var WINDOW_UNIT_MS = {
+  h: 36e5,
+  d: 864e5,
+  w: 6048e5
+};
+function parseWindow(window) {
+  const match = /^(\d+)([hdw])$/.exec(window);
+  if (!match) throw new Error(`invalid window: ${window}`);
+  const count = Number.parseInt(match[1] ?? "", 10);
+  const unit = match[2];
+  return count * WINDOW_UNIT_MS[unit];
+}
+function detectCrossing(points, rule) {
+  const prev = points.at(-2);
+  const curr = points.at(-1);
+  if (!prev || !curr) return false;
+  if (rule.direction === "above") {
+    return prev.value < rule.threshold && curr.value >= rule.threshold;
+  }
+  return prev.value > rule.threshold && curr.value <= rule.threshold;
+}
+function windowStart(now, window) {
+  return new Date(now.getTime() - parseWindow(window)).toISOString();
+}
+function pointsInWindow(points, now, window) {
+  const startDate = windowStart(now, window).slice(0, 10);
+  const nowDate = now.toISOString().slice(0, 10);
+  return points.filter((p) => p.date >= startDate && p.date <= nowDate);
+}
+async function runRollbackSweep(signals, deps) {
+  const now = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
+  for (const [name, rule] of Object.entries(signals)) {
+    const pts = pointsInWindow(deps.readTimeline(name), now, rule.window);
+    const crossed = detectCrossing(pts, rule);
+    const forwarded = [];
+    if (crossed) {
+      const prs = await deps.resolveMergedPrs(windowStart(now, rule.window), now.toISOString());
+      for (const pr of prs) {
+        const decision = await deps.evaluate(pr);
+        forwarded.push({
+          pr,
+          action: decision.action,
+          ...decision.prUrl ? { prUrl: decision.prUrl } : {}
+        });
+      }
+    }
+    deps.report?.({ signal: name, window: rule.window, crossed, forwarded });
+  }
+}
+function createTimelineReader(root) {
+  const store = new SignalTimelineStore(root);
+  return (name) => store.read(name);
+}
+function createPrResolver() {
+  return async (startIso, nowIso) => {
+    try {
+      const raw = execFileSync9(
+        "gh",
+        [
+          "pr",
+          "list",
+          "--state",
+          "merged",
+          "--search",
+          `merged:${startIso}..${nowIso}`,
+          "--json",
+          "number",
+          "--limit",
+          "100"
+        ],
+        { encoding: "utf-8" }
+      );
+      return JSON.parse(raw).map((p) => p.number);
+    } catch {
+      return [];
+    }
+  };
+}
+
+// src/commands/rollback.ts
+async function runRollbackEvaluate(args, deps) {
+  const trigger = args.trigger ?? "signal";
+  const target = await deps.io.resolveTarget(args.pr);
+  const laterMerges = await deps.io.listLaterMerges(args.pr);
+  const decision = await classifyRevert(
+    {
+      targetPr: args.pr,
+      trigger,
+      mergeSha: target.mergeSha,
+      changedFiles: target.changedFiles,
+      laterMerges
+    },
+    deps.io
+  );
+  const composed = await composeRevertPr(decision, target.title, {
+    gh: deps.gh,
+    ...args.dryRun ? { dryRun: true } : {},
+    ...deps.print ? { print: deps.print } : {},
+    ...args.reason !== void 0 ? { reason: args.reason } : {}
+  });
+  const finalDecision = {
+    ...decision,
+    action: composed.action,
+    ...composed.prUrl ? { prUrl: composed.prUrl } : {}
+  };
+  await appendRollbackEvent(
+    {
+      targetPr: finalDecision.targetPr,
+      trigger: finalDecision.trigger,
+      revertReady: finalDecision.revertReady,
+      action: finalDecision.action,
+      ...finalDecision.prUrl ? { prUrl: finalDecision.prUrl } : {},
+      // #4: record the human-provided reason on the breadcrumb (help text promises it).
+      ...args.reason !== void 0 ? { reason: args.reason } : {}
+    },
+    deps.root !== void 0 ? { root: deps.root } : {}
+  );
+  return finalDecision;
+}
+var gh2 = (args) => execFileSync10("gh", args, { encoding: "utf-8" }).toString();
+function referencesTargetPr(text, targetPr) {
+  if (!text) return false;
+  return new RegExp(`(?<!\\d)#${targetPr}(?!\\d)`).test(text);
+}
+function findOpenRevertPrNode(targetPr) {
+  try {
+    const raw = gh2([
+      "pr",
+      "list",
+      "--state",
+      "open",
+      "--label",
+      ROLLBACK_LABEL,
+      "--search",
+      `#${targetPr}`,
+      "--json",
+      "number,url,body,title"
+    ]);
+    const list = JSON.parse(raw);
+    const match = list.find(
+      (p) => referencesTargetPr(p.body, targetPr) || referencesTargetPr(p.title, targetPr)
+    );
+    return match ? { number: match.number, url: match.url } : null;
+  } catch {
+    return null;
+  }
+}
+function createGhSeam() {
+  return {
+    async findOpenRevertPr(targetPr) {
+      return findOpenRevertPrNode(targetPr);
+    },
+    async openPr({ title, body, label }) {
+      return execFileSync10(
+        "gh",
+        ["pr", "create", "--title", title, "--body-file", "-", "--label", label],
+        { input: body, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+      ).toString().trim();
+    }
+  };
+}
+function summarizeSweepReport(r) {
+  if (!r.crossed) {
+    return `rollback sweep: ${r.signal} (${r.window}) \u2014 no crossing`;
+  }
+  if (r.forwarded.length === 0) {
+    return `rollback sweep: ${r.signal} (${r.window}) \u2014 crossed, no PRs in window`;
+  }
+  const parts = r.forwarded.map((f) => `#${f.pr} \u2192 ${f.action}${f.prUrl ? ` (${f.prUrl})` : ""}`);
+  return `rollback sweep: ${r.signal} (${r.window}) \u2014 crossed; forwarded ${parts.join(", ")}`;
+}
+async function runRollbackSweepCommand(deps) {
+  const cfg = deps.resolveConfig();
+  if (!cfg.ok) {
+    deps.warn(`rollback sweep: config error, breaker inactive: ${cfg.error.message}`);
+  }
+  const signals = cfg.ok ? cfg.value.rollback?.signals ?? {} : {};
+  await deps.runSweep(signals, {
+    readTimeline: deps.makeReader(deps.root),
+    resolveMergedPrs: deps.makeResolver(),
+    evaluate: deps.evaluate,
+    report: (r) => deps.info(summarizeSweepReport(r))
+  });
+}
+function createRollbackCommand() {
+  const rollback = new Command90("rollback").description(
+    "Post-ship revert circuit breaker (propose-only in v1)"
+  );
+  rollback.command("evaluate").description("Classify a merged PR for revert-readiness and, if ready, propose a revert PR").requiredOption("--pr <n>", "target merged PR number", (v) => {
+    const n = Number.parseInt(v, 10);
+    if (Number.isNaN(n)) throw new InvalidArgumentError("--pr must be a number");
+    return n;
+  }).addOption(
+    new Option3("--trigger <trigger>", "what fired this evaluation").choices(["signal", "eval"]).default("signal")
+  ).option("--reason <str>", "human-readable reason recorded on the proposal").option("--dry-run", "print the revert PR body without opening a PR", false).action(async (opts) => {
+    const reason = opts.reason;
+    const dryRun = opts.dryRun;
+    const decision = await runRollbackEvaluate(
+      {
+        pr: opts.pr,
+        trigger: opts.trigger,
+        ...reason !== void 0 ? { reason } : {},
+        ...dryRun !== void 0 ? { dryRun } : {}
+      },
+      { io: createNodeRollbackIO(), gh: createGhSeam() }
+    );
+    await linkRollbackEventToGraph({
+      targetPr: decision.targetPr,
+      trigger: decision.trigger,
+      revertReady: decision.revertReady,
+      action: decision.action,
+      ...decision.prUrl ? { prUrl: decision.prUrl } : {}
+    });
+    logger.info(JSON.stringify(decision, null, 2));
+  });
+  rollback.command("sweep").description(
+    "Read the signal timeline and propose reverts for threshold crossings (signal arm)"
+  ).action(async () => {
+    await runRollbackSweepCommand({
+      resolveConfig,
+      runSweep: runRollbackSweep,
+      makeReader: createTimelineReader,
+      makeResolver: createPrResolver,
+      evaluate: (pr) => runRollbackEvaluate(
+        { pr, trigger: "signal" },
+        { io: createNodeRollbackIO(), gh: createGhSeam() }
+      ),
+      root: process.cwd(),
+      // #S4: per-signal summary on stdout so the sweep's work is auditable.
+      info: (line) => logger.info(line),
+      // #I2: config error → disarm warning on stderr, never silent.
+      warn: (line) => logger.error(line)
+    });
+  });
+  return rollback;
+}
+
 // src/commands/routing/index.ts
-import { Command as Command93 } from "commander";
+import { Command as Command96 } from "commander";
 
 // src/commands/routing/config.ts
-import { Command as Command90 } from "commander";
+import { Command as Command91 } from "commander";
 
 // src/commands/routing/http-client.ts
 function orchestratorBase() {
@@ -11851,7 +12274,7 @@ function renderHuman(data) {
   }
 }
 function createConfigCommand() {
-  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) => {
+  return new Command91("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) {
@@ -11877,7 +12300,13 @@ function createConfigCommand() {
 }
 
 // src/commands/routing/trace.ts
-import { Command as Command91 } from "commander";
+import { Command as Command92 } from "commander";
+var COMPLEXITY_VALUES = ["trivial", "simple", "moderate", "complex"];
+var RISK_VALUES = ["low", "high"];
+function validateEnum(flag, value, allowed) {
+  if (value === void 0 || allowed.includes(value)) return null;
+  return `Invalid ${flag} "${value}". Allowed values: ${allowed.join(", ")}.`;
+}
 function buildUseCase(opts) {
   if (opts.skill) {
     return opts.mode ? { kind: "skill", skillName: opts.skill, cognitiveMode: opts.mode } : { kind: "skill", skillName: opts.skill };
@@ -11896,41 +12325,60 @@ function renderHuman2(r) {
   for (const step of r.decision.resolutionPath) {
     console.log(`  ${step.source}:${step.candidate} -> ${step.outcome}`);
   }
+  if (r.tierRequired !== void 0) {
+    console.log(`Tier required: ${r.tierRequired}`);
+  }
+  if (r.estCostUsd !== void 0) {
+    console.log(`Est cost: $${r.estCostUsd.toFixed(4)}`);
+  }
 }
-function createTraceCommand() {
-  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");
-      process.exit(ExitCode.ERROR);
-      return;
-    }
-    const r = await postJson("/api/v1/routing/trace", { useCase });
-    if (!r.ok) {
-      if (r.status === 0) {
-        logger.error(
-          `Failed to reach orchestrator at ${orchestratorBase()}: ${r.error ?? "unknown error"}`
-        );
-      } else if (r.status === 503) {
-        logger.error(
-          "Routing observability not available \u2014 orchestrator has no BackendRouter (legacy single-backend config)"
-        );
-      } else {
-        logger.error(`Trace failed (${r.status}): ${r.error ?? ""}`);
-      }
-      process.exit(ExitCode.ERROR);
-      return;
-    }
-    if (opts.json) {
-      console.log(JSON.stringify(r.body, null, 2));
-      return;
-    }
-    if (r.body) renderHuman2(r.body);
+function traceErrorMessage(r) {
+  if (r.status === 0) {
+    return `Failed to reach orchestrator at ${orchestratorBase()}: ${r.error ?? "unknown error"}`;
+  }
+  if (r.status === 503) {
+    return "Routing observability not available \u2014 orchestrator has no BackendRouter (legacy single-backend config)";
+  }
+  return `Trace failed (${r.status}): ${r.error ?? ""}`;
+}
+async function runTrace(opts) {
+  const useCase = buildUseCase(opts);
+  if (!useCase) {
+    logger.error("Either --skill <name> or --mode <m> is required");
+    process.exit(ExitCode.ERROR);
+    return;
+  }
+  const enumError = validateEnum("--complexity", opts.complexity, COMPLEXITY_VALUES) ?? validateEnum("--risk", opts.risk, RISK_VALUES);
+  if (enumError) {
+    logger.error(enumError);
+    process.exit(ExitCode.ERROR);
+    return;
+  }
+  const r = await postJson("/api/v1/routing/trace", {
+    useCase,
+    ...opts.complexity ? { complexity: opts.complexity } : {},
+    ...opts.risk ? { risk: opts.risk } : {}
   });
+  if (!r.ok) {
+    logger.error(traceErrorMessage(r));
+    process.exit(ExitCode.ERROR);
+    return;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(r.body, null, 2));
+    return;
+  }
+  if (r.body) renderHuman2(r.body);
+}
+function createTraceCommand() {
+  return new Command92("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(
+    "--complexity <level>",
+    "Synthetic complexity (trivial|simple|moderate|complex) \u2014 dry-run only"
+  ).option("--risk <band>", "Synthetic risk band (low|high) \u2014 dry-run only").option("--json", "Emit JSON to stdout instead of human-readable text").action(runTrace);
 }
 
 // src/commands/routing/decisions.ts
-import { Command as Command92 } from "commander";
+import { Command as Command93 } from "commander";
 function summarizeUseCase(uc) {
   switch (uc.kind) {
     case "skill":
@@ -11978,7 +12426,7 @@ function buildQuery(opts) {
   return q ? `?${q}` : "";
 }
 function createDecisionsCommand() {
-  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(
+  return new Command93("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}`);
@@ -12006,22 +12454,162 @@ function createDecisionsCommand() {
   );
 }
 
+// src/commands/routing/telemetry.ts
+import { Command as Command94 } from "commander";
+var TIERS = ["fast", "standard", "strong"];
+function shortIso2(iso) {
+  const tail = iso.split("T")[1] ?? iso;
+  return tail.replace("Z", "");
+}
+function renderHuman4(data, tableLimit) {
+  if (data.decisions.length === 0) {
+    console.log("(no routing telemetry \u2014 AMR is off or no decisions recorded yet)");
+    return;
+  }
+  const byTier = /* @__PURE__ */ new Map();
+  for (const t of TIERS) byTier.set(t, { count: 0, cost: 0 });
+  for (const d of data.decisions) {
+    const bucket = byTier.get(d.tierRequired);
+    if (bucket) {
+      bucket.count += 1;
+      bucket.cost += d.estCostUsd;
+    }
+  }
+  console.log(`Decisions (retained ring): ${data.decisions.length}`);
+  console.log(`Ring spend total:          $${data.spentUsd.toFixed(4)}`);
+  console.log("");
+  console.log("TIER      COUNT   SHARE   COST");
+  for (const t of TIERS) {
+    const b = byTier.get(t);
+    const share = Math.round(b.count / data.decisions.length * 100);
+    console.log(
+      `${t.padEnd(9)} ${String(b.count).padStart(5)}   ${String(share).padStart(4)}%   $${b.cost.toFixed(4)}`
+    );
+  }
+  console.log("");
+  const rows = tableLimit !== void 0 ? data.decisions.slice(0, tableLimit) : data.decisions;
+  console.log(
+    `TIMESTAMP     TIER      BACKEND         COST${tableLimit !== void 0 ? `  (latest ${rows.length} of ${data.decisions.length})` : ""}`
+  );
+  for (const d of rows) {
+    const ts = shortIso2(d.decisionTs).padEnd(13);
+    const tier = d.tierRequired.padEnd(9);
+    const be = d.backend.padEnd(15);
+    console.log(`${ts} ${tier} ${be} $${d.estCostUsd.toFixed(4)}`);
+  }
+}
+function createTelemetryCommand() {
+  return new Command94("telemetry").description("Routing telemetry: per-decision tier/backend/cost + tier distribution (AMR)").option("--last <N>", "Show only the N most recent decisions in the per-decision table").option("--json", "Emit JSON to stdout instead of human-readable text").action(async (opts) => {
+    const r = await getJson("/api/v1/routing/telemetry");
+    if (!r.ok) {
+      if (r.status === 0) {
+        logger.error(
+          `Failed to reach orchestrator at ${orchestratorBase()}: ${r.error ?? "unknown error"}`
+        );
+      } else {
+        logger.error(`Request failed (${r.status}): ${r.error ?? ""}`);
+      }
+      process.exit(ExitCode.ERROR);
+      return;
+    }
+    const body = r.body ?? { decisions: [], spentUsd: 0 };
+    if (opts.json) {
+      console.log(JSON.stringify(body, null, 2));
+      return;
+    }
+    const tableLimit = opts.last && Number.isFinite(Number(opts.last)) && Number(opts.last) > 0 ? Math.floor(Number(opts.last)) : void 0;
+    renderHuman4(body, tableLimit);
+  });
+}
+
+// src/commands/routing/status.ts
+import { Command as Command95 } from "commander";
+function bar(pct, width = 24) {
+  const clamped = Math.max(0, Math.min(100, pct));
+  const filled = Math.round(clamped / 100 * width);
+  return `[${"#".repeat(filled)}${"-".repeat(width - filled)}]`;
+}
+function renderHuman5(s) {
+  if (!s.active) {
+    console.log("Adaptive routing: OFF (no routing.policy configured \u2014 dispatch is unchanged)");
+    return;
+  }
+  console.log("Adaptive routing: ON");
+  if (s.budget) {
+    const b = s.budget;
+    const state = b.exhausted ? "EXHAUSTED (hard cap \u2014 forcing fast / surfacing to steward)" : b.degrading ? "DEGRADING (clamping tiers down)" : "ok";
+    console.log("");
+    console.log("Budget:");
+    console.log(
+      `  $${b.spentUsd.toFixed(4)} / $${b.capUsd.toFixed(2)}  ${bar(b.spentPct)} ${b.spentPct}%`
+    );
+    console.log(`  degrade at ${b.degradeAtPct}% \u2192 ${state}`);
+  } else {
+    console.log("Budget:      (none configured)");
+  }
+  console.log("");
+  if (s.escalation.length === 0) {
+    console.log("Escalation:  (no units have climbed above the fast floor)");
+  } else {
+    console.log(`Escalation:  ${s.escalation.length} unit(s) climbed`);
+    console.log("  UNIT                                   FLOOR");
+    for (const u of s.escalation) {
+      console.log(`  ${u.coherenceUnit.padEnd(38)} ${u.floor}`);
+    }
+  }
+  console.log("");
+  console.log(
+    `Allowlist:   ${s.allowedProviders && s.allowedProviders.length > 0 ? s.allowedProviders.join(", ") : "(all providers allowed)"}`
+  );
+}
+function createStatusCommand() {
+  return new Command95("status").description(
+    "Live routing status: budget spend-vs-cap, escalated units, provider allowlist (AMR)"
+  ).option("--json", "Emit JSON to stdout instead of human-readable text").action(async (opts) => {
+    const r = await getJson("/api/v1/routing/status");
+    if (!r.ok) {
+      if (r.status === 0) {
+        logger.error(
+          `Failed to reach orchestrator at ${orchestratorBase()}: ${r.error ?? "unknown error"}`
+        );
+      } else {
+        logger.error(`Request failed (${r.status}): ${r.error ?? ""}`);
+      }
+      process.exit(ExitCode.ERROR);
+      return;
+    }
+    const body = r.body ?? {
+      active: false,
+      budget: null,
+      escalation: [],
+      allowedProviders: null
+    };
+    if (opts.json) {
+      console.log(JSON.stringify(body, null, 2));
+      return;
+    }
+    renderHuman5(body);
+  });
+}
+
 // src/commands/routing/index.ts
 function createRoutingCommand() {
-  const cmd = new Command93("routing").description(
-    "Inspect routing config, trace decisions, and read recent dispatches"
+  const cmd = new Command96("routing").description(
+    "Inspect routing config, trace decisions, and read AMR telemetry + status"
   );
   cmd.addCommand(createConfigCommand());
   cmd.addCommand(createTraceCommand());
   cmd.addCommand(createDecisionsCommand());
+  cmd.addCommand(createTelemetryCommand());
+  cmd.addCommand(createStatusCommand());
   return cmd;
 }
 
 // src/commands/scan-config.ts
 init_dist3();
-import { Command as Command94 } from "commander";
+import { Command as Command97 } from "commander";
 import { existsSync as existsSync31, readFileSync as readFileSync22, writeFileSync as writeFileSync23 } from "fs";
-import { join as join50, relative as relative4 } from "path";
+import { join as join51, relative as relative4 } from "path";
 var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".gemini/settings.json", "skill.yaml"];
 function stripHighSeverityPatterns(content, injectionFindings) {
   const highLines = /* @__PURE__ */ new Set();
@@ -12078,7 +12666,7 @@ async function runScanConfig(targetDir, options) {
   const scanner = new SecurityScanner(parseSecurityConfig({}));
   const results = [];
   for (const configFile of CONFIG_FILES) {
-    const result = scanSingleFile(join50(targetDir, configFile), targetDir, scanner, options);
+    const result = scanSingleFile(join51(targetDir, configFile), targetDir, scanner, options);
     if (result) results.push(result);
   }
   return { exitCode: computeScanExitCode(results), results };
@@ -12108,7 +12696,7 @@ function formatTextOutput(result) {
   }
 }
 function createScanConfigCommand() {
-  const command = new Command94("scan-config").description(
+  const command = new Command97("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();
@@ -12126,7 +12714,7 @@ function createScanConfigCommand() {
 
 // src/commands/search.ts
 init_dist();
-import { Command as Command95 } from "commander";
+import { Command as Command98 } from "commander";
 function parseFileKinds(raw) {
   if (!raw) return void 0;
   const set = /* @__PURE__ */ new Set();
@@ -12147,7 +12735,7 @@ function fmtBytes(n) {
   return n.toFixed(0);
 }
 function createSearchCommand() {
-  return new Command95("search").description("Full-text search over archived + live session content.").argument(
+  return new Command98("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(
@@ -12207,9 +12795,9 @@ function createSearchCommand() {
 }
 
 // src/commands/security-craft.ts
-import { Command as Command96 } from "commander";
+import { Command as Command99 } from "commander";
 function createSecurityCraftCommand() {
-  return new Command96("security-craft").description(
+  return new Command99("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();
@@ -12275,7 +12863,7 @@ ${file}`);
 }
 
 // src/commands/setup.ts
-import { Command as Command97 } from "commander";
+import { Command as Command100 } from "commander";
 import * as fs38 from "fs";
 import * as os9 from "os";
 import * as path62 from "path";
@@ -12314,10 +12902,10 @@ function prompt2(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve50) => {
+  return new Promise((resolve49) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve50(answer.trim().toLowerCase());
+      resolve49(answer.trim().toLowerCase());
     });
   });
 }
@@ -12326,10 +12914,10 @@ function promptRaw(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve50) => {
+  return new Promise((resolve49) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve50(answer.trim());
+      resolve49(answer.trim());
     });
   });
 }
@@ -12620,7 +13208,7 @@ async function runSetup(cwd) {
   return { steps, success };
 }
 function createSetupCommand() {
-  return new Command97("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
+  return new Command100("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
     const cwd = process.cwd();
     console.log("");
     console.log(`  ${chalk16.bold("harness setup")}`);
@@ -12643,7 +13231,7 @@ function createSetupCommand() {
 
 // src/commands/share.ts
 init_dist3();
-import { Command as Command98 } from "commander";
+import { Command as Command101 } from "commander";
 import * as fs39 from "fs";
 import * as path63 from "path";
 import { parse as parseYaml3 } from "yaml";
@@ -12702,16 +13290,16 @@ Create a constraints.yaml in your project root to define what to share.`
   logger.success(`Bundle written to ${outputPath}`);
 }
 function createShareCommand() {
-  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) => {
+  return new Command101("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 Command106 } from "commander";
+import { Command as Command109 } from "commander";
 
 // src/commands/skill/list.ts
-import { Command as Command99 } from "commander";
+import { Command as Command102 } from "commander";
 import * as fs40 from "fs";
 import * as path64 from "path";
 import { parse } from "yaml";
@@ -12814,7 +13402,7 @@ function printSkillsVerbose(skills) {
   for (const s of skills) printSkillEntry(s);
 }
 function createListCommand3() {
-  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) => {
+  return new Command102("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) {
@@ -12829,13 +13417,13 @@ function createListCommand3() {
 }
 
 // src/commands/skill/run.ts
-import { Command as Command100 } from "commander";
+import { Command as Command103 } from "commander";
 import * as fs41 from "fs";
 import * as path65 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/skill/complexity.ts
-import { execFileSync as execFileSync8 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 function evaluateSignals(signals) {
   if (signals.fileCount >= 3) return "thorough";
   if (signals.newDir) return "thorough";
@@ -12847,17 +13435,17 @@ function evaluateSignals(signals) {
 }
 function detectComplexity(projectPath) {
   try {
-    const base = execFileSync8("git", ["merge-base", "HEAD", "main"], {
+    const base = execFileSync11("git", ["merge-base", "HEAD", "main"], {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const diffFiles = execFileSync8("git", ["diff", "--name-only", base], {
+    const diffFiles = execFileSync11("git", ["diff", "--name-only", base], {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim().split("\n").filter(Boolean);
-    const diffStat = execFileSync8("git", ["diff", "--stat", base], {
+    const diffStat = execFileSync11("git", ["diff", "--stat", base], {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -12977,7 +13565,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-PBDNQPXT.js");
+  const { readHarnessState: readHarnessState2, isEmptyHarnessState } = await import("./state-events-PTWAEGJ2.js");
   const stateResult = await readHarnessState2(projectPath);
   if (!stateResult.ok || isEmptyHarnessState(stateResult.value)) return content;
   const stateContent = JSON.stringify(stateResult.value, null, 2);
@@ -13043,14 +13631,14 @@ async function runSkill(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createRunCommand3() {
-  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(
+  return new Command103("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 Command101 } from "commander";
+import { Command as Command104 } from "commander";
 import * as fs42 from "fs";
 import * as path66 from "path";
 import { parse as parse3 } from "yaml";
@@ -13114,7 +13702,7 @@ function validateSkillEntry(name, skillsDir, errors) {
   }
 }
 function createValidateCommand2() {
-  return new Command101("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
+  return new Command104("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
     if (!fs42.existsSync(skillsDir)) {
@@ -13144,7 +13732,7 @@ function createValidateCommand2() {
 }
 
 // src/commands/skill/info.ts
-import { Command as Command102 } from "commander";
+import { Command as Command105 } from "commander";
 import * as fs43 from "fs";
 import * as path67 from "path";
 import { parse as parse4 } from "yaml";
@@ -13189,7 +13777,7 @@ function printSkillInfo(skill) {
   console.log(`Persistent:  ${skill.state.persistent}`);
 }
 function createInfoCommand() {
-  return new Command102("info").description("Show metadata for a skill").argument("<name>", "Skill name (e.g., harness-tdd)").action(async (name, _opts, cmd) => {
+  return new Command105("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) {
@@ -13206,7 +13794,7 @@ function createInfoCommand() {
 }
 
 // src/commands/skill/search.ts
-import { Command as Command103 } from "commander";
+import { Command as Command106 } from "commander";
 async function runSearch(query, opts) {
   const results = await searchNpmRegistry(query, opts.registry);
   return results.filter((r) => {
@@ -13251,13 +13839,13 @@ async function runSearchAction(query, opts, globalOpts) {
   }
 }
 function createSearchCommand2() {
-  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) => {
+  return new Command106("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 Command104 } from "commander";
+import { Command as Command107 } from "commander";
 import * as path68 from "path";
 import * as fs44 from "fs";
 import YAML from "yaml";
@@ -13377,7 +13965,7 @@ Next steps:`);
   logger.info(`  3. Run: harness skills publish`);
 }
 function createCreateCommand() {
-  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) => {
+  return new Command107("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, {
@@ -13400,10 +13988,10 @@ function createCreateCommand() {
 }
 
 // src/commands/skill/publish.ts
-import { Command as Command105 } from "commander";
+import { Command as Command108 } from "commander";
 import * as fs46 from "fs";
 import * as path70 from "path";
-import { execFileSync as execFileSync9 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 
 // src/registry/validator.ts
 import * as fs45 from "fs";
@@ -13557,7 +14145,7 @@ ${skillMdContent}`;
   if (opts.registry) {
     publishArgs.push("--registry", opts.registry);
   }
-  execFileSync9("npm", publishArgs, {
+  execFileSync12("npm", publishArgs, {
     cwd: skillDir,
     stdio: "pipe",
     timeout: 6e4
@@ -13569,7 +14157,7 @@ ${skillMdContent}`;
   };
 }
 function createPublishCommand() {
-  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) => {
+  return new Command108("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 {
@@ -13594,7 +14182,7 @@ function createPublishCommand() {
 
 // src/commands/skill/index.ts
 function createSkillCommand() {
-  const command = new Command106("skill").description("Skill management commands");
+  const command = new Command109("skill").description("Skill management commands");
   command.addCommand(createListCommand3());
   command.addCommand(createRunCommand3());
   command.addCommand(createValidateCommand2());
@@ -13607,7 +14195,7 @@ function createSkillCommand() {
 
 // src/commands/snapshot.ts
 init_dist3();
-import { Command as Command107 } from "commander";
+import { Command as Command110 } from "commander";
 import { execSync as execSync5 } from "child_process";
 import chalk17 from "chalk";
 function getCommitHash3(cwd) {
@@ -13789,7 +14377,7 @@ function registerListCommand2(parent) {
   });
 }
 function createSnapshotCommand() {
-  const command = new Command107("snapshot").description("Architecture timeline snapshot commands");
+  const command = new Command110("snapshot").description("Architecture timeline snapshot commands");
   registerCaptureCommand(command);
   registerTrendsCommand(command);
   registerListCommand2(command);
@@ -13797,9 +14385,9 @@ function createSnapshotCommand() {
 }
 
 // src/commands/spec-craft.ts
-import { Command as Command108 } from "commander";
+import { Command as Command111 } from "commander";
 function createSpecCraftCommand() {
-  return new Command108("spec-craft").description(
+  return new Command111("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();
@@ -13867,7 +14455,7 @@ ${file}`);
 
 // src/commands/stale-constraints.ts
 init_dist3();
-import { Command as Command109 } from "commander";
+import { Command as Command112 } from "commander";
 import chalk18 from "chalk";
 var CATEGORIES = [
   "circular-deps",
@@ -13954,7 +14542,7 @@ async function runStaleConstraintsCommand(options) {
   );
 }
 function createStaleConstraintsCommand() {
-  return new Command109("stale-constraints").description(
+  return new Command112("stale-constraints").description(
     "Detect architectural constraints not violated within a window (candidates for removal)"
   ).option(
     "--window <days>",
@@ -13972,10 +14560,10 @@ function createStaleConstraintsCommand() {
 }
 
 // src/commands/state/index.ts
-import { Command as Command114 } from "commander";
+import { Command as Command117 } from "commander";
 
 // src/commands/state/show.ts
-import { Command as Command110 } from "commander";
+import { Command as Command113 } from "commander";
 import * as path71 from "path";
 function printStateText(state, stream) {
   if (stream) console.log(`Stream:         ${stream}`);
@@ -14000,7 +14588,7 @@ function printStateProgress(progress) {
   }
 }
 function createShowCommand() {
-  return new Command110("show").description("Show current project state").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (opts, cmd) => {
+  return new Command113("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(path71.resolve(opts.path), { stream: opts.stream });
     if (!result.ok) {
@@ -14018,13 +14606,13 @@ function createShowCommand() {
 
 // src/commands/state/reset.ts
 init_dist3();
-import { Command as Command111 } from "commander";
+import { Command as Command114 } from "commander";
 import * as path72 from "path";
 import * as readline3 from "readline";
 async function confirmReset() {
   const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve50) => {
-    rl.question("Reset project state? This cannot be undone. [y/N] ", resolve50);
+  const answer = await new Promise((resolve49) => {
+    rl.question("Reset project state? This cannot be undone. [y/N] ", resolve49);
   });
   rl.close();
   return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
@@ -14044,15 +14632,15 @@ async function runReset(opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createResetCommand() {
-  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));
+  return new Command114("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 Command112 } from "commander";
+import { Command as Command115 } from "commander";
 import * as path73 from "path";
 function createLearnCommand() {
-  return new Command112("learn").description("Append a learning to .harness/learnings.md").argument("<message>", "The learning to record").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (message, opts, _cmd) => {
+  return new Command115("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 = path73.resolve(opts.path);
     const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
     if (!result.ok) {
@@ -14067,7 +14655,7 @@ function createLearnCommand() {
 
 // src/commands/state/streams.ts
 init_dist3();
-import { Command as Command113 } from "commander";
+import { Command as Command116 } from "commander";
 import * as path74 from "path";
 async function runListStreams(opts, globalOpts) {
   const projectPath = path74.resolve(opts.path);
@@ -14118,7 +14706,7 @@ async function runActivateStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createStreamsCommand() {
-  const command = new Command113("streams").description("Manage state streams");
+  const command = new Command116("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));
@@ -14128,7 +14716,7 @@ function createStreamsCommand() {
 
 // src/commands/state/index.ts
 function createStateCommand() {
-  const command = new Command114("state").description("Project state management commands");
+  const command = new Command117("state").description("Project state management commands");
   command.addCommand(createShowCommand());
   command.addCommand(createResetCommand());
   command.addCommand(createLearnCommand());
@@ -14139,7 +14727,7 @@ function createStateCommand() {
 // src/commands/sync-analyses.ts
 import * as fs47 from "fs";
 import * as path75 from "path";
-import { Command as Command115 } from "commander";
+import { Command as Command118 } 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);
@@ -14264,7 +14852,7 @@ async function runSyncAnalyses(opts) {
     return;
   }
   const { AnalysisArchive, loadPublishedIndex: loadPublishedIndex2, savePublishedIndex: savePublishedIndex2 } = await import("@harness-engineering/orchestrator");
-  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-BWFFVKEW.js");
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-4CZLCE33.js");
   const adapter = new GitHubIssuesSyncAdapter2({ token, config: trackerConfig });
   const archive = new AnalysisArchive(path75.join(projectPath, ".harness", "analyses"));
   const publishedIndex = loadPublishedIndex2(projectPath);
@@ -14286,7 +14874,7 @@ async function runSyncAnalyses(opts) {
   }
 }
 function createSyncAnalysesCommand() {
-  const command = new Command115("sync-analyses").description(
+  const command = new Command118("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 {
@@ -14300,7 +14888,7 @@ function createSyncAnalysesCommand() {
 }
 
 // src/commands/sync-main.ts
-import { Command as Command116 } from "commander";
+import { Command as Command119 } from "commander";
 import * as path76 from "path";
 import {
   syncMain as defaultSyncMain
@@ -14331,7 +14919,7 @@ function formatHuman2(r) {
   }
 }
 function createSyncMainCommand() {
-  return new Command116("sync-main").description("Fast-forward the local default branch from origin (no-op on conflict)").option("--json", "Emit a SyncMainResult JSON object", false).option("--path <path>", "Project root path", ".").action(async (opts) => {
+  return new Command119("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 = path76.resolve(opts.path ?? ".");
     const exitCode = await runSyncMain({ cwd, json: Boolean(opts.json) });
     process.exit(exitCode);
@@ -14340,7 +14928,7 @@ function createSyncMainCommand() {
 
 // src/commands/taint.ts
 init_dist3();
-import { Command as Command117 } from "commander";
+import { Command as Command120 } from "commander";
 function getProjectRoot() {
   return process.cwd();
 }
@@ -14412,18 +15000,18 @@ function registerStatusCommand(taint) {
   });
 }
 function createTaintCommand() {
-  const taint = new Command117("taint").description("Manage sentinel session taint state");
+  const taint = new Command120("taint").description("Manage sentinel session taint state");
   registerClearCommand(taint);
   registerStatusCommand(taint);
   return taint;
 }
 
 // src/commands/telemetry/index.ts
-import { Command as Command121 } from "commander";
+import { Command as Command124 } from "commander";
 
 // src/commands/telemetry/identify.ts
 init_dist3();
-import { Command as Command118 } from "commander";
+import { Command as Command121 } from "commander";
 import * as fs48 from "fs";
 import * as path77 from "path";
 function telemetryFilePath(cwd) {
@@ -14447,7 +15035,7 @@ function printIdentity(identity) {
   }
 }
 function createIdentifyCommand() {
-  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 cmd = new Command121("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: {} });
@@ -14472,7 +15060,7 @@ function createIdentifyCommand() {
 
 // src/commands/telemetry/status.ts
 init_dist3();
-import { Command as Command119 } from "commander";
+import { Command as Command122 } from "commander";
 function gatherEnvOverrides() {
   const overrides = {};
   if (process.env.DO_NOT_TRACK) overrides.DO_NOT_TRACK = process.env.DO_NOT_TRACK;
@@ -14513,8 +15101,8 @@ function printHumanStatus(result) {
   printIdentity2(result.identity);
   printEnvOverrides(result.envOverrides);
 }
-function createStatusCommand() {
-  const cmd = new Command119("status").description("Show current telemetry consent state, install ID, and identity").option("--json", "Output as JSON").action((opts) => {
+function createStatusCommand2() {
+  const cmd = new Command122("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);
@@ -14547,20 +15135,20 @@ function createStatusCommand() {
 
 // src/commands/telemetry/test.ts
 init_dist3();
-import { Command as Command120 } from "commander";
+import { Command as Command123 } from "commander";
 
 // src/bin/command-telemetry.ts
-import { existsSync as existsSync44, readFileSync as readFileSync32, mkdirSync as mkdirSync23, appendFileSync, writeFileSync as writeFileSync29 } from "fs";
-import { join as join64, parse as parsePath, resolve as resolve47 } from "path";
+import { existsSync as existsSync44, readFileSync as readFileSync32, mkdirSync as mkdirSync24, appendFileSync as appendFileSync2, writeFileSync as writeFileSync29 } from "fs";
+import { join as join65, parse as parsePath, resolve as resolve46 } from "path";
 import { spawn as spawn2 } from "child_process";
 var POSTHOG_API_KEY = "phc_wNTdCMcfJXZPgdNeDociZW6vwoGGo4nb7vqEfWThFfsG";
 var EXCLUDED_COMMANDS = /* @__PURE__ */ new Set(["help", "completion"]);
 function findProjectRoot(cwd) {
-  let dir = resolve47(cwd);
+  let dir = resolve46(cwd);
   const { root } = parsePath(dir);
   while (dir !== root) {
-    if (existsSync44(join64(dir, "harness.config.json"))) return dir;
-    dir = resolve47(dir, "..");
+    if (existsSync44(join65(dir, "harness.config.json"))) return dir;
+    dir = resolve46(dir, "..");
   }
   return cwd;
 }
@@ -14597,8 +15185,8 @@ function resolveCommandName(cmd) {
 }
 function writeCommandRecordSync(cwd, command, duration, outcome) {
   try {
-    const metricsDir = join64(cwd, ".harness", "metrics");
-    mkdirSync23(metricsDir, { recursive: true });
+    const metricsDir = join65(cwd, ".harness", "metrics");
+    mkdirSync24(metricsDir, { recursive: true });
     const record = {
       skill: command,
       session: `cli-${Date.now()}`,
@@ -14607,13 +15195,13 @@ function writeCommandRecordSync(cwd, command, duration, outcome) {
       outcome,
       phasesReached: []
     };
-    const adoptionFile = join64(metricsDir, "adoption.jsonl");
-    appendFileSync(adoptionFile, JSON.stringify(record) + "\n");
+    const adoptionFile = join65(metricsDir, "adoption.jsonl");
+    appendFileSync2(adoptionFile, JSON.stringify(record) + "\n");
   } catch {
   }
 }
 function isTelemetryDisabledByConfig(cwd) {
-  const configPath = join64(cwd, "harness.config.json");
+  const configPath = join65(cwd, "harness.config.json");
   if (!existsSync44(configPath)) return false;
   try {
     const config = JSON.parse(readFileSync32(configPath, "utf-8"));
@@ -14628,10 +15216,10 @@ function isTelemetryOptedOut(cwd) {
 }
 function flushTelemetryBackground(cwd) {
   try {
-    const adoptionFile = join64(cwd, ".harness", "metrics", "adoption.jsonl");
+    const adoptionFile = join65(cwd, ".harness", "metrics", "adoption.jsonl");
     if (!existsSync44(adoptionFile)) return;
     if (isTelemetryOptedOut(cwd)) return;
-    const reporterPath = join64(cwd, ".harness", "hooks", "telemetry-reporter.js");
+    const reporterPath = join65(cwd, ".harness", "hooks", "telemetry-reporter.js");
     if (!existsSync44(reporterPath)) return;
     const child = spawn2(process.execPath, [reporterPath], {
       cwd,
@@ -14669,7 +15257,7 @@ function reportTestSuccess(status, distinctId, identity) {
   if (identity.team) logger.info(`  team:        ${identity.team}`);
 }
 function createTestCommand() {
-  return new Command120("test").description("Send a test event to PostHog and verify connectivity").action(async () => {
+  return new Command123("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) {
@@ -14705,18 +15293,18 @@ function createTestCommand() {
 }
 
 // src/commands/telemetry/index.ts
-function createTelemetryCommand() {
-  const command = new Command121("telemetry").description("Telemetry identity and status management");
+function createTelemetryCommand2() {
+  const command = new Command124("telemetry").description("Telemetry identity and status management");
   command.addCommand(createIdentifyCommand());
-  command.addCommand(createStatusCommand());
+  command.addCommand(createStatusCommand2());
   command.addCommand(createTestCommand());
   return command;
 }
 
 // src/commands/test-craft.ts
-import { Command as Command122 } from "commander";
+import { Command as Command125 } from "commander";
 function createTestCraftCommand() {
-  return new Command122("test-craft").description(
+  return new Command125("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();
@@ -14786,7 +15374,7 @@ ${file}`);
 }
 
 // src/commands/traceability.ts
-import { Command as Command123 } from "commander";
+import { Command as Command126 } from "commander";
 import chalk19 from "chalk";
 function confidenceLabel(maxConfidence) {
   if (maxConfidence >= 0.8) return "explicit";
@@ -14926,7 +15514,7 @@ async function runTraceability(options) {
   process.exit(ExitCode.SUCCESS);
 }
 function createTraceabilityCommand() {
-  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) => {
+  return new Command126("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,
@@ -14940,7 +15528,7 @@ function createTraceabilityCommand() {
 
 // src/commands/uninstall.ts
 import * as path78 from "path";
-import { Command as Command124 } from "commander";
+import { Command as Command127 } from "commander";
 async function runUninstall(skillName, options) {
   const packageName = resolvePackageName(skillName);
   const shortName = extractSkillName(packageName);
@@ -14977,7 +15565,7 @@ async function runUninstall(skillName, options) {
   return result;
 }
 function createUninstallCommand() {
-  const cmd = new Command124("uninstall");
+  const cmd = new Command127("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);
@@ -14999,7 +15587,7 @@ function createUninstallCommand() {
 init_dist3();
 import * as fs49 from "fs/promises";
 import * as path79 from "path";
-import { Command as Command125 } from "commander";
+import { Command as Command128 } from "commander";
 async function runUninstallConstraints(options) {
   const { packageName, configPath, lockfilePath } = options;
   const lockfileResult = await readLockfile(lockfilePath);
@@ -15056,7 +15644,7 @@ async function runUninstallConstraints(options) {
   };
 }
 function createUninstallConstraintsCommand() {
-  const cmd = new Command125("uninstall-constraints");
+  const cmd = new Command128("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) {
@@ -15096,10 +15684,10 @@ function createUninstallConstraintsCommand() {
 
 // src/commands/update.ts
 init_dist3();
-import { Command as Command126 } from "commander";
-import { execFile as execFile2, execFileSync as execFileSync10 } from "child_process";
+import { Command as Command129 } from "commander";
+import { execFile as execFile2, execFileSync as execFileSync13 } from "child_process";
 import { realpathSync, existsSync as existsSync45, readFileSync as readFileSync33 } from "fs";
-import { dirname as dirname25, join as join67 } from "path";
+import { dirname as dirname25, join as join68 } from "path";
 import { promisify as promisify2 } from "util";
 import readline4 from "readline";
 import chalk20 from "chalk";
@@ -15139,7 +15727,7 @@ async function getLatestVersionAsync(pkg) {
 function getInstalledVersions(pm, packages) {
   const versions = {};
   try {
-    const output = execFileSync10(pm, ["list", "-g", "--json"], {
+    const output = execFileSync13(pm, ["list", "-g", "--json"], {
       encoding: "utf-8",
       timeout: 15e3
     });
@@ -15160,7 +15748,7 @@ function getInstalledVersions(pm, packages) {
 }
 function getInstalledPackages(pm) {
   try {
-    const output = execFileSync10(pm, ["list", "-g", "--json"], {
+    const output = execFileSync13(pm, ["list", "-g", "--json"], {
       encoding: "utf-8",
       timeout: 15e3
     });
@@ -15180,19 +15768,19 @@ function prompt3(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve50) => {
+  return new Promise((resolve49) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve50(answer.trim().toLowerCase());
+      resolve49(answer.trim().toLowerCase());
     });
   });
 }
 function findPackageDir(resolvedBin) {
   let dir = dirname25(resolvedBin);
   for (let i = 0; i < 6; i++) {
-    if (existsSync45(join67(dir, "package.json"))) {
+    if (existsSync45(join68(dir, "package.json"))) {
       try {
-        const pkg = JSON.parse(readFileSync33(join67(dir, "package.json"), "utf-8"));
+        const pkg = JSON.parse(readFileSync33(join68(dir, "package.json"), "utf-8"));
         if (pkg?.name === CLI_PACKAGE) return dir;
       } catch {
       }
@@ -15215,7 +15803,7 @@ function findAllInstalls() {
   const args = isWindows ? ["harness"] : ["-a", "harness"];
   let output;
   try {
-    const raw = execFileSync10(cmd, args, { encoding: "utf-8", timeout: 5e3 });
+    const raw = execFileSync13(cmd, args, { encoding: "utf-8", timeout: 5e3 });
     if (typeof raw !== "string") return [];
     output = raw;
   } catch {
@@ -15237,7 +15825,7 @@ function findAllInstalls() {
     if (!packageDir) continue;
     let version = null;
     try {
-      const pkg = JSON.parse(readFileSync33(join67(packageDir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync33(join68(packageDir, "package.json"), "utf-8"));
       if (typeof pkg?.version === "string") version = pkg.version;
     } catch {
     }
@@ -15292,7 +15880,7 @@ async function offerCleanupOfOtherInstalls(activeDir) {
     }
     try {
       logger.info(`Uninstalling: ${cmd.display}`);
-      execFileSync10(cmd.bin, cmd.args, { stdio: "inherit", timeout: 12e4 });
+      execFileSync13(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)}`);
@@ -15330,10 +15918,10 @@ async function ensureTelemetryIfNeeded() {
 }
 function refreshHooks() {
   const cwd = process.cwd();
-  const configPath = join67(cwd, "harness.config.json");
+  const configPath = join68(cwd, "harness.config.json");
   if (!existsSync45(configPath)) return;
   let profile = "standard";
-  const profilePath = join67(cwd, ".harness", "hooks", "profile.json");
+  const profilePath = join68(cwd, ".harness", "hooks", "profile.json");
   try {
     const data = JSON.parse(readFileSync33(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
@@ -15352,7 +15940,7 @@ function refreshHooks() {
 function runLocalGraphScan() {
   try {
     logger.info("Scanning codebase to rebuild knowledge graph...");
-    execFileSync10("harness", ["graph", "scan", "."], { stdio: "inherit" });
+    execFileSync13("harness", ["graph", "scan", "."], { stdio: "inherit" });
   } catch {
     logger.warn("Graph scan failed. Run manually:");
     console.log(`  ${chalk20.cyan("harness graph scan .")}`);
@@ -15367,7 +15955,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 {
-    execFileSync10("harness", ["generate", ...isGlobal ? ["--global"] : []], {
+    execFileSync13("harness", ["generate", ...isGlobal ? ["--global"] : []], {
       stdio: "inherit"
     });
   } catch {
@@ -15447,7 +16035,7 @@ async function runUpdateAction(opts, globalOpts) {
   }
   try {
     logger.info("Updating packages...");
-    execFileSync10(pm, ["install", "-g", ...installPkgs], { stdio: "inherit", timeout: 12e4 });
+    execFileSync13(pm, ["install", "-g", ...installPkgs], { stdio: "inherit", timeout: 12e4 });
     console.log("");
     logger.success("Update complete");
     invalidateCheckState();
@@ -15464,7 +16052,7 @@ async function runUpdateAction(opts, globalOpts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createUpdateCommand() {
-  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(
+  return new Command129("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) => {
@@ -15474,9 +16062,9 @@ function createUpdateCommand() {
 }
 
 // src/commands/usage.ts
-import { Command as Command127 } from "commander";
+import { Command as Command130 } from "commander";
 async function loadAndPriceRecords(cwd, includeClaudeSessions = false) {
-  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-BWFFVKEW.js");
+  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-4CZLCE33.js");
   const records = readCostRecords(cwd);
   if (includeClaudeSessions) {
     const ccRecords = parseCCRecords();
@@ -15569,7 +16157,7 @@ function registerDailyCommand(usage) {
       else logger.info("No usage data found. Run some harness sessions first.");
       return;
     }
-    const { aggregateByDay } = await import("./dist-BWFFVKEW.js");
+    const { aggregateByDay } = await import("./dist-4CZLCE33.js");
     const limited = aggregateByDay(records).slice(0, days);
     if (globalOpts.json) {
       console.log(
@@ -15598,7 +16186,7 @@ function registerSessionsCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-BWFFVKEW.js");
+    const { aggregateBySession } = await import("./dist-4CZLCE33.js");
     const sessionData = aggregateBySession(records);
     const limited = sessionData.slice(0, limit);
     if (globalOpts.json) {
@@ -15678,7 +16266,7 @@ function registerSessionCommand(usage) {
       cwd,
       globalOpts.includeClaudeSessions
     );
-    const { aggregateBySession } = await import("./dist-BWFFVKEW.js");
+    const { aggregateBySession } = await import("./dist-4CZLCE33.js");
     const sessionData = aggregateBySession(records);
     const match = sessionData.find((s) => s.sessionId === id);
     if (!match) {
@@ -15713,7 +16301,7 @@ function registerLatestCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-BWFFVKEW.js");
+    const { aggregateBySession } = await import("./dist-4CZLCE33.js");
     const sessionData = aggregateBySession(records);
     const latest = sessionData[0];
     if (!latest) {
@@ -15739,7 +16327,7 @@ function registerLatestCommand(usage) {
   });
 }
 function createUsageCommand() {
-  const usage = new Command127("usage").description("Token usage and cost tracking");
+  const usage = new Command130("usage").description("Token usage and cost tracking");
   usage.option(
     "--include-claude-sessions",
     "Include Claude Code session data from ~/.claude/projects/"
@@ -15754,10 +16342,10 @@ function createUsageCommand() {
 // src/commands/validate.ts
 init_dist3();
 init_dist3();
-import { Command as Command128 } from "commander";
+import { Command as Command131 } from "commander";
 import * as fs50 from "fs";
 import * as path80 from "path";
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync14 } from "child_process";
 async function runValidate(options) {
   const configResult = resolveConfig(options.configPath);
   if (!configResult.ok) {
@@ -15876,7 +16464,7 @@ async function runValidate(options) {
     const gitattributesContent = fs50.readFileSync(gitattributesPath, "utf-8");
     let driverConfigured = false;
     try {
-      const out = execFileSync11("git", ["config", "--get", "merge.ours.driver"], {
+      const out = execFileSync14("git", ["config", "--get", "merge.ours.driver"], {
         cwd,
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "ignore"]
@@ -16062,7 +16650,7 @@ function resolveValidateMode(globalOpts) {
   return OutputMode.TEXT;
 }
 async function printCrossCheckWarnings(mode) {
-  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-H2OUHTID.js");
+  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-YYVYMSPA.js");
   const cwd = process.cwd();
   const crossResult = await runCrossCheck2({
     specsDir: path80.join(cwd, "docs", "specs"),
@@ -16078,7 +16666,7 @@ async function printCrossCheckWarnings(mode) {
   ${crossResult.value.warnings} warnings`);
 }
 function createValidateCommand3() {
-  const command = new Command128("validate").description("Run all validation checks").option("--cross-check", "Run cross-artifact consistency validation").option(
+  const command = new Command131("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()));
@@ -16127,7 +16715,7 @@ Agent configs checked via ${engineLabel}${note}`);
 
 // src/commands/verify.ts
 init_dist3();
-import { Command as Command129 } from "commander";
+import { Command as Command132 } from "commander";
 import { execSync as execSync6 } from "child_process";
 function loadBranchingConfig(configPath) {
   const shouldLoad = configPath !== void 0 || findConfigFile().ok;
@@ -16190,7 +16778,7 @@ async function runVerify(options) {
   process.exit(ExitCode.VALIDATION_FAILED);
 }
 function createVerifyCommand() {
-  return new Command129("verify").description(
+  return new Command132("verify").description(
     "Verify project conventions (currently: branch naming). Works with or without a harness.config.json."
   ).option(
     "--branch <name>",
@@ -16268,6 +16856,7 @@ var commandCreators = [
   createRecommendCommand,
   createReviewCiCommand,
   createRoadmapCommand,
+  createRollbackCommand,
   createRoutingCommand,
   createScanConfigCommand,
   createSearchCommand,
@@ -16283,7 +16872,7 @@ var commandCreators = [
   createSyncAnalysesCommand,
   createSyncMainCommand,
   createTaintCommand,
-  createTelemetryCommand,
+  createTelemetryCommand2,
   createTestCraftCommand,
   createTraceabilityCommand,
   createUninstallCommand,
@@ -16317,7 +16906,7 @@ function registerDeprecatedGraphAliases(program) {
 
 // src/index.ts
 function createProgram() {
-  const program = new Command130();
+  const program = new Command133();
   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());