@harness-engineering/cli 6.0.1 → 8.0.0

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

@@ -1,22 +1,22 @@
 import {
   generateRuntime
-} from "./chunk-TM4KFUWP.js";
+} from "./chunk-PYDUECJ3.js";
 import {
   generateAgentsMd
-} from "./chunk-VRA64HYI.js";
+} from "./chunk-7IVIRKHD.js";
 import {
   generateCIWorkflow
-} from "./chunk-XF6RE3JQ.js";
+} from "./chunk-XYP5CIEN.js";
 import {
   readHarnessState
-} from "./chunk-MEIUXTFY.js";
+} from "./chunk-PQBSP5AO.js";
 import {
   runCrossCheck
-} from "./chunk-D7QXGI6E.js";
+} from "./chunk-INT5MUQX.js";
 import {
   createGenerateAgentDefinitionsCommand,
   generateAgentDefinitions
-} from "./chunk-IXGYIQSR.js";
+} from "./chunk-HQUQA5D7.js";
 import {
   toKebabCase
 } from "./chunk-KET4QQZB.js";
@@ -26,7 +26,7 @@ import {
 } from "./chunk-YYFSFSB3.js";
 import {
   TemplateEngine
-} from "./chunk-JJLOWMGC.js";
+} from "./chunk-YQK3GRW7.js";
 import {
   generate,
   validate
@@ -37,7 +37,7 @@ import {
 import {
   listPersonas,
   loadPersona
-} from "./chunk-KPBGAB35.js";
+} from "./chunk-UFZ6FMFC.js";
 import {
   runPersona
 } from "./chunk-GISMXMVL.js";
@@ -51,7 +51,7 @@ import {
   OutputFormatter,
   OutputMode,
   createCheckPhaseGateCommand
-} from "./chunk-6Y6M3AZA.js";
+} from "./chunk-N3S6JTRS.js";
 import {
   appendFrameworkAgents,
   captureHealthSnapshot,
@@ -79,7 +79,7 @@ import {
   runSecurityCraft,
   runSpecCraft,
   runTestCraft
-} from "./chunk-EFWRZHZ7.js";
+} from "./chunk-P7DXQAKU.js";
 import {
   VALID_PLATFORMS
 } from "./chunk-3ISINLYT.js";
@@ -108,7 +108,7 @@ import {
   BranchingConfigSchema,
   findConfigFile,
   resolveConfig
-} from "./chunk-IOJGLIEQ.js";
+} from "./chunk-ILKL5I4J.js";
 import {
   logger
 } from "./chunk-EBJQ6N4M.js";
@@ -202,6 +202,7 @@ import {
   requestPeerReview,
   resolveConsent,
   resolveRoadmapStore,
+  resolveRoadmapStoreForFile,
   roadmapSourceExists,
   roadmapToShards,
   runAll,
@@ -226,7 +227,7 @@ import {
   writeConfig,
   writeLockfile,
   writeRegeneratedRoadmap
-} from "./chunk-CTMHHMHQ.js";
+} from "./chunk-6SP665CR.js";
 import {
   CLI_VERSION
 } from "./chunk-BM3PWGXQ.js";
@@ -263,7 +264,7 @@ import {
 } from "./chunk-KFQGP6VL.js";
 
 // src/index.ts
-import { Command as Command133 } from "commander";
+import { Command as Command134 } from "commander";
 
 // src/commands/add.ts
 init_dist3();
