@harness-engineering/cli 2.2.1 → 2.3.1

package/dist/{chunk-GOOTYTTV.js → chunk-N6DVSOLZ.js}

@@ -1,15 +1,15 @@
 import {
   generateRuntime
-} from "./chunk-TNZYQTEE.js";
+} from "./chunk-WMZKZCCE.js";
 import {
   generateAgentsMd
-} from "./chunk-4HKVZO7R.js";
+} from "./chunk-IYA3NS5P.js";
 import {
   generateCIWorkflow
-} from "./chunk-JPWICLXQ.js";
+} from "./chunk-DHWFOHPX.js";
 import {
   TemplateEngine
-} from "./chunk-224XKVLP.js";
+} from "./chunk-JMACX5FN.js";
 import {
   generate,
   validate
@@ -28,22 +28,22 @@ import {
   OutputMode,
   createCheckPhaseGateCommand,
   findFiles
-} from "./chunk-E7W3YOXL.js";
+} from "./chunk-U2SF3KAQ.js";
 import {
   createGenerateAgentDefinitionsCommand,
   generateAgentDefinitions
-} from "./chunk-OJMO4JBQ.js";
+} from "./chunk-LBYGGNEZ.js";
 import {
   toKebabCase
 } from "./chunk-KET4QQZB.js";
 import {
   listPersonas,
   loadPersona
-} from "./chunk-VJQLUS5I.js";
+} from "./chunk-KT5PWWWO.js";
 import {
   createScanCommand,
   loadIngestOptions
-} from "./chunk-YG4ZBGEH.js";
+} from "./chunk-7BNK4M23.js";
 import {
   appendFrameworkAgents,
   captureHealthSnapshot,
@@ -57,17 +57,17 @@ import {
   loadCachedSnapshot,
   persistToolingConfig,
   recommend
-} from "./chunk-L2IDE7WS.js";
+} from "./chunk-A36MGB3V.js";
 import {
   loadGraphStore
-} from "./chunk-KTWKW6KJ.js";
+} from "./chunk-TIQU5VY7.js";
 import {
   loadOrRebuildIndex
 } from "./chunk-27AJKSQY.js";
 import {
   findConfigFile,
   resolveConfig
-} from "./chunk-LO7ZLV7S.js";
+} from "./chunk-DBJC4ULT.js";
 import {
   VALID_PLATFORMS
 } from "./chunk-3ISINLYT.js";
@@ -115,6 +115,7 @@ import {
   computeWindow,
   createFixes,
   createStream,
+  createTrackerClient,
   crossReferenceUndocumentedFixes,
   deepMergeConstraints,
   defineLayer,
@@ -129,18 +130,22 @@ import {
   generateSuggestions,
   getOrCreateInstallId,
   gitScan,
-  init_dist,
+  init_dist as init_dist2,
   isoWeek,
   listStreams,
   listTaintedSessions,
+  loadProjectRoadmapMode,
   loadState,
   loadStreamIndex,
+  loadTrackerClientConfigFromProject,
   loadTrackerSyncConfig,
   mapInjectionFindings,
   mapSecurityFindings,
+  migrate_exports,
   parseDiff,
   parseFileRegions,
   parseManifest,
+  parseRoadmap,
   parseSecurityConfig,
   pruneLearnings,
   readIdentity,
@@ -161,14 +166,19 @@ import {
   validateDependencies,
   validateKnowledgeMap,
   validatePulseConfig,
+  validateRoadmapMode,
   validateSolutionsDir,
   writeConfig,
   writeLockfile
-} from "./chunk-K4WRQTEF.js";
+} from "./chunk-YNG7BWGB.js";
 import {
   Err,
   Ok
 } from "./chunk-RL4VMEXL.js";
+import {
+  DEFAULT_SKIP_DIRS,
+  init_dist
+} from "./chunk-XPRGWHBL.js";
 import {
   createCreateSkillCommand
 } from "./chunk-ZP5E7YET.js";
@@ -189,10 +199,10 @@ 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();
+init_dist2();
 import { Command } from "commander";
 import * as fs from "fs";
 import * as path from "path";
@@ -378,7 +388,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-ZS3Y3YWP.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -414,7 +424,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-ZS3Y3YWP.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -492,7 +502,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-ZS3Y3YWP.js");
     const records = readAdoptionRecords(cwd);
     const skillRecords = records.filter((r) => r.skill === name);
     if (skillRecords.length === 0) {
@@ -523,8 +533,8 @@ function createAdoptionCommand() {
 import { Command as Command5 } from "commander";
 
 // src/commands/agent/run.ts
-init_dist();
-init_dist();
+init_dist2();
+init_dist2();
 import { Command as Command3 } from "commander";
 import * as path2 from "path";
 import * as childProcess from "child_process";
@@ -646,7 +656,7 @@ function createRunCommand() {
 }
 
 // src/commands/agent/review.ts
-init_dist();
+init_dist2();
 import { Command as Command4 } from "commander";
 import { execSync } from "child_process";
 async function runAgentReview(options) {
@@ -783,7 +793,7 @@ function createAgentCommand() {
 }
 
 // src/commands/audit-protected.ts
-init_dist();
+init_dist2();
 import { Command as Command6 } from "commander";
 import * as path3 from "path";
 import * as fs2 from "fs";
@@ -891,7 +901,7 @@ function createAuditProtectedCommand() {
 }
 
 // src/commands/blueprint.ts
-init_dist();
+init_dist2();
 import { Command as Command7 } from "commander";
 import * as path4 from "path";
 function createBlueprintCommand() {
@@ -916,7 +926,7 @@ function createBlueprintCommand() {
 }
 
 // src/commands/check-arch.ts
-init_dist();
+init_dist2();
 import { Command as Command8 } from "commander";
 import { execSync as execSync2 } from "child_process";
 function getCommitHash(cwd) {
@@ -1076,8 +1086,8 @@ function createCheckArchCommand() {
 }
 
 // src/commands/check-deps.ts
-init_dist();
-init_dist();
+init_dist2();
+init_dist2();
 import { Command as Command9 } from "commander";
 import * as path5 from "path";
 async function runCheckDeps(options) {
@@ -1177,8 +1187,8 @@ function createCheckDepsCommand() {
 }
 
 // src/commands/check-docs.ts
-init_dist();
-init_dist();
+init_dist2();
+init_dist2();
 import { Command as Command10 } from "commander";
 import * as path6 from "path";
 async function runCheckDocs(options) {
@@ -1287,7 +1297,7 @@ function createCheckDocsCommand() {
 }
 
 // src/commands/check-perf.ts
-init_dist();
+init_dist2();
 import { Command as Command11 } from "commander";
 import * as path7 from "path";
 async function runCheckPerf(cwd, options) {
@@ -1412,7 +1422,7 @@ function createCheckPerfCommand() {
 }
 
 // src/commands/check-security.ts
-init_dist();
+init_dist2();
 import { Command as Command12 } from "commander";
 import * as path8 from "path";
 import { execSync as execSync3 } from "child_process";
@@ -1436,10 +1446,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 ?? {};
     }
@@ -1534,7 +1544,7 @@ function createCheckSecurityCommand() {
 import { Command as Command16 } from "commander";
 
 // src/commands/ci/check.ts
-init_dist();
+init_dist2();
 import { Command as Command13 } from "commander";
 var VALID_CHECKS = [
   "validate",
@@ -1631,7 +1641,7 @@ function createCheckCommand() {
 }
 
 // src/commands/ci/init.ts
-init_dist();
+init_dist2();
 import { Command as Command14 } from "commander";
 import * as fs3 from "fs";
 import * as path9 from "path";
@@ -1775,7 +1785,7 @@ function createInitCommand() {
 }
 
 // src/commands/ci/notify.ts
-init_dist();
+init_dist2();
 import { Command as Command15 } from "commander";
 import * as fs4 from "fs";
 function loadReport(reportPath) {
@@ -1888,7 +1898,7 @@ function createCICommand() {
 }
 
 // src/commands/cleanup.ts
-init_dist();
+init_dist2();
 import { Command as Command17 } from "commander";
 import * as path10 from "path";
 async function runCleanup(options) {
@@ -1910,7 +1920,7 @@ async function runCleanup(options) {
   const entropyConfig = {
     rootDir,
     ...config.entropy?.entryPoints && { entryPoints: config.entropy.entryPoints },
-    docPaths: [docsDir],
+    docPaths: [path10.join(docsDir, "**/*.md")],
     analyze: {
       drift: type === "all" || type === "drift",
       deadCode: type === "all" || type === "dead-code",
@@ -2008,7 +2018,7 @@ function createCleanupCommand() {
 }
 
 // src/commands/cleanup-sessions.ts
-init_dist();
+init_dist2();
 import { Command as Command18 } from "commander";
 import * as fs5 from "fs";
 import * as path11 from "path";
@@ -2117,9 +2127,9 @@ function createCleanupSessionsCommand() {
 import { Command as Command20 } from "commander";
 
 // src/commands/compound/scan-candidates.ts
-init_dist();
+init_dist2();
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname2, join as join6, resolve as resolve11 } from "path";
+import { dirname as dirname2, join as join7, resolve as resolve11 } from "path";
 import { Command as Command19 } from "commander";
 var HOTSPOT_THRESHOLD = 7;
 var DEFAULT_LOOKBACK = "7d";
@@ -2146,7 +2156,7 @@ async function runCompoundScanCandidatesCommand(opts) {
     isoWeek: week,
     lookback
   });
-  const outputPath = opts.outputPath ?? join6(cwd, "docs/solutions/.candidates", `${formatIsoWeek(week)}.md`);
+  const outputPath = opts.outputPath ?? join7(cwd, "docs/solutions/.candidates", `${formatIsoWeek(week)}.md`);
   mkdirSync3(dirname2(outputPath), { recursive: true });
   writeFileSync3(outputPath, report);
   const candidatesFound = undocumented.length + hotspots.length;
@@ -2210,7 +2220,7 @@ import { Command as Command21 } from "commander";
 import { spawn } from "child_process";
 import { existsSync as existsSync4 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname3, join as join7, resolve as resolve12 } from "path";
+import { dirname as dirname3, join as join8, resolve as resolve12 } from "path";
 import { setTimeout } from "timers";
 import { fileURLToPath } from "url";
 var __filename = fileURLToPath(import.meta.url);
@@ -2226,20 +2236,20 @@ function resolveServerScript() {
   try {
     const pkgPath = require2.resolve("@harness-engineering/dashboard/package.json");
     const pkgDir = dirname3(pkgPath);
-    const built2 = join7(pkgDir, "dist", "server", "serve.js");
+    const built2 = join8(pkgDir, "dist", "server", "serve.js");
     if (existsSync4(built2)) return { script: built2, dev: false };
-    const dev2 = join7(pkgDir, "src", "server", "serve.ts");
+    const dev2 = join8(pkgDir, "src", "server", "serve.ts");
     if (existsSync4(dev2)) return { script: dev2, dev: true };
   } catch {
   }
   const built = [
-    join7(__dirname, "..", "..", "..", "dashboard", "dist", "server", "serve.js"),
-    join7(__dirname, "..", "..", "..", "..", "packages", "dashboard", "dist", "server", "serve.js")
+    join8(__dirname, "..", "..", "..", "dashboard", "dist", "server", "serve.js"),
+    join8(__dirname, "..", "..", "..", "..", "packages", "dashboard", "dist", "server", "serve.js")
   ].find((p) => existsSync4(p));
   if (built) return { script: built, dev: false };
   const dev = [
-    join7(__dirname, "..", "..", "..", "dashboard", "src", "server", "serve.ts"),
-    join7(__dirname, "..", "..", "..", "..", "packages", "dashboard", "src", "server", "serve.ts")
+    join8(__dirname, "..", "..", "..", "dashboard", "src", "server", "serve.ts"),
+    join8(__dirname, "..", "..", "..", "..", "packages", "dashboard", "src", "server", "serve.ts")
   ].find((p) => existsSync4(p));
   return dev ? { script: dev, dev: true } : null;
 }
@@ -2653,7 +2663,7 @@ function createDoctorCommand() {
 }
 
 // src/commands/fix-drift.ts
-init_dist();
+init_dist2();
 import { Command as Command23 } from "commander";
 import * as path14 from "path";
 async function runFixDrift(options) {
@@ -2669,7 +2679,7 @@ async function runFixDrift(options) {
   const entropyConfig = {
     rootDir,
     ...config.entropy?.entryPoints && { entryPoints: config.entropy.entryPoints },
-    docPaths: [docsDir],
+    docPaths: [path14.join(docsDir, "**/*.md")],
     analyze: {
       drift: true,
       deadCode: true,
@@ -2888,11 +2898,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;
     }
@@ -2901,7 +2911,7 @@ async function readConnectorSyncStatus(graphDir) {
   return result;
 }
 async function runGraphStatus(projectPath) {
-  const { GraphStore, loadGraphMetadata } = await import("./dist-D27LJR2T.js");
+  const { GraphStore, loadGraphMetadata } = await import("./dist-SQAOKWXM.js");
   const graphDir = path15.join(projectPath, ".harness", "graph");
   const metaResult = await loadGraphMetadata(graphDir);
   if (metaResult.status === "not_found") {
@@ -2953,7 +2963,7 @@ async function runGraphStatus(projectPath) {
 // src/commands/graph/export.ts
 import * as path16 from "path";
 async function runGraphExport(projectPath, format) {
-  const { GraphStore } = await import("./dist-D27LJR2T.js");
+  const { GraphStore } = await import("./dist-SQAOKWXM.js");
   const graphDir = path16.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);
@@ -2989,7 +2999,7 @@ import * as path19 from "path";
 import { Command as Command25 } from "commander";
 import * as path17 from "path";
 async function runQuery(projectPath, rootNodeId, opts) {
-  const { GraphStore, ContextQL } = await import("./dist-D27LJR2T.js");
+  const { GraphStore, ContextQL } = await import("./dist-SQAOKWXM.js");
   const store = new GraphStore();
   const graphDir = path17.join(projectPath, ".harness", "graph");
   const loaded = await store.load(graphDir);
@@ -3042,9 +3052,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 {
@@ -3086,7 +3096,7 @@ async function runIngest(projectPath, source, opts) {
     ConfluenceConnector,
     FigmaConnector,
     MiroConnector
-  } = await import("./dist-D27LJR2T.js");
+  } = await import("./dist-SQAOKWXM.js");
   const graphDir = path18.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   await store.load(graphDir);
@@ -3100,7 +3110,7 @@ async function runIngest(projectPath, source, opts) {
       path18.join(projectPath, "docs", "changes")
     );
     const gitResult = await new GitIngestor(store).ingest(projectPath);
-    const { createExtractionRunner } = await import("./dist-D27LJR2T.js");
+    const { createExtractionRunner } = await import("./dist-SQAOKWXM.js");
     const extractedDir = path18.join(projectPath, ".harness", "knowledge", "extracted");
     const signalsResult = await createExtractionRunner().run(projectPath, store, extractedDir);
     const syncManager = new SyncManager(store, graphDir);
@@ -3146,7 +3156,7 @@ async function runIngest(projectPath, source, opts) {
       );
       break;
     case "business-signals": {
-      const { createExtractionRunner } = await import("./dist-D27LJR2T.js");
+      const { createExtractionRunner } = await import("./dist-SQAOKWXM.js");
       const extractedDir = path18.join(projectPath, ".harness", "knowledge", "extracted");
       result = await createExtractionRunner().run(projectPath, store, extractedDir);
       break;
@@ -3840,7 +3850,7 @@ function createImpactPreviewCommand() {
 }
 
 // src/commands/init.ts
-init_dist();
+init_dist2();
 import { Command as Command35 } from "commander";
 import chalk3 from "chalk";
 import * as fs15 from "fs";
@@ -4372,8 +4382,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 {
@@ -4654,6 +4664,7 @@ function getBundledSkillNames(bundledSkillsDir) {
 }
 
 // src/commands/install.ts
+init_dist();
 function validateSkillYaml(parsed) {
   const result = SkillMetadataSchema.safeParse(parsed);
   if (!result.success) {
@@ -4720,7 +4731,7 @@ function discoverSkillDirs(rootDir) {
     const entries = fs20.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      if (entry.name.startsWith(".") || DEFAULT_SKIP_DIRS.has(entry.name)) continue;
       scan(path32.join(dir, entry.name), depth + 1);
     }
   }
@@ -4939,7 +4950,7 @@ function createInstallCommand() {
 }
 
 // src/commands/install-constraints.ts
-init_dist();
+init_dist2();
 import * as fs21 from "fs/promises";
 import * as path33 from "path";
 import { Command as Command37 } from "commander";
@@ -5205,7 +5216,7 @@ function createInstallConstraintsCommand() {
 import { Command as Command42 } from "commander";
 
 // src/commands/integrations/add.ts
-init_dist();
+init_dist2();
 import { Command as Command38 } from "commander";
 import * as fs22 from "fs";
 import * as path34 from "path";
@@ -5345,7 +5356,7 @@ function createListIntegrationsCommand() {
 }
 
 // src/commands/integrations/remove.ts
-init_dist();
+init_dist2();
 import { Command as Command40 } from "commander";
 import * as fs23 from "fs";
 import * as path36 from "path";
@@ -5394,7 +5405,7 @@ function createRemoveIntegrationCommand() {
 }
 
 // src/commands/integrations/dismiss.ts
-init_dist();
+init_dist2();
 import { Command as Command41 } from "commander";
 import * as path37 from "path";
 function dismissIntegration(cwd, name) {
@@ -5461,9 +5472,9 @@ 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 { GraphStore, KnowledgePipelineRunner } = await import("./dist-D27LJR2T.js");
+      const fs44 = await import("fs/promises");
+      await fs44.mkdir(graphDir, { recursive: true });
+      const { GraphStore, KnowledgePipelineRunner } = await import("./dist-SQAOKWXM.js");
       const store = new GraphStore();
       try {
         await store.load(graphDir);
@@ -5623,7 +5634,7 @@ function createKnowledgePipelineCommand() {
 import { Command as Command45 } from "commander";
 
 // src/commands/learnings/prune.ts
-init_dist();
+init_dist2();
 import { Command as Command44 } from "commander";
 import * as path39 from "path";
 async function handlePrune(opts) {
@@ -5805,7 +5816,7 @@ function createMcpCommand() {
     parseBudget
   ).action(async (opts) => {
     const [{ startServer: startServer2, getToolDefinitions: getToolDefinitions2 }, { selectTier }] = await Promise.all([
-      import("./mcp-JDJGELGD.js"),
+      import("./mcp-ST26QMDK.js"),
       import("./tool-tiers-7QGZ3FKY.js")
     ]);
     if (opts.tools && opts.tools.length > 0) {
@@ -5826,6 +5837,7 @@ function createMcpCommand() {
 }
 
 // src/commands/migrate.ts
+init_dist2();
 init_dist();
 import { Command as Command50 } from "commander";
 import * as fs24 from "fs";
@@ -5860,25 +5872,27 @@ function walk(dir, predicate) {
   if (!fs24.existsSync(dir)) return [];
   const out = [];
   for (const entry of fs24.readdirSync(dir, { withFileTypes: true })) {
-    if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") continue;
+    if (DEFAULT_SKIP_DIRS.has(entry.name)) continue;
     const full = path40.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...walk(full, predicate));
     else if (predicate(full)) out.push(full);
   }
   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 +5926,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 +5942,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 +6082,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 +6180,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 +6225,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({
@@ -6289,14 +6305,14 @@ function createOrchestratorCommand() {
 }
 
 // src/commands/perf.ts
-init_dist();
+init_dist2();
 import { Command as Command52 } from "commander";
 import * as path42 from "path";
 function registerBenchCommand(perf) {
   perf.command("bench [glob]").description("Run benchmarks via vitest bench").action(async (glob2, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { BenchmarkRunner } = await import("./dist-6RT2AVYU.js");
+    const { BenchmarkRunner } = await import("./dist-ZS3Y3YWP.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob2);
     if (benchFiles.length === 0) {
@@ -6360,7 +6376,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-ZS3Y3YWP.js");
   const runner = new BenchmarkRunner();
   const manager = new BaselineManager(cwd);
   logger.info("Running benchmarks to update baselines...");
@@ -6401,7 +6417,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-ZS3Y3YWP.js");
     const analyzer = new EntropyAnalyzer2({
       rootDir: path42.resolve(cwd),
       analyze: { complexity: true, coupling: true }
@@ -6572,7 +6588,7 @@ function createPersonaCommand() {
 }
 
 // src/commands/predict.ts
-init_dist();
+init_dist2();
 import { Command as Command56 } from "commander";
 import chalk8 from "chalk";
 var CATEGORY_ORDER = [
@@ -6705,7 +6721,7 @@ function createPredictCommand() {
 import * as fs26 from "fs";
 import * as path44 from "path";
 import { Command as Command57 } from "commander";
-init_dist();
+init_dist2();
 import {
   renderAnalysisComment,
   loadPublishedIndex,
@@ -6735,14 +6751,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_dist2(), __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 +6830,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-ZS3Y3YWP.js");
   const archive = new AnalysisArchive(path44.join(projectPath, ".harness", "analyses"));
   const analyses = await archive.list();
   if (analyses.length === 0) {
@@ -6834,9 +6875,9 @@ function createPublishAnalysesCommand() {
 import { Command as Command59 } from "commander";
 
 // src/commands/pulse/run.ts
-init_dist();
+init_dist2();
 import { readFileSync as readFileSync15, mkdirSync as mkdirSync13, writeFileSync as writeFileSync14 } from "fs";
-import { dirname as dirname17, join as join33, resolve as resolve28 } from "path";
+import { dirname as dirname17, join as join35, resolve as resolve28 } from "path";
 import { Command as Command58 } from "commander";
 async function runPulseRunCommand(opts) {
   const startedAt = Date.now();
@@ -6868,7 +6909,7 @@ async function runPulseRunCommand(opts) {
   const report = assembleReport(result, productName, lookback);
   const now = /* @__PURE__ */ new Date();
   const ts = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}_${String(now.getHours()).padStart(2, "0")}-${String(now.getMinutes()).padStart(2, "0")}`;
-  const filePath = join33(opts.outputDir, `${ts}.md`);
+  const filePath = join35(opts.outputDir, `${ts}.md`);
   mkdirSync13(dirname17(filePath), { recursive: true });
   writeFileSync14(filePath, report);
   const headlines = extractHeadlines(report);
@@ -7031,11 +7072,326 @@ function createRecommendCommand() {
   return command;
 }
 
-// src/commands/scan-config.ts
-init_dist();
+// src/commands/roadmap/index.ts
+import { Command as Command62 } from "commander";
+
+// src/commands/roadmap/migrate.ts
+init_dist2();
 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_dist2();
+import { Command as Command63 } from "commander";
+import { existsSync as existsSync25, readFileSync as readFileSync18, writeFileSync as writeFileSync17 } from "fs";
+import { join as join38, 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 +7417,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 +7448,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(join38(targetDir, configFile), targetDir, scanner, options);
     if (result) results.push(result);
   }
   return { exitCode: computeScanExitCode(results), results };
@@ -7122,7 +7478,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 +7495,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 +7525,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 +7546,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 +7557,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 +7579,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 +7605,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 +7628,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 +7675,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 +7691,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 +7718,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 +7732,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 +7742,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 +7762,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;
     }
@@ -7445,7 +7801,7 @@ async function detectLegacyLayout(cwd) {
 }
 async function runInitialGraphScan(cwd) {
   try {
-    const { runScan: runScan2 } = await import("./scan-BIJYHOE7.js");
+    const { runScan: runScan2 } = await import("./scan-SFX5U3TE.js");
     const result = await runScan2(cwd);
     return {
       status: "pass",
@@ -7484,10 +7840,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) {
@@ -7506,16 +7862,16 @@ function createSetupCommand() {
 }
 
 // src/commands/share.ts
-init_dist();
-import { Command as Command63 } from "commander";
-import * as fs30 from "fs";
-import * as path48 from "path";
+init_dist2();
+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 +7880,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 +7894,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 +7912,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 +7922,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 +7961,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 +8034,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 +8049,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 +8147,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 +8162,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 +8197,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 +8211,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 +8245,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 +8261,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 +8279,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 +8308,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 +8329,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 +8359,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 +8405,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 +8422,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 +8467,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 +8559,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 +8588,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 +8616,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 +8657,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 +8741,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 +8759,7 @@ harness install ${meta.name}
 ---
 
 ${skillMdContent}`;
-    fs37.writeFileSync(readmePath, readme);
+    fs39.writeFileSync(readmePath, readme);
   }
   if (opts.dryRun) {
     return {
@@ -8429,7 +8785,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 +8810,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());
@@ -8466,10 +8822,10 @@ function createSkillCommand() {
 }
 
 // src/commands/snapshot.ts
-init_dist();
-import { Command as Command72 } from "commander";
+init_dist2();
+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 +8850,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 +9005,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 +9013,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";
+init_dist2();
+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 +9042,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);
@@ -8703,10 +9059,10 @@ 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";
+init_dist2();
+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 +9071,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 +9095,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 +9104,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";
+init_dist2();
+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);
@@ -8770,11 +9126,11 @@ function createLearnCommand() {
 }
 
 // src/commands/state/streams.ts
-init_dist();
-import { Command as Command76 } from "commander";
-import * as path59 from "path";
+init_dist2();
+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 +9151,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 +9160,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 +9169,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 +9178,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 +9188,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,10 +9197,10 @@ function createStateCommand() {
 }
 
 // src/commands/sync-analyses.ts
-import * as fs39 from "fs";
-import * as path60 from "path";
-import { Command as Command78 } from "commander";
-init_dist();
+import * as fs41 from "fs";
+import * as path62 from "path";
+import { Command as Command80 } from "commander";
+init_dist2();
 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 +9225,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 +9237,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 +9248,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_dist2(), __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 +9318,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-ZS3Y3YWP.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 +9347,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 +9360,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";
+init_dist2();
+import { Command as Command82 } from "commander";
 function getProjectRoot() {
   return process.cwd();
 }
@@ -9059,28 +9473,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";
+init_dist2();
+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 +9508,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: {} });
@@ -9118,8 +9532,8 @@ function createIdentifyCommand() {
 }
 
 // src/commands/telemetry/status.ts
-init_dist();
-import { Command as Command81 } from "commander";
+init_dist2();
+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 +9575,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);
@@ -9193,21 +9607,21 @@ function createStatusCommand() {
 }
 
 // src/commands/telemetry/test.ts
-init_dist();
-import { Command as Command82 } from "commander";
+init_dist2();
+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 join53, 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(join53(dir, "harness.config.json"))) return dir;
+    dir = resolve37(dir, "..");
   }
   return cwd;
 }
@@ -9244,8 +9658,8 @@ function resolveCommandName(cmd) {
 }
 function writeCommandRecordSync(cwd, command, duration, outcome) {
   try {
-    const metricsDir = join49(cwd, ".harness", "metrics");
-    mkdirSync18(metricsDir, { recursive: true });
+    const metricsDir = join53(cwd, ".harness", "metrics");
+    mkdirSync19(metricsDir, { recursive: true });
     const record = {
       skill: command,
       session: `cli-${Date.now()}`,
@@ -9254,16 +9668,16 @@ function writeCommandRecordSync(cwd, command, duration, outcome) {
       outcome,
       phasesReached: []
     };
-    const adoptionFile = join49(metricsDir, "adoption.jsonl");
+    const adoptionFile = join53(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 = join53(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 +9689,11 @@ function isTelemetryOptedOut(cwd) {
 }
 function flushTelemetryBackground(cwd) {
   try {
-    const adoptionFile = join49(cwd, ".harness", "metrics", "adoption.jsonl");
-    if (!existsSync37(adoptionFile)) return;
+    const adoptionFile = join53(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 = join53(cwd, ".harness", "hooks", "telemetry-reporter.js");
+    if (!existsSync39(reporterPath)) return;
     const child = spawn2(process.execPath, [reporterPath], {
       cwd,
       stdio: ["pipe", "ignore", "ignore"],
@@ -9316,7 +9730,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 +9767,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 +9775,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 +9785,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 +9838,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 +9874,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 +9888,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) {
@@ -9482,7 +9896,7 @@ async function runTraceability(options) {
   const projectPath = process.cwd();
   const store = await loadGraphStore(projectPath);
   if (!store) handleNoStore(mode);
-  const graphModule = await import("./dist-D27LJR2T.js");
+  const graphModule = await import("./dist-SQAOKWXM.js");
   const filterOptions = buildFilterOptions(options);
   const results = graphModule.queryTraceability(store, filterOptions);
   if (results.length === 0) handleEmptyResults(mode);
@@ -9490,14 +9904,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 +9924,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 +9962,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);
@@ -9567,10 +9981,10 @@ 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";
+init_dist2();
+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 +10004,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 +10041,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 +10054,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 +10080,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 join56 } 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 +10149,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 +10167,12 @@ async function ensureTelemetryIfNeeded() {
 }
 function refreshHooks() {
   const cwd = process.cwd();
-  const configPath = join52(cwd, "harness.config.json");
-  if (!existsSync38(configPath)) return;
+  const configPath = join56(cwd, "harness.config.json");
+  if (!existsSync40(configPath)) return;
   let profile = "standard";
-  const profilePath = join52(cwd, ".harness", "hooks", "profile.json");
+  const profilePath = join56(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 +10192,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 +10209,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 +10272,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 +10289,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 +10298,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 +10308,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-ZS3Y3YWP.js");
   const records = readCostRecords(cwd);
   if (includeClaudeSessions) {
     const ccRecords = parseCCRecords();
@@ -9989,7 +10403,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-ZS3Y3YWP.js");
     const limited = aggregateByDay(records).slice(0, days);
     if (globalOpts.json) {
       console.log(
@@ -10018,7 +10432,7 @@ function registerSessionsCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-6RT2AVYU.js");
+    const { aggregateBySession } = await import("./dist-ZS3Y3YWP.js");
     const sessionData = aggregateBySession(records);
     const limited = sessionData.slice(0, limit);
     if (globalOpts.json) {
@@ -10098,7 +10512,7 @@ function registerSessionCommand(usage) {
       cwd,
       globalOpts.includeClaudeSessions
     );
-    const { aggregateBySession } = await import("./dist-6RT2AVYU.js");
+    const { aggregateBySession } = await import("./dist-ZS3Y3YWP.js");
     const sessionData = aggregateBySession(records);
     const match = sessionData.find((s) => s.sessionId === id);
     if (!match) {
@@ -10133,7 +10547,7 @@ function registerLatestCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-6RT2AVYU.js");
+    const { aggregateBySession } = await import("./dist-ZS3Y3YWP.js");
     const sessionData = aggregateBySession(records);
     const latest = sessionData[0];
     if (!latest) {
@@ -10159,7 +10573,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/"
@@ -10172,17 +10586,17 @@ function createUsageCommand() {
 }
 
 // src/commands/validate.ts
-init_dist();
-init_dist();
-import { Command as Command89 } from "commander";
-import * as path64 from "path";
+init_dist2();
+init_dist2();
+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 +10606,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 +10670,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 +10716,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-F5YQVXLT.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 +10732,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 +10825,7 @@ var commandCreators = [
   createPulseCommand,
   createQueryCommand,
   createRecommendCommand,
+  createRoadmapCommand,
   createScanCommand,
   createScanConfigCommand,
   createSetupCommand,
@@ -10403,6 +10835,7 @@ var commandCreators = [
   createSnapshotCommand,
   createStateCommand,
   createSyncAnalysesCommand,
+  createSyncMainCommand,
   createTaintCommand,
   createTelemetryCommand,
   createTraceabilityCommand,
@@ -10415,7 +10848,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());