npm - @harness-engineering/cli - Versions diffs - 2.2.0 → 2.3.0 - Mend

@harness-engineering/cli 2.2.0 → 2.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (51) hide show

package/dist/{chunk-GOOTYTTV.js → chunk-35FI23SO.js} RENAMED Viewed

@@ -1,15 +1,15 @@
 import {
   generateRuntime
-} from "./chunk-TNZYQTEE.js";
+} from "./chunk-KUVPSUG4.js";
 import {
   generateAgentsMd
-} from "./chunk-4HKVZO7R.js";
+} from "./chunk-DLBMYLYR.js";
 import {
   generateCIWorkflow
-} from "./chunk-JPWICLXQ.js";
+} from "./chunk-MKPRB4PL.js";
 import {
   TemplateEngine
-} from "./chunk-224XKVLP.js";
+} from "./chunk-5KTTKXQN.js";
 import {
   generate,
   validate
@@ -28,18 +28,18 @@ import {
   OutputMode,
   createCheckPhaseGateCommand,
   findFiles
-} from "./chunk-E7W3YOXL.js";
+} from "./chunk-D2LZUJLP.js";
 import {
   createGenerateAgentDefinitionsCommand,
   generateAgentDefinitions
-} from "./chunk-OJMO4JBQ.js";
+} from "./chunk-GUIX2TMZ.js";
 import {
   toKebabCase
 } from "./chunk-KET4QQZB.js";
 import {
   listPersonas,
   loadPersona
-} from "./chunk-VJQLUS5I.js";
+} from "./chunk-L3CEN42B.js";
 import {
   createScanCommand,
   loadIngestOptions
@@ -57,7 +57,7 @@ import {
   loadCachedSnapshot,
   persistToolingConfig,
   recommend
-} from "./chunk-L2IDE7WS.js";
+} from "./chunk-3LPOTTPX.js";
 import {
   loadGraphStore
 } from "./chunk-KTWKW6KJ.js";
@@ -67,7 +67,7 @@ import {
 import {
   findConfigFile,
   resolveConfig
-} from "./chunk-LO7ZLV7S.js";
+} from "./chunk-PW3U4YJV.js";
 import {
   VALID_PLATFORMS
 } from "./chunk-3ISINLYT.js";
@@ -115,6 +115,7 @@ import {
   computeWindow,
   createFixes,
   createStream,
+  createTrackerClient,
   crossReferenceUndocumentedFixes,
   deepMergeConstraints,
   defineLayer,
@@ -133,14 +134,18 @@ import {
   isoWeek,
   listStreams,
   listTaintedSessions,
+  loadProjectRoadmapMode,
   loadState,
   loadStreamIndex,
+  loadTrackerClientConfigFromProject,
   loadTrackerSyncConfig,
   mapInjectionFindings,
   mapSecurityFindings,
+  migrate_exports,
   parseDiff,
   parseFileRegions,
   parseManifest,
+  parseRoadmap,
   parseSecurityConfig,
   pruneLearnings,
   readIdentity,
@@ -161,10 +166,11 @@ import {
   validateDependencies,
   validateKnowledgeMap,
   validatePulseConfig,
+  validateRoadmapMode,
   validateSolutionsDir,
   writeConfig,
   writeLockfile
-} from "./chunk-K4WRQTEF.js";
+} from "./chunk-4DWOMGUM.js";
 import {
   Err,
   Ok
@@ -189,7 +195,7 @@ import {
 } from "./chunk-KFQGP6VL.js";
 // src/index.ts
-import { Command as Command90 } from "commander";
+import { Command as Command93 } from "commander";
 // src/commands/add.ts
 init_dist();
@@ -378,7 +384,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-6RT2AVYU.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-I4LWG3IN.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -414,7 +420,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-6RT2AVYU.js");
+    const { readAdoptionRecords } = await import("./dist-I4LWG3IN.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -492,7 +498,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-6RT2AVYU.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-I4LWG3IN.js");
     const records = readAdoptionRecords(cwd);
     const skillRecords = records.filter((r) => r.skill === name);
     if (skillRecords.length === 0) {
@@ -1436,10 +1442,10 @@ async function runCheckSecurity(cwd, options) {
   const projectRoot = path8.resolve(cwd);
   let configData = {};
   try {
-    const fs42 = await import("fs");
+    const fs44 = await import("fs");
     const configPath = path8.join(projectRoot, "harness.config.json");
-    if (fs42.existsSync(configPath)) {
-      const raw = fs42.readFileSync(configPath, "utf-8");
+    if (fs44.existsSync(configPath)) {
+      const raw = fs44.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       configData = parsed.security ?? {};
     }
@@ -2888,11 +2894,11 @@ import { Command as Command27 } from "commander";
 // src/commands/graph/status.ts
 import * as path15 from "path";
 async function readConnectorSyncStatus(graphDir) {
-  const fs42 = await import("fs/promises");
+  const fs44 = await import("fs/promises");
   const result = {};
   try {
     const syncMetaPath = path15.join(graphDir, "sync-metadata.json");
-    const syncMeta = JSON.parse(await fs42.readFile(syncMetaPath, "utf-8"));
+    const syncMeta = JSON.parse(await fs44.readFile(syncMetaPath, "utf-8"));
     for (const [name, data] of Object.entries(syncMeta.connectors ?? {})) {
       result[name] = data.lastSyncTimestamp;
     }
@@ -3042,9 +3048,9 @@ import { Command as Command26 } from "commander";
 import * as path18 from "path";
 async function loadConnectorConfig(projectPath, source) {
   try {
-    const fs42 = await import("fs/promises");
+    const fs44 = await import("fs/promises");
     const configPath = path18.join(projectPath, "harness.config.json");
-    const config = JSON.parse(await fs42.readFile(configPath, "utf-8"));
+    const config = JSON.parse(await fs44.readFile(configPath, "utf-8"));
     const connector = config.graph?.connectors?.[source];
     return connector ?? {};
   } catch {
@@ -4372,8 +4378,8 @@ function extractSkillName(packageName) {
   return packageName;
 }
 function readNpmrcToken(registryUrl) {
-  const { hostname, pathname } = new URL(registryUrl);
-  const registryPath = `//${hostname}${pathname.replace(/\/$/, "")}/:_authToken=`;
+  const { hostname: hostname2, pathname } = new URL(registryUrl);
+  const registryPath = `//${hostname2}${pathname.replace(/\/$/, "")}/:_authToken=`;
   const candidates = [path28.join(process.cwd(), ".npmrc"), path28.join(os3.homedir(), ".npmrc")];
   for (const npmrcPath of candidates) {
     try {
@@ -5461,8 +5467,8 @@ function createKnowledgePipelineCommand() {
     const projectDir = process.cwd();
     try {
       const graphDir = path38.join(projectDir, ".harness", "graph");
-      const fs42 = await import("fs/promises");
-      await fs42.mkdir(graphDir, { recursive: true });
+      const fs44 = await import("fs/promises");
+      await fs44.mkdir(graphDir, { recursive: true });
       const { GraphStore, KnowledgePipelineRunner } = await import("./dist-D27LJR2T.js");
       const store = new GraphStore();
       try {
@@ -5805,7 +5811,7 @@ function createMcpCommand() {
     parseBudget
   ).action(async (opts) => {
     const [{ startServer: startServer2, getToolDefinitions: getToolDefinitions2 }, { selectTier }] = await Promise.all([
-      import("./mcp-JDJGELGD.js"),
+      import("./mcp-YW7PLXVQ.js"),
       import("./tool-tiers-7QGZ3FKY.js")
     ]);
     if (opts.tools && opts.tools.length > 0) {
@@ -5867,18 +5873,20 @@ function walk(dir, predicate) {
   }
   return out;
 }
+function extractAutopilotTopic(state) {
+  const match = (state.specPath ?? "").match(/^docs\/changes\/([^/]+)\/proposal\.md$/);
+  return match?.[1] ?? null;
+}
 function buildAutopilotMap(cwd) {
   const map = /* @__PURE__ */ new Map();
   const sessionsDir = path40.join(cwd, ".harness", "sessions");
   if (!fs24.existsSync(sessionsDir)) return map;
   for (const session of listDirs(sessionsDir)) {
     if (!session.startsWith("changes--")) continue;
-    const statePath = path40.join(sessionsDir, session, "autopilot-state.json");
-    const state = readJson2(statePath);
+    const state = readJson2(path40.join(sessionsDir, session, "autopilot-state.json"));
     if (!state) continue;
-    const specMatch = (state.specPath ?? "").match(/^docs\/changes\/([^/]+)\/proposal\.md$/);
-    if (!specMatch || !specMatch[1]) continue;
-    const topic = specMatch[1];
+    const topic = extractAutopilotTopic(state);
+    if (!topic) continue;
     for (const phase of state.phases ?? []) {
       if (phase.planPath) map.set(phase.planPath, topic);
     }
@@ -5912,8 +5920,7 @@ function extractTopicFromFilename(filename, proposalTopics) {
   }
   return best;
 }
-async function buildPlan(opts) {
-  const cwd = opts.cwd ?? process.cwd();
+function resolveDocsDir(cwd) {
   const configPath = path40.join(cwd, "harness.config.json");
   const configResult = fs24.existsSync(configPath) ? resolveConfig(configPath) : null;
   let docsDir;
@@ -5929,71 +5936,72 @@ async function buildPlan(opts) {
   }
   const docsAbs = path40.resolve(cwd, docsDir);
   const relRaw = path40.relative(cwd, docsAbs).replaceAll("\\", "/");
-  const docsRel = relRaw === "" ? "docs" : relRaw;
+  return relRaw === "" ? "docs" : relRaw;
+}
+function collectAdrMoves(cwd, docsRel) {
+  const moves = [];
+  const legacyAdrDir = path40.join(cwd, ".harness", "architecture");
+  if (!fs24.existsSync(legacyAdrDir)) return moves;
+  for (const topic of listDirs(legacyAdrDir)) {
+    const topicSrc = path40.join(legacyAdrDir, topic);
+    for (const file of listFiles(topicSrc, (n) => n.endsWith(".md"))) {
+      moves.push({
+        src: `.harness/architecture/${topic}/${file}`,
+        dest: `${docsRel}/architecture/${topic}/${file}`
+      });
+    }
+  }
+  return moves;
+}
+function collectProposalTopics(cwd) {
+  const topics = /* @__PURE__ */ new Set();
+  const changesDir = path40.join(cwd, "docs", "changes");
+  for (const topic of listDirs(changesDir)) {
+    if (fs24.existsSync(path40.join(changesDir, topic, "proposal.md"))) {
+      topics.add(topic);
+    }
+  }
+  return topics;
+}
+function classifyPlan(planRel, planAbs, filename, autopilotMap, proposalTopics) {
+  const fromAutopilot = autopilotMap.get(planRel);
+  if (fromAutopilot) return { topic: fromAutopilot, via: "autopilot" };
+  const fromHeader = extractTopicFromHeader(planAbs, proposalTopics);
+  if (fromHeader) return { topic: fromHeader, via: "header" };
+  const fromFilename = extractTopicFromFilename(filename, proposalTopics);
+  if (fromFilename) return { topic: fromFilename, via: "filename" };
+  return null;
+}
+async function buildPlan(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const docsRel = resolveDocsDir(cwd);
   const plan = {
     cwd,
     isGitRepo: isGitRepo(cwd),
     docsDir: docsRel,
-    adrMoves: [],
+    adrMoves: collectAdrMoves(cwd, docsRel),
     planMoves: [],
     orphanPlans: [],
-    proposalTopics: /* @__PURE__ */ new Set()
+    proposalTopics: collectProposalTopics(cwd)
   };
-  const legacyAdrDir = path40.join(cwd, ".harness", "architecture");
-  if (fs24.existsSync(legacyAdrDir)) {
-    for (const topic of listDirs(legacyAdrDir)) {
-      const topicSrc = path40.join(legacyAdrDir, topic);
-      for (const file of listFiles(topicSrc, (n) => n.endsWith(".md"))) {
-        const src = `.harness/architecture/${topic}/${file}`;
-        const dest = `${docsRel}/architecture/${topic}/${file}`;
-        plan.adrMoves.push({ src, dest });
-      }
-    }
-  }
   const legacyPlanDir = path40.join(cwd, "docs", "plans");
-  const changesDir = path40.join(cwd, "docs", "changes");
-  for (const topic of listDirs(changesDir)) {
-    if (fs24.existsSync(path40.join(changesDir, topic, "proposal.md"))) {
-      plan.proposalTopics.add(topic);
-    }
-  }
-  if (fs24.existsSync(legacyPlanDir)) {
-    const autopilotMap = buildAutopilotMap(cwd);
-    for (const file of listFiles(legacyPlanDir, (n) => n.endsWith(".md") && n !== "index.md")) {
-      const planRel = `docs/plans/${file}`;
-      const planAbs = path40.join(legacyPlanDir, file);
-      const isVerification = file.includes("VERIFICATION");
-      const subdir = isVerification ? "verifications" : "plans";
-      let topic = null;
-      let via = null;
-      const fromAutopilot = autopilotMap.get(planRel);
-      if (fromAutopilot) {
-        topic = fromAutopilot;
-        via = "autopilot";
-      } else {
-        const fromHeader = extractTopicFromHeader(planAbs, plan.proposalTopics);
-        if (fromHeader) {
-          topic = fromHeader;
-          via = "header";
-        } else {
-          const fromFilename = extractTopicFromFilename(file, plan.proposalTopics);
-          if (fromFilename) {
-            topic = fromFilename;
-            via = "filename";
-          }
-        }
-      }
-      if (topic && via) {
-        plan.planMoves.push({
-          src: planRel,
-          dest: `docs/changes/${topic}/${subdir}/${file}`,
-          topic,
-          via,
-          subdir
-        });
-      } else {
-        plan.orphanPlans.push(planRel);
-      }
+  if (!fs24.existsSync(legacyPlanDir)) return plan;
+  const autopilotMap = buildAutopilotMap(cwd);
+  for (const file of listFiles(legacyPlanDir, (n) => n.endsWith(".md") && n !== "index.md")) {
+    const planRel = `docs/plans/${file}`;
+    const planAbs = path40.join(legacyPlanDir, file);
+    const subdir = file.includes("VERIFICATION") ? "verifications" : "plans";
+    const classified = classifyPlan(planRel, planAbs, file, autopilotMap, plan.proposalTopics);
+    if (classified) {
+      plan.planMoves.push({
+        src: planRel,
+        dest: `docs/changes/${classified.topic}/${subdir}/${file}`,
+        topic: classified.topic,
+        via: classified.via,
+        subdir
+      });
+    } else {
+      plan.orphanPlans.push(planRel);
     }
   }
   return plan;
@@ -6068,7 +6076,7 @@ function updateReferences(plan) {
 }
 async function prompt(question, def = "n") {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve39) => rl.question(question, resolve39));
+  const answer = await new Promise((resolve40) => rl.question(question, resolve40));
   rl.close();
   return (answer.trim() || def).toLowerCase();
 }
@@ -6166,6 +6174,29 @@ async function detectLegacyArtifacts(cwd) {
   const planLegacy = fs24.existsSync(planLegacyDir) && listFiles(planLegacyDir, (n) => n.endsWith(".md") && n !== "index.md").length > 0;
   return { adrLegacy, planLegacy };
 }
+async function confirmApply(opts) {
+  if (opts.yes || !process.stdin.isTTY) return true;
+  const answer = await prompt("Apply this migration? [y/N] ", "n");
+  return answer === "y" || answer === "yes";
+}
+function applyMigration(plan, opts) {
+  const { moved, failed } = executeMigration(plan);
+  console.log("");
+  if (failed > 0) logger.error(`  Moved ${moved} file(s); ${failed} failed.`);
+  else logger.success(`  Moved ${moved} file(s).`);
+  let references = { files: 0, replacements: 0 };
+  if (!opts.skipReferences) {
+    references = updateReferences(plan);
+    if (references.replacements > 0) {
+      logger.success(
+        `  Updated ${references.replacements} reference(s) across ${references.files} file(s).`
+      );
+    } else {
+      logger.info("  No reference updates needed.");
+    }
+  }
+  return { moved, failed, references };
+}
 async function runMigrate(opts) {
   const cwd = opts.cwd ?? process.cwd();
   const plan = await buildPlan({ ...opts, cwd });
@@ -6188,34 +6219,13 @@ async function runMigrate(opts) {
   const movesPlanned = plan.adrMoves.length + plan.planMoves.length;
   if (opts.dryRun) {
     logger.info("  Dry run \u2014 no files moved.");
-    return Ok({
-      ...empty,
-      movesPlanned,
-      orphansRemaining: plan.orphanPlans.length
-    });
+    return Ok({ ...empty, movesPlanned, orphansRemaining: plan.orphanPlans.length });
   }
-  if (!opts.yes && process.stdin.isTTY) {
-    const answer = await prompt("Apply this migration? [y/N] ", "n");
-    if (answer !== "y" && answer !== "yes") {
-      logger.info("  Cancelled.");
-      return Ok({ ...empty, movesPlanned, cancelled: true });
-    }
-  }
-  const { moved, failed } = executeMigration(plan);
-  console.log("");
-  if (failed > 0) logger.error(`  Moved ${moved} file(s); ${failed} failed.`);
-  else logger.success(`  Moved ${moved} file(s).`);
-  let references = { files: 0, replacements: 0 };
-  if (!opts.skipReferences) {
-    references = updateReferences(plan);
-    if (references.replacements > 0) {
-      logger.success(
-        `  Updated ${references.replacements} reference(s) across ${references.files} file(s).`
-      );
-    } else {
-      logger.info("  No reference updates needed.");
-    }
+  if (!await confirmApply(opts)) {
+    logger.info("  Cancelled.");
+    return Ok({ ...empty, movesPlanned, cancelled: true });
   }
+  const { moved, failed, references } = applyMigration(plan, opts);
   console.log("");
   logger.info("  Next: review changes with `git status` / `git diff`, then commit.");
   return Ok({
@@ -6296,7 +6306,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-6RT2AVYU.js");
+    const { BenchmarkRunner } = await import("./dist-I4LWG3IN.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob2);
     if (benchFiles.length === 0) {
@@ -6360,7 +6370,7 @@ async function runBaselinesShow(globalOpts) {
 }
 async function runBaselinesUpdate(globalOpts) {
   const cwd = process.cwd();
-  const { BenchmarkRunner } = await import("./dist-6RT2AVYU.js");
+  const { BenchmarkRunner } = await import("./dist-I4LWG3IN.js");
   const runner = new BenchmarkRunner();
   const manager = new BaselineManager(cwd);
   logger.info("Running benchmarks to update baselines...");
@@ -6401,7 +6411,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-6RT2AVYU.js");
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-I4LWG3IN.js");
     const analyzer = new EntropyAnalyzer2({
       rootDir: path42.resolve(cwd),
       analyze: { complexity: true, coupling: true }
@@ -6735,14 +6745,39 @@ function bootstrapTrackerCommand(opts, verb) {
   }
   return { token, projectPath, trackerConfig };
 }
-function buildNameToExternalIdMap(projectPath) {
+async function buildNameToExternalIdMap(projectPath) {
+  const mode = loadProjectRoadmapMode(projectPath);
+  if (mode === "file-less") {
+    const trackerCfg = loadTrackerClientConfigFromProject(projectPath);
+    if (!trackerCfg.ok) {
+      logger.error(`File-less mode: ${trackerCfg.error.message}`);
+      return null;
+    }
+    const clientR = createTrackerClient(trackerCfg.value);
+    if (!clientR.ok) {
+      logger.error(`File-less mode: ${clientR.error.message}`);
+      return null;
+    }
+    const r = await clientR.value.fetchAll();
+    if (!r.ok) {
+      logger.error(`File-less mode: failed to fetch features from tracker: ${r.error.message}`);
+      return null;
+    }
+    const fileLessMap = /* @__PURE__ */ new Map();
+    for (const f of r.value.features) {
+      if (f.externalId) {
+        fileLessMap.set(f.name.toLowerCase(), f.externalId);
+      }
+    }
+    return fileLessMap;
+  }
   const roadmapFile = path44.join(projectPath, "docs", "roadmap.md");
   if (!fs26.existsSync(roadmapFile)) {
     logger.error("No docs/roadmap.md found. Cannot map issue hashes to external IDs.");
     return null;
   }
-  const { parseRoadmap } = (init_dist(), __toCommonJS(dist_exports));
-  const roadmapParsed = parseRoadmap(fs26.readFileSync(roadmapFile, "utf-8"));
+  const { parseRoadmap: parseRoadmap2 } = (init_dist(), __toCommonJS(dist_exports));
+  const roadmapParsed = parseRoadmap2(fs26.readFileSync(roadmapFile, "utf-8"));
   if (!roadmapParsed.ok) {
     logger.error("Failed to parse docs/roadmap.md");
     return null;
@@ -6789,10 +6824,10 @@ async function runPublishAnalyses(opts) {
   const bootstrap = bootstrapTrackerCommand(opts, "publish");
   if (!bootstrap) return process.exit(1);
   const { token, projectPath, trackerConfig } = bootstrap;
-  const nameToExternalId = buildNameToExternalIdMap(projectPath);
+  const nameToExternalId = await buildNameToExternalIdMap(projectPath);
   if (!nameToExternalId) return process.exit(1);
   const { AnalysisArchive } = await import("@harness-engineering/orchestrator");
-  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-6RT2AVYU.js");
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-I4LWG3IN.js");
   const archive = new AnalysisArchive(path44.join(projectPath, ".harness", "analyses"));
   const analyses = await archive.list();
   if (analyses.length === 0) {
@@ -7031,11 +7066,326 @@ function createRecommendCommand() {
   return command;
 }
-// src/commands/scan-config.ts
+// src/commands/roadmap/index.ts
+import { Command as Command62 } from "commander";
+// src/commands/roadmap/migrate.ts
 init_dist();
 import { Command as Command61 } from "commander";
-import { existsSync as existsSync23, readFileSync as readFileSync16, writeFileSync as writeFileSync15 } from "fs";
-import { join as join34, relative as relative3 } from "path";
+import * as fs28 from "fs";
+import * as path46 from "path";
+import chalk10 from "chalk";
+// src/commands/roadmap/migrate-lock.ts
+import * as fs27 from "fs";
+import * as path45 from "path";
+import * as os6 from "os";
+var LOCK_FILE_NAME = "migrate.lock";
+var STALE_LOCK_MS = 30 * 60 * 1e3;
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireMigrateLock(projectRoot) {
+  const harnessDir = path45.join(projectRoot, ".harness");
+  const lockPath = path45.join(harnessDir, LOCK_FILE_NAME);
+  if (!fs27.existsSync(harnessDir)) fs27.mkdirSync(harnessDir, { recursive: true });
+  if (fs27.existsSync(lockPath)) {
+    const existingRaw = (() => {
+      try {
+        return fs27.readFileSync(lockPath, "utf-8");
+      } catch {
+        return null;
+      }
+    })();
+    const existing = (() => {
+      if (!existingRaw) return null;
+      try {
+        return JSON.parse(existingRaw);
+      } catch {
+        return null;
+      }
+    })();
+    if (existing) {
+      const ageMs = Date.now() - new Date(existing.startedAt).getTime();
+      const stale = !isPidAlive(existing.pid) || ageMs > STALE_LOCK_MS;
+      if (!stale) {
+        return {
+          reason: "in-progress",
+          existing,
+          message: `another migration is in progress (pid ${existing.pid} on ${existing.hostname}, started ${existing.startedAt})`
+        };
+      }
+    }
+  }
+  const payload = {
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    hostname: os6.hostname()
+  };
+  fs27.writeFileSync(lockPath, JSON.stringify(payload, null, 2) + "\n");
+  return {
+    release: () => {
+      try {
+        fs27.unlinkSync(lockPath);
+      } catch {
+      }
+    }
+  };
+}
+function isRefusal(r) {
+  return r.reason === "in-progress";
+}
+// src/commands/roadmap/migrate.ts
+var MigrateExitCode = {
+  SUCCESS: 0,
+  GENERIC_FAILURE: 1,
+  AMBIGUOUS: 2,
+  ARCHIVE_COLLISION: 3,
+  CONFIG_ERROR: 4,
+  PARTIAL_CREATE: 5
+};
+function reportToExitCode(report) {
+  if (report.mode !== "aborted") return MigrateExitCode.SUCCESS;
+  const reason = report.abortReason ?? "";
+  if (reason.startsWith("create failed") && report.createdSoFar && report.createdSoFar.length > 0) {
+    return MigrateExitCode.PARTIAL_CREATE;
+  }
+  if (reason.startsWith("ambiguous features")) return MigrateExitCode.AMBIGUOUS;
+  if (reason.startsWith("archive-collision")) return MigrateExitCode.ARCHIVE_COLLISION;
+  if (reason.startsWith("config rewrite failed")) return MigrateExitCode.CONFIG_ERROR;
+  return MigrateExitCode.GENERIC_FAILURE;
+}
+function printPlanSummary(plan, dryRun) {
+  const banner = dryRun ? chalk10.cyan("DRY RUN ") : "";
+  console.log(`${banner}Migration plan:`);
+  console.log(`  Would create: ${plan.toCreate.length}`);
+  for (const e of plan.toCreate) console.log(`    - ${e.name}`);
+  console.log(`  Would update: ${plan.toUpdate.length}`);
+  for (const e of plan.toUpdate) console.log(`    - ${e.name} (${e.externalId}): ${e.diff}`);
+  console.log(`  Unchanged:    ${plan.unchanged.length}`);
+  console.log(`  Would append history: ${plan.historyToAppend.length}`);
+  console.log(`  Ambiguous:    ${plan.ambiguous.length}`);
+  for (const a of plan.ambiguous) {
+    console.log(`    - ${a.name} (existing: ${a.existingIssueRef})`);
+  }
+}
+function printReport(report) {
+  if (report.mode === "aborted") {
+    logger.error(`Migration aborted: ${report.abortReason ?? "unknown reason"}`);
+    if (report.createdSoFar && report.createdSoFar.length > 0) {
+      logger.warn(
+        `Features created before abort (record manually): ${report.createdSoFar.map((c) => `${c.name} \u2192 ${c.externalId}`).join(", ")}`
+      );
+    }
+    return;
+  }
+  if (report.mode === "dry-run") {
+    logger.info(`DRY RUN complete: ${report.created + report.updated} writes would be performed.`);
+    return;
+  }
+  if (report.mode === "already-migrated") {
+    logger.success("Already migrated; nothing to do.");
+    return;
+  }
+  logger.success(
+    `Migration applied: ${report.created} created, ${report.updated} updated, ${report.unchanged} unchanged, ${report.historyAppended} history events appended.`
+  );
+  if (report.archivedTo) logger.info(`Archived: ${report.archivedFrom} -> ${report.archivedTo}`);
+  if (report.configBackup) logger.info(`Config backup: ${report.configBackup}`);
+}
+async function collectHistoryHashes(client, externalId) {
+  const result = await client.fetchHistory(externalId);
+  const set = /* @__PURE__ */ new Set();
+  if (!result.ok) return set;
+  for (const e of result.value) set.add(migrate_exports.hashHistoryEvent(e));
+  return set;
+}
+function makeRawBodyResolver(_client, _features) {
+  return async () => null;
+}
+function buildJsonOutput(plan, report, error, exitCode) {
+  const out = {
+    ok: exitCode === MigrateExitCode.SUCCESS,
+    mode: report ? report.mode : "error",
+    exitCode
+  };
+  if (plan) {
+    out.plan = {
+      toCreate: plan.toCreate.map((e) => ({ name: e.name })),
+      toUpdate: plan.toUpdate.map((e) => ({
+        name: e.name,
+        externalId: e.externalId,
+        diff: e.diff
+      })),
+      unchanged: plan.unchanged,
+      historyToAppend: plan.historyToAppend.map((e) => ({
+        externalId: e.externalId,
+        type: e.event.type
+      })),
+      ambiguous: plan.ambiguous
+    };
+  }
+  if (report) out.report = report;
+  if (error) out.error = error;
+  return out;
+}
+async function runRoadmapMigrate(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const format = opts.format ?? "human";
+  const isJson = format === "json";
+  if (!opts.to) {
+    return Err(new CLIError("missing required argument: --to <target>", ExitCode.ERROR));
+  }
+  if (opts.to === "file-backed") {
+    return Err(
+      new CLIError(
+        "--to=file-backed reverse migration is not yet implemented; track in a future spec"
+      )
+    );
+  }
+  if (opts.to !== "file-less") {
+    return Err(
+      new CLIError(`unsupported migration target: ${opts.to} (only "file-less" supported today)`)
+    );
+  }
+  if (loadProjectRoadmapMode(cwd) === "file-less") {
+    const alreadyMigratedReport = {
+      created: 0,
+      updated: 0,
+      unchanged: 0,
+      historyAppended: 0,
+      archivedFrom: null,
+      archivedTo: null,
+      configBackup: null,
+      mode: "already-migrated"
+    };
+    if (isJson) {
+      console.log(
+        JSON.stringify(
+          buildJsonOutput(void 0, alreadyMigratedReport, void 0, MigrateExitCode.SUCCESS)
+        )
+      );
+    } else {
+      logger.success("Already migrated; nothing to do.");
+    }
+    return Ok(alreadyMigratedReport);
+  }
+  const lockResult = acquireMigrateLock(cwd);
+  if (isRefusal(lockResult)) {
+    return Err(new CLIError(lockResult.message));
+  }
+  try {
+    let client;
+    if (opts.client) {
+      client = opts.client;
+    } else {
+      const cfgR = loadTrackerClientConfigFromProject(cwd);
+      if (!cfgR.ok) return Err(new CLIError(cfgR.error.message));
+      const clientR = createTrackerClient(cfgR.value);
+      if (!clientR.ok) return Err(new CLIError(clientR.error.message));
+      client = clientR.value;
+    }
+    const roadmapPath = path46.join(cwd, "docs", "roadmap.md");
+    if (!fs28.existsSync(roadmapPath)) {
+      return Err(new CLIError(`docs/roadmap.md not found in ${cwd}`));
+    }
+    const roadmapR = parseRoadmap(fs28.readFileSync(roadmapPath, "utf-8"));
+    if (!roadmapR.ok) {
+      return Err(new CLIError(`failed to parse docs/roadmap.md: ${roadmapR.error.message}`));
+    }
+    const roadmap = roadmapR.value;
+    const fetchR = await client.fetchAll();
+    if (!fetchR.ok) {
+      return Err(new CLIError(`failed to fetch tracker features: ${fetchR.error.message}`));
+    }
+    const existingFeatures = fetchR.value.features;
+    const getRawBody = makeRawBodyResolver(client, existingFeatures);
+    const fetchHashes = (id) => collectHistoryHashes(client, id);
+    const plan = await migrate_exports.buildMigrationPlan(
+      roadmap,
+      existingFeatures,
+      fetchHashes,
+      getRawBody
+    );
+    if (!isJson) printPlanSummary(plan, opts.dryRun);
+    const deps = {
+      client,
+      readFile: (p) => fs28.readFileSync(p, "utf-8"),
+      writeFile: (p, b) => fs28.writeFileSync(p, b),
+      renameFile: (from, to) => fs28.renameSync(from, to),
+      existsFile: (p) => fs28.existsSync(p)
+    };
+    const reportR = await migrate_exports.runMigrationPlan(plan, deps, {
+      projectRoot: cwd,
+      dryRun: opts.dryRun
+    });
+    if (!reportR.ok) {
+      return Err(new CLIError(`migration failed: ${reportR.error.message}`));
+    }
+    if (isJson) {
+      const exitCode = reportToExitCode(reportR.value);
+      console.log(JSON.stringify(buildJsonOutput(plan, reportR.value, void 0, exitCode)));
+    } else {
+      printReport(reportR.value);
+    }
+    return Ok(reportR.value);
+  } finally {
+    lockResult.release();
+  }
+}
+function createRoadmapMigrateCommand() {
+  return new Command61("migrate").description("Migrate the project roadmap to a different storage mode").requiredOption("--to <target>", 'Migration target (only "file-less" supported today)').option("--dry-run", "Print the migration plan without making any changes", false).option(
+    "--format <fmt>",
+    'Output format: "human" (default) or "json" (single JSON object for CI consumers)',
+    "human"
+  ).action(async (options) => {
+    const format = options.format === "json" ? "json" : "human";
+    const result = await runRoadmapMigrate({
+      to: options.to,
+      dryRun: Boolean(options.dryRun),
+      format
+    });
+    if (!result.ok) {
+      if (format === "json") {
+        console.log(
+          JSON.stringify(
+            buildJsonOutput(
+              void 0,
+              void 0,
+              result.error.message,
+              MigrateExitCode.CONFIG_ERROR
+            )
+          )
+        );
+      } else {
+        logger.error(result.error.message);
+      }
+      process.exit(format === "json" ? MigrateExitCode.CONFIG_ERROR : result.error.exitCode);
+    }
+    const exitCode = reportToExitCode(result.value);
+    process.exit(exitCode);
+  });
+}
+// src/commands/roadmap/index.ts
+function createRoadmapCommand() {
+  const roadmap = new Command62("roadmap").description("Roadmap management");
+  roadmap.addCommand(createRoadmapMigrateCommand());
+  return roadmap;
+}
+// src/commands/scan-config.ts
+init_dist();
+import { Command as Command63 } from "commander";
+import { existsSync as existsSync25, readFileSync as readFileSync18, writeFileSync as writeFileSync17 } from "fs";
+import { join as join36, relative as relative3 } from "path";
 var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".gemini/settings.json", "skill.yaml"];
 function stripHighSeverityPatterns(content, injectionFindings) {
   const highLines = /* @__PURE__ */ new Set();
@@ -7061,17 +7411,17 @@ function applyFix(filePath, targetDir, content, injectionFindings) {
   if (!hasHighSeverity) return;
   const { cleaned, linesStripped } = stripHighSeverityPatterns(content, injectionFindings);
   if (linesStripped > 0) {
-    writeFileSync15(filePath, cleaned);
+    writeFileSync17(filePath, cleaned);
     logger.info(
       `scan-config --fix: stripped ${linesStripped} high-severity line(s) from ${relative3(targetDir, filePath).replaceAll("\\", "/")}`
     );
   }
 }
 function scanSingleFile(filePath, targetDir, scanner, options) {
-  if (!existsSync23(filePath)) return null;
+  if (!existsSync25(filePath)) return null;
   let content;
   try {
-    content = readFileSync16(filePath, "utf8");
+    content = readFileSync18(filePath, "utf8");
   } catch {
     return null;
   }
@@ -7092,7 +7442,7 @@ async function runScanConfig(targetDir, options) {
   const scanner = new SecurityScanner(parseSecurityConfig({}));
   const results = [];
   for (const configFile of CONFIG_FILES) {
-    const result = scanSingleFile(join34(targetDir, configFile), targetDir, scanner, options);
+    const result = scanSingleFile(join36(targetDir, configFile), targetDir, scanner, options);
     if (result) results.push(result);
   }
   return { exitCode: computeScanExitCode(results), results };
@@ -7122,7 +7472,7 @@ function formatTextOutput(result) {
   }
 }
 function createScanConfigCommand() {
-  const command = new Command61("scan-config").description(
+  const command = new Command63("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();
@@ -7139,24 +7489,24 @@ function createScanConfigCommand() {
 }
 // src/commands/setup.ts
-import { Command as Command62 } from "commander";
+import { Command as Command64 } from "commander";
+import * as fs31 from "fs";
+import * as os8 from "os";
+import * as path49 from "path";
+import chalk12 from "chalk";
+// src/utils/first-run.ts
 import * as fs29 from "fs";
 import * as os7 from "os";
 import * as path47 from "path";
-import chalk11 from "chalk";
-// src/utils/first-run.ts
-import * as fs27 from "fs";
-import * as os6 from "os";
-import * as path45 from "path";
-var HARNESS_DIR = path45.join(os6.homedir(), ".harness");
-var MARKER_FILE = path45.join(HARNESS_DIR, ".setup-complete");
+var HARNESS_DIR = path47.join(os7.homedir(), ".harness");
+var MARKER_FILE = path47.join(HARNESS_DIR, ".setup-complete");
 function isFirstRun() {
-  return !fs27.existsSync(MARKER_FILE);
+  return !fs29.existsSync(MARKER_FILE);
 }
 function markSetupComplete() {
-  fs27.mkdirSync(HARNESS_DIR, { recursive: true });
-  fs27.writeFileSync(MARKER_FILE, "", "utf-8");
+  fs29.mkdirSync(HARNESS_DIR, { recursive: true });
+  fs29.writeFileSync(MARKER_FILE, "", "utf-8");
 }
 function printFirstRunWelcome() {
   try {
@@ -7169,19 +7519,19 @@ function printFirstRunWelcome() {
 }
 // src/commands/telemetry-wizard.ts
-import * as fs28 from "fs";
-import * as path46 from "path";
+import * as fs30 from "fs";
+import * as path48 from "path";
 import readline2 from "readline";
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 function prompt2(question) {
   const rl = readline2.createInterface({
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve39) => {
+  return new Promise((resolve40) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve39(answer.trim().toLowerCase());
+      resolve40(answer.trim().toLowerCase());
     });
   });
 }
@@ -7190,10 +7540,10 @@ function promptRaw(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve39) => {
+  return new Promise((resolve40) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve39(answer.trim());
+      resolve40(answer.trim());
     });
   });
 }
@@ -7201,21 +7551,21 @@ function isNo(answer) {
   return answer === "n" || answer === "no";
 }
 function isTelemetryConfigured(cwd) {
-  const configPath = path46.join(cwd, "harness.config.json");
+  const configPath = path48.join(cwd, "harness.config.json");
   try {
-    const raw = JSON.parse(fs28.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs30.readFileSync(configPath, "utf-8"));
     return raw.telemetry !== void 0 && raw.adoption !== void 0;
   } catch {
     return false;
   }
 }
 function writeTelemetryConfig(cwd, result) {
-  const configPath = path46.join(cwd, "harness.config.json");
+  const configPath = path48.join(cwd, "harness.config.json");
   try {
-    const raw = JSON.parse(fs28.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs30.readFileSync(configPath, "utf-8"));
     raw.telemetry = { enabled: result.telemetryEnabled };
     raw.adoption = { enabled: result.adoptionEnabled };
-    fs28.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
+    fs30.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
   } catch (err) {
     console.warn(
       `\u26A0 Could not update ${configPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -7223,15 +7573,15 @@ function writeTelemetryConfig(cwd, result) {
   }
   const hasIdentity = result.identity.project || result.identity.team || result.identity.alias;
   if (hasIdentity) {
-    const harnessDir = path46.join(cwd, ".harness");
-    fs28.mkdirSync(harnessDir, { recursive: true });
-    const telemetryFile = path46.join(harnessDir, "telemetry.json");
-    fs28.writeFileSync(telemetryFile, JSON.stringify({ identity: result.identity }, null, 2) + "\n");
+    const harnessDir = path48.join(cwd, ".harness");
+    fs30.mkdirSync(harnessDir, { recursive: true });
+    const telemetryFile = path48.join(harnessDir, "telemetry.json");
+    fs30.writeFileSync(telemetryFile, JSON.stringify({ identity: result.identity }, null, 2) + "\n");
   }
 }
 async function promptIdentity() {
   console.log(
-    `  ${chalk10.cyan("Identity")} (optional) \u2014 tag telemetry with project/team/alias for filtering.`
+    `  ${chalk11.cyan("Identity")} (optional) \u2014 tag telemetry with project/team/alias for filtering.`
   );
   console.log("  Leave blank to keep anonymous.");
   const answer = await prompt2("  Set identity fields? (y/N) ");
@@ -7249,20 +7599,20 @@ async function promptIdentity() {
 async function runTelemetryWizard() {
   if (!process.stdin.isTTY) return null;
   console.log("");
-  console.log(`  ${chalk10.bold("Telemetry Configuration")}`);
+  console.log(`  ${chalk11.bold("Telemetry Configuration")}`);
   console.log("");
   console.log("  Harness can collect anonymous usage data to help improve the tool.");
   console.log("  You can change these settings anytime in harness.config.json.");
   console.log("");
   console.log(
-    `  ${chalk10.cyan("Anonymous telemetry")} \u2014 error rates, command usage, performance metrics.`
+    `  ${chalk11.cyan("Anonymous telemetry")} \u2014 error rates, command usage, performance metrics.`
   );
   console.log("  No code, file contents, or personally identifiable info is sent.");
   const telemetryAnswer = await prompt2("  Enable anonymous telemetry? (Y/n) ");
   const telemetryEnabled = !isNo(telemetryAnswer);
   console.log("");
   console.log(
-    `  ${chalk10.cyan("Adoption tracking")} \u2014 which skills are used, how often, and success rates.`
+    `  ${chalk11.cyan("Adoption tracking")} \u2014 which skills are used, how often, and success rates.`
   );
   console.log("  Stored locally in .harness/adoption/. Never sent externally.");
   const adoptionAnswer = await prompt2("  Enable local adoption tracking? (Y/n) ");
@@ -7272,8 +7622,8 @@ async function runTelemetryWizard() {
   return { telemetryEnabled, adoptionEnabled, identity };
 }
 async function ensureTelemetryConfigured(cwd) {
-  const configPath = path46.join(cwd, "harness.config.json");
-  if (!fs28.existsSync(configPath)) {
+  const configPath = path48.join(cwd, "harness.config.json");
+  if (!fs30.existsSync(configPath)) {
     return { status: "warn", message: "Not a harness project \u2014 skipped telemetry configuration" };
   }
   if (isTelemetryConfigured(cwd)) {
@@ -7319,7 +7669,7 @@ function runSlashCommandGeneration() {
   }
 }
 function detectClient(dirName) {
-  return fs29.existsSync(path47.join(os7.homedir(), dirName));
+  return fs31.existsSync(path49.join(os8.homedir(), dirName));
 }
 async function runMcpSetup(cwd) {
   const results = [];
@@ -7335,7 +7685,7 @@ async function runMcpSetup(cwd) {
     { name: "Cursor", dir: ".cursor", client: "cursor", configTarget: ".cursor/mcp.json" },
     {
       name: "OpenCode",
-      dir: path47.join(".config", "opencode"),
+      dir: path49.join(".config", "opencode"),
       client: "opencode",
       configTarget: "opencode.json"
     }
@@ -7362,12 +7712,12 @@ async function runMcpSetup(cwd) {
   return results;
 }
 function formatStep(result) {
-  const icon = result.status === "pass" ? chalk11.green("\u2713") : result.status === "warn" ? chalk11.yellow("\u26A0") : chalk11.red("\u2717");
+  const icon = result.status === "pass" ? chalk12.green("\u2713") : result.status === "warn" ? chalk12.yellow("\u26A0") : chalk12.red("\u2717");
   return `  ${icon} ${result.message}`;
 }
 function configureTier0Integrations(cwd) {
   try {
-    const mcpPath = path47.join(cwd, ".mcp.json");
+    const mcpPath = path49.join(cwd, ".mcp.json");
     const config = readMcpConfig(mcpPath);
     const tier0 = INTEGRATION_REGISTRY.filter((i) => i.tier === 0);
     const added = [];
@@ -7376,9 +7726,9 @@ function configureTier0Integrations(cwd) {
       writeMcpEntry(mcpPath, integration.name, integration.mcpConfig);
       added.push(integration.displayName);
     }
-    const geminiDir = path47.join(cwd, ".gemini");
-    if (fs29.existsSync(geminiDir)) {
-      const geminiPath = path47.join(geminiDir, "settings.json");
+    const geminiDir = path49.join(cwd, ".gemini");
+    if (fs31.existsSync(geminiDir)) {
+      const geminiPath = path49.join(geminiDir, "settings.json");
       const geminiConfig = readMcpConfig(geminiPath);
       for (const integration of tier0) {
         if (!geminiConfig.mcpServers[integration.name]) {
@@ -7386,9 +7736,9 @@ function configureTier0Integrations(cwd) {
         }
       }
     }
-    const opencodePath = path47.join(cwd, "opencode.json");
-    const opencodeGlobalDir = path47.join(os7.homedir(), ".config", "opencode");
-    if (fs29.existsSync(opencodePath) || fs29.existsSync(opencodeGlobalDir)) {
+    const opencodePath = path49.join(cwd, "opencode.json");
+    const opencodeGlobalDir = path49.join(os8.homedir(), ".config", "opencode");
+    if (fs31.existsSync(opencodePath) || fs31.existsSync(opencodeGlobalDir)) {
       for (const integration of tier0) {
         writeOpencodeMcpEntry(opencodePath, integration.name, integration.mcpConfig);
       }
@@ -7406,14 +7756,14 @@ function configureTier0Integrations(cwd) {
   }
 }
 function ensureHooks(cwd) {
-  const configPath = path47.join(cwd, "harness.config.json");
-  if (!fs29.existsSync(configPath)) {
+  const configPath = path49.join(cwd, "harness.config.json");
+  if (!fs31.existsSync(configPath)) {
     return { status: "warn", message: "Not a harness project \u2014 skipped hook installation" };
   }
   let profile = "standard";
-  const profilePath = path47.join(cwd, ".harness", "hooks", "profile.json");
+  const profilePath = path49.join(cwd, ".harness", "hooks", "profile.json");
   try {
-    const data = JSON.parse(fs29.readFileSync(profilePath, "utf-8"));
+    const data = JSON.parse(fs31.readFileSync(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
       profile = data.profile;
     }
@@ -7484,10 +7834,10 @@ async function runSetup(cwd) {
   return { steps, success };
 }
 function createSetupCommand() {
-  return new Command62("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
+  return new Command64("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
     const cwd = process.cwd();
     console.log("");
-    console.log(`  ${chalk11.bold("harness setup")}`);
+    console.log(`  ${chalk12.bold("harness setup")}`);
     console.log("");
     const { steps, success } = await runSetup(cwd);
     for (const step of steps) {
@@ -7507,15 +7857,15 @@ function createSetupCommand() {
 // src/commands/share.ts
 init_dist();
-import { Command as Command63 } from "commander";
-import * as fs30 from "fs";
-import * as path48 from "path";
+import { Command as Command65 } from "commander";
+import * as fs32 from "fs";
+import * as path50 from "path";
 import { parse as parseYaml } from "yaml";
 var MANIFEST_FILENAME = "constraints.yaml";
 async function runShareAction(projectPath, options) {
-  const rootDir = path48.resolve(projectPath);
-  const manifestPath = path48.join(rootDir, MANIFEST_FILENAME);
-  if (!fs30.existsSync(manifestPath)) {
+  const rootDir = path50.resolve(projectPath);
+  const manifestPath = path50.join(rootDir, MANIFEST_FILENAME);
+  if (!fs32.existsSync(manifestPath)) {
     logger.error(
       `No ${MANIFEST_FILENAME} found at ${manifestPath}.
 Create a constraints.yaml in your project root to define what to share.`
@@ -7524,7 +7874,7 @@ Create a constraints.yaml in your project root to define what to share.`
   }
   let parsed;
   try {
-    const raw = fs30.readFileSync(manifestPath, "utf-8");
+    const raw = fs32.readFileSync(manifestPath, "utf-8");
     parsed = parseYaml(raw);
   } catch (err) {
     logger.error(
@@ -7538,7 +7888,7 @@ Create a constraints.yaml in your project root to define what to share.`
     process.exit(1);
   }
   const manifest = manifestResult.value;
-  const configResult = resolveConfig(path48.join(rootDir, "harness.config.json"));
+  const configResult = resolveConfig(path50.join(rootDir, "harness.config.json"));
   if (!configResult.ok) {
     logger.error(configResult.error.message);
     process.exit(1);
@@ -7556,8 +7906,8 @@ Create a constraints.yaml in your project root to define what to share.`
     );
     process.exit(1);
   }
-  const outputDir = path48.resolve(options.output);
-  const outputPath = path48.join(outputDir, `${manifest.name}.harness-constraints.json`);
+  const outputDir = path50.resolve(options.output);
+  const outputPath = path50.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}`);
@@ -7566,28 +7916,28 @@ Create a constraints.yaml in your project root to define what to share.`
   logger.success(`Bundle written to ${outputPath}`);
 }
 function createShareCommand() {
-  return new Command63("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 Command65("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 Command71 } from "commander";
+import { Command as Command73 } from "commander";
 // src/commands/skill/list.ts
-import { Command as Command64 } from "commander";
-import * as fs31 from "fs";
-import * as path49 from "path";
+import { Command as Command66 } from "commander";
+import * as fs33 from "fs";
+import * as path51 from "path";
 import { parse } from "yaml";
 function scanDirectory(dirPath, source) {
-  if (!fs31.existsSync(dirPath)) return [];
-  const entries = fs31.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  if (!fs33.existsSync(dirPath)) return [];
+  const entries = fs33.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   const skills = [];
   for (const name of entries) {
-    const yamlPath = path49.join(dirPath, name, "skill.yaml");
-    if (!fs31.existsSync(yamlPath)) continue;
+    const yamlPath = path51.join(dirPath, name, "skill.yaml");
+    if (!fs33.existsSync(yamlPath)) continue;
     try {
-      const raw = fs31.readFileSync(yamlPath, "utf-8");
+      const raw = fs33.readFileSync(yamlPath, "utf-8");
       const parsed = parse(raw);
       const result = SkillMetadataSchema.safeParse(parsed);
       if (result.success) {
@@ -7605,10 +7955,10 @@ function scanDirectory(dirPath, source) {
 }
 function collectCommunitySkills(seen, allSkills) {
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path49.dirname(globalDir);
-  const communityBase = path49.join(skillsDir, "community");
-  const communityPlatformDir = path49.join(communityBase, "claude-code");
-  const lockfilePath = path49.join(communityBase, "skills-lock.json");
+  const skillsDir = path51.dirname(globalDir);
+  const communityBase = path51.join(skillsDir, "community");
+  const communityPlatformDir = path51.join(communityBase, "claude-code");
+  const lockfilePath = path51.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const communitySkills = scanDirectory(communityPlatformDir, "community");
   for (const skill of communitySkills) {
@@ -7678,7 +8028,7 @@ function printSkillsVerbose(skills) {
   for (const s of skills) printSkillEntry(s);
 }
 function createListCommand3() {
-  return new Command64("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 Command66("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) {
@@ -7693,9 +8043,9 @@ function createListCommand3() {
 }
 // src/commands/skill/run.ts
-import { Command as Command65 } from "commander";
-import * as fs32 from "fs";
-import * as path50 from "path";
+import { Command as Command67 } from "commander";
+import * as fs34 from "fs";
+import * as path52 from "path";
 import { parse as parse2 } from "yaml";
 // src/skill/complexity.ts
@@ -7791,10 +8141,10 @@ ${options.principles}`);
 // src/commands/skill/run.ts
 function loadSkillMetadata(skillDir) {
-  const yamlPath = path50.join(skillDir, "skill.yaml");
-  if (!fs32.existsSync(yamlPath)) return null;
+  const yamlPath = path52.join(skillDir, "skill.yaml");
+  if (!fs34.existsSync(yamlPath)) return null;
   try {
-    const result = SkillMetadataSchema.safeParse(parse2(fs32.readFileSync(yamlPath, "utf-8")));
+    const result = SkillMetadataSchema.safeParse(parse2(fs34.readFileSync(yamlPath, "utf-8")));
     return result.success ? result.data : null;
   } catch {
     return null;
@@ -7806,22 +8156,22 @@ function resolveComplexity(metadata, requested, projectPath) {
   return requested;
 }
 function loadPrinciples(projectPath) {
-  const principlesPath = path50.join(projectPath, "docs", "principles.md");
-  return fs32.existsSync(principlesPath) ? fs32.readFileSync(principlesPath, "utf-8") : void 0;
+  const principlesPath = path52.join(projectPath, "docs", "principles.md");
+  return fs34.existsSync(principlesPath) ? fs34.readFileSync(principlesPath, "utf-8") : void 0;
 }
 function readMostRecentFileInDir(dirPath) {
-  const files = fs32.readdirSync(dirPath).map((f) => ({ name: f, mtime: fs32.statSync(path50.join(dirPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
-  if (files.length > 0) return fs32.readFileSync(path50.join(dirPath, files[0].name), "utf-8");
+  const files = fs34.readdirSync(dirPath).map((f) => ({ name: f, mtime: fs34.statSync(path52.join(dirPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  if (files.length > 0) return fs34.readFileSync(path52.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 = path50.join(projectPath, stateFilePath);
-    if (!fs32.existsSync(fullPath)) continue;
-    const stat = fs32.statSync(fullPath);
+    const fullPath = path52.join(projectPath, stateFilePath);
+    if (!fs34.existsSync(fullPath)) continue;
+    const stat = fs34.statSync(fullPath);
     if (stat.isDirectory()) return readMostRecentFileInDir(fullPath);
-    return fs32.readFileSync(fullPath, "utf-8");
+    return fs34.readFileSync(fullPath, "utf-8");
   }
   return void 0;
 }
@@ -7841,9 +8191,9 @@ function resolvePhaseState(metadata, projectPath, phase) {
 }
 function appendProjectState(content, metadata, projectPath, hasPathOpt) {
   if (!metadata?.state.persistent || !hasPathOpt) return content;
-  const stateFile = path50.join(projectPath, ".harness", "state.json");
-  if (!fs32.existsSync(stateFile)) return content;
-  const stateContent = fs32.readFileSync(stateFile, "utf-8");
+  const stateFile = path52.join(projectPath, ".harness", "state.json");
+  if (!fs34.existsSync(stateFile)) return content;
+  const stateContent = fs34.readFileSync(stateFile, "utf-8");
   return content + `
 ---
@@ -7855,14 +8205,14 @@ ${stateContent}
 }
 async function runSkill(name, opts) {
   const skillsDir = resolveSkillsDir();
-  const skillDir = path50.join(skillsDir, name);
-  if (!fs32.existsSync(skillDir)) {
+  const skillDir = path52.join(skillsDir, name);
+  if (!fs34.existsSync(skillDir)) {
     logger.error(`Skill not found: ${name}`);
     process.exit(ExitCode.ERROR);
     return;
   }
   const metadata = loadSkillMetadata(skillDir);
-  const projectPath = opts.path ? path50.resolve(opts.path) : process.cwd();
+  const projectPath = opts.path ? path52.resolve(opts.path) : process.cwd();
   const complexity = resolveComplexity(
     metadata,
     opts.complexity ?? "standard",
@@ -7889,14 +8239,14 @@ async function runSkill(name, opts) {
     ...stateWarning !== void 0 && { stateWarning },
     ...opts.party !== void 0 && { party: opts.party }
   });
-  const skillMdPath = path50.join(skillDir, "SKILL.md");
-  if (!fs32.existsSync(skillMdPath)) {
+  const skillMdPath = path52.join(skillDir, "SKILL.md");
+  if (!fs34.existsSync(skillMdPath)) {
     logger.error(`SKILL.md not found for skill: ${name}`);
     process.exit(ExitCode.ERROR);
     return;
   }
   const content = appendProjectState(
-    fs32.readFileSync(skillMdPath, "utf-8"),
+    fs34.readFileSync(skillMdPath, "utf-8"),
     metadata,
     projectPath,
     !!opts.path
@@ -7905,13 +8255,13 @@ async function runSkill(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createRunCommand3() {
-  return new Command65("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").action(async (name, opts) => runSkill(name, opts));
+  return new Command67("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").action(async (name, opts) => runSkill(name, opts));
 }
 // src/commands/skill/validate.ts
-import { Command as Command66 } from "commander";
-import * as fs33 from "fs";
-import * as path51 from "path";
+import { Command as Command68 } from "commander";
+import * as fs35 from "fs";
+import * as path53 from "path";
 import { parse as parse3 } from "yaml";
 var BEHAVIORAL_REQUIRED_SECTIONS = [
   "## When to Use",
@@ -7923,11 +8273,11 @@ var BEHAVIORAL_REQUIRED_SECTIONS = [
 ];
 var KNOWLEDGE_REQUIRED_SECTIONS = ["## Instructions"];
 function validateSkillMd(name, skillMdPath, skillType, errors) {
-  if (!fs33.existsSync(skillMdPath)) {
+  if (!fs35.existsSync(skillMdPath)) {
     errors.push(`${name}: missing SKILL.md`);
     return;
   }
-  const mdContent = fs33.readFileSync(skillMdPath, "utf-8");
+  const mdContent = fs35.readFileSync(skillMdPath, "utf-8");
   if (!mdContent.trim().startsWith("# ")) {
     errors.push(`${name}/SKILL.md: must start with an h1 heading`);
   }
@@ -7952,20 +8302,20 @@ function validateSkillMd(name, skillMdPath, skillType, errors) {
   }
 }
 function validateSkillEntry(name, skillsDir, errors) {
-  const skillDir = path51.join(skillsDir, name);
-  const yamlPath = path51.join(skillDir, "skill.yaml");
-  if (!fs33.existsSync(yamlPath)) {
+  const skillDir = path53.join(skillsDir, name);
+  const yamlPath = path53.join(skillDir, "skill.yaml");
+  if (!fs35.existsSync(yamlPath)) {
     errors.push(`${name}: missing skill.yaml`);
     return false;
   }
   try {
-    const raw = fs33.readFileSync(yamlPath, "utf-8");
+    const raw = fs35.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, path51.join(skillDir, "SKILL.md"), result.data.type, errors);
+    validateSkillMd(name, path53.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)}`);
@@ -7973,15 +8323,15 @@ function validateSkillEntry(name, skillsDir, errors) {
   }
 }
 function createValidateCommand2() {
-  return new Command66("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
+  return new Command68("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    if (!fs33.existsSync(skillsDir)) {
+    if (!fs35.existsSync(skillsDir)) {
       logger.info("No skills directory found.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
-    const entries = fs33.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const entries = fs35.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     const errors = [];
     let validated = 0;
     for (const name of entries) {
@@ -8003,24 +8353,24 @@ function createValidateCommand2() {
 }
 // src/commands/skill/info.ts
-import { Command as Command67 } from "commander";
-import * as fs34 from "fs";
-import * as path52 from "path";
+import { Command as Command69 } from "commander";
+import * as fs36 from "fs";
+import * as path54 from "path";
 import { parse as parse4 } from "yaml";
 function loadSkillMetadata2(name) {
   const skillsDir = resolveSkillsDir();
-  const skillDir = path52.join(skillsDir, name);
-  if (!fs34.existsSync(skillDir)) {
+  const skillDir = path54.join(skillsDir, name);
+  if (!fs36.existsSync(skillDir)) {
     logger.error(`Skill not found: ${name}`);
     return { ok: false, exitCode: ExitCode.ERROR };
   }
-  const yamlPath = path52.join(skillDir, "skill.yaml");
-  if (!fs34.existsSync(yamlPath)) {
+  const yamlPath = path54.join(skillDir, "skill.yaml");
+  if (!fs36.existsSync(yamlPath)) {
     logger.error(`skill.yaml not found for skill: ${name}`);
     return { ok: false, exitCode: ExitCode.ERROR };
   }
   try {
-    const raw = fs34.readFileSync(yamlPath, "utf-8");
+    const raw = fs36.readFileSync(yamlPath, "utf-8");
     const parsed = parse4(raw);
     const result = SkillMetadataSchema.safeParse(parsed);
     if (!result.success) {
@@ -8049,7 +8399,7 @@ function printSkillInfo(skill) {
   console.log(`Persistent:  ${skill.state.persistent}`);
 }
 function createInfoCommand() {
-  return new Command67("info").description("Show metadata for a skill").argument("<name>", "Skill name (e.g., harness-tdd)").action(async (name, _opts, cmd) => {
+  return new Command69("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) {
@@ -8066,7 +8416,7 @@ function createInfoCommand() {
 }
 // src/commands/skill/search.ts
-import { Command as Command68 } from "commander";
+import { Command as Command70 } from "commander";
 async function runSearch(query, opts) {
   const results = await searchNpmRegistry(query, opts.registry);
   return results.filter((r) => {
@@ -8111,15 +8461,15 @@ async function runSearchAction(query, opts, globalOpts) {
   }
 }
 function createSearchCommand() {
-  return new Command68("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 Command70("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 Command69 } from "commander";
-import * as path53 from "path";
-import * as fs35 from "fs";
+import { Command as Command71 } from "commander";
+import * as path55 from "path";
+import * as fs37 from "fs";
 import YAML from "yaml";
 var KEBAB_CASE_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 function buildReadme(name, description) {
@@ -8203,22 +8553,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 ?? path53.join(process.cwd(), "agents", "skills", "claude-code");
-  const skillDir = path53.join(baseDir, name);
-  if (fs35.existsSync(skillDir)) {
+  const baseDir = opts.outputDir ?? path55.join(process.cwd(), "agents", "skills", "claude-code");
+  const skillDir = path55.join(baseDir, name);
+  if (fs37.existsSync(skillDir)) {
     throw new Error(`Skill directory already exists: ${skillDir}`);
   }
-  fs35.mkdirSync(skillDir, { recursive: true });
+  fs37.mkdirSync(skillDir, { recursive: true });
   const description = opts.description || `A community skill: ${name}`;
   const skillYaml = buildSkillYaml(name, opts);
-  const skillYamlPath = path53.join(skillDir, "skill.yaml");
-  fs35.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
+  const skillYamlPath = path55.join(skillDir, "skill.yaml");
+  fs37.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
   const skillMd = buildSkillMd(name, description);
-  const skillMdPath = path53.join(skillDir, "SKILL.md");
-  fs35.writeFileSync(skillMdPath, skillMd);
+  const skillMdPath = path55.join(skillDir, "SKILL.md");
+  fs37.writeFileSync(skillMdPath, skillMd);
   const readme = buildReadme(name, description);
-  const readmePath = path53.join(skillDir, "README.md");
-  fs35.writeFileSync(readmePath, readme);
+  const readmePath = path55.join(skillDir, "README.md");
+  fs37.writeFileSync(readmePath, readme);
   return {
     name,
     directory: skillDir,
@@ -8232,12 +8582,12 @@ function printCreateResult(name, result) {
   }
   logger.info(`
 Next steps:`);
-  logger.info(`  1. Edit ${path53.join(result.directory, "SKILL.md")} with your skill content`);
+  logger.info(`  1. Edit ${path55.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 Command69("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 Command71("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, {
@@ -8260,26 +8610,26 @@ function createCreateCommand() {
 }
 // src/commands/skill/publish.ts
-import { Command as Command70 } from "commander";
-import * as fs37 from "fs";
-import * as path55 from "path";
+import { Command as Command72 } from "commander";
+import * as fs39 from "fs";
+import * as path57 from "path";
 import { execFileSync as execFileSync6 } from "child_process";
 // src/registry/validator.ts
-import * as fs36 from "fs";
-import * as path54 from "path";
+import * as fs38 from "fs";
+import * as path56 from "path";
 import { parse as parse5 } from "yaml";
 import semver4 from "semver";
 async function validateForPublish(skillDir, registryUrl) {
   const errors = [];
-  const skillYamlPath = path54.join(skillDir, "skill.yaml");
-  if (!fs36.existsSync(skillYamlPath)) {
+  const skillYamlPath = path56.join(skillDir, "skill.yaml");
+  if (!fs38.existsSync(skillYamlPath)) {
     errors.push("skill.yaml not found. Create one with: harness skill create <name>");
     return { valid: false, errors };
   }
   let skillMeta;
   try {
-    const raw = fs36.readFileSync(skillYamlPath, "utf-8");
+    const raw = fs38.readFileSync(skillYamlPath, "utf-8");
     const parsed = parse5(raw);
     const result = SkillMetadataSchema.safeParse(parsed);
     if (!result.success) {
@@ -8301,11 +8651,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 = path54.join(skillDir, "SKILL.md");
-  if (!fs36.existsSync(skillMdPath)) {
+  const skillMdPath = path56.join(skillDir, "SKILL.md");
+  if (!fs38.existsSync(skillMdPath)) {
     errors.push("SKILL.md not found. Create it with content describing your skill.");
   } else {
-    const content = fs36.readFileSync(skillMdPath, "utf-8");
+    const content = fs38.readFileSync(skillMdPath, "utf-8");
     if (!content.includes("## When to Use")) {
       errors.push('SKILL.md must contain a "## When to Use" section.');
     }
@@ -8385,11 +8735,11 @@ ${errorList}`);
   }
   const meta = validation.skillMeta;
   const pkg = derivePackageJson(meta);
-  const pkgPath = path55.join(skillDir, "package.json");
-  fs37.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-  const readmePath = path55.join(skillDir, "README.md");
-  if (!fs37.existsSync(readmePath)) {
-    const skillMdContent = fs37.readFileSync(path55.join(skillDir, "SKILL.md"), "utf-8");
+  const pkgPath = path57.join(skillDir, "package.json");
+  fs39.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  const readmePath = path57.join(skillDir, "README.md");
+  if (!fs39.existsSync(readmePath)) {
+    const skillMdContent = fs39.readFileSync(path57.join(skillDir, "SKILL.md"), "utf-8");
     const readme = `# ${pkg.name}
 ${meta.description}
@@ -8403,7 +8753,7 @@ harness install ${meta.name}
 ---
 ${skillMdContent}`;
-    fs37.writeFileSync(readmePath, readme);
+    fs39.writeFileSync(readmePath, readme);
   }
   if (opts.dryRun) {
     return {
@@ -8429,7 +8779,7 @@ ${skillMdContent}`;
   };
 }
 function createPublishCommand() {
-  return new Command70("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 Command72("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 {
@@ -8454,7 +8804,7 @@ function createPublishCommand() {
 // src/commands/skill/index.ts
 function createSkillCommand() {
-  const command = new Command71("skill").description("Skill management commands");
+  const command = new Command73("skill").description("Skill management commands");
   command.addCommand(createListCommand3());
   command.addCommand(createRunCommand3());
   command.addCommand(createValidateCommand2());
@@ -8467,9 +8817,9 @@ function createSkillCommand() {
 // src/commands/snapshot.ts
 init_dist();
-import { Command as Command72 } from "commander";
+import { Command as Command74 } from "commander";
 import { execSync as execSync5 } from "child_process";
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 function getCommitHash3(cwd) {
   try {
     return execSync5("git rev-parse --short HEAD", { cwd, encoding: "utf-8" }).toString().trim();
@@ -8494,9 +8844,9 @@ function formatDelta(delta) {
 function directionSymbol(direction) {
   switch (direction) {
     case "improving":
-      return chalk12.green("improving");
+      return chalk13.green("improving");
     case "declining":
-      return chalk12.red("declining");
+      return chalk13.red("declining");
     case "stable":
       return "=";
   }
@@ -8649,7 +8999,7 @@ function registerListCommand(parent) {
   });
 }
 function createSnapshotCommand() {
-  const command = new Command72("snapshot").description("Architecture timeline snapshot commands");
+  const command = new Command74("snapshot").description("Architecture timeline snapshot commands");
   registerCaptureCommand(command);
   registerTrendsCommand(command);
   registerListCommand(command);
@@ -8657,12 +9007,12 @@ function createSnapshotCommand() {
 }
 // src/commands/state/index.ts
-import { Command as Command77 } from "commander";
+import { Command as Command79 } from "commander";
 // src/commands/state/show.ts
 init_dist();
-import { Command as Command73 } from "commander";
-import * as path56 from "path";
+import { Command as Command75 } from "commander";
+import * as path58 from "path";
 function printStateText(state, stream) {
   if (stream) console.log(`Stream:         ${stream}`);
   console.log(`Schema Version: ${state.schemaVersion}`);
@@ -8686,9 +9036,9 @@ function printStateProgress(progress) {
   }
 }
 function createShowCommand() {
-  return new Command73("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 Command75("show").description("Show current project state").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const result = await loadState(path56.resolve(opts.path), opts.stream);
+    const result = await loadState(path58.resolve(opts.path), opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
       process.exit(ExitCode.ERROR);
@@ -8704,9 +9054,9 @@ function createShowCommand() {
 // src/commands/state/reset.ts
 init_dist();
-import { Command as Command74 } from "commander";
-import * as fs38 from "fs";
-import * as path57 from "path";
+import { Command as Command76 } from "commander";
+import * as fs40 from "fs";
+import * as path59 from "path";
 import * as readline3 from "readline";
 async function resolveStatePath(projectPath, stream) {
   if (stream) {
@@ -8715,22 +9065,22 @@ async function resolveStatePath(projectPath, stream) {
       logger.error(streamResult.error.message);
       process.exit(ExitCode.ERROR);
     }
-    return path57.join(streamResult.value, "state.json");
+    return path59.join(streamResult.value, "state.json");
   }
-  return path57.join(projectPath, ".harness", "state.json");
+  return path59.join(projectPath, ".harness", "state.json");
 }
 async function confirmReset() {
   const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve39) => {
-    rl.question("Reset project state? This cannot be undone. [y/N] ", resolve39);
+  const answer = await new Promise((resolve40) => {
+    rl.question("Reset project state? This cannot be undone. [y/N] ", resolve40);
   });
   rl.close();
   return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
 }
 async function runReset(opts) {
-  const projectPath = path57.resolve(opts.path);
+  const projectPath = path59.resolve(opts.path);
   const statePath = await resolveStatePath(projectPath, opts.stream);
-  if (!fs38.existsSync(statePath)) {
+  if (!fs40.existsSync(statePath)) {
     logger.info("No state file found. Nothing to reset.");
     process.exit(ExitCode.SUCCESS);
   }
@@ -8739,7 +9089,7 @@ async function runReset(opts) {
     process.exit(ExitCode.SUCCESS);
   }
   try {
-    fs38.unlinkSync(statePath);
+    fs40.unlinkSync(statePath);
     logger.success("Project state reset.");
   } catch (e) {
     logger.error(`Failed to reset state: ${e instanceof Error ? e.message : String(e)}`);
@@ -8748,16 +9098,16 @@ async function runReset(opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createResetCommand() {
-  return new Command74("reset").description("Reset project state (deletes .harness/state.json)").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").option("--yes", "Skip confirmation prompt").action(async (opts) => runReset(opts));
+  return new Command76("reset").description("Reset project state (deletes .harness/state.json)").option("--path <path>", "Project root path", ".").option("--stream <name>", "Target a specific stream").option("--yes", "Skip confirmation prompt").action(async (opts) => runReset(opts));
 }
 // src/commands/state/learn.ts
 init_dist();
-import { Command as Command75 } from "commander";
-import * as path58 from "path";
+import { Command as Command77 } from "commander";
+import * as path60 from "path";
 function createLearnCommand() {
-  return new Command75("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 = path58.resolve(opts.path);
+  return new Command77("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 = path60.resolve(opts.path);
     const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -8771,10 +9121,10 @@ function createLearnCommand() {
 // src/commands/state/streams.ts
 init_dist();
-import { Command as Command76 } from "commander";
-import * as path59 from "path";
+import { Command as Command78 } from "commander";
+import * as path61 from "path";
 async function runListStreams(opts, globalOpts) {
-  const projectPath = path59.resolve(opts.path);
+  const projectPath = path61.resolve(opts.path);
   const indexResult = await loadStreamIndex(projectPath);
   const result = await listStreams(projectPath);
   if (!result.ok) {
@@ -8795,7 +9145,7 @@ async function runListStreams(opts, globalOpts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runCreateStream(name, opts) {
-  const result = await createStream(path59.resolve(opts.path), name, opts.branch);
+  const result = await createStream(path61.resolve(opts.path), name, opts.branch);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -8804,7 +9154,7 @@ async function runCreateStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runArchiveStream(name, opts) {
-  const result = await archiveStream(path59.resolve(opts.path), name);
+  const result = await archiveStream(path61.resolve(opts.path), name);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -8813,7 +9163,7 @@ async function runArchiveStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runActivateStream(name, opts) {
-  const result = await setActiveStream(path59.resolve(opts.path), name);
+  const result = await setActiveStream(path61.resolve(opts.path), name);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -8822,7 +9172,7 @@ async function runActivateStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createStreamsCommand() {
-  const command = new Command76("streams").description("Manage state streams");
+  const command = new Command78("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));
@@ -8832,7 +9182,7 @@ function createStreamsCommand() {
 // src/commands/state/index.ts
 function createStateCommand() {
-  const command = new Command77("state").description("Project state management commands");
+  const command = new Command79("state").description("Project state management commands");
   command.addCommand(createShowCommand());
   command.addCommand(createResetCommand());
   command.addCommand(createLearnCommand());
@@ -8841,9 +9191,9 @@ function createStateCommand() {
 }
 // src/commands/sync-analyses.ts
-import * as fs39 from "fs";
-import * as path60 from "path";
-import { Command as Command78 } from "commander";
+import * as fs41 from "fs";
+import * as path62 from "path";
+import { Command as Command80 } from "commander";
 init_dist();
 function isValidRecord(record) {
   return typeof record.issueId === "string" && !!record.issueId && typeof record.identifier === "string" && !!record.identifier && typeof record.analyzedAt === "string" && !/[/\\]/.test(record.issueId);
@@ -8869,7 +9219,7 @@ function extractAnalysisFromComments(comments) {
   return null;
 }
 function bootstrapTrackerCommand2(opts, verb) {
-  const projectPath = path60.resolve(opts.dir);
+  const projectPath = path62.resolve(opts.dir);
   const trackerConfig = loadTrackerSyncConfig(projectPath);
   if (!trackerConfig) {
     logger.error(`No tracker config found in harness.config.json. Cannot ${verb}.`);
@@ -8881,8 +9231,8 @@ function bootstrapTrackerCommand2(opts, verb) {
     );
     return null;
   }
-  const projectEnvPath = path60.join(projectPath, ".env");
-  if (fs39.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
+  const projectEnvPath = path62.join(projectPath, ".env");
+  if (fs41.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
     __require("dotenv").config({ path: projectEnvPath });
   }
   const token = process.env.GITHUB_TOKEN;
@@ -8892,14 +9242,33 @@ function bootstrapTrackerCommand2(opts, verb) {
   }
   return { token, projectPath, trackerConfig };
 }
-function loadRoadmapFeatures(projectPath) {
-  const roadmapFile = path60.join(projectPath, "docs", "roadmap.md");
-  if (!fs39.existsSync(roadmapFile)) {
+async function loadRoadmapFeatures(projectPath) {
+  const mode = loadProjectRoadmapMode(projectPath);
+  if (mode === "file-less") {
+    const trackerCfg = loadTrackerClientConfigFromProject(projectPath);
+    if (!trackerCfg.ok) {
+      logger.error(`File-less mode: ${trackerCfg.error.message}`);
+      return null;
+    }
+    const clientR = createTrackerClient(trackerCfg.value);
+    if (!clientR.ok) {
+      logger.error(`File-less mode: ${clientR.error.message}`);
+      return null;
+    }
+    const r = await clientR.value.fetchAll();
+    if (!r.ok) {
+      logger.error(`File-less mode: failed to fetch features from tracker: ${r.error.message}`);
+      return null;
+    }
+    return r.value.features.filter((f) => !!f.externalId).map((f) => ({ name: f.name, externalId: f.externalId }));
+  }
+  const roadmapFile = path62.join(projectPath, "docs", "roadmap.md");
+  if (!fs41.existsSync(roadmapFile)) {
     logger.error("No docs/roadmap.md found. Cannot discover features with externalIds.");
     return null;
   }
-  const { parseRoadmap } = (init_dist(), __toCommonJS(dist_exports));
-  const roadmapParsed = parseRoadmap(fs39.readFileSync(roadmapFile, "utf-8"));
+  const { parseRoadmap: parseRoadmap2 } = (init_dist(), __toCommonJS(dist_exports));
+  const roadmapParsed = parseRoadmap2(fs41.readFileSync(roadmapFile, "utf-8"));
   if (!roadmapParsed.ok) {
     logger.error("Failed to parse docs/roadmap.md");
     return null;
@@ -8943,16 +9312,16 @@ async function runSyncAnalyses(opts) {
   const bootstrap = bootstrapTrackerCommand2(opts, "sync");
   if (!bootstrap) return process.exit(1);
   const { token, projectPath, trackerConfig } = bootstrap;
-  const features = loadRoadmapFeatures(projectPath);
+  const features = await loadRoadmapFeatures(projectPath);
   if (!features) return process.exit(1);
   if (features.length === 0) {
     logger.info("No roadmap features have externalIds. Nothing to sync.");
     return;
   }
   const { AnalysisArchive, loadPublishedIndex: loadPublishedIndex2, savePublishedIndex: savePublishedIndex2 } = await import("@harness-engineering/orchestrator");
-  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-6RT2AVYU.js");
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-I4LWG3IN.js");
   const adapter = new GitHubIssuesSyncAdapter2({ token, config: trackerConfig });
-  const archive = new AnalysisArchive(path60.join(projectPath, ".harness", "analyses"));
+  const archive = new AnalysisArchive(path62.join(projectPath, ".harness", "analyses"));
   const publishedIndex = loadPublishedIndex2(projectPath);
   const { syncedCount, skippedCount, warnCount } = await syncFeatureAnalyses(
     features,
@@ -8972,7 +9341,7 @@ async function runSyncAnalyses(opts) {
   }
 }
 function createSyncAnalysesCommand() {
-  const command = new Command78("sync-analyses").description(
+  const command = new Command80("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 {
@@ -8985,9 +9354,48 @@ function createSyncAnalysesCommand() {
   return command;
 }
+// src/commands/sync-main.ts
+import { Command as Command81 } from "commander";
+import * as path63 from "path";
+import {
+  syncMain as defaultSyncMain
+} from "@harness-engineering/orchestrator";
+async function runSyncMain(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const fn = opts.syncMainFn ?? ((root) => defaultSyncMain(root));
+  const result = await fn(cwd);
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(result)}
+`);
+  } else {
+    process.stdout.write(`${formatHuman(result)}
+`);
+  }
+  return result.status === "error" ? ExitCode.ERROR : ExitCode.SUCCESS;
+}
+function formatHuman(r) {
+  switch (r.status) {
+    case "updated":
+      return `updated ${r.defaultBranch}: ${r.from.slice(0, 7)} -> ${r.to.slice(0, 7)}`;
+    case "no-op":
+      return `up-to-date: ${r.defaultBranch}`;
+    case "skipped":
+      return `skipped (${r.reason}): ${r.detail}`;
+    case "error":
+      return `error: ${r.message}`;
+  }
+}
+function createSyncMainCommand() {
+  return new Command81("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 = path63.resolve(opts.path ?? ".");
+    const exitCode = await runSyncMain({ cwd, json: Boolean(opts.json) });
+    process.exit(exitCode);
+  });
+}
 // src/commands/taint.ts
 init_dist();
-import { Command as Command79 } from "commander";
+import { Command as Command82 } from "commander";
 function getProjectRoot() {
   return process.cwd();
 }
@@ -9059,28 +9467,28 @@ function registerStatusCommand(taint) {
   });
 }
 function createTaintCommand() {
-  const taint = new Command79("taint").description("Manage sentinel session taint state");
+  const taint = new Command82("taint").description("Manage sentinel session taint state");
   registerClearCommand(taint);
   registerStatusCommand(taint);
   return taint;
 }
 // src/commands/telemetry/index.ts
-import { Command as Command83 } from "commander";
+import { Command as Command86 } from "commander";
 // src/commands/telemetry/identify.ts
 init_dist();
-import { Command as Command80 } from "commander";
-import * as fs40 from "fs";
-import * as path61 from "path";
+import { Command as Command83 } from "commander";
+import * as fs42 from "fs";
+import * as path64 from "path";
 function telemetryFilePath(cwd) {
-  return path61.join(cwd, ".harness", "telemetry.json");
+  return path64.join(cwd, ".harness", "telemetry.json");
 }
 function writeTelemetryFile(cwd, data) {
   const filePath = telemetryFilePath(cwd);
-  const dir = path61.dirname(filePath);
-  fs40.mkdirSync(dir, { recursive: true });
-  fs40.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  const dir = path64.dirname(filePath);
+  fs42.mkdirSync(dir, { recursive: true });
+  fs42.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 var IDENTITY_FIELDS = ["project", "team", "alias"];
 function applyIdentityFields(opts, identity) {
@@ -9094,7 +9502,7 @@ function printIdentity(identity) {
   }
 }
 function createIdentifyCommand() {
-  const cmd = new Command80("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 Command83("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: {} });
@@ -9119,7 +9527,7 @@ function createIdentifyCommand() {
 // src/commands/telemetry/status.ts
 init_dist();
-import { Command as Command81 } from "commander";
+import { Command as Command84 } from "commander";
 function gatherEnvOverrides() {
   const overrides = {};
   if (process.env.DO_NOT_TRACK) overrides.DO_NOT_TRACK = process.env.DO_NOT_TRACK;
@@ -9161,7 +9569,7 @@ function printHumanStatus(result) {
   printEnvOverrides(result.envOverrides);
 }
 function createStatusCommand() {
-  const cmd = new Command81("status").description("Show current telemetry consent state, install ID, and identity").option("--json", "Output as JSON").action((opts) => {
+  const cmd = new Command84("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);
@@ -9194,20 +9602,20 @@ function createStatusCommand() {
 // src/commands/telemetry/test.ts
 init_dist();
-import { Command as Command82 } from "commander";
+import { Command as Command85 } from "commander";
 // src/bin/command-telemetry.ts
-import { existsSync as existsSync37, readFileSync as readFileSync27, mkdirSync as mkdirSync18, appendFileSync, writeFileSync as writeFileSync21 } from "fs";
-import { join as join49, parse as parsePath, resolve as resolve36 } from "path";
+import { existsSync as existsSync39, readFileSync as readFileSync29, mkdirSync as mkdirSync19, appendFileSync, writeFileSync as writeFileSync23 } from "fs";
+import { join as join51, parse as parsePath, resolve as resolve37 } from "path";
 import { spawn as spawn2 } from "child_process";
 var POSTHOG_API_KEY = "phc_wNTdCMcfJXZPgdNeDociZW6vwoGGo4nb7vqEfWThFfsG";
 var EXCLUDED_COMMANDS = /* @__PURE__ */ new Set(["help", "completion"]);
 function findProjectRoot(cwd) {
-  let dir = resolve36(cwd);
+  let dir = resolve37(cwd);
   const { root } = parsePath(dir);
   while (dir !== root) {
-    if (existsSync37(join49(dir, "harness.config.json"))) return dir;
-    dir = resolve36(dir, "..");
+    if (existsSync39(join51(dir, "harness.config.json"))) return dir;
+    dir = resolve37(dir, "..");
   }
   return cwd;
 }
@@ -9244,8 +9652,8 @@ function resolveCommandName(cmd) {
 }
 function writeCommandRecordSync(cwd, command, duration, outcome) {
   try {
-    const metricsDir = join49(cwd, ".harness", "metrics");
-    mkdirSync18(metricsDir, { recursive: true });
+    const metricsDir = join51(cwd, ".harness", "metrics");
+    mkdirSync19(metricsDir, { recursive: true });
     const record = {
       skill: command,
       session: `cli-${Date.now()}`,
@@ -9254,16 +9662,16 @@ function writeCommandRecordSync(cwd, command, duration, outcome) {
       outcome,
       phasesReached: []
     };
-    const adoptionFile = join49(metricsDir, "adoption.jsonl");
+    const adoptionFile = join51(metricsDir, "adoption.jsonl");
     appendFileSync(adoptionFile, JSON.stringify(record) + "\n");
   } catch {
   }
 }
 function isTelemetryDisabledByConfig(cwd) {
-  const configPath = join49(cwd, "harness.config.json");
-  if (!existsSync37(configPath)) return false;
+  const configPath = join51(cwd, "harness.config.json");
+  if (!existsSync39(configPath)) return false;
   try {
-    const config = JSON.parse(readFileSync27(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync29(configPath, "utf-8"));
     return config?.telemetry?.enabled === false;
   } catch {
     return false;
@@ -9275,11 +9683,11 @@ function isTelemetryOptedOut(cwd) {
 }
 function flushTelemetryBackground(cwd) {
   try {
-    const adoptionFile = join49(cwd, ".harness", "metrics", "adoption.jsonl");
-    if (!existsSync37(adoptionFile)) return;
+    const adoptionFile = join51(cwd, ".harness", "metrics", "adoption.jsonl");
+    if (!existsSync39(adoptionFile)) return;
     if (isTelemetryOptedOut(cwd)) return;
-    const reporterPath = join49(cwd, ".harness", "hooks", "telemetry-reporter.js");
-    if (!existsSync37(reporterPath)) return;
+    const reporterPath = join51(cwd, ".harness", "hooks", "telemetry-reporter.js");
+    if (!existsSync39(reporterPath)) return;
     const child = spawn2(process.execPath, [reporterPath], {
       cwd,
       stdio: ["pipe", "ignore", "ignore"],
@@ -9316,7 +9724,7 @@ function reportTestSuccess(status, distinctId, identity) {
   if (identity.team) logger.info(`  team:        ${identity.team}`);
 }
 function createTestCommand() {
-  return new Command82("test").description("Send a test event to PostHog and verify connectivity").action(async () => {
+  return new Command85("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) {
@@ -9353,7 +9761,7 @@ function createTestCommand() {
 // src/commands/telemetry/index.ts
 function createTelemetryCommand() {
-  const command = new Command83("telemetry").description("Telemetry identity and status management");
+  const command = new Command86("telemetry").description("Telemetry identity and status management");
   command.addCommand(createIdentifyCommand());
   command.addCommand(createStatusCommand());
   command.addCommand(createTestCommand());
@@ -9361,8 +9769,8 @@ function createTelemetryCommand() {
 }
 // src/commands/traceability.ts
-import { Command as Command84 } from "commander";
-import chalk13 from "chalk";
+import { Command as Command87 } from "commander";
+import chalk14 from "chalk";
 function confidenceLabel(maxConfidence) {
   if (maxConfidence >= 0.8) return "explicit";
   if (maxConfidence > 0) return "inferred";
@@ -9371,13 +9779,13 @@ function confidenceLabel(maxConfidence) {
 function statusIcon(status) {
   switch (status) {
     case "full":
-      return chalk13.green("\u2713 full");
+      return chalk14.green("\u2713 full");
     case "code-only":
-      return chalk13.yellow("\u25D0 code-only");
+      return chalk14.yellow("\u25D0 code-only");
     case "test-only":
-      return chalk13.yellow("\u25D0 test-only");
+      return chalk14.yellow("\u25D0 test-only");
     case "none":
-      return chalk13.red("\u2717 none");
+      return chalk14.red("\u2717 none");
     default:
       return status;
   }
@@ -9424,14 +9832,14 @@ function handleEmptyResults(mode) {
 }
 function printResultTable(result, mode) {
   const specLabel = result.specPath || result.featureName || "Unknown";
-  console.log(`  ${chalk13.cyan(specLabel)} ${chalk13.dim(`(${result.summary.total} requirements)`)}`);
+  console.log(`  ${chalk14.cyan(specLabel)} ${chalk14.dim(`(${result.summary.total} requirements)`)}`);
   console.log("");
   const numWidth = 4;
   const nameWidth = mode === OutputMode.VERBOSE ? 44 : 36;
   const codeWidth = 6;
   const testWidth = 7;
   const confWidth = 12;
-  const header = chalk13.dim(
+  const header = chalk14.dim(
     `  ${pad("#", numWidth)}${pad("Requirement", nameWidth)}${pad("Code", codeWidth)}${pad("Tests", testWidth)}${pad("Confidence", confWidth)}Status`
   );
   console.log(header);
@@ -9460,10 +9868,10 @@ function printRequirementRows(requirements, mode, cols) {
     );
     if (mode === OutputMode.VERBOSE) {
       for (const f of req.codeFiles) {
-        console.log(chalk13.dim(`        code: ${f.path} (${f.method})`));
+        console.log(chalk14.dim(`        code: ${f.path} (${f.method})`));
       }
       for (const f of req.testFiles) {
-        console.log(chalk13.dim(`        test: ${f.path} (${f.method})`));
+        console.log(chalk14.dim(`        test: ${f.path} (${f.method})`));
       }
     }
   }
@@ -9474,7 +9882,7 @@ function printCoverageSummary(summary) {
   const codePct = s.total > 0 ? Math.round(s.withCode / s.total * 100) : 0;
   const testPct = s.total > 0 ? Math.round(s.withTests / s.total * 100) : 0;
   console.log(
-    `  ${chalk13.bold("Coverage:")} ${fullyPct}% fully traced (${s.fullyTraced}/${s.total}), ${codePct}% with code (${s.withCode}/${s.total}), ${testPct}% with tests (${s.withTests}/${s.total})`
+    `  ${chalk14.bold("Coverage:")} ${fullyPct}% fully traced (${s.fullyTraced}/${s.total}), ${codePct}% with code (${s.withCode}/${s.total}), ${testPct}% with tests (${s.withTests}/${s.total})`
   );
 }
 async function runTraceability(options) {
@@ -9490,14 +9898,14 @@ async function runTraceability(options) {
     console.log(JSON.stringify(results, null, 2));
   } else {
     console.log("");
-    console.log(chalk13.bold("Spec-to-Implementation Traceability"));
+    console.log(chalk14.bold("Spec-to-Implementation Traceability"));
     console.log("");
     for (const result of results) printResultTable(result, mode);
   }
   process.exit(ExitCode.SUCCESS);
 }
 function createTraceabilityCommand() {
-  return new Command84("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 Command87("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,
@@ -9510,15 +9918,15 @@ function createTraceabilityCommand() {
 }
 // src/commands/uninstall.ts
-import * as path62 from "path";
-import { Command as Command85 } from "commander";
+import * as path65 from "path";
+import { Command as Command88 } from "commander";
 async function runUninstall(skillName, options) {
   const packageName = resolvePackageName(skillName);
   const shortName = extractSkillName(packageName);
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path62.dirname(globalDir);
-  const communityBase = path62.join(skillsDir, "community");
-  const lockfilePath = path62.join(communityBase, "skills-lock.json");
+  const skillsDir = path65.dirname(globalDir);
+  const communityBase = path65.join(skillsDir, "community");
+  const lockfilePath = path65.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const entry = lockfile.skills[packageName];
   if (!entry) {
@@ -9548,7 +9956,7 @@ async function runUninstall(skillName, options) {
   return result;
 }
 function createUninstallCommand() {
-  const cmd = new Command85("uninstall");
+  const cmd = new Command88("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);
@@ -9568,9 +9976,9 @@ function createUninstallCommand() {
 // src/commands/uninstall-constraints.ts
 init_dist();
-import * as fs41 from "fs/promises";
-import * as path63 from "path";
-import { Command as Command86 } from "commander";
+import * as fs43 from "fs/promises";
+import * as path66 from "path";
+import { Command as Command89 } from "commander";
 async function runUninstallConstraints(options) {
   const { packageName, configPath, lockfilePath } = options;
   const lockfileResult = await readLockfile(lockfilePath);
@@ -9590,7 +9998,7 @@ async function runUninstallConstraints(options) {
   }
   let localConfig;
   try {
-    const raw = await fs41.readFile(configPath, "utf-8");
+    const raw = await fs43.readFile(configPath, "utf-8");
     localConfig = JSON.parse(raw);
   } catch (err) {
     return {
@@ -9627,11 +10035,11 @@ async function runUninstallConstraints(options) {
   };
 }
 function createUninstallConstraintsCommand() {
-  const cmd = new Command86("uninstall-constraints");
+  const cmd = new Command89("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 = path63.resolve(opts.config);
+      configPath = path66.resolve(opts.config);
     } else {
       const found = findConfigFile();
       if (!found.ok) {
@@ -9640,8 +10048,8 @@ function createUninstallConstraintsCommand() {
       }
       configPath = found.value;
     }
-    const projectRoot = path63.dirname(configPath);
-    const lockfilePath = path63.join(projectRoot, ".harness", "constraints.lock.json");
+    const projectRoot = path66.dirname(configPath);
+    const lockfilePath = path66.join(projectRoot, ".harness", "constraints.lock.json");
     const result = await runUninstallConstraints({
       packageName: name,
       configPath,
@@ -9666,13 +10074,13 @@ function createUninstallConstraintsCommand() {
 }
 // src/commands/update.ts
-import { Command as Command87 } from "commander";
+import { Command as Command90 } from "commander";
 import { execFile, execFileSync as execFileSync7 } from "child_process";
-import { realpathSync, existsSync as existsSync38, readFileSync as readFileSync28 } from "fs";
-import { join as join52 } from "path";
+import { realpathSync, existsSync as existsSync40, readFileSync as readFileSync30 } from "fs";
+import { join as join54 } from "path";
 import { promisify } from "util";
 import readline4 from "readline";
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 function detectPackageManager() {
   try {
     const argv1 = process.argv[1];
@@ -9735,10 +10143,10 @@ function prompt3(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve39) => {
+  return new Promise((resolve40) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve39(answer.trim().toLowerCase());
+      resolve40(answer.trim().toLowerCase());
     });
   });
 }
@@ -9753,12 +10161,12 @@ async function ensureTelemetryIfNeeded() {
 }
 function refreshHooks() {
   const cwd = process.cwd();
-  const configPath = join52(cwd, "harness.config.json");
-  if (!existsSync38(configPath)) return;
+  const configPath = join54(cwd, "harness.config.json");
+  if (!existsSync40(configPath)) return;
   let profile = "standard";
-  const profilePath = join52(cwd, ".harness", "hooks", "profile.json");
+  const profilePath = join54(cwd, ".harness", "hooks", "profile.json");
   try {
-    const data = JSON.parse(readFileSync28(profilePath, "utf-8"));
+    const data = JSON.parse(readFileSync30(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
       profile = data.profile;
     }
@@ -9778,7 +10186,7 @@ function runLocalGraphScan() {
     execFileSync7("harness", ["graph", "scan", "."], { stdio: "inherit" });
   } catch {
     logger.warn("Graph scan failed. Run manually:");
-    console.log(`  ${chalk14.cyan("harness graph scan .")}`);
+    console.log(`  ${chalk15.cyan("harness graph scan .")}`);
   }
 }
 async function offerRegeneration() {
@@ -9795,7 +10203,7 @@ async function offerRegeneration() {
     });
   } catch {
     logger.warn("Generation failed. Run manually:");
-    console.log(`  ${chalk14.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
+    console.log(`  ${chalk15.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
   }
   if (!isGlobal) {
     runLocalGraphScan();
@@ -9858,8 +10266,8 @@ async function runUpdateAction(opts, globalOpts) {
     console.log("");
     for (const { pkg, current, latest } of outdated) {
       const shortName = pkg.replace("@harness-engineering/", "");
-      const currentStr = current ? chalk14.dim(`v${current}`) : chalk14.dim("not installed");
-      logger.info(`${shortName}: ${currentStr} \u2192 ${chalk14.green(`v${latest}`)}`);
+      const currentStr = current ? chalk15.dim(`v${current}`) : chalk15.dim("not installed");
+      logger.info(`${shortName}: ${currentStr} \u2192 ${chalk15.green(`v${latest}`)}`);
     }
     console.log("");
   }
@@ -9875,7 +10283,7 @@ async function runUpdateAction(opts, globalOpts) {
   } catch {
     console.log("");
     logger.error("Update failed. You can try manually:");
-    console.log(`  ${chalk14.cyan(installCmd)}`);
+    console.log(`  ${chalk15.cyan(installCmd)}`);
     process.exit(ExitCode.ERROR);
   }
   refreshHooks();
@@ -9884,7 +10292,7 @@ async function runUpdateAction(opts, globalOpts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createUpdateCommand() {
-  return new Command87("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 Command90("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) => {
@@ -9894,9 +10302,9 @@ function createUpdateCommand() {
 }
 // src/commands/usage.ts
-import { Command as Command88 } from "commander";
+import { Command as Command91 } from "commander";
 async function loadAndPriceRecords(cwd, includeClaudeSessions = false) {
-  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-6RT2AVYU.js");
+  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-I4LWG3IN.js");
   const records = readCostRecords(cwd);
   if (includeClaudeSessions) {
     const ccRecords = parseCCRecords();
@@ -9989,7 +10397,7 @@ function registerDailyCommand(usage) {
       else logger.info("No usage data found. Run some harness sessions first.");
       return;
     }
-    const { aggregateByDay } = await import("./dist-6RT2AVYU.js");
+    const { aggregateByDay } = await import("./dist-I4LWG3IN.js");
     const limited = aggregateByDay(records).slice(0, days);
     if (globalOpts.json) {
       console.log(
@@ -10018,7 +10426,7 @@ function registerSessionsCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-6RT2AVYU.js");
+    const { aggregateBySession } = await import("./dist-I4LWG3IN.js");
     const sessionData = aggregateBySession(records);
     const limited = sessionData.slice(0, limit);
     if (globalOpts.json) {
@@ -10098,7 +10506,7 @@ function registerSessionCommand(usage) {
       cwd,
       globalOpts.includeClaudeSessions
     );
-    const { aggregateBySession } = await import("./dist-6RT2AVYU.js");
+    const { aggregateBySession } = await import("./dist-I4LWG3IN.js");
     const sessionData = aggregateBySession(records);
     const match = sessionData.find((s) => s.sessionId === id);
     if (!match) {
@@ -10133,7 +10541,7 @@ function registerLatestCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-6RT2AVYU.js");
+    const { aggregateBySession } = await import("./dist-I4LWG3IN.js");
     const sessionData = aggregateBySession(records);
     const latest = sessionData[0];
     if (!latest) {
@@ -10159,7 +10567,7 @@ function registerLatestCommand(usage) {
   });
 }
 function createUsageCommand() {
-  const usage = new Command88("usage").description("Token usage and cost tracking");
+  const usage = new Command91("usage").description("Token usage and cost tracking");
   usage.option(
     "--include-claude-sessions",
     "Include Claude Code session data from ~/.claude/projects/"
@@ -10174,15 +10582,15 @@ function createUsageCommand() {
 // src/commands/validate.ts
 init_dist();
 init_dist();
-import { Command as Command89 } from "commander";
-import * as path64 from "path";
+import { Command as Command92 } from "commander";
+import * as path67 from "path";
 async function runValidate(options) {
   const configResult = resolveConfig(options.configPath);
   if (!configResult.ok) {
     return configResult;
   }
   const config = configResult.value;
-  const cwd = options.cwd ?? (options.configPath ? path64.dirname(path64.resolve(options.configPath)) : process.cwd());
+  const cwd = options.cwd ?? (options.configPath ? path67.dirname(path67.resolve(options.configPath)) : process.cwd());
   const result = {
     valid: true,
     checks: {
@@ -10192,7 +10600,7 @@ async function runValidate(options) {
     },
     issues: []
   };
-  const agentsMapPath = path64.resolve(cwd, config.agentsMapPath);
+  const agentsMapPath = path67.resolve(cwd, config.agentsMapPath);
   const agentsResult = await validateAgentsMap(agentsMapPath);
   if (agentsResult.ok) {
     result.checks.agentsMap = true;
@@ -10256,6 +10664,23 @@ async function runValidate(options) {
       result.issues.push({ check: "solutionsDir", file: issue.file, message: issue.message });
     }
   }
+  const roadmapModeResult = validateRoadmapMode(config, cwd);
+  if (roadmapModeResult.ok) {
+    result.checks.roadmapMode = true;
+  } else {
+    result.valid = false;
+    result.checks.roadmapMode = false;
+    result.issues.push({
+      check: "roadmapMode",
+      file: "harness.config.json",
+      ruleId: roadmapModeResult.error.code,
+      severity: "error",
+      message: roadmapModeResult.error.message,
+      ...roadmapModeResult.error.suggestions?.[0] !== void 0 && {
+        suggestion: roadmapModeResult.error.suggestions[0]
+      }
+    });
+  }
   if (options.agentConfigs) {
     const agentCfg = await validateAgentConfigs(cwd, {
       strict: options.strict === true,
@@ -10285,11 +10710,11 @@ function resolveValidateMode(globalOpts) {
   return OutputMode.TEXT;
 }
 async function printCrossCheckWarnings(mode) {
-  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-MI5MZ7MB.js");
+  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-XRSSAXJP.js");
   const cwd = process.cwd();
   const crossResult = await runCrossCheck2({
-    specsDir: path64.join(cwd, "docs", "specs"),
-    plansDir: path64.join(cwd, "docs", "plans"),
+    specsDir: path67.join(cwd, "docs", "specs"),
+    plansDir: path67.join(cwd, "docs", "plans"),
     projectPath: cwd
   });
   if (!crossResult.ok || crossResult.value.warnings === 0) return;
@@ -10301,7 +10726,7 @@ async function printCrossCheckWarnings(mode) {
   ${crossResult.value.warnings} warnings`);
 }
 function createValidateCommand3() {
-  const command = new Command89("validate").description("Run all validation checks").option("--cross-check", "Run cross-artifact consistency validation").option(
+  const command = new Command92("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()));
@@ -10394,6 +10819,7 @@ var commandCreators = [
   createPulseCommand,
   createQueryCommand,
   createRecommendCommand,
+  createRoadmapCommand,
   createScanCommand,
   createScanConfigCommand,
   createSetupCommand,
@@ -10403,6 +10829,7 @@ var commandCreators = [
   createSnapshotCommand,
   createStateCommand,
   createSyncAnalysesCommand,
+  createSyncMainCommand,
   createTaintCommand,
   createTelemetryCommand,
   createTraceabilityCommand,
@@ -10415,7 +10842,7 @@ var commandCreators = [
 // src/index.ts
 function createProgram() {
-  const program = new Command90();
+  const program = new Command93();
   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());