@@ -454,7 +455,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-4CZLCE33.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-DTXVNQAY.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -490,7 +491,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-4CZLCE33.js");
+    const { readAdoptionRecords } = await import("./dist-DTXVNQAY.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -568,7 +569,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-4CZLCE33.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-DTXVNQAY.js");
     const records = readAdoptionRecords(cwd);
     const skillRecords = records.filter((r) => r.skill === name);
     if (skillRecords.length === 0) {
@@ -602,7 +603,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-4CZLCE33.js");
+    const { readAdoptionRecords, getCatalogRetrospectiveReport, renderRetrospectiveMarkdown } = await import("./dist-DTXVNQAY.js");
     const records = readAdoptionRecords(cwd);
     const catalogSkills = discoverCatalogSkills(cwd);
     const report = getCatalogRetrospectiveReport(records, {
@@ -1750,9 +1751,9 @@ ${name} (${count} finding${count === 1 ? "" : "s"})`);
 }
 function printAnatomyFindings(findings, verbose) {
   const byFile = groupByFile(findings, (f) => f.file);
-  for (const [file, fs51] of byFile) {
+  for (const [file, fs52] of byFile) {
     console.log(`  ${file}`);
-    for (const f of fs51) {
+    for (const f of fs52) {
       const line = f.line !== null && f.line !== void 0 ? `:${f.line}` : "";
       console.log(`    ${f.code} [${f.severity}]    line${line}: ${f.message}`);
       if (verbose) {
@@ -1763,9 +1764,9 @@ function printAnatomyFindings(findings, verbose) {
 }
 function printCraftFindings(findings, verbose) {
   const byFile = groupByFile(findings, (f) => f.target.file);
-  for (const [file, fs51] of byFile) {
+  for (const [file, fs52] of byFile) {
     console.log(`  ${file}`);
-    for (const f of fs51) {
+    for (const f of fs52) {
       const line = f.target.line !== void 0 ? `:${f.target.line}` : "";
       const sev = craftTierToSeverity(f.tier);
       console.log(
@@ -1779,9 +1780,9 @@ function printCraftFindings(findings, verbose) {
 }
 function printDriftFindings(findings, verbose) {
   const byFile = groupByFile(findings, (f) => f.file);
-  for (const [file, fs51] of byFile) {
+  for (const [file, fs52] of byFile) {
     console.log(`  ${file}`);
-    for (const f of fs51) {
+    for (const f of fs52) {
       const line = f.line !== null && f.line !== void 0 ? `:${f.line}` : "";
       console.log(`    ${f.code} [${f.severity}]    line${line}: ${f.message}`);
       if (verbose) {
@@ -1792,9 +1793,9 @@ function printDriftFindings(findings, verbose) {
 }
 function printBrandFindings(findings, verbose) {
   const byFile = groupByFile(findings, (f) => f.file);
-  for (const [file, fs51] of byFile) {
+  for (const [file, fs52] of byFile) {
     console.log(`  ${file}`);
-    for (const f of fs51) {
+    for (const f of fs52) {
       const line = f.line !== null && f.line !== void 0 ? `:${f.line}` : "";
       console.log(`    ${f.code} [${f.severity}]    line${line}: ${f.message}`);
       if (verbose) {
@@ -2203,10 +2204,10 @@ async function runCheckSecurity(cwd, options) {
   const projectRoot3 = path11.resolve(cwd);
   let configData = {};
   try {
-    const fs51 = await import("fs");
+    const fs52 = await import("fs");
     const configPath = path11.join(projectRoot3, "harness.config.json");
-    if (fs51.existsSync(configPath)) {
-      const raw = fs51.readFileSync(configPath, "utf-8");
+    if (fs52.existsSync(configPath)) {
+      const raw = fs52.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       configData = parsed.security ?? {};
     }
@@ -3239,10 +3240,10 @@ function printResult2(result, mode, _formatter) {
       list.push(f);
       bySurface.set(f.target.surface, list);
     }
-    for (const [surface, fs51] of bySurface) {
+    for (const [surface, fs52] of bySurface) {
       console.log(`
 [${surface}]`);
-      for (const f of fs51) {
+      for (const f of fs52) {
         const line = f.target.line !== void 0 ? `:${f.target.line}` : "";
         console.log(`  ${f.code} [${f.tier}/${f.impact}/${f.confidence}] ${f.target.file}${line}`);
         console.log(`    "${truncate(f.target.snippet, 80)}"`);
@@ -4548,11 +4549,11 @@ import { Command as Command37 } from "commander";
 // src/commands/graph/status.ts
 import * as path19 from "path";
 async function readConnectorSyncStatus(graphDir) {
-  const fs51 = await import("fs/promises");
+  const fs52 = await import("fs/promises");
   const result = {};
   try {
     const syncMetaPath = path19.join(graphDir, "sync-metadata.json");
-    const syncMeta = JSON.parse(await fs51.readFile(syncMetaPath, "utf-8"));
+    const syncMeta = JSON.parse(await fs52.readFile(syncMetaPath, "utf-8"));
     for (const [name, data] of Object.entries(syncMeta.connectors ?? {})) {
       result[name] = data.lastSyncTimestamp;
     }
@@ -4699,9 +4700,9 @@ import { Command as Command36 } from "commander";
 import * as path22 from "path";
 async function loadConnectorConfig(projectPath, source) {
   try {
-    const fs51 = await import("fs/promises");
+    const fs52 = await import("fs/promises");
     const configPath = path22.join(projectPath, "harness.config.json");
-    const config = JSON.parse(await fs51.readFile(configPath, "utf-8"));
+    const config = JSON.parse(await fs52.readFile(configPath, "utf-8"));
     const connector = config.graph?.connectors?.[source];
     return connector ?? {};
   } catch {
@@ -6203,7 +6204,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-4CZLCE33.js");
+    const { composeInsights } = await import("./dist-DTXVNQAY.js");
     const report = await composeInsights(cwd, { skip });
     if (opts.json) {
       console.log(JSON.stringify(report, null, 2));
@@ -7375,10 +7376,10 @@ function printResult3(result, mode, _formatter) {
       list.push(f);
       byFile.set(f.target.file, list);
     }
-    for (const [file, fs51] of byFile) {
+    for (const [file, fs52] of byFile) {
       console.log(`
 ${file}`);
-      for (const f of fs51) {
+      for (const f of fs52) {
         console.log(`  ${f.code} [${f.tier}/${f.impact}/${f.confidence}] ${f.target.relative}`);
         console.log(`    ${f.message}`);
         if (verbose) console.log(`    source: ${f.cite.source}`);
@@ -7561,8 +7562,8 @@ function createKnowledgePipelineCommand() {
     const projectDir = process.cwd();
     try {
       const graphDir = path42.join(projectDir, ".harness", "graph");
-      const fs51 = await import("fs/promises");
-      await fs51.mkdir(graphDir, { recursive: true });
+      const fs52 = await import("fs/promises");
+      await fs52.mkdir(graphDir, { recursive: true });
       const { GraphStore: GraphStore2, KnowledgePipelineRunner } = await import("./dist-DWBTZXR5.js");
       const store = new GraphStore2();
       try {
@@ -8314,7 +8315,7 @@ function createMcpCommand() {
     parseBudget
   ).action(async (opts) => {
     const [{ startServer: startServer2, getToolDefinitions: getToolDefinitions2 }, { selectTier }] = await Promise.all([
-      import("./mcp-XX6EIBLL.js"),
+      import("./mcp-5MEIUQLV.js"),
       import("./tool-tiers-OKK5FE57.js")
     ]);
     if (opts.tools && opts.tools.length > 0) {
@@ -9395,10 +9396,10 @@ function printResult4(result, mode, _formatter) {
       list.push(f);
       byFile.set(f.target.file, list);
     }
-    for (const [file, fs51] of byFile) {
+    for (const [file, fs52] of byFile) {
       console.log(`
 ${file}`);
-      for (const f of fs51) {
+      for (const f of fs52) {
         const line = f.target.line !== void 0 ? `:${f.target.line}` : "";
         console.log(
           `  ${f.code} [${f.tier}/${f.impact}/${f.confidence}] ${f.target.kind} ${f.target.identifier}${line}`
@@ -9550,7 +9551,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-4CZLCE33.js");
+    const { BenchmarkRunner } = await import("./dist-DTXVNQAY.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob2);
     if (benchFiles.length === 0) {
@@ -9614,7 +9615,7 @@ async function runBaselinesShow(globalOpts) {
 }
 async function runBaselinesUpdate(globalOpts) {
   const cwd = process.cwd();
-  const { BenchmarkRunner } = await import("./dist-4CZLCE33.js");
+  const { BenchmarkRunner } = await import("./dist-DTXVNQAY.js");
   const runner = new BenchmarkRunner();
   const manager = new BaselineManager(cwd);
   logger.info("Running benchmarks to update baselines...");
@@ -9655,7 +9656,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-4CZLCE33.js");
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-DTXVNQAY.js");
     const analyzer = new EntropyAnalyzer2({
       rootDir: path51.resolve(cwd),
       analyze: { complexity: true, coupling: true }
@@ -10323,11 +10324,11 @@ var defaultPostBrief = (body) => {
     }
   );
 };
-var defaultReadFile = (path81) => readFileSync18(path81, "utf-8");
-function readReview(path81, readFile4 = defaultReadFile) {
-  if (!path81) return void 0;
+var defaultReadFile = (path82) => readFileSync18(path82, "utf-8");
+function readReview(path82, readFile4 = defaultReadFile) {
+  if (!path82) return void 0;
   try {
-    const parsed = JSON.parse(readFile4(path81));
+    const parsed = JSON.parse(readFile4(path82));
     return parsed?.verdict && typeof parsed.verdict === "object" ? parsed.verdict : void 0;
   } catch {
     return void 0;
@@ -10678,7 +10679,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-4CZLCE33.js");
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-DTXVNQAY.js");
   const archive = new AnalysisArchive(path53.join(projectPath, ".harness", "analyses"));
   const analyses = await archive.list();
   if (analyses.length === 0) {
@@ -10918,7 +10919,7 @@ function createRecommendCommand() {
 }
 
 // src/commands/roadmap/index.ts
-import { Command as Command89 } from "commander";
+import { Command as Command90 } from "commander";
 
 // src/commands/roadmap/migrate.ts
 init_dist3();
@@ -11374,17 +11375,17 @@ import * as path56 from "path";
 import * as fsp from "fs/promises";
 function createNodeShardIO() {
   return {
-    readFile: (path81) => fsp.readFile(path81, "utf-8"),
-    writeFile: (path81, data) => fsp.writeFile(path81, data, "utf-8"),
+    readFile: (path82) => fsp.readFile(path82, "utf-8"),
+    writeFile: (path82, data) => fsp.writeFile(path82, data, "utf-8"),
     listDir: (dir) => fsp.readdir(dir),
-    deleteFile: (path81) => fsp.rm(path81),
+    deleteFile: (path82) => fsp.rm(path82),
     mkdirp: async (dir) => {
       await fsp.mkdir(dir, { recursive: true });
     },
-    rmrf: (path81) => fsp.rm(path81, { recursive: true, force: true }),
-    exists: async (path81) => {
+    rmrf: (path82) => fsp.rm(path82, { recursive: true, force: true }),
+    exists: async (path82) => {
       try {
-        await fsp.access(path81);
+        await fsp.access(path82);
         return true;
       } catch {
         return false;
@@ -11769,22 +11770,658 @@ function createRoadmapReferencedIssuesCommand() {
   });
 }
 
+// src/commands/roadmap/triage.ts
+init_dist3();
+import { Command as Command89 } from "commander";
+import * as fs36 from "fs";
+import * as path60 from "path";
+import {
+  triageIssue,
+  rankTriageCandidates,
+  runBrainstormForIssue,
+  markApprovedForDispatch,
+  precedentLookupFromStored
+} from "@harness-engineering/orchestrator";
+
+// src/commands/roadmap/triage-provider.ts
+import {
+  AnthropicAnalysisProvider,
+  OpenAICompatibleAnalysisProvider as OpenAICompatibleAnalysisProvider2
+} from "@harness-engineering/intelligence";
+function firstModel(model) {
+  if (Array.isArray(model)) return model[0];
+  return model;
+}
+function resolveTriageProvider(config, modelOverride) {
+  const explicit = config?.intelligence?.provider;
+  if (explicit) {
+    if (explicit.kind === "anthropic") {
+      const apiKey = explicit.apiKey ?? process.env.ANTHROPIC_API_KEY;
+      if (!apiKey) return null;
+      const model2 = modelOverride ?? explicit.model;
+      return new AnthropicAnalysisProvider(
+        model2 !== void 0 ? { apiKey, defaultModel: model2 } : { apiKey }
+      );
+    }
+    const baseUrl = explicit.baseUrl ?? "http://localhost:11434/v1";
+    const model = modelOverride ?? explicit.model;
+    return new OpenAICompatibleAnalysisProvider2({
+      apiKey: explicit.apiKey ?? "ollama",
+      baseUrl,
+      ...model !== void 0 && { defaultModel: model }
+    });
+  }
+  const backends = config?.agent?.backends;
+  if (!backends) return null;
+  const local = pickBackend(backends, ["local", "pi"]);
+  if (local && local.endpoint) {
+    const model = modelOverride ?? firstModel(local.model);
+    return new OpenAICompatibleAnalysisProvider2({
+      apiKey: local.apiKey ?? "ollama",
+      baseUrl: local.endpoint,
+      ...model !== void 0 && { defaultModel: model },
+      ...local.timeoutMs !== void 0 && { timeoutMs: local.timeoutMs }
+    });
+  }
+  const anthropic = pickBackend(backends, ["anthropic"]);
+  if (anthropic) {
+    const apiKey = anthropic.apiKey ?? process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) return null;
+    const model = modelOverride ?? firstModel(anthropic.model);
+    return new AnthropicAnalysisProvider(
+      model !== void 0 ? { apiKey, defaultModel: model } : { apiKey }
+    );
+  }
+  return null;
+}
+function pickBackend(backends, types) {
+  for (const def of Object.values(backends)) {
+    if (def.type !== void 0 && types.includes(def.type)) return def;
+  }
+  return null;
+}
+
+// src/commands/roadmap/triage-approve.ts
+import {
+  detectScopeTier,
+  artifactPresenceFromIssue
+} from "@harness-engineering/orchestrator";
+import {
+  resolveGoNoGoStaged,
+  resolveStage,
+  dispatchableShapeKey,
+  V1_MAX_STAGE
+} from "@harness-engineering/intelligence";
+
+// src/commands/roadmap/triage-feature.ts
+function isActionable(feature) {
+  return feature.status === "planned" || feature.status === "backlog";
+}
+function featureToIssue(feature) {
+  return {
+    id: feature.name,
+    identifier: feature.name,
+    title: feature.name,
+    description: feature.summary,
+    priority: null,
+    state: feature.status,
+    branchName: null,
+    url: null,
+    labels: [],
+    blockedBy: feature.blockedBy.map((b) => ({ id: b, identifier: b, state: null })),
+    spec: feature.spec,
+    plans: feature.plans,
+    createdAt: null,
+    updatedAt: feature.updatedAt ?? null,
+    externalId: feature.externalId ?? null,
+    assignee: feature.assignee ?? null
+  };
+}
+
+// src/commands/roadmap/triage-approve.ts
+function deriveReadyCandidates(rows, roadmap) {
+  const featureByExternalId = new Map(
+    roadmap.milestones.flatMap((m) => m.features).filter((f) => f.externalId != null).map((f) => [f.externalId, f])
+  );
+  const ready = [];
+  for (const row of rows) {
+    if (row.result.outcome.kind !== "completed") continue;
+    if (!row.result.specPath) continue;
+    const rescore = row.result.rescore;
+    if (!rescore || !rescore.dispatchable) continue;
+    const feature = featureByExternalId.get(row.externalId);
+    if (!feature || !isActionable(feature)) continue;
+    const issue = featureToIssue({ ...feature, spec: row.result.specPath });
+    const category = detectScopeTier(issue, artifactPresenceFromIssue(issue));
+    const v = rescore.verdict;
+    ready.push({
+      externalId: row.externalId,
+      featureName: feature.name,
+      specPath: row.result.specPath,
+      category,
+      level: v.level,
+      confidence: v.confidence,
+      signals: v.signals,
+      source: v.source,
+      // scopeEstimate: the resolved-entity blast radius from the scope lever, when present.
+      scopeEstimate: scopeEstimateOf(rescore),
+      // Roadmap features carry no labels today, so this is always `[]`. The shapeKey
+      // buckets on empty labels for now (Phase-4 calibration note): if/when labels land,
+      // this is the single place to feed them into the precedent/ratchet bucket.
+      labels: []
+    });
+  }
+  return ready;
+}
+function scopeEstimateOf(rescore) {
+  const scope = rescore?.levers.scope.value;
+  if (scope && scope !== "unknown") return scope.blastRadius;
+  return 0;
+}
+function shapeKeyForCandidate(r) {
+  return dispatchableShapeKey(r.labels, r.level);
+}
+function resolveEffectiveStage(history, ceiling) {
+  const earned = resolveStage(history);
+  return Math.min(earned, ceiling, V1_MAX_STAGE);
+}
+function buildApprovalPlan(ready, opts) {
+  const historyForShape = opts.historyForShape ?? (() => []);
+  const candidates = ready.map((r) => ({
+    externalId: r.externalId,
+    category: r.category,
+    humanApproved: opts.approveAll === true || opts.approvedIds.has(r.externalId),
+    // Per-shape evidence-derived stage, ceilinged by config + hard-capped at 2 (SC6).
+    effectiveStage: resolveEffectiveStage(historyForShape(shapeKeyForCandidate(r)), opts.stage)
+  }));
+  const decision = resolveGoNoGoStaged(candidates);
+  const byId = new Map(ready.map((r) => [r.externalId, r]));
+  const toMark = decision.approved.map((c) => {
+    const r = byId.get(c.externalId);
+    return {
+      candidate: c,
+      featureName: r.featureName,
+      specPath: r.specPath,
+      labels: r.labels,
+      verdict: { level: r.level, confidence: r.confidence, signals: r.signals, source: r.source },
+      scopeEstimate: r.scopeEstimate,
+      // The per-shape earned stage the marker stamps onto the prediction (SC6).
+      effectiveStage: c.effectiveStage
+    };
+  });
+  const held = decision.held.map((h) => ({ externalId: h.externalId, reason: h.reason }));
+  return { toMark, held };
+}
+
+// src/commands/roadmap/triage.ts
+var CONFIDENCE_SCORE = { low: 1, medium: 2, high: 3 };
+var EFFORT_BY_LEVEL = { trivial: 1, simple: 2, moderate: 3, complex: 4 };
+var IMPACT_BY_PRIORITY = { P0: 4, P1: 3, P2: 2, P3: 1 };
+function rankingInputs(feature, verdict) {
+  return {
+    impact: feature.priority ? IMPACT_BY_PRIORITY[feature.priority] ?? 2 : 2,
+    confidence: CONFIDENCE_SCORE[verdict.verdict.confidence],
+    effort: EFFORT_BY_LEVEL[verdict.verdict.level] ?? 3
+  };
+}
+async function buildPrecedentLookup(cwd) {
+  const loaded = await event_sourcing_exports.loadTriageRecords(cwd);
+  if (!loaded.ok) return void 0;
+  return precedentLookupFromStored(
+    loaded.value.map((r) => ({
+      shapeKey: r.shapeKey,
+      ...r.outcome ? { outcome: { matched: r.outcome.matched } } : {}
+    }))
+  );
+}
+async function buildShapeHistory(cwd) {
+  const loaded = await event_sourcing_exports.loadTriageRecords(cwd);
+  const byShape = /* @__PURE__ */ new Map();
+  if (loaded.ok) {
+    for (const rec of loaded.value) {
+      if (!rec.outcome) continue;
+      const list = byShape.get(rec.shapeKey) ?? [];
+      list.push({ matched: rec.outcome.matched, ts: rec.ts });
+      byShape.set(rec.shapeKey, list);
+    }
+  }
+  return (shapeKey) => byShape.get(shapeKey) ?? [];
+}
+function selectActionableFeatures(roadmap, opts = {}) {
+  let features = roadmap.milestones.flatMap((m) => m.features).filter(isActionable);
+  if (opts.only !== void 0 && opts.only.trim().length > 0) {
+    const needle = opts.only.trim().toLowerCase();
+    features = features.filter((f) => f.name.toLowerCase().includes(needle));
+  }
+  if (opts.limit !== void 0 && opts.limit >= 0) {
+    features = features.slice(0, opts.limit);
+  }
+  return features;
+}
+function isPlausibleForModel(verdict) {
+  const scope = verdict.levers.scope.value;
+  const scopeResolvedBounded = scope !== "unknown" && scope.resolved.length > 0;
+  const level = verdict.verdict.level;
+  const inBand = level === "trivial" || level === "simple";
+  return scopeResolvedBounded && inBand;
+}
+async function runTriageReport(roadmap, deps = {}) {
+  const features = selectActionableFeatures(roadmap, {
+    ...deps.only !== void 0 ? { only: deps.only } : {},
+    ...deps.limit !== void 0 ? { limit: deps.limit } : {}
+  });
+  const cheapDeps = {
+    ...deps.graphStore ? { graphStore: deps.graphStore } : {},
+    ...deps.precedent ? { precedent: deps.precedent } : {},
+    ...deps.config ? { config: deps.config } : {}
+  };
+  const useModel = deps.offline !== true && deps.provider != null;
+  const rows = [];
+  for (const feature of features) {
+    let verdict = await triageIssue(featureToIssue(feature), cheapDeps);
+    if (useModel && isPlausibleForModel(verdict)) {
+      deps.onProgress?.(`Refining "${feature.name}" on the local model\u2026`);
+      verdict = await triageIssue(featureToIssue(feature), {
+        ...cheapDeps,
+        ...deps.provider ? { provider: deps.provider } : {}
+      });
+    }
+    rows.push({
+      externalId: verdict.externalId,
+      name: feature.name,
+      status: feature.status,
+      ...rankingInputs(feature, verdict),
+      verdict
+    });
+  }
+  return rankTriageCandidates(rows);
+}
+function renderHuman(rows) {
+  if (rows.length === 0) return "No actionable roadmap items to triage.";
+  const lines = [];
+  lines.push(`Triaged ${rows.length} actionable item(s):
+`);
+  for (const row of rows) {
+    const v = row.verdict;
+    const badge = v.dispatchable ? "\u2713 DISPATCHABLE" : `\u2717 HELD (${v.holdReason})`;
+    lines.push(`${badge}  ${row.name}`);
+    lines.push(
+      `    level=${v.verdict.level} confidence=${v.verdict.confidence} impact=${row.impact} effort=${row.effort}`
+    );
+    lines.push(`    ${v.rationale}`);
+    lines.push("");
+  }
+  const dispatchable = rows.filter((r) => r.verdict.dispatchable).length;
+  lines.push(
+    `${dispatchable}/${rows.length} dispatchable; ${rows.length - dispatchable} to human.`
+  );
+  return lines.join("\n");
+}
+function renderJson(rows) {
+  return JSON.stringify(
+    {
+      count: rows.length,
+      dispatchable: rows.filter((r) => r.verdict.dispatchable).length,
+      items: rows.map((r) => ({
+        externalId: r.externalId,
+        name: r.name,
+        status: r.status,
+        dispatchable: r.verdict.dispatchable,
+        holdReason: r.verdict.holdReason ?? null,
+        level: r.verdict.verdict.level,
+        confidence: r.verdict.verdict.confidence,
+        impact: r.impact,
+        effort: r.effort,
+        pilotInputs: { impact: r.impact, confidence: r.confidence, effort: r.effort },
+        levers: r.verdict.levers,
+        rationale: r.verdict.rationale
+      }))
+    },
+    null,
+    2
+  );
+}
+function skippedBrainstormRow(feature, verdict, level) {
+  return {
+    externalId: verdict.externalId,
+    name: feature.name,
+    status: feature.status,
+    level,
+    result: {
+      outcome: {
+        kind: "halted",
+        reason: "error",
+        fork: { id: "scope-gate", question: "", options: [] },
+        detail: `Skipped brainstorm \u2014 not a plausible candidate (${verdict.holdReason ?? "held"}). Held to human by the cheap scope/band gate.`
+      }
+    }
+  };
+}
+async function runBrainstormReport(roadmap, deps = {}) {
+  const features = selectActionableFeatures(roadmap, {
+    ...deps.only !== void 0 ? { only: deps.only } : {},
+    ...deps.limit !== void 0 ? { limit: deps.limit } : {}
+  });
+  const rows = [];
+  for (const feature of features) {
+    const issue = featureToIssue(feature);
+    const verdict = await triageIssue(issue, {
+      ...deps.graphStore ? { graphStore: deps.graphStore } : {},
+      ...deps.provider ? { provider: deps.provider } : {},
+      ...deps.precedent ? { precedent: deps.precedent } : {},
+      ...deps.config ? { config: deps.config } : {}
+    });
+    const level = verdict.verdict.level;
+    if (deps.gatePlausible === true && !isPlausibleForModel(verdict)) {
+      rows.push(skippedBrainstormRow(feature, verdict, level));
+      continue;
+    }
+    deps.onProgress?.(`Brainstorming "${feature.name}" [${level}]\u2026`);
+    const wiringDeps = {
+      ...deps.generator ? { generator: deps.generator } : {},
+      ...deps.provider ? { provider: deps.provider } : {},
+      ...deps.generatorOptions ? { generatorOptions: deps.generatorOptions } : {},
+      ...deps.docsRoot ? { docsRoot: deps.docsRoot } : {},
+      // Re-score the enriched item on completion (SC4), reusing the same seams — the
+      // precedent lever included so the RE-SCORE (the prediction the marker records) is
+      // graded against real base-rates too (SC5).
+      rescore: {
+        ...deps.graphStore ? { graphStore: deps.graphStore } : {},
+        ...deps.provider ? { provider: deps.provider } : {},
+        ...deps.precedent ? { precedent: deps.precedent } : {},
+        ...deps.config ? { config: deps.config } : {}
+      }
+    };
+    const result = await runBrainstormForIssue(issue, level, wiringDeps);
+    rows.push({
+      externalId: verdict.externalId,
+      name: feature.name,
+      status: feature.status,
+      level,
+      result
+    });
+  }
+  return rows;
+}
+function renderBrainstormHuman(rows) {
+  if (rows.length === 0) return "No actionable roadmap items to brainstorm.";
+  const lines = [];
+  lines.push(`Brainstormed ${rows.length} actionable item(s):
+`);
+  for (const row of rows) {
+    const o = row.result.outcome;
+    if (o.kind === "completed") {
+      const where = row.result.specPath ? ` \u2192 ${row.result.specPath}` : " (dry run \u2014 no docs root)";
+      lines.push(`\u2713 SPEC DRAFTED  ${row.name} [${row.level}]${where}`);
+      lines.push(`    ${o.spec.decisions.length} fork(s) resolved at high confidence`);
+      if (row.result.rescore) {
+        const rv = row.result.rescore;
+        lines.push(
+          `    re-score: ${rv.dispatchable ? "DISPATCHABLE" : `held (${rv.holdReason})`} \u2014 ${rv.verdict.level}/${rv.verdict.confidence}`
+        );
+      }
+    } else {
+      lines.push(`\u2717 HALTED \u2192 HUMAN  ${row.name} [${row.level}]  (${o.reason})`);
+      lines.push(`    fork: ${o.fork.question || o.fork.id}`);
+      lines.push(`    ${o.detail}`);
+    }
+    lines.push("");
+  }
+  const completed = rows.filter((r) => r.result.outcome.kind === "completed").length;
+  lines.push(
+    `${completed}/${rows.length} spec(s) drafted; ${rows.length - completed} halted to human.`
+  );
+  return lines.join("\n");
+}
+function renderBrainstormJson(rows) {
+  return JSON.stringify(
+    {
+      count: rows.length,
+      drafted: rows.filter((r) => r.result.outcome.kind === "completed").length,
+      items: rows.map((r) => {
+        const o = r.result.outcome;
+        return {
+          externalId: r.externalId,
+          name: r.name,
+          status: r.status,
+          level: r.level,
+          outcome: o.kind,
+          ...o.kind === "completed" ? {
+            specPath: r.result.specPath ?? null,
+            forks: o.spec.decisions.map((d) => ({
+              id: d.fork.id,
+              question: d.fork.question,
+              recommendation: d.recommendation,
+              confidence: d.confidence
+            })),
+            rescore: r.result.rescore ? {
+              dispatchable: r.result.rescore.dispatchable,
+              holdReason: r.result.rescore.holdReason ?? null,
+              level: r.result.rescore.verdict.level,
+              confidence: r.result.rescore.verdict.confidence
+            } : null
+          } : {
+            halt: {
+              reason: o.reason,
+              fork: { id: o.fork.id, question: o.fork.question },
+              detail: o.detail
+            }
+          }
+        };
+      })
+    },
+    null,
+    2
+  );
+}
+function resolveBrainstormProvider(configPath, model) {
+  const configResult = resolveConfig(configPath);
+  if (!configResult.ok) return null;
+  return resolveTriageProvider(configResult.value, model);
+}
+async function runApproveCommand(cwd, opts) {
+  const configResult = resolveConfig(opts.config);
+  const cfg = configResult.ok ? configResult.value : void 0;
+  const autoTriage = cfg?.roadmap?.autoTriage;
+  if (!autoTriage || autoTriage.enabled !== true) {
+    return { marked: [], held: [], note: "disabled" };
+  }
+  const stage = autoTriage.ratchetStage ?? 1;
+  const roadmapPath = path60.join(cwd, "docs", "roadmap.md");
+  if (!fs36.existsSync(roadmapPath)) {
+    return { marked: [], held: [], note: "no-roadmap" };
+  }
+  const parsed = parseRoadmap(fs36.readFileSync(roadmapPath, "utf-8"));
+  if (!parsed.ok) return { marked: [], held: [], note: "roadmap-parse-error" };
+  const graphStore = await loadGraphStore(cwd);
+  const provider = resolveBrainstormProvider(opts.config);
+  const precedent = await buildPrecedentLookup(cwd);
+  const rows = await runBrainstormReport(parsed.value, {
+    ...graphStore ? { graphStore } : {},
+    ...provider ? { provider } : {},
+    ...precedent ? { precedent } : {},
+    docsRoot: path60.join(cwd, "docs")
+  });
+  const ready = deriveReadyCandidates(rows, parsed.value);
+  const approvedIds = new Set(
+    (opts.approve ?? "").split(",").map((s) => s.trim()).filter((s) => s.length > 0)
+  );
+  const historyForShape = await buildShapeHistory(cwd);
+  const plan = buildApprovalPlan(ready, {
+    approvedIds,
+    ...opts.approveAll ? { approveAll: true } : {},
+    stage,
+    historyForShape
+  });
+  const store = resolveRoadmapStoreForFile({ roadmapPath });
+  const recordPrediction = (payload) => event_sourcing_exports.recordTriagePrediction(cwd, payload);
+  const result = await markApprovedForDispatch(plan.toMark, {
+    store,
+    config: { enabled: true, ratchetStage: stage },
+    recordPrediction
+  });
+  if (!result.ok) {
+    return { marked: [], held: plan.held, note: `mark-failed: ${result.error.message}` };
+  }
+  return { marked: result.value.marked, held: plan.held };
+}
+function renderApproveHuman(res) {
+  if (res.note === "disabled") {
+    return "Roadmap auto-triage is disabled (roadmap.autoTriage.enabled is not true). Enable it to use `triage approve`. No changes made.";
+  }
+  if (res.note === "no-roadmap") return "No roadmap aggregate at docs/roadmap.md. No changes made.";
+  if (res.note === "roadmap-parse-error") return "Failed to parse roadmap. No changes made.";
+  const lines = [];
+  if (res.marked.length > 0) {
+    lines.push(`Marked ${res.marked.length} item(s) eligible for orchestrator pickup:`);
+    for (const id of res.marked) lines.push(`  \u2713 ${id}`);
+  } else {
+    lines.push("No items marked.");
+  }
+  if (res.held.length > 0) {
+    lines.push(`
+Held to human (${res.held.length}):`);
+    for (const h of res.held) lines.push(`  \u2717 ${h.externalId} \u2014 ${h.reason}`);
+  }
+  if (res.note && res.note.startsWith("mark-failed")) lines.push(`
+ERROR: ${res.note}`);
+  lines.push(
+    "\nApproved items are NOT dispatched here \u2014 the existing orchestrator pickup loop dispatches them through its normal gating on its next tick."
+  );
+  return lines.join("\n");
+}
+function createTriageApproveCommand() {
+  return new Command89("approve").description(
+    "Batched human go/no-go (autonomy ratchet stage 1): review READY candidates (Phase-2 spec-bearing, re-score dispatchable) and approve a subset. Approved + auto-executable items are MARKED eligible for the EXISTING orchestrator pickup \u2014 nothing is dispatched here, and nothing is marked without an explicit approval. Gated behind roadmap.autoTriage.enabled (default off)."
+  ).option(
+    "--approve <ids>",
+    "Comma-separated externalIds to approve (the explicit human go). Omit to mark nothing."
+  ).option("--approve-all", "Approve every READY candidate (still subject to the category gate).").action(async (opts, cmd) => {
+    const cwd = process.cwd();
+    const globalOpts = cmd.optsWithGlobals();
+    const res = await runApproveCommand(cwd, {
+      ...opts,
+      ...globalOpts.config !== void 0 ? { config: globalOpts.config } : {}
+    });
+    if (globalOpts.json) {
+      process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+    } else {
+      logger.info(renderApproveHuman(res));
+    }
+  });
+}
+function createRoadmapTriageCommand() {
+  return new Command89("triage").description(
+    "Read-only triage report: score every actionable roadmap item with the four-lever scoping probe and rank dispatchability. Gated behind roadmap.autoTriage.enabled (default off); never writes. Offline by default (holds to human without a live model). With --brainstorm, additionally run the autonomous brainstorm per candidate, emitting a drafted spec (docs only) or a halt handoff (fork + reason) \u2014 still no dispatch."
+  ).option(
+    "--brainstorm",
+    "Run the autonomous brainstorm per candidate: draft a spec (docs only) or halt to a human at the first fork it can not confidently recommend. No dispatch, no execution."
+  ).option(
+    "--only <substring>",
+    'Process ONLY roadmap items whose title contains this substring (case-insensitive). Lets you triage/brainstorm a single item, e.g. --only "prefer-execfile".'
+  ).option(
+    "--limit <n>",
+    "Process at most N items (applied after --only). Useful for a quick partial scan.",
+    (v) => Number.parseInt(v, 10)
+  ).option(
+    "--offline",
+    "Force the pure static path \u2014 never consult the local model. A fast scan that holds every item to a human (byte-identical to running without a resolvable model)."
+  ).action(
+    async (opts, cmd) => {
+      await runTriageCommandAction(opts, cmd);
+    }
+  ).addCommand(createTriageApproveCommand());
+}
+async function runTriageCommandAction(opts, cmd) {
+  const cwd = process.cwd();
+  const globalOpts = cmd.optsWithGlobals();
+  const parsed = gateAndParseRoadmap(cwd, globalOpts.config);
+  if (!parsed) return;
+  const graphStore = await loadGraphStore(cwd);
+  const precedent = await buildPrecedentLookup(cwd);
+  const provider = opts.offline === true ? null : resolveBrainstormProvider(globalOpts.config);
+  const onProgress = globalOpts.json === true ? void 0 : (message) => logger.info(message);
+  const shared = {
+    ...graphStore ? { graphStore } : {},
+    ...provider ? { provider } : {},
+    ...precedent ? { precedent } : {},
+    ...opts.only !== void 0 ? { only: opts.only } : {},
+    ...typeof opts.limit === "number" && !Number.isNaN(opts.limit) ? { limit: opts.limit } : {},
+    ...onProgress ? { onProgress } : {}
+  };
+  if (opts.brainstorm) {
+    const rows2 = await runBrainstormReport(parsed, {
+      ...shared,
+      gatePlausible: true,
+      docsRoot: path60.join(cwd, "docs")
+    });
+    emitReport(
+      globalOpts.json === true,
+      () => renderBrainstormJson(rows2),
+      () => renderBrainstormHuman(rows2)
+    );
+    return;
+  }
+  const rows = await runTriageReport(parsed, {
+    ...shared,
+    ...opts.offline === true ? { offline: true } : {}
+  });
+  emitReport(
+    globalOpts.json === true,
+    () => renderJson(rows),
+    () => renderHuman(rows)
+  );
+}
+function gateAndParseRoadmap(cwd, configPath) {
+  const configResult = resolveConfig(configPath);
+  const enabled = configResult.ok && configResult.value.roadmap?.autoTriage?.enabled === true;
+  if (!enabled) {
+    logger.info(
+      "Roadmap auto-triage is disabled (roadmap.autoTriage.enabled is not true). Enable it in harness.config.json to run the read-only triage report. No changes made."
+    );
+    return null;
+  }
+  const roadmapPath = path60.join(cwd, "docs", "roadmap.md");
+  if (!fs36.existsSync(roadmapPath)) {
+    logger.error(
+      `No roadmap aggregate at ${roadmapPath}. If your roadmap is sharded, run \`harness roadmap regen\` first, then re-run triage.`
+    );
+    process.exitCode = 1;
+    return null;
+  }
+  const parsed = parseRoadmap(fs36.readFileSync(roadmapPath, "utf-8"));
+  if (!parsed.ok) {
+    logger.error(`Failed to parse roadmap: ${parsed.error.message}`);
+    process.exitCode = 1;
+    return null;
+  }
+  return parsed.value;
+}
+function emitReport(json, toJson, toHuman) {
+  if (json) {
+    process.stdout.write(toJson() + "\n");
+  } else {
+    logger.info(toHuman());
+  }
+}
+
 // src/commands/roadmap/index.ts
 function createRoadmapCommand() {
-  const roadmap = new Command89("roadmap").description("Roadmap management");
+  const roadmap = new Command90("roadmap").description("Roadmap management");
   roadmap.addCommand(createRoadmapMigrateCommand());
   roadmap.addCommand(createRoadmapShardCommand());
   roadmap.addCommand(createRoadmapUnshardCommand());
   roadmap.addCommand(createRoadmapRegenCommand());
   roadmap.addCommand(createRoadmapReconcileCommand());
   roadmap.addCommand(createRoadmapReferencedIssuesCommand());
+  roadmap.addCommand(createRoadmapTriageCommand());
   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";
+import { Command as Command91, Option as Option3, InvalidArgumentError } from "commander";
 
 // src/rollback/compose.ts
 var ROLLBACK_LABEL = "harness:rollback";
@@ -11842,12 +12479,12 @@ async function composeRevertPr(decision, originalTitle, opts) {
 
 // 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");
+import { dirname as dirname20, join as join51 } from "path";
+var ROLLBACK_EVENTS_FILE = join51(".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);
+  const file = join51(root, ROLLBACK_EVENTS_FILE);
   mkdirSync19(dirname20(file), { recursive: true });
   appendFileSync(file, `${JSON.stringify({ ...event, ts })}
 `, "utf-8");
@@ -11874,7 +12511,7 @@ async function linkRollbackEventToGraph(event, opts = {}) {
     if (target) {
       store.addEdge({ from: nodeId, to: target.id, type: "references" });
     }
-    await store.save(join50(root, ".harness", "graph"));
+    await store.save(join51(root, ".harness", "graph"));
   } catch {
   }
 }
@@ -11906,8 +12543,8 @@ function parseConflictPaths(stdout) {
     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);
+    const path82 = line.slice(tab + 1).trim();
+    if (path82) paths.add(path82);
   }
   return [...paths];
 }
@@ -12153,7 +12790,7 @@ async function runRollbackSweepCommand(deps) {
   });
 }
 function createRollbackCommand() {
-  const rollback = new Command90("rollback").description(
+  const rollback = new Command91("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) => {
@@ -12206,10 +12843,10 @@ function createRollbackCommand() {
 }
 
 // src/commands/routing/index.ts
-import { Command as Command96 } from "commander";
+import { Command as Command97 } from "commander";
 
 // src/commands/routing/config.ts
-import { Command as Command91 } from "commander";
+import { Command as Command92 } from "commander";
 
 // src/commands/routing/http-client.ts
 function orchestratorBase() {
@@ -12219,9 +12856,9 @@ function authHeader() {
   const tok = process.env["HARNESS_API_TOKEN"];
   return tok ? { Authorization: `Bearer ${tok}` } : {};
 }
-async function getJson(path81) {
+async function getJson(path82) {
   try {
-    const res = await fetch(`${orchestratorBase()}${path81}`, {
+    const res = await fetch(`${orchestratorBase()}${path82}`, {
       headers: { ...authHeader() }
     });
     const text = await res.text();
@@ -12236,9 +12873,9 @@ async function getJson(path81) {
     };
   }
 }
-async function postJson(path81, body) {
+async function postJson(path82, body) {
   try {
-    const res = await fetch(`${orchestratorBase()}${path81}`, {
+    const res = await fetch(`${orchestratorBase()}${path82}`, {
       method: "POST",
       headers: { "Content-Type": "application/json", ...authHeader() },
       body: JSON.stringify(body)
@@ -12257,7 +12894,7 @@ async function postJson(path81, body) {
 }
 
 // src/commands/routing/config.ts
-function renderHuman(data) {
+function renderHuman2(data) {
   console.log("Backends:");
   for (const b of data.backends) console.log(`  - ${b}`);
   console.log("");
@@ -12274,7 +12911,7 @@ function renderHuman(data) {
   }
 }
 function createConfigCommand() {
-  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) => {
+  return new Command92("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) {
@@ -12295,12 +12932,12 @@ function createConfigCommand() {
       console.log(JSON.stringify(r.body, null, 2));
       return;
     }
-    if (r.body) renderHuman(r.body);
+    if (r.body) renderHuman2(r.body);
   });
 }
 
 // src/commands/routing/trace.ts
-import { Command as Command92 } from "commander";
+import { Command as Command93 } from "commander";
 var COMPLEXITY_VALUES = ["trivial", "simple", "moderate", "complex"];
 var RISK_VALUES = ["low", "high"];
 function validateEnum(flag, value, allowed) {
@@ -12314,20 +12951,28 @@ function buildUseCase(opts) {
   if (opts.mode) return { kind: "mode", cognitiveMode: opts.mode };
   return null;
 }
-function renderHuman2(r) {
-  console.log(`Backend: ${r.decision.backendName} (type: ${r.def.type})`);
+function renderHuman3(r) {
+  const amr = r.tierRequired !== void 0 && r.costedBackendName !== void 0;
+  const backend = amr ? r.costedBackendName : r.decision.backendName;
+  const type = amr && r.costedBackendType !== void 0 ? r.costedBackendType : r.def.type;
+  console.log(`Backend: ${backend} (type: ${type})`);
   console.log(`Duration: ${r.decision.durationMs.toFixed(2)} ms`);
   console.log("Resolution path:");
   if (r.decision.resolutionPath.length === 0) {
     console.log("  (empty)");
-    return;
-  }
-  for (const step of r.decision.resolutionPath) {
-    console.log(`  ${step.source}:${step.candidate} -> ${step.outcome}`);
+  } else {
+    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 (amr && r.costedBackendName !== r.decision.backendName) {
+    console.log(
+      `  (AMR overrides the identity pick '${r.decision.backendName}' \u2192 cheapest backend at/above the tier)`
+    );
+  }
   if (r.estCostUsd !== void 0) {
     console.log(`Est cost: $${r.estCostUsd.toFixed(4)}`);
   }
@@ -12368,17 +13013,17 @@ async function runTrace(opts) {
     console.log(JSON.stringify(r.body, null, 2));
     return;
   }
-  if (r.body) renderHuman2(r.body);
+  if (r.body) renderHuman3(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(
+  return new Command93("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 Command93 } from "commander";
+import { Command as Command94 } from "commander";
 function summarizeUseCase(uc) {
   switch (uc.kind) {
     case "skill":
@@ -12402,7 +13047,7 @@ function shortIso(iso) {
   const tail = parts[1] ?? iso;
   return tail.replace("Z", "");
 }
-function renderHuman3(data) {
+function renderHuman4(data) {
   if (data.decisions.length === 0) {
     console.log("(no decisions in buffer)");
     return;
@@ -12426,7 +13071,7 @@ function buildQuery(opts) {
   return q ? `?${q}` : "";
 }
 function createDecisionsCommand() {
-  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(
+  return new Command94("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}`);
@@ -12449,19 +13094,19 @@ function createDecisionsCommand() {
         console.log(JSON.stringify(r.body, null, 2));
         return;
       }
-      if (r.body) renderHuman3(r.body);
+      if (r.body) renderHuman4(r.body);
     }
   );
 }
 
 // src/commands/routing/telemetry.ts
-import { Command as Command94 } from "commander";
+import { Command as Command95 } 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) {
+function renderHuman5(data, tableLimit) {
   if (data.decisions.length === 0) {
     console.log("(no routing telemetry \u2014 AMR is off or no decisions recorded yet)");
     return;
@@ -12499,7 +13144,7 @@ function renderHuman4(data, tableLimit) {
   }
 }
 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) => {
+  return new Command95("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) {
@@ -12518,18 +13163,18 @@ function createTelemetryCommand() {
       return;
     }
     const tableLimit = opts.last && Number.isFinite(Number(opts.last)) && Number(opts.last) > 0 ? Math.floor(Number(opts.last)) : void 0;
-    renderHuman4(body, tableLimit);
+    renderHuman5(body, tableLimit);
   });
 }
 
 // src/commands/routing/status.ts
-import { Command as Command95 } from "commander";
+import { Command as Command96 } 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) {
+function renderHuman6(s) {
   if (!s.active) {
     console.log("Adaptive routing: OFF (no routing.policy configured \u2014 dispatch is unchanged)");
     return;
@@ -12563,7 +13208,7 @@ function renderHuman5(s) {
   );
 }
 function createStatusCommand() {
-  return new Command95("status").description(
+  return new Command96("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");
@@ -12588,13 +13233,13 @@ function createStatusCommand() {
       console.log(JSON.stringify(body, null, 2));
       return;
     }
-    renderHuman5(body);
+    renderHuman6(body);
   });
 }
 
 // src/commands/routing/index.ts
 function createRoutingCommand() {
-  const cmd = new Command96("routing").description(
+  const cmd = new Command97("routing").description(
     "Inspect routing config, trace decisions, and read AMR telemetry + status"
   );
   cmd.addCommand(createConfigCommand());
@@ -12607,9 +13252,9 @@ function createRoutingCommand() {
 
 // src/commands/scan-config.ts
 init_dist3();
-import { Command as Command97 } from "commander";
-import { existsSync as existsSync31, readFileSync as readFileSync22, writeFileSync as writeFileSync23 } from "fs";
-import { join as join51, relative as relative4 } from "path";
+import { Command as Command98 } from "commander";
+import { existsSync as existsSync32, readFileSync as readFileSync23, writeFileSync as writeFileSync23 } from "fs";
+import { join as join52, 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();
@@ -12642,10 +13287,10 @@ function applyFix(filePath, targetDir, content, injectionFindings) {
   }
 }
 function scanSingleFile(filePath, targetDir, scanner, options) {
-  if (!existsSync31(filePath)) return null;
+  if (!existsSync32(filePath)) return null;
   let content;
   try {
-    content = readFileSync22(filePath, "utf8");
+    content = readFileSync23(filePath, "utf8");
   } catch {
     return null;
   }
@@ -12666,7 +13311,7 @@ async function runScanConfig(targetDir, options) {
   const scanner = new SecurityScanner(parseSecurityConfig({}));
   const results = [];
   for (const configFile of CONFIG_FILES) {
-    const result = scanSingleFile(join51(targetDir, configFile), targetDir, scanner, options);
+    const result = scanSingleFile(join52(targetDir, configFile), targetDir, scanner, options);
     if (result) results.push(result);
   }
   return { exitCode: computeScanExitCode(results), results };
@@ -12696,7 +13341,7 @@ function formatTextOutput(result) {
   }
 }
 function createScanConfigCommand() {
-  const command = new Command97("scan-config").description(
+  const command = new Command98("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();
@@ -12714,7 +13359,7 @@ function createScanConfigCommand() {
 
 // src/commands/search.ts
 init_dist();
-import { Command as Command98 } from "commander";
+import { Command as Command99 } from "commander";
 function parseFileKinds(raw) {
   if (!raw) return void 0;
   const set = /* @__PURE__ */ new Set();
@@ -12735,7 +13380,7 @@ function fmtBytes(n) {
   return n.toFixed(0);
 }
 function createSearchCommand() {
-  return new Command98("search").description("Full-text search over archived + live session content.").argument(
+  return new Command99("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(
@@ -12795,9 +13440,9 @@ function createSearchCommand() {
 }
 
 // src/commands/security-craft.ts
-import { Command as Command99 } from "commander";
+import { Command as Command100 } from "commander";
 function createSecurityCraftCommand() {
-  return new Command99("security-craft").description(
+  return new Command100("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();
@@ -12844,10 +13489,10 @@ function printResult5(result, mode, _formatter) {
       list.push(f);
       byFile.set(f.target.file, list);
     }
-    for (const [file, fs51] of byFile) {
+    for (const [file, fs52] of byFile) {
       console.log(`
 ${file}`);
-      for (const f of fs51) {
+      for (const f of fs52) {
         console.log(
           `  ${f.code} [${f.tier}/${f.impact}/${f.confidence}] ${f.target.signal}:${f.target.line}`
         );
@@ -12863,24 +13508,24 @@ ${file}`);
 }
 
 // src/commands/setup.ts
-import { Command as Command100 } from "commander";
-import * as fs38 from "fs";
+import { Command as Command101 } from "commander";
+import * as fs39 from "fs";
 import * as os9 from "os";
-import * as path62 from "path";
+import * as path63 from "path";
 import chalk16 from "chalk";
 
 // src/utils/first-run.ts
-import * as fs36 from "fs";
+import * as fs37 from "fs";
 import * as os8 from "os";
-import * as path60 from "path";
-var HARNESS_DIR = path60.join(os8.homedir(), ".harness");
-var MARKER_FILE = path60.join(HARNESS_DIR, ".setup-complete");
+import * as path61 from "path";
+var HARNESS_DIR = path61.join(os8.homedir(), ".harness");
+var MARKER_FILE = path61.join(HARNESS_DIR, ".setup-complete");
 function isFirstRun() {
-  return !fs36.existsSync(MARKER_FILE);
+  return !fs37.existsSync(MARKER_FILE);
 }
 function markSetupComplete() {
-  fs36.mkdirSync(HARNESS_DIR, { recursive: true });
-  fs36.writeFileSync(MARKER_FILE, "", "utf-8");
+  fs37.mkdirSync(HARNESS_DIR, { recursive: true });
+  fs37.writeFileSync(MARKER_FILE, "", "utf-8");
 }
 function printFirstRunWelcome() {
   try {
@@ -12893,8 +13538,8 @@ function printFirstRunWelcome() {
 }
 
 // src/commands/telemetry-wizard.ts
-import * as fs37 from "fs";
-import * as path61 from "path";
+import * as fs38 from "fs";
+import * as path62 from "path";
 import readline2 from "readline";
 import chalk15 from "chalk";
 function prompt2(question) {
@@ -12925,21 +13570,21 @@ function isNo(answer) {
   return answer === "n" || answer === "no";
 }
 function isTelemetryConfigured(cwd) {
-  const configPath = path61.join(cwd, "harness.config.json");
+  const configPath = path62.join(cwd, "harness.config.json");
   try {
-    const raw = JSON.parse(fs37.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs38.readFileSync(configPath, "utf-8"));
     return raw.telemetry !== void 0 && raw.adoption !== void 0;
   } catch {
     return false;
   }
 }
 function writeTelemetryConfig(cwd, result) {
-  const configPath = path61.join(cwd, "harness.config.json");
+  const configPath = path62.join(cwd, "harness.config.json");
   try {
-    const raw = JSON.parse(fs37.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs38.readFileSync(configPath, "utf-8"));
     raw.telemetry = { enabled: result.telemetryEnabled };
     raw.adoption = { enabled: result.adoptionEnabled };
-    fs37.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
+    fs38.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
   } catch (err) {
     console.warn(
       `\u26A0 Could not update ${configPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -12947,10 +13592,10 @@ function writeTelemetryConfig(cwd, result) {
   }
   const hasIdentity = result.identity.project || result.identity.team || result.identity.alias;
   if (hasIdentity) {
-    const harnessDir = path61.join(cwd, ".harness");
-    fs37.mkdirSync(harnessDir, { recursive: true });
-    const telemetryFile = path61.join(harnessDir, "telemetry.json");
-    fs37.writeFileSync(telemetryFile, JSON.stringify({ identity: result.identity }, null, 2) + "\n");
+    const harnessDir = path62.join(cwd, ".harness");
+    fs38.mkdirSync(harnessDir, { recursive: true });
+    const telemetryFile = path62.join(harnessDir, "telemetry.json");
+    fs38.writeFileSync(telemetryFile, JSON.stringify({ identity: result.identity }, null, 2) + "\n");
   }
 }
 async function promptIdentity() {
@@ -12996,8 +13641,8 @@ async function runTelemetryWizard() {
   return { telemetryEnabled, adoptionEnabled, identity };
 }
 async function ensureTelemetryConfigured(cwd) {
-  const configPath = path61.join(cwd, "harness.config.json");
-  if (!fs37.existsSync(configPath)) {
+  const configPath = path62.join(cwd, "harness.config.json");
+  if (!fs38.existsSync(configPath)) {
     return { status: "warn", message: "Not a harness project \u2014 skipped telemetry configuration" };
   }
   if (isTelemetryConfigured(cwd)) {
@@ -13043,7 +13688,7 @@ function runSlashCommandGeneration() {
   }
 }
 function detectClient(dirName) {
-  return fs38.existsSync(path62.join(os9.homedir(), dirName));
+  return fs39.existsSync(path63.join(os9.homedir(), dirName));
 }
 async function runMcpSetup(cwd) {
   const results = [];
@@ -13059,7 +13704,7 @@ async function runMcpSetup(cwd) {
     { name: "Cursor", dir: ".cursor", client: "cursor", configTarget: ".cursor/mcp.json" },
     {
       name: "OpenCode",
-      dir: path62.join(".config", "opencode"),
+      dir: path63.join(".config", "opencode"),
       client: "opencode",
       configTarget: "opencode.json"
     }
@@ -13091,7 +13736,7 @@ function formatStep(result) {
 }
 function configureTier0Integrations(cwd) {
   try {
-    const mcpPath = path62.join(cwd, ".mcp.json");
+    const mcpPath = path63.join(cwd, ".mcp.json");
     const config = readMcpConfig(mcpPath);
     const tier0 = INTEGRATION_REGISTRY.filter((i) => i.tier === 0);
     const added = [];
@@ -13100,9 +13745,9 @@ function configureTier0Integrations(cwd) {
       writeMcpEntry(mcpPath, integration.name, integration.mcpConfig);
       added.push(integration.displayName);
     }
-    const geminiDir = path62.join(cwd, ".gemini");
-    if (fs38.existsSync(geminiDir)) {
-      const geminiPath = path62.join(geminiDir, "settings.json");
+    const geminiDir = path63.join(cwd, ".gemini");
+    if (fs39.existsSync(geminiDir)) {
+      const geminiPath = path63.join(geminiDir, "settings.json");
       const geminiConfig = readMcpConfig(geminiPath);
       for (const integration of tier0) {
         if (!geminiConfig.mcpServers[integration.name]) {
@@ -13110,9 +13755,9 @@ function configureTier0Integrations(cwd) {
         }
       }
     }
-    const opencodePath = path62.join(cwd, "opencode.json");
-    const opencodeGlobalDir = path62.join(os9.homedir(), ".config", "opencode");
-    if (fs38.existsSync(opencodePath) || fs38.existsSync(opencodeGlobalDir)) {
+    const opencodePath = path63.join(cwd, "opencode.json");
+    const opencodeGlobalDir = path63.join(os9.homedir(), ".config", "opencode");
+    if (fs39.existsSync(opencodePath) || fs39.existsSync(opencodeGlobalDir)) {
       for (const integration of tier0) {
         writeOpencodeMcpEntry(opencodePath, integration.name, integration.mcpConfig);
       }
@@ -13130,14 +13775,14 @@ function configureTier0Integrations(cwd) {
   }
 }
 function ensureHooks(cwd) {
-  const configPath = path62.join(cwd, "harness.config.json");
-  if (!fs38.existsSync(configPath)) {
+  const configPath = path63.join(cwd, "harness.config.json");
+  if (!fs39.existsSync(configPath)) {
     return { status: "warn", message: "Not a harness project \u2014 skipped hook installation" };
   }
   let profile = "standard";
-  const profilePath = path62.join(cwd, ".harness", "hooks", "profile.json");
+  const profilePath = path63.join(cwd, ".harness", "hooks", "profile.json");
   try {
-    const data = JSON.parse(fs38.readFileSync(profilePath, "utf-8"));
+    const data = JSON.parse(fs39.readFileSync(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
       profile = data.profile;
     }
@@ -13208,7 +13853,7 @@ async function runSetup(cwd) {
   return { steps, success };
 }
 function createSetupCommand() {
-  return new Command100("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
+  return new Command101("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
     const cwd = process.cwd();
     console.log("");
     console.log(`  ${chalk16.bold("harness setup")}`);
@@ -13231,15 +13876,15 @@ function createSetupCommand() {
 
 // src/commands/share.ts
 init_dist3();
-import { Command as Command101 } from "commander";
-import * as fs39 from "fs";
-import * as path63 from "path";
+import { Command as Command102 } from "commander";
+import * as fs40 from "fs";
+import * as path64 from "path";
 import { parse as parseYaml3 } from "yaml";
 var MANIFEST_FILENAME = "constraints.yaml";
 async function runShareAction(projectPath, options) {
-  const rootDir = path63.resolve(projectPath);
-  const manifestPath = path63.join(rootDir, MANIFEST_FILENAME);
-  if (!fs39.existsSync(manifestPath)) {
+  const rootDir = path64.resolve(projectPath);
+  const manifestPath = path64.join(rootDir, MANIFEST_FILENAME);
+  if (!fs40.existsSync(manifestPath)) {
     logger.error(
       `No ${MANIFEST_FILENAME} found at ${manifestPath}.
 Create a constraints.yaml in your project root to define what to share.`
@@ -13248,7 +13893,7 @@ Create a constraints.yaml in your project root to define what to share.`
   }
   let parsed;
   try {
-    const raw = fs39.readFileSync(manifestPath, "utf-8");
+    const raw = fs40.readFileSync(manifestPath, "utf-8");
     parsed = parseYaml3(raw);
   } catch (err) {
     logger.error(
@@ -13262,7 +13907,7 @@ Create a constraints.yaml in your project root to define what to share.`
     process.exit(1);
   }
   const manifest = manifestResult.value;
-  const configResult = resolveConfig(path63.join(rootDir, "harness.config.json"));
+  const configResult = resolveConfig(path64.join(rootDir, "harness.config.json"));
   if (!configResult.ok) {
     logger.error(configResult.error.message);
     process.exit(1);
@@ -13280,8 +13925,8 @@ Create a constraints.yaml in your project root to define what to share.`
     );
     process.exit(1);
   }
-  const outputDir = path63.resolve(options.output);
-  const outputPath = path63.join(outputDir, `${manifest.name}.harness-constraints.json`);
+  const outputDir = path64.resolve(options.output);
+  const outputPath = path64.join(outputDir, `${manifest.name}.harness-constraints.json`);
   const writeResult = await writeConfig(outputPath, bundle);
   if (!writeResult.ok) {
     logger.error(`Failed to write bundle: ${writeResult.error.message}`);
@@ -13290,28 +13935,28 @@ Create a constraints.yaml in your project root to define what to share.`
   logger.success(`Bundle written to ${outputPath}`);
 }
 function createShareCommand() {
-  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) => {
+  return new Command102("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 Command109 } from "commander";
+import { Command as Command110 } from "commander";
 
 // src/commands/skill/list.ts
-import { Command as Command102 } from "commander";
-import * as fs40 from "fs";
-import * as path64 from "path";
+import { Command as Command103 } from "commander";
+import * as fs41 from "fs";
+import * as path65 from "path";
 import { parse } from "yaml";
 function scanDirectory(dirPath, source) {
-  if (!fs40.existsSync(dirPath)) return [];
-  const entries = fs40.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  if (!fs41.existsSync(dirPath)) return [];
+  const entries = fs41.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   const skills = [];
   for (const name of entries) {
-    const yamlPath = path64.join(dirPath, name, "skill.yaml");
-    if (!fs40.existsSync(yamlPath)) continue;
+    const yamlPath = path65.join(dirPath, name, "skill.yaml");
+    if (!fs41.existsSync(yamlPath)) continue;
     try {
-      const raw = fs40.readFileSync(yamlPath, "utf-8");
+      const raw = fs41.readFileSync(yamlPath, "utf-8");
       const parsed = parse(raw);
       const result = SkillMetadataSchema.safeParse(parsed);
       if (result.success) {
@@ -13329,10 +13974,10 @@ function scanDirectory(dirPath, source) {
 }
 function collectCommunitySkills(seen, allSkills) {
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path64.dirname(globalDir);
-  const communityBase = path64.join(skillsDir, "community");
-  const communityPlatformDir = path64.join(communityBase, "claude-code");
-  const lockfilePath = path64.join(communityBase, "skills-lock.json");
+  const skillsDir = path65.dirname(globalDir);
+  const communityBase = path65.join(skillsDir, "community");
+  const communityPlatformDir = path65.join(communityBase, "claude-code");
+  const lockfilePath = path65.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const communitySkills = scanDirectory(communityPlatformDir, "community");
   for (const skill of communitySkills) {
@@ -13402,7 +14047,7 @@ function printSkillsVerbose(skills) {
   for (const s of skills) printSkillEntry(s);
 }
 function createListCommand3() {
-  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) => {
+  return new Command103("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) {
@@ -13417,9 +14062,9 @@ function createListCommand3() {
 }
 
 // src/commands/skill/run.ts
-import { Command as Command103 } from "commander";
-import * as fs41 from "fs";
-import * as path65 from "path";
+import { Command as Command104 } from "commander";
+import * as fs42 from "fs";
+import * as path66 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/skill/complexity.ts
@@ -13515,10 +14160,10 @@ ${options.principles}`);
 
 // src/commands/skill/run.ts
 function loadSkillMetadata(skillDir) {
-  const yamlPath = path65.join(skillDir, "skill.yaml");
-  if (!fs41.existsSync(yamlPath)) return null;
+  const yamlPath = path66.join(skillDir, "skill.yaml");
+  if (!fs42.existsSync(yamlPath)) return null;
   try {
-    const result = SkillMetadataSchema.safeParse(parse2(fs41.readFileSync(yamlPath, "utf-8")));
+    const result = SkillMetadataSchema.safeParse(parse2(fs42.readFileSync(yamlPath, "utf-8")));
     return result.success ? result.data : null;
   } catch {
     return null;
@@ -13530,22 +14175,22 @@ function resolveComplexity(metadata, requested, projectPath) {
   return requested;
 }
 function loadPrinciples(projectPath) {
-  const principlesPath = path65.join(projectPath, "docs", "principles.md");
-  return fs41.existsSync(principlesPath) ? fs41.readFileSync(principlesPath, "utf-8") : void 0;
+  const principlesPath = path66.join(projectPath, "docs", "principles.md");
+  return fs42.existsSync(principlesPath) ? fs42.readFileSync(principlesPath, "utf-8") : void 0;
 }
 function readMostRecentFileInDir(dirPath) {
-  const files = fs41.readdirSync(dirPath).map((f) => ({ name: f, mtime: fs41.statSync(path65.join(dirPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
-  if (files.length > 0) return fs41.readFileSync(path65.join(dirPath, files[0].name), "utf-8");
+  const files = fs42.readdirSync(dirPath).map((f) => ({ name: f, mtime: fs42.statSync(path66.join(dirPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  if (files.length > 0) return fs42.readFileSync(path66.join(dirPath, files[0].name), "utf-8");
   return void 0;
 }
 function loadPriorState(metadata, projectPath) {
   if (!metadata?.state.persistent || metadata.state.files.length === 0) return void 0;
   for (const stateFilePath of metadata.state.files) {
-    const fullPath = path65.join(projectPath, stateFilePath);
-    if (!fs41.existsSync(fullPath)) continue;
-    const stat = fs41.statSync(fullPath);
+    const fullPath = path66.join(projectPath, stateFilePath);
+    if (!fs42.existsSync(fullPath)) continue;
+    const stat = fs42.statSync(fullPath);
     if (stat.isDirectory()) return readMostRecentFileInDir(fullPath);
-    return fs41.readFileSync(fullPath, "utf-8");
+    return fs42.readFileSync(fullPath, "utf-8");
   }
   return void 0;
 }
@@ -13565,7 +14210,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-PTWAEGJ2.js");
+  const { readHarnessState: readHarnessState2, isEmptyHarnessState } = await import("./state-events-YLQEYOLI.js");
   const stateResult = await readHarnessState2(projectPath);
   if (!stateResult.ok || isEmptyHarnessState(stateResult.value)) return content;
   const stateContent = JSON.stringify(stateResult.value, null, 2);
@@ -13586,7 +14231,7 @@ async function runSkill(name, opts) {
     return;
   }
   const metadata = loadSkillMetadata(skillDir);
-  const projectPath = opts.path ? path65.resolve(opts.path) : process.cwd();
+  const projectPath = opts.path ? path66.resolve(opts.path) : process.cwd();
   const complexity = resolveComplexity(
     metadata,
     opts.complexity ?? "standard",
@@ -13613,14 +14258,14 @@ async function runSkill(name, opts) {
     ...stateWarning !== void 0 && { stateWarning },
     ...opts.party !== void 0 && { party: opts.party }
   });
-  const skillMdPath = path65.join(skillDir, "SKILL.md");
-  if (!fs41.existsSync(skillMdPath)) {
+  const skillMdPath = path66.join(skillDir, "SKILL.md");
+  if (!fs42.existsSync(skillMdPath)) {
     logger.error(`SKILL.md not found for skill: ${name}`);
     process.exit(ExitCode.ERROR);
     return;
   }
   const content = await appendProjectState(
-    fs41.readFileSync(skillMdPath, "utf-8"),
+    fs42.readFileSync(skillMdPath, "utf-8"),
     metadata,
     projectPath,
     !!opts.path
@@ -13631,16 +14276,16 @@ async function runSkill(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createRunCommand3() {
-  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(
+  return new Command104("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 Command104 } from "commander";
-import * as fs42 from "fs";
-import * as path66 from "path";
+import { Command as Command105 } from "commander";
+import * as fs43 from "fs";
+import * as path67 from "path";
 import { parse as parse3 } from "yaml";
 var BEHAVIORAL_REQUIRED_SECTIONS = [
   "## When to Use",
@@ -13652,11 +14297,11 @@ var BEHAVIORAL_REQUIRED_SECTIONS = [
 ];
 var KNOWLEDGE_REQUIRED_SECTIONS = ["## Instructions"];
 function validateSkillMd(name, skillMdPath, skillType, errors) {
-  if (!fs42.existsSync(skillMdPath)) {
+  if (!fs43.existsSync(skillMdPath)) {
     errors.push(`${name}: missing SKILL.md`);
     return;
   }
-  const mdContent = fs42.readFileSync(skillMdPath, "utf-8");
+  const mdContent = fs43.readFileSync(skillMdPath, "utf-8");
   if (!mdContent.trim().startsWith("# ")) {
     errors.push(`${name}/SKILL.md: must start with an h1 heading`);
   }
@@ -13681,20 +14326,20 @@ function validateSkillMd(name, skillMdPath, skillType, errors) {
   }
 }
 function validateSkillEntry(name, skillsDir, errors) {
-  const skillDir = path66.join(skillsDir, name);
-  const yamlPath = path66.join(skillDir, "skill.yaml");
-  if (!fs42.existsSync(yamlPath)) {
+  const skillDir = path67.join(skillsDir, name);
+  const yamlPath = path67.join(skillDir, "skill.yaml");
+  if (!fs43.existsSync(yamlPath)) {
     errors.push(`${name}: missing skill.yaml`);
     return false;
   }
   try {
-    const raw = fs42.readFileSync(yamlPath, "utf-8");
+    const raw = fs43.readFileSync(yamlPath, "utf-8");
     const result = SkillMetadataSchema.safeParse(parse3(raw));
     if (!result.success) {
       errors.push(`${name}/skill.yaml: ${result.error.message}`);
       return false;
     }
-    validateSkillMd(name, path66.join(skillDir, "SKILL.md"), result.data.type, errors);
+    validateSkillMd(name, path67.join(skillDir, "SKILL.md"), result.data.type, errors);
     return true;
   } catch (e) {
     errors.push(`${name}: parse error \u2014 ${e instanceof Error ? e.message : String(e)}`);
@@ -13702,15 +14347,15 @@ function validateSkillEntry(name, skillsDir, errors) {
   }
 }
 function createValidateCommand2() {
-  return new Command104("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
+  return new Command105("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)) {
+    if (!fs43.existsSync(skillsDir)) {
       logger.info("No skills directory found.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
-    const entries = fs42.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const entries = fs43.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     const errors = [];
     let validated = 0;
     for (const name of entries) {
@@ -13732,9 +14377,9 @@ function createValidateCommand2() {
 }
 
 // src/commands/skill/info.ts
-import { Command as Command105 } from "commander";
-import * as fs43 from "fs";
-import * as path67 from "path";
+import { Command as Command106 } from "commander";
+import * as fs44 from "fs";
+import * as path68 from "path";
 import { parse as parse4 } from "yaml";
 function loadSkillMetadata2(name) {
   const skillDir = resolveSkillDir(name);
@@ -13742,13 +14387,13 @@ function loadSkillMetadata2(name) {
     logger.error(`Skill not found: ${name}`);
     return { ok: false, exitCode: ExitCode.ERROR };
   }
-  const yamlPath = path67.join(skillDir, "skill.yaml");
-  if (!fs43.existsSync(yamlPath)) {
+  const yamlPath = path68.join(skillDir, "skill.yaml");
+  if (!fs44.existsSync(yamlPath)) {
     logger.error(`skill.yaml not found for skill: ${name}`);
     return { ok: false, exitCode: ExitCode.ERROR };
   }
   try {
-    const raw = fs43.readFileSync(yamlPath, "utf-8");
+    const raw = fs44.readFileSync(yamlPath, "utf-8");
     const parsed = parse4(raw);
     const result = SkillMetadataSchema.safeParse(parsed);
     if (!result.success) {
@@ -13777,7 +14422,7 @@ function printSkillInfo(skill) {
   console.log(`Persistent:  ${skill.state.persistent}`);
 }
 function createInfoCommand() {
-  return new Command105("info").description("Show metadata for a skill").argument("<name>", "Skill name (e.g., harness-tdd)").action(async (name, _opts, cmd) => {
+  return new Command106("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) {
@@ -13794,7 +14439,7 @@ function createInfoCommand() {
 }
 
 // src/commands/skill/search.ts
-import { Command as Command106 } from "commander";
+import { Command as Command107 } from "commander";
 async function runSearch(query, opts) {
   const results = await searchNpmRegistry(query, opts.registry);
   return results.filter((r) => {
@@ -13839,15 +14484,15 @@ async function runSearchAction(query, opts, globalOpts) {
   }
 }
 function createSearchCommand2() {
-  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) => {
+  return new Command107("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 Command107 } from "commander";
-import * as path68 from "path";
-import * as fs44 from "fs";
+import { Command as Command108 } from "commander";
+import * as path69 from "path";
+import * as fs45 from "fs";
 import YAML from "yaml";
 var KEBAB_CASE_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 function buildReadme(name, description) {
@@ -13931,22 +14576,22 @@ function runCreate(name, opts) {
   if (!KEBAB_CASE_RE.test(name)) {
     throw new Error(`Invalid skill name "${name}". Must be kebab-case (e.g., my-skill).`);
   }
-  const baseDir = opts.outputDir ?? path68.join(process.cwd(), "agents", "skills", "claude-code");
-  const skillDir = path68.join(baseDir, name);
-  if (fs44.existsSync(skillDir)) {
+  const baseDir = opts.outputDir ?? path69.join(process.cwd(), "agents", "skills", "claude-code");
+  const skillDir = path69.join(baseDir, name);
+  if (fs45.existsSync(skillDir)) {
     throw new Error(`Skill directory already exists: ${skillDir}`);
   }
-  fs44.mkdirSync(skillDir, { recursive: true });
+  fs45.mkdirSync(skillDir, { recursive: true });
   const description = opts.description || `A community skill: ${name}`;
   const skillYaml = buildSkillYaml(name, opts);
-  const skillYamlPath = path68.join(skillDir, "skill.yaml");
-  fs44.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
+  const skillYamlPath = path69.join(skillDir, "skill.yaml");
+  fs45.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
   const skillMd = buildSkillMd(name, description);
-  const skillMdPath = path68.join(skillDir, "SKILL.md");
-  fs44.writeFileSync(skillMdPath, skillMd);
+  const skillMdPath = path69.join(skillDir, "SKILL.md");
+  fs45.writeFileSync(skillMdPath, skillMd);
   const readme = buildReadme(name, description);
-  const readmePath = path68.join(skillDir, "README.md");
-  fs44.writeFileSync(readmePath, readme);
+  const readmePath = path69.join(skillDir, "README.md");
+  fs45.writeFileSync(readmePath, readme);
   return {
     name,
     directory: skillDir,
@@ -13960,12 +14605,12 @@ function printCreateResult(name, result) {
   }
   logger.info(`
 Next steps:`);
-  logger.info(`  1. Edit ${path68.join(result.directory, "SKILL.md")} with your skill content`);
+  logger.info(`  1. Edit ${path69.join(result.directory, "SKILL.md")} with your skill content`);
   logger.info(`  2. Run: harness skill validate ${name}`);
   logger.info(`  3. Run: harness skills publish`);
 }
 function createCreateCommand() {
-  return new 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) => {
+  return new Command108("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, {
@@ -13988,26 +14633,26 @@ function createCreateCommand() {
 }
 
 // src/commands/skill/publish.ts
-import { Command as Command108 } from "commander";
-import * as fs46 from "fs";
-import * as path70 from "path";
+import { Command as Command109 } from "commander";
+import * as fs47 from "fs";
+import * as path71 from "path";
 import { execFileSync as execFileSync12 } from "child_process";
 
 // src/registry/validator.ts
-import * as fs45 from "fs";
-import * as path69 from "path";
+import * as fs46 from "fs";
+import * as path70 from "path";
 import { parse as parse5 } from "yaml";
 import semver4 from "semver";
 async function validateForPublish(skillDir, registryUrl) {
   const errors = [];
-  const skillYamlPath = path69.join(skillDir, "skill.yaml");
-  if (!fs45.existsSync(skillYamlPath)) {
+  const skillYamlPath = path70.join(skillDir, "skill.yaml");
+  if (!fs46.existsSync(skillYamlPath)) {
     errors.push("skill.yaml not found. Create one with: harness skill create <name>");
     return { valid: false, errors };
   }
   let skillMeta;
   try {
-    const raw = fs45.readFileSync(skillYamlPath, "utf-8");
+    const raw = fs46.readFileSync(skillYamlPath, "utf-8");
     const parsed = parse5(raw);
     const result = SkillMetadataSchema.safeParse(parsed);
     if (!result.success) {
@@ -14029,11 +14674,11 @@ async function validateForPublish(skillDir, registryUrl) {
   if (!skillMeta.triggers || skillMeta.triggers.length === 0) {
     errors.push("At least one trigger is required. Add triggers to skill.yaml.");
   }
-  const skillMdPath = path69.join(skillDir, "SKILL.md");
-  if (!fs45.existsSync(skillMdPath)) {
+  const skillMdPath = path70.join(skillDir, "SKILL.md");
+  if (!fs46.existsSync(skillMdPath)) {
     errors.push("SKILL.md not found. Create it with content describing your skill.");
   } else {
-    const content = fs45.readFileSync(skillMdPath, "utf-8");
+    const content = fs46.readFileSync(skillMdPath, "utf-8");
     if (!content.includes("## When to Use")) {
       errors.push('SKILL.md must contain a "## When to Use" section.');
     }
@@ -14113,11 +14758,11 @@ ${errorList}`);
   }
   const meta = validation.skillMeta;
   const pkg = derivePackageJson(meta);
-  const pkgPath = path70.join(skillDir, "package.json");
-  fs46.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-  const readmePath = path70.join(skillDir, "README.md");
-  if (!fs46.existsSync(readmePath)) {
-    const skillMdContent = fs46.readFileSync(path70.join(skillDir, "SKILL.md"), "utf-8");
+  const pkgPath = path71.join(skillDir, "package.json");
+  fs47.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  const readmePath = path71.join(skillDir, "README.md");
+  if (!fs47.existsSync(readmePath)) {
+    const skillMdContent = fs47.readFileSync(path71.join(skillDir, "SKILL.md"), "utf-8");
     const readme = `# ${pkg.name}
 
 ${meta.description}
@@ -14131,7 +14776,7 @@ harness install ${meta.name}
 ---
 
 ${skillMdContent}`;
-    fs46.writeFileSync(readmePath, readme);
+    fs47.writeFileSync(readmePath, readme);
   }
   if (opts.dryRun) {
     return {
@@ -14157,7 +14802,7 @@ ${skillMdContent}`;
   };
 }
 function createPublishCommand() {
-  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) => {
+  return new Command109("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 {
@@ -14182,7 +14827,7 @@ function createPublishCommand() {
 
 // src/commands/skill/index.ts
 function createSkillCommand() {
-  const command = new Command109("skill").description("Skill management commands");
+  const command = new Command110("skill").description("Skill management commands");
   command.addCommand(createListCommand3());
   command.addCommand(createRunCommand3());
   command.addCommand(createValidateCommand2());
@@ -14195,7 +14840,7 @@ function createSkillCommand() {
 
 // src/commands/snapshot.ts
 init_dist3();
-import { Command as Command110 } from "commander";
+import { Command as Command111 } from "commander";
 import { execSync as execSync5 } from "child_process";
 import chalk17 from "chalk";
 function getCommitHash3(cwd) {
@@ -14377,7 +15022,7 @@ function registerListCommand2(parent) {
   });
 }
 function createSnapshotCommand() {
-  const command = new Command110("snapshot").description("Architecture timeline snapshot commands");
+  const command = new Command111("snapshot").description("Architecture timeline snapshot commands");
   registerCaptureCommand(command);
   registerTrendsCommand(command);
   registerListCommand2(command);
@@ -14385,9 +15030,9 @@ function createSnapshotCommand() {
 }
 
 // src/commands/spec-craft.ts
-import { Command as Command111 } from "commander";
+import { Command as Command112 } from "commander";
 function createSpecCraftCommand() {
-  return new Command111("spec-craft").description(
+  return new Command112("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();
@@ -14435,10 +15080,10 @@ function printResult6(result, mode, _formatter) {
       list.push(f);
       byFile.set(f.target.file, list);
     }
-    for (const [file, fs51] of byFile) {
+    for (const [file, fs52] of byFile) {
       console.log(`
 ${file}`);
-      for (const f of fs51) {
+      for (const f of fs52) {
         console.log(
           `  ${f.code} [${f.tier}/${f.impact}/${f.confidence}] ## ${f.target.section}:${f.target.line}`
         );
@@ -14455,7 +15100,7 @@ ${file}`);
 
 // src/commands/stale-constraints.ts
 init_dist3();
-import { Command as Command112 } from "commander";
+import { Command as Command113 } from "commander";
 import chalk18 from "chalk";
 var CATEGORIES = [
   "circular-deps",
@@ -14542,7 +15187,7 @@ async function runStaleConstraintsCommand(options) {
   );
 }
 function createStaleConstraintsCommand() {
-  return new Command112("stale-constraints").description(
+  return new Command113("stale-constraints").description(
     "Detect architectural constraints not violated within a window (candidates for removal)"
   ).option(
     "--window <days>",
@@ -14560,11 +15205,11 @@ function createStaleConstraintsCommand() {
 }
 
 // src/commands/state/index.ts
-import { Command as Command117 } from "commander";
+import { Command as Command118 } from "commander";
 
 // src/commands/state/show.ts
-import { Command as Command113 } from "commander";
-import * as path71 from "path";
+import { Command as Command114 } from "commander";
+import * as path72 from "path";
 function printStateText(state, stream) {
   if (stream) console.log(`Stream:         ${stream}`);
   console.log(`Schema Version: ${state.schemaVersion}`);
@@ -14588,9 +15233,9 @@ function printStateProgress(progress) {
   }
 }
 function createShowCommand() {
-  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) => {
+  return new Command114("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 });
+    const result = await readHarnessState(path72.resolve(opts.path), { stream: opts.stream });
     if (!result.ok) {
       logger.error(result.error.message);
       process.exit(ExitCode.ERROR);
@@ -14606,8 +15251,8 @@ function createShowCommand() {
 
 // src/commands/state/reset.ts
 init_dist3();
-import { Command as Command114 } from "commander";
-import * as path72 from "path";
+import { Command as Command115 } from "commander";
+import * as path73 from "path";
 import * as readline3 from "readline";
 async function confirmReset() {
   const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
@@ -14618,7 +15263,7 @@ async function confirmReset() {
   return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
 }
 async function runReset(opts) {
-  const projectPath = path72.resolve(opts.path);
+  const projectPath = path73.resolve(opts.path);
   if (!opts.yes && !await confirmReset()) {
     logger.info("Reset cancelled.");
     process.exit(ExitCode.SUCCESS);
@@ -14632,16 +15277,16 @@ async function runReset(opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createResetCommand() {
-  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));
+  return new Command115("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 Command115 } from "commander";
-import * as path73 from "path";
+import { Command as Command116 } from "commander";
+import * as path74 from "path";
 function createLearnCommand() {
-  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);
+  return new Command116("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 = path74.resolve(opts.path);
     const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -14655,10 +15300,10 @@ function createLearnCommand() {
 
 // src/commands/state/streams.ts
 init_dist3();
-import { Command as Command116 } from "commander";
-import * as path74 from "path";
+import { Command as Command117 } from "commander";
+import * as path75 from "path";
 async function runListStreams(opts, globalOpts) {
-  const projectPath = path74.resolve(opts.path);
+  const projectPath = path75.resolve(opts.path);
   const indexResult = await loadStreamIndex(projectPath);
   const result = await listStreams(projectPath);
   if (!result.ok) {
@@ -14679,7 +15324,7 @@ async function runListStreams(opts, globalOpts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runCreateStream(name, opts) {
-  const result = await createStream(path74.resolve(opts.path), name, opts.branch);
+  const result = await createStream(path75.resolve(opts.path), name, opts.branch);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -14688,7 +15333,7 @@ async function runCreateStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runArchiveStream(name, opts) {
-  const result = await archiveStream(path74.resolve(opts.path), name);
+  const result = await archiveStream(path75.resolve(opts.path), name);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -14697,7 +15342,7 @@ async function runArchiveStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runActivateStream(name, opts) {
-  const result = await setActiveStream(path74.resolve(opts.path), name);
+  const result = await setActiveStream(path75.resolve(opts.path), name);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -14706,7 +15351,7 @@ async function runActivateStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createStreamsCommand() {
-  const command = new Command116("streams").description("Manage state streams");
+  const command = new Command117("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));
@@ -14716,7 +15361,7 @@ function createStreamsCommand() {
 
 // src/commands/state/index.ts
 function createStateCommand() {
-  const command = new Command117("state").description("Project state management commands");
+  const command = new Command118("state").description("Project state management commands");
   command.addCommand(createShowCommand());
   command.addCommand(createResetCommand());
   command.addCommand(createLearnCommand());
@@ -14725,9 +15370,9 @@ function createStateCommand() {
 }
 
 // src/commands/sync-analyses.ts
-import * as fs47 from "fs";
-import * as path75 from "path";
-import { Command as Command118 } from "commander";
+import * as fs48 from "fs";
+import * as path76 from "path";
+import { Command as Command119 } 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);
@@ -14753,7 +15398,7 @@ function extractAnalysisFromComments(comments) {
   return null;
 }
 function bootstrapTrackerCommand2(opts, verb) {
-  const projectPath = path75.resolve(opts.dir);
+  const projectPath = path76.resolve(opts.dir);
   const trackerConfig = loadTrackerSyncConfig(projectPath);
   if (!trackerConfig) {
     logger.error(`No tracker config found in harness.config.json. Cannot ${verb}.`);
@@ -14765,8 +15410,8 @@ function bootstrapTrackerCommand2(opts, verb) {
     );
     return null;
   }
-  const projectEnvPath = path75.join(projectPath, ".env");
-  if (fs47.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
+  const projectEnvPath = path76.join(projectPath, ".env");
+  if (fs48.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
     __require("dotenv").config({ path: projectEnvPath });
   }
   const token = process.env.GITHUB_TOKEN;
@@ -14852,9 +15497,9 @@ async function runSyncAnalyses(opts) {
     return;
   }
   const { AnalysisArchive, loadPublishedIndex: loadPublishedIndex2, savePublishedIndex: savePublishedIndex2 } = await import("@harness-engineering/orchestrator");
-  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-4CZLCE33.js");
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-DTXVNQAY.js");
   const adapter = new GitHubIssuesSyncAdapter2({ token, config: trackerConfig });
-  const archive = new AnalysisArchive(path75.join(projectPath, ".harness", "analyses"));
+  const archive = new AnalysisArchive(path76.join(projectPath, ".harness", "analyses"));
   const publishedIndex = loadPublishedIndex2(projectPath);
   const { syncedCount, skippedCount, warnCount } = await syncFeatureAnalyses(
     features,
@@ -14874,7 +15519,7 @@ async function runSyncAnalyses(opts) {
   }
 }
 function createSyncAnalysesCommand() {
-  const command = new Command118("sync-analyses").description(
+  const command = new Command119("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 {
@@ -14888,8 +15533,8 @@ function createSyncAnalysesCommand() {
 }
 
 // src/commands/sync-main.ts
-import { Command as Command119 } from "commander";
-import * as path76 from "path";
+import { Command as Command120 } from "commander";
+import * as path77 from "path";
 import {
   syncMain as defaultSyncMain
 } from "@harness-engineering/orchestrator";
@@ -14919,8 +15564,8 @@ function formatHuman2(r) {
   }
 }
 function createSyncMainCommand() {
-  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 ?? ".");
+  return new Command120("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 = path77.resolve(opts.path ?? ".");
     const exitCode = await runSyncMain({ cwd, json: Boolean(opts.json) });
     process.exit(exitCode);
   });
@@ -14928,7 +15573,7 @@ function createSyncMainCommand() {
 
 // src/commands/taint.ts
 init_dist3();
-import { Command as Command120 } from "commander";
+import { Command as Command121 } from "commander";
 function getProjectRoot() {
   return process.cwd();
 }
@@ -15000,28 +15645,28 @@ function registerStatusCommand(taint) {
   });
 }
 function createTaintCommand() {
-  const taint = new Command120("taint").description("Manage sentinel session taint state");
+  const taint = new Command121("taint").description("Manage sentinel session taint state");
   registerClearCommand(taint);
   registerStatusCommand(taint);
   return taint;
 }
 
 // src/commands/telemetry/index.ts
-import { Command as Command124 } from "commander";
+import { Command as Command125 } from "commander";
 
 // src/commands/telemetry/identify.ts
 init_dist3();
-import { Command as Command121 } from "commander";
-import * as fs48 from "fs";
-import * as path77 from "path";
+import { Command as Command122 } from "commander";
+import * as fs49 from "fs";
+import * as path78 from "path";
 function telemetryFilePath(cwd) {
-  return path77.join(cwd, ".harness", "telemetry.json");
+  return path78.join(cwd, ".harness", "telemetry.json");
 }
 function writeTelemetryFile(cwd, data) {
   const filePath = telemetryFilePath(cwd);
-  const dir = path77.dirname(filePath);
-  fs48.mkdirSync(dir, { recursive: true });
-  fs48.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  const dir = path78.dirname(filePath);
+  fs49.mkdirSync(dir, { recursive: true });
+  fs49.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 var IDENTITY_FIELDS = ["project", "team", "alias"];
 function applyIdentityFields(opts, identity) {
@@ -15035,7 +15680,7 @@ function printIdentity(identity) {
   }
 }
 function createIdentifyCommand() {
-  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 cmd = new Command122("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: {} });
@@ -15060,7 +15705,7 @@ function createIdentifyCommand() {
 
 // src/commands/telemetry/status.ts
 init_dist3();
-import { Command as Command122 } from "commander";
+import { Command as Command123 } from "commander";
 function gatherEnvOverrides() {
   const overrides = {};
   if (process.env.DO_NOT_TRACK) overrides.DO_NOT_TRACK = process.env.DO_NOT_TRACK;
@@ -15102,7 +15747,7 @@ function printHumanStatus(result) {
   printEnvOverrides(result.envOverrides);
 }
 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 cmd = new Command123("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);
@@ -15135,11 +15780,11 @@ function createStatusCommand2() {
 
 // src/commands/telemetry/test.ts
 init_dist3();
-import { Command as Command123 } from "commander";
+import { Command as Command124 } from "commander";
 
 // src/bin/command-telemetry.ts
-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 { existsSync as existsSync45, readFileSync as readFileSync33, mkdirSync as mkdirSync24, appendFileSync as appendFileSync2, writeFileSync as writeFileSync29 } from "fs";
+import { join as join66, 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"]);
@@ -15147,7 +15792,7 @@ function findProjectRoot(cwd) {
   let dir = resolve46(cwd);
   const { root } = parsePath(dir);
   while (dir !== root) {
-    if (existsSync44(join65(dir, "harness.config.json"))) return dir;
+    if (existsSync45(join66(dir, "harness.config.json"))) return dir;
     dir = resolve46(dir, "..");
   }
   return cwd;
@@ -15185,7 +15830,7 @@ function resolveCommandName(cmd) {
 }
 function writeCommandRecordSync(cwd, command, duration, outcome) {
   try {
-    const metricsDir = join65(cwd, ".harness", "metrics");
+    const metricsDir = join66(cwd, ".harness", "metrics");
     mkdirSync24(metricsDir, { recursive: true });
     const record = {
       skill: command,
@@ -15195,16 +15840,16 @@ function writeCommandRecordSync(cwd, command, duration, outcome) {
       outcome,
       phasesReached: []
     };
-    const adoptionFile = join65(metricsDir, "adoption.jsonl");
+    const adoptionFile = join66(metricsDir, "adoption.jsonl");
     appendFileSync2(adoptionFile, JSON.stringify(record) + "\n");
   } catch {
   }
 }
 function isTelemetryDisabledByConfig(cwd) {
-  const configPath = join65(cwd, "harness.config.json");
-  if (!existsSync44(configPath)) return false;
+  const configPath = join66(cwd, "harness.config.json");
+  if (!existsSync45(configPath)) return false;
   try {
-    const config = JSON.parse(readFileSync32(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync33(configPath, "utf-8"));
     return config?.telemetry?.enabled === false;
   } catch {
     return false;
@@ -15216,11 +15861,11 @@ function isTelemetryOptedOut(cwd) {
 }
 function flushTelemetryBackground(cwd) {
   try {
-    const adoptionFile = join65(cwd, ".harness", "metrics", "adoption.jsonl");
-    if (!existsSync44(adoptionFile)) return;
+    const adoptionFile = join66(cwd, ".harness", "metrics", "adoption.jsonl");
+    if (!existsSync45(adoptionFile)) return;
     if (isTelemetryOptedOut(cwd)) return;
-    const reporterPath = join65(cwd, ".harness", "hooks", "telemetry-reporter.js");
-    if (!existsSync44(reporterPath)) return;
+    const reporterPath = join66(cwd, ".harness", "hooks", "telemetry-reporter.js");
+    if (!existsSync45(reporterPath)) return;
     const child = spawn2(process.execPath, [reporterPath], {
       cwd,
       stdio: ["pipe", "ignore", "ignore"],
@@ -15257,7 +15902,7 @@ function reportTestSuccess(status, distinctId, identity) {
   if (identity.team) logger.info(`  team:        ${identity.team}`);
 }
 function createTestCommand() {
-  return new Command123("test").description("Send a test event to PostHog and verify connectivity").action(async () => {
+  return new Command124("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) {
@@ -15294,7 +15939,7 @@ function createTestCommand() {
 
 // src/commands/telemetry/index.ts
 function createTelemetryCommand2() {
-  const command = new Command124("telemetry").description("Telemetry identity and status management");
+  const command = new Command125("telemetry").description("Telemetry identity and status management");
   command.addCommand(createIdentifyCommand());
   command.addCommand(createStatusCommand2());
   command.addCommand(createTestCommand());
@@ -15302,9 +15947,9 @@ function createTelemetryCommand2() {
 }
 
 // src/commands/test-craft.ts
-import { Command as Command125 } from "commander";
+import { Command as Command126 } from "commander";
 function createTestCraftCommand() {
-  return new Command125("test-craft").description(
+  return new Command126("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();
@@ -15352,10 +15997,10 @@ function printResult7(result, mode, _formatter) {
       list.push(f);
       byFile.set(f.target.file, list);
     }
-    for (const [file, fs51] of byFile) {
+    for (const [file, fs52] of byFile) {
       console.log(`
 ${file}`);
-      for (const f of fs51) {
+      for (const f of fs52) {
         const nestingStr = f.target.nesting.length > 0 ? f.target.nesting.join(" > ") + " > " : "";
         console.log(
           `  ${f.code} [${f.tier}/${f.impact}/${f.confidence}] ${f.target.framework}:${f.target.line}`
@@ -15374,7 +16019,7 @@ ${file}`);
 }
 
 // src/commands/traceability.ts
-import { Command as Command126 } from "commander";
+import { Command as Command127 } from "commander";
 import chalk19 from "chalk";
 function confidenceLabel(maxConfidence) {
   if (maxConfidence >= 0.8) return "explicit";
@@ -15514,7 +16159,7 @@ async function runTraceability(options) {
   process.exit(ExitCode.SUCCESS);
 }
 function createTraceabilityCommand() {
-  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) => {
+  return new Command127("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,
@@ -15527,15 +16172,15 @@ function createTraceabilityCommand() {
 }
 
 // src/commands/uninstall.ts
-import * as path78 from "path";
-import { Command as Command127 } from "commander";
+import * as path79 from "path";
+import { Command as Command128 } from "commander";
 async function runUninstall(skillName, options) {
   const packageName = resolvePackageName(skillName);
   const shortName = extractSkillName(packageName);
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path78.dirname(globalDir);
-  const communityBase = path78.join(skillsDir, "community");
-  const lockfilePath = path78.join(communityBase, "skills-lock.json");
+  const skillsDir = path79.dirname(globalDir);
+  const communityBase = path79.join(skillsDir, "community");
+  const lockfilePath = path79.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const entry = lockfile.skills[packageName];
   if (!entry) {
@@ -15565,7 +16210,7 @@ async function runUninstall(skillName, options) {
   return result;
 }
 function createUninstallCommand() {
-  const cmd = new Command127("uninstall");
+  const cmd = new Command128("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);
@@ -15585,9 +16230,9 @@ function createUninstallCommand() {
 
 // src/commands/uninstall-constraints.ts
 init_dist3();
-import * as fs49 from "fs/promises";
-import * as path79 from "path";
-import { Command as Command128 } from "commander";
+import * as fs50 from "fs/promises";
+import * as path80 from "path";
+import { Command as Command129 } from "commander";
 async function runUninstallConstraints(options) {
   const { packageName, configPath, lockfilePath } = options;
   const lockfileResult = await readLockfile(lockfilePath);
@@ -15607,7 +16252,7 @@ async function runUninstallConstraints(options) {
   }
   let localConfig;
   try {
-    const raw = await fs49.readFile(configPath, "utf-8");
+    const raw = await fs50.readFile(configPath, "utf-8");
     localConfig = JSON.parse(raw);
   } catch (err) {
     return {
@@ -15644,11 +16289,11 @@ async function runUninstallConstraints(options) {
   };
 }
 function createUninstallConstraintsCommand() {
-  const cmd = new Command128("uninstall-constraints");
+  const cmd = new Command129("uninstall-constraints");
   cmd.description("Remove a previously installed constraints package").argument("<name>", "Name of the constraint package to uninstall").option("-c, --config <path>", "Path to harness.config.json").action(async (name, opts) => {
     let configPath;
     if (opts.config) {
-      configPath = path79.resolve(opts.config);
+      configPath = path80.resolve(opts.config);
     } else {
       const found = findConfigFile();
       if (!found.ok) {
@@ -15657,8 +16302,8 @@ function createUninstallConstraintsCommand() {
       }
       configPath = found.value;
     }
-    const projectRoot3 = path79.dirname(configPath);
-    const lockfilePath = path79.join(projectRoot3, ".harness", "constraints.lock.json");
+    const projectRoot3 = path80.dirname(configPath);
+    const lockfilePath = path80.join(projectRoot3, ".harness", "constraints.lock.json");
     const result = await runUninstallConstraints({
       packageName: name,
       configPath,
@@ -15684,10 +16329,10 @@ function createUninstallConstraintsCommand() {
 
 // src/commands/update.ts
 init_dist3();
-import { Command as Command129 } from "commander";
+import { Command as Command130 } 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 join68 } from "path";
+import { realpathSync, existsSync as existsSync46, readFileSync as readFileSync34 } from "fs";
+import { dirname as dirname25, join as join69 } from "path";
 import { promisify as promisify2 } from "util";
 import readline4 from "readline";
 import chalk20 from "chalk";
@@ -15778,9 +16423,9 @@ function prompt3(question) {
 function findPackageDir(resolvedBin) {
   let dir = dirname25(resolvedBin);
   for (let i = 0; i < 6; i++) {
-    if (existsSync45(join68(dir, "package.json"))) {
+    if (existsSync46(join69(dir, "package.json"))) {
       try {
-        const pkg = JSON.parse(readFileSync33(join68(dir, "package.json"), "utf-8"));
+        const pkg = JSON.parse(readFileSync34(join69(dir, "package.json"), "utf-8"));
         if (pkg?.name === CLI_PACKAGE) return dir;
       } catch {
       }
@@ -15825,7 +16470,7 @@ function findAllInstalls() {
     if (!packageDir) continue;
     let version = null;
     try {
-      const pkg = JSON.parse(readFileSync33(join68(packageDir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync34(join69(packageDir, "package.json"), "utf-8"));
       if (typeof pkg?.version === "string") version = pkg.version;
     } catch {
     }
@@ -15918,12 +16563,12 @@ async function ensureTelemetryIfNeeded() {
 }
 function refreshHooks() {
   const cwd = process.cwd();
-  const configPath = join68(cwd, "harness.config.json");
-  if (!existsSync45(configPath)) return;
+  const configPath = join69(cwd, "harness.config.json");
+  if (!existsSync46(configPath)) return;
   let profile = "standard";
-  const profilePath = join68(cwd, ".harness", "hooks", "profile.json");
+  const profilePath = join69(cwd, ".harness", "hooks", "profile.json");
   try {
-    const data = JSON.parse(readFileSync33(profilePath, "utf-8"));
+    const data = JSON.parse(readFileSync34(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
       profile = data.profile;
     }
@@ -16052,7 +16697,7 @@ async function runUpdateAction(opts, globalOpts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createUpdateCommand() {
-  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(
+  return new Command130("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) => {
@@ -16062,9 +16707,9 @@ function createUpdateCommand() {
 }
 
 // src/commands/usage.ts
-import { Command as Command130 } from "commander";
+import { Command as Command131 } from "commander";
 async function loadAndPriceRecords(cwd, includeClaudeSessions = false) {
-  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-4CZLCE33.js");
+  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-DTXVNQAY.js");
   const records = readCostRecords(cwd);
   if (includeClaudeSessions) {
     const ccRecords = parseCCRecords();
@@ -16157,7 +16802,7 @@ function registerDailyCommand(usage) {
       else logger.info("No usage data found. Run some harness sessions first.");
       return;
     }
-    const { aggregateByDay } = await import("./dist-4CZLCE33.js");
+    const { aggregateByDay } = await import("./dist-DTXVNQAY.js");
     const limited = aggregateByDay(records).slice(0, days);
     if (globalOpts.json) {
       console.log(
@@ -16186,7 +16831,7 @@ function registerSessionsCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-4CZLCE33.js");
+    const { aggregateBySession } = await import("./dist-DTXVNQAY.js");
     const sessionData = aggregateBySession(records);
     const limited = sessionData.slice(0, limit);
     if (globalOpts.json) {
@@ -16266,7 +16911,7 @@ function registerSessionCommand(usage) {
       cwd,
       globalOpts.includeClaudeSessions
     );
-    const { aggregateBySession } = await import("./dist-4CZLCE33.js");
+    const { aggregateBySession } = await import("./dist-DTXVNQAY.js");
     const sessionData = aggregateBySession(records);
     const match = sessionData.find((s) => s.sessionId === id);
     if (!match) {
@@ -16301,7 +16946,7 @@ function registerLatestCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-4CZLCE33.js");
+    const { aggregateBySession } = await import("./dist-DTXVNQAY.js");
     const sessionData = aggregateBySession(records);
     const latest = sessionData[0];
     if (!latest) {
@@ -16327,7 +16972,7 @@ function registerLatestCommand(usage) {
   });
 }
 function createUsageCommand() {
-  const usage = new Command130("usage").description("Token usage and cost tracking");
+  const usage = new Command131("usage").description("Token usage and cost tracking");
   usage.option(
     "--include-claude-sessions",
     "Include Claude Code session data from ~/.claude/projects/"
@@ -16342,9 +16987,9 @@ function createUsageCommand() {
 // src/commands/validate.ts
 init_dist3();
 init_dist3();
-import { Command as Command131 } from "commander";
-import * as fs50 from "fs";
-import * as path80 from "path";
+import { Command as Command132 } from "commander";
+import * as fs51 from "fs";
+import * as path81 from "path";
 import { execFileSync as execFileSync14 } from "child_process";
 async function runValidate(options) {
   const configResult = resolveConfig(options.configPath);
@@ -16352,7 +16997,7 @@ async function runValidate(options) {
     return configResult;
   }
   const config = configResult.value;
-  const cwd = options.cwd ?? (options.configPath ? path80.dirname(path80.resolve(options.configPath)) : process.cwd());
+  const cwd = options.cwd ?? (options.configPath ? path81.dirname(path81.resolve(options.configPath)) : process.cwd());
   const result = {
     valid: true,
     checks: {
@@ -16362,7 +17007,7 @@ async function runValidate(options) {
     },
     issues: []
   };
-  const agentsMapPath = path80.resolve(cwd, config.agentsMapPath);
+  const agentsMapPath = path81.resolve(cwd, config.agentsMapPath);
   const agentsResult = await validateAgentsMap(agentsMapPath);
   if (agentsResult.ok) {
     result.checks.agentsMap = true;
@@ -16459,9 +17104,9 @@ async function runValidate(options) {
       }
     });
   }
-  const gitattributesPath = path80.join(cwd, ".gitattributes");
-  if (fs50.existsSync(gitattributesPath)) {
-    const gitattributesContent = fs50.readFileSync(gitattributesPath, "utf-8");
+  const gitattributesPath = path81.join(cwd, ".gitattributes");
+  if (fs51.existsSync(gitattributesPath)) {
+    const gitattributesContent = fs51.readFileSync(gitattributesPath, "utf-8");
     let driverConfigured = false;
     try {
       const out = execFileSync14("git", ["config", "--get", "merge.ours.driver"], {
@@ -16485,10 +17130,10 @@ async function runValidate(options) {
     }
   }
   if (detectRoadmapStorageMode(cwd) === "sharded") {
-    const shardDir = path80.join(cwd, "docs", "roadmap.d");
+    const shardDir = path81.join(cwd, "docs", "roadmap.d");
     const regenerated = await regenerate(shardDir, createNodeRoadmapIO());
-    const aggregatePath = path80.join(cwd, "docs", "roadmap.md");
-    const committedAggregate = fs50.existsSync(aggregatePath) ? fs50.readFileSync(aggregatePath, "utf-8") : null;
+    const aggregatePath = path81.join(cwd, "docs", "roadmap.md");
+    const committedAggregate = fs51.existsSync(aggregatePath) ? fs51.readFileSync(aggregatePath, "utf-8") : null;
     const drift = checkRoadmapAggregateDrift({
       shardDirExists: true,
       committedAggregate,
@@ -16506,9 +17151,9 @@ async function runValidate(options) {
       result.checks.roadmapAggregateDrift = true;
     }
   }
-  const roadmapPath = path80.join(cwd, "docs", "roadmap.md");
-  if (fs50.existsSync(roadmapPath)) {
-    const parsed = parseRoadmap(fs50.readFileSync(roadmapPath, "utf-8"));
+  const roadmapPath = path81.join(cwd, "docs", "roadmap.md");
+  if (fs51.existsSync(roadmapPath)) {
+    const parsed = parseRoadmap(fs51.readFileSync(roadmapPath, "utf-8"));
     if (parsed.ok) {
       const findings = checkRoadmapHealth(parsed.value);
       result.checks.roadmapHealth = !findings.some((f) => f.severity === "error");
@@ -16650,11 +17295,11 @@ function resolveValidateMode(globalOpts) {
   return OutputMode.TEXT;
 }
 async function printCrossCheckWarnings(mode) {
-  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-YYVYMSPA.js");
+  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-QJGCDWRO.js");
   const cwd = process.cwd();
   const crossResult = await runCrossCheck2({
-    specsDir: path80.join(cwd, "docs", "specs"),
-    plansDir: path80.join(cwd, "docs", "plans"),
+    specsDir: path81.join(cwd, "docs", "specs"),
+    plansDir: path81.join(cwd, "docs", "plans"),
     projectPath: cwd
   });
   if (!crossResult.ok || crossResult.value.warnings === 0) return;
@@ -16666,7 +17311,7 @@ async function printCrossCheckWarnings(mode) {
   ${crossResult.value.warnings} warnings`);
 }
 function createValidateCommand3() {
-  const command = new Command131("validate").description("Run all validation checks").option("--cross-check", "Run cross-artifact consistency validation").option(
+  const command = new Command132("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()));
@@ -16715,7 +17360,7 @@ Agent configs checked via ${engineLabel}${note}`);
 
 // src/commands/verify.ts
 init_dist3();
-import { Command as Command132 } from "commander";
+import { Command as Command133 } from "commander";
 import { execSync as execSync6 } from "child_process";
 function loadBranchingConfig(configPath) {
   const shouldLoad = configPath !== void 0 || findConfigFile().ok;
@@ -16778,7 +17423,7 @@ async function runVerify(options) {
   process.exit(ExitCode.VALIDATION_FAILED);
 }
 function createVerifyCommand() {
-  return new Command132("verify").description(
+  return new Command133("verify").description(
     "Verify project conventions (currently: branch naming). Works with or without a harness.config.json."
   ).option(
     "--branch <name>",
@@ -16906,7 +17551,7 @@ function registerDeprecatedGraphAliases(program) {
 
 // src/index.ts
 function createProgram() {
-  const program = new Command133();
+  const program = new Command134();
   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());