@harness-engineering/cli 1.27.1 → 1.28.0

package/dist/{chunk-VCC47EXU.js → chunk-Z63IDQ7Y.js}

@@ -1,15 +1,15 @@
 import {
   generateRuntime
-} from "./chunk-EICASBYP.js";
+} from "./chunk-YZZVOT7I.js";
 import {
   generateAgentsMd
-} from "./chunk-C7RPQWBG.js";
+} from "./chunk-77OMOFZL.js";
 import {
   generateCIWorkflow
-} from "./chunk-FUS4OOGC.js";
+} from "./chunk-3WLXR23L.js";
 import {
   TemplateEngine
-} from "./chunk-L3Y7L4EG.js";
+} from "./chunk-OQS7KURX.js";
 import {
   generate,
   validate
@@ -28,21 +28,21 @@ import {
   OutputMode,
   createCheckPhaseGateCommand,
   findFiles
-} from "./chunk-3XMOWLK3.js";
+} from "./chunk-USG7DV5N.js";
 import {
   createGenerateAgentDefinitionsCommand,
   generateAgentDefinitions
-} from "./chunk-SDDQPMZK.js";
+} from "./chunk-D25P6763.js";
 import {
   toKebabCase
 } from "./chunk-KET4QQZB.js";
 import {
   listPersonas,
   loadPersona
-} from "./chunk-BO4AJZRE.js";
+} from "./chunk-H43UQY6B.js";
 import {
   createScanCommand
-} from "./chunk-XKU37HGH.js";
+} from "./chunk-DHGL3SF2.js";
 import {
   appendFrameworkAgents,
   captureHealthSnapshot,
@@ -56,17 +56,17 @@ import {
   loadCachedSnapshot,
   persistToolingConfig,
   recommend
-} from "./chunk-EHTUWULH.js";
+} from "./chunk-OPOSSZJS.js";
 import {
   loadGraphStore
-} from "./chunk-776JFSPK.js";
+} from "./chunk-VITLE3PS.js";
 import {
   loadOrRebuildIndex
 } from "./chunk-27AJKSQY.js";
 import {
   findConfigFile,
   resolveConfig
-} from "./chunk-A4ETL34H.js";
+} from "./chunk-KLE6FXWM.js";
 import {
   VALID_PLATFORMS
 } from "./chunk-3ISINLYT.js";
@@ -151,7 +151,7 @@ import {
   validateKnowledgeMap,
   writeConfig,
   writeLockfile
-} from "./chunk-IBTHD2UA.js";
+} from "./chunk-6JBJ5FSW.js";
 import {
   Err,
   Ok
@@ -176,7 +176,7 @@ import {
 } from "./chunk-KFQGP6VL.js";
 
 // src/index.ts
-import { Command as Command85 } from "commander";
+import { Command as Command86 } from "commander";
 
 // src/commands/add.ts
 init_dist();
@@ -365,7 +365,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-CPKL5Y2R.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-46VOJIG4.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -401,7 +401,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-CPKL5Y2R.js");
+    const { readAdoptionRecords } = await import("./dist-46VOJIG4.js");
     const records = readAdoptionRecords(cwd);
     if (records.length === 0) {
       if (globalOpts.json) {
@@ -479,7 +479,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-CPKL5Y2R.js");
+    const { readAdoptionRecords, aggregateBySkill } = await import("./dist-46VOJIG4.js");
     const records = readAdoptionRecords(cwd);
     const skillRecords = records.filter((r) => r.skill === name);
     if (skillRecords.length === 0) {
@@ -1424,10 +1424,10 @@ async function runCheckSecurity(cwd, options) {
   const projectRoot = path8.resolve(cwd);
   let configData = {};
   try {
-    const fs41 = await import("fs");
+    const fs42 = await import("fs");
     const configPath = path8.join(projectRoot, "harness.config.json");
-    if (fs41.existsSync(configPath)) {
-      const raw = fs41.readFileSync(configPath, "utf-8");
+    if (fs42.existsSync(configPath)) {
+      const raw = fs42.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       configData = parsed.security ?? {};
     }
@@ -2768,16 +2768,16 @@ import { Command as Command25 } from "commander";
 // src/commands/graph/status.ts
 import * as path15 from "path";
 async function runGraphStatus(projectPath) {
-  const { GraphStore } = await import("./dist-BZS2XRLG.js");
+  const { GraphStore } = await import("./dist-BP6E6QGG.js");
   const graphDir = path15.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);
   if (!loaded) return { status: "no_graph", message: "No graph found. Run `harness scan` first." };
-  const fs41 = await import("fs/promises");
+  const fs42 = await import("fs/promises");
   const metaPath = path15.join(graphDir, "metadata.json");
   let lastScan = "unknown";
   try {
-    const meta = JSON.parse(await fs41.readFile(metaPath, "utf-8"));
+    const meta = JSON.parse(await fs42.readFile(metaPath, "utf-8"));
     lastScan = meta.lastScanTimestamp;
   } catch {
   }
@@ -2789,7 +2789,7 @@ async function runGraphStatus(projectPath) {
   let connectorSyncStatus = {};
   try {
     const syncMetaPath = path15.join(graphDir, "sync-metadata.json");
-    const syncMeta = JSON.parse(await fs41.readFile(syncMetaPath, "utf-8"));
+    const syncMeta = JSON.parse(await fs42.readFile(syncMetaPath, "utf-8"));
     for (const [name, data] of Object.entries(syncMeta.connectors ?? {})) {
       connectorSyncStatus[name] = data.lastSyncTimestamp;
     }
@@ -2808,7 +2808,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-BZS2XRLG.js");
+  const { GraphStore } = await import("./dist-BP6E6QGG.js");
   const graphDir = path16.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);
@@ -2844,7 +2844,7 @@ import * as path19 from "path";
 import { Command as Command23 } from "commander";
 import * as path17 from "path";
 async function runQuery(projectPath, rootNodeId, opts) {
-  const { GraphStore, ContextQL } = await import("./dist-BZS2XRLG.js");
+  const { GraphStore, ContextQL } = await import("./dist-BP6E6QGG.js");
   const store = new GraphStore();
   const graphDir = path17.join(projectPath, ".harness", "graph");
   const loaded = await store.load(graphDir);
@@ -2897,9 +2897,9 @@ import { Command as Command24 } from "commander";
 import * as path18 from "path";
 async function loadConnectorConfig(projectPath, source) {
   try {
-    const fs41 = await import("fs/promises");
+    const fs42 = await import("fs/promises");
     const configPath = path18.join(projectPath, "harness.config.json");
-    const config = JSON.parse(await fs41.readFile(configPath, "utf-8"));
+    const config = JSON.parse(await fs42.readFile(configPath, "utf-8"));
     const connector = config.graph?.connectors?.[source];
     return connector ?? {};
   } catch {
@@ -2941,7 +2941,7 @@ async function runIngest(projectPath, source, opts) {
     ConfluenceConnector,
     FigmaConnector,
     MiroConnector
-  } = await import("./dist-BZS2XRLG.js");
+  } = await import("./dist-BP6E6QGG.js");
   const graphDir = path18.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   await store.load(graphDir);
@@ -2954,7 +2954,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-BZS2XRLG.js");
+    const { createExtractionRunner } = await import("./dist-BP6E6QGG.js");
     const extractedDir = path18.join(projectPath, ".harness", "knowledge", "extracted");
     const signalsResult = await createExtractionRunner().run(projectPath, store, extractedDir);
     const syncManager = new SyncManager(store, graphDir);
@@ -3000,7 +3000,7 @@ async function runIngest(projectPath, source, opts) {
       );
       break;
     case "business-signals": {
-      const { createExtractionRunner } = await import("./dist-BZS2XRLG.js");
+      const { createExtractionRunner } = await import("./dist-BP6E6QGG.js");
       const extractedDir = path18.join(projectPath, ".harness", "knowledge", "extracted");
       result = await createExtractionRunner().run(projectPath, store, extractedDir);
       break;
@@ -5299,21 +5299,28 @@ function createKnowledgePipelineCommand() {
     const projectDir = process.cwd();
     try {
       const graphDir = path38.join(projectDir, ".harness", "graph");
-      const fs41 = await import("fs/promises");
-      await fs41.mkdir(graphDir, { recursive: true });
-      const { GraphStore, KnowledgePipelineRunner } = await import("./dist-BZS2XRLG.js");
+      const fs42 = await import("fs/promises");
+      await fs42.mkdir(graphDir, { recursive: true });
+      const { GraphStore, KnowledgePipelineRunner } = await import("./dist-BP6E6QGG.js");
       const store = new GraphStore();
       try {
         await store.load(graphDir);
       } catch {
       }
+      const cfgResult = resolveConfig();
+      const cfgKnowledge = cfgResult.ok ? cfgResult.value.knowledge : void 0;
+      const inferenceOptions = cfgKnowledge && ((cfgKnowledge.domainPatterns?.length ?? 0) > 0 || (cfgKnowledge.domainBlocklist?.length ?? 0) > 0) ? {
+        ...(cfgKnowledge.domainPatterns?.length ?? 0) > 0 ? { extraPatterns: cfgKnowledge.domainPatterns } : {},
+        ...(cfgKnowledge.domainBlocklist?.length ?? 0) > 0 ? { extraBlocklist: cfgKnowledge.domainBlocklist } : {}
+      } : void 0;
       const pipelineOpts = {
         projectDir,
         fix: Boolean(opts.fix),
         ci: Boolean(opts.ci),
         ...opts.domain ? { domain: opts.domain } : {},
         graphDir,
-        analyzeImages: Boolean(opts.analyzeImages)
+        analyzeImages: Boolean(opts.analyzeImages),
+        ...inferenceOptions ? { inferenceOptions } : {}
       };
       if (opts.imagePaths) {
         pipelineOpts.imagePaths = opts.imagePaths.split(",").map((p) => p.trim());
@@ -5636,7 +5643,7 @@ function createMcpCommand() {
     parseBudget
   ).action(async (opts) => {
     const [{ startServer: startServer2, getToolDefinitions: getToolDefinitions2 }, { selectTier }] = await Promise.all([
-      import("./mcp-NUG4BMKJ.js"),
+      import("./mcp-N6XVWPXJ.js"),
       import("./tool-tiers-7QGZ3FKY.js")
     ]);
     if (opts.tools && opts.tools.length > 0) {
@@ -5656,14 +5663,439 @@ function createMcpCommand() {
   });
 }
 
-// src/commands/orchestrator.ts
+// src/commands/migrate.ts
+init_dist();
 import { Command as Command48 } from "commander";
+import * as fs24 from "fs";
 import * as path40 from "path";
+import * as readline from "readline";
+import { execFileSync as execFileSync4 } from "child_process";
+import chalk7 from "chalk";
+function isGitRepo(cwd) {
+  try {
+    execFileSync4("git", ["rev-parse", "--is-inside-work-tree"], { cwd, stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readJson2(p) {
+  try {
+    return JSON.parse(fs24.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function listDirs(p) {
+  if (!fs24.existsSync(p)) return [];
+  return fs24.readdirSync(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+}
+function listFiles(p, predicate) {
+  if (!fs24.existsSync(p)) return [];
+  return fs24.readdirSync(p, { withFileTypes: true }).filter((e) => e.isFile() && predicate(e.name)).map((e) => e.name);
+}
+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;
+    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 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);
+    if (!state) continue;
+    const specMatch = (state.specPath ?? "").match(/^docs\/changes\/([^/]+)\/proposal\.md$/);
+    if (!specMatch || !specMatch[1]) continue;
+    const topic = specMatch[1];
+    for (const phase of state.phases ?? []) {
+      if (phase.planPath) map.set(phase.planPath, topic);
+    }
+  }
+  return map;
+}
+function extractTopicFromHeader(planAbs, proposalTopics) {
+  let text;
+  try {
+    text = fs24.readFileSync(planAbs, "utf8").slice(0, 4e3);
+  } catch {
+    return null;
+  }
+  const patterns = [
+    /docs\/changes\/([a-z0-9-]+)\/proposal\.md/i,
+    /\*\*Spec[^:]*:\*\*\s*\[?[^\]]*?docs\/changes\/([a-z0-9-]+)/i
+  ];
+  for (const re of patterns) {
+    const m = text.match(re);
+    if (m && m[1] && proposalTopics.has(m[1])) return m[1];
+  }
+  return null;
+}
+function extractTopicFromFilename(filename, proposalTopics) {
+  const stripped = filename.replace(/\.md$/, "").replace(/^\d{4}-\d{2}-\d{2}-/, "").replace(/-plan$/, "").replace(/-phase\d+(-plan)?$/, "");
+  if (proposalTopics.has(stripped)) return stripped;
+  let best = null;
+  for (const topic of proposalTopics) {
+    const matches = stripped === topic || stripped.startsWith(`${topic}-`);
+    if (matches && (!best || topic.length > best.length)) best = topic;
+  }
+  return best;
+}
+async function buildPlan(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const configPath = path40.join(cwd, "harness.config.json");
+  const configResult = fs24.existsSync(configPath) ? resolveConfig(configPath) : null;
+  let docsDir;
+  if (configResult?.ok) {
+    docsDir = configResult.value.docsDir;
+  } else if (configResult && !configResult.ok) {
+    docsDir = "./docs";
+    logger.warn(
+      `  harness.config.json failed to load (${configResult.error.message}); defaulting docsDir to ./docs`
+    );
+  } else {
+    docsDir = "./docs";
+  }
+  const docsAbs = path40.resolve(cwd, docsDir);
+  const relRaw = path40.relative(cwd, docsAbs).replaceAll("\\", "/");
+  const docsRel = relRaw === "" ? "docs" : relRaw;
+  const plan = {
+    cwd,
+    isGitRepo: isGitRepo(cwd),
+    docsDir: docsRel,
+    adrMoves: [],
+    planMoves: [],
+    orphanPlans: [],
+    proposalTopics: /* @__PURE__ */ new Set()
+  };
+  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);
+      }
+    }
+  }
+  return plan;
+}
+function gitMv(cwd, src, dest, useGit) {
+  const destAbs = path40.join(cwd, dest);
+  fs24.mkdirSync(path40.dirname(destAbs), { recursive: true });
+  if (useGit) {
+    try {
+      execFileSync4("git", ["mv", src, dest], { cwd, stdio: "pipe" });
+      return;
+    } catch {
+    }
+  }
+  fs24.renameSync(path40.join(cwd, src), destAbs);
+}
+function executeMigration(plan) {
+  let moved = 0;
+  let failed = 0;
+  const allMoves = [
+    ...plan.adrMoves.map((m) => ({ src: m.src, dest: m.dest })),
+    ...plan.planMoves.map((m) => ({ src: m.src, dest: m.dest }))
+  ];
+  for (const { src, dest } of allMoves) {
+    try {
+      gitMv(plan.cwd, src, dest, plan.isGitRepo);
+      moved++;
+    } catch (err) {
+      failed++;
+      logger.error(`  ${src} -> ${dest}: ${err.message}`);
+    }
+  }
+  return { moved, failed };
+}
+function buildPathLookup(plan) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const m of plan.adrMoves) lookup.set(m.src, m.dest);
+  for (const m of plan.planMoves) lookup.set(m.src, m.dest);
+  return lookup;
+}
+function updateReferences(plan) {
+  const lookup = buildPathLookup(plan);
+  if (lookup.size === 0) return { files: 0, replacements: 0 };
+  let files = 0;
+  let replacements = 0;
+  const targets = [
+    ...walk(path40.join(plan.cwd, "docs"), (p) => p.endsWith(".md")),
+    ...walk(path40.join(plan.cwd, ".harness", "sessions"), (p) => p.endsWith(".json"))
+  ];
+  for (const target of targets) {
+    let text;
+    try {
+      text = fs24.readFileSync(target, "utf8");
+    } catch {
+      continue;
+    }
+    let result = text;
+    let count = 0;
+    for (const [oldPath, newPath] of lookup) {
+      if (!result.includes(oldPath)) continue;
+      const occurrences = result.split(oldPath).length - 1;
+      result = result.split(oldPath).join(newPath);
+      count += occurrences;
+    }
+    if (count > 0 && result !== text) {
+      fs24.writeFileSync(target, result);
+      files++;
+      replacements += count;
+    }
+  }
+  return { files, replacements };
+}
+async function prompt(question, def = "n") {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve37) => rl.question(question, resolve37));
+  rl.close();
+  return (answer.trim() || def).toLowerCase();
+}
+async function resolveOrphans(plan, opts) {
+  if (plan.orphanPlans.length === 0) return Ok({ bucketed: false });
+  const strategy = opts.orphanStrategy ?? "ask";
+  if (opts.dryRun && strategy === "ask") {
+    logger.info(
+      `  Dry run + --orphan-strategy=ask: not prompting; ${plan.orphanPlans.length} orphan(s) would be asked about interactively.`
+    );
+    return Ok({ bucketed: false });
+  }
+  if (strategy === "skip" || strategy === "ask" && !process.stdin.isTTY) {
+    logger.warn(
+      `  Leaving ${plan.orphanPlans.length} orphan plan(s) in docs/plans/ (no proposal match)`
+    );
+    return Ok({ bucketed: false });
+  }
+  if (strategy === "bucket") {
+    const topic = opts.orphanTopic;
+    if (!topic) {
+      return Err(
+        new CLIError(
+          "--orphan-strategy=bucket requires --orphan-topic <name>",
+          ExitCode.VALIDATION_FAILED
+        )
+      );
+    }
+    bucketOrphans(plan, topic);
+    return Ok({ bucketed: true });
+  }
+  console.log("");
+  logger.warn(`Found ${plan.orphanPlans.length} plan(s) with no matching proposal:`);
+  for (const p of plan.orphanPlans.slice(0, 10)) console.log(`  - ${p}`);
+  if (plan.orphanPlans.length > 10) console.log(`  ... and ${plan.orphanPlans.length - 10} more`);
+  console.log("");
+  console.log("  [s] skip \u2014 leave them in docs/plans/");
+  console.log("  [b] bucket \u2014 move all into a single stub topic");
+  const answer = await prompt("Choose [s/b]: ", "s");
+  if (answer === "b") {
+    const topicAnswer = await prompt("Stub topic name (e.g., legacy-plans): ", "legacy-plans");
+    bucketOrphans(plan, topicAnswer);
+    return Ok({ bucketed: true });
+  }
+  logger.info(`  Leaving ${plan.orphanPlans.length} orphan plan(s) in docs/plans/`);
+  return Ok({ bucketed: false });
+}
+function bucketOrphans(plan, topic) {
+  for (const src of plan.orphanPlans) {
+    const file = path40.basename(src);
+    const isVerification = file.includes("VERIFICATION");
+    const subdir = isVerification ? "verifications" : "plans";
+    plan.planMoves.push({
+      src,
+      dest: `docs/changes/${topic}/${subdir}/${file}`,
+      topic,
+      via: "orphan-bucket",
+      subdir
+    });
+  }
+  plan.orphanPlans = [];
+}
+function summarize(plan) {
+  console.log("");
+  console.log(chalk7.bold("  Migration plan"));
+  console.log("");
+  if (plan.adrMoves.length === 0 && plan.planMoves.length === 0 && plan.orphanPlans.length === 0) {
+    logger.success("  Nothing to migrate. Layout is already up to date.");
+    return;
+  }
+  if (plan.adrMoves.length > 0) {
+    logger.info(
+      `  ADR moves: ${plan.adrMoves.length} file(s) \u2014 .harness/architecture/ \u2192 ${plan.docsDir}/architecture/`
+    );
+  }
+  if (plan.planMoves.length > 0) {
+    const byVia = plan.planMoves.reduce((acc, m) => {
+      acc[m.via] = (acc[m.via] ?? 0) + 1;
+      return acc;
+    }, {});
+    logger.info(
+      `  Plan moves: ${plan.planMoves.length} file(s) \u2014 docs/plans/ \u2192 docs/changes/<topic>/{plans,verifications}/`
+    );
+    for (const [via, n] of Object.entries(byVia)) console.log(chalk7.dim(`    via ${via}: ${n}`));
+  }
+  if (plan.orphanPlans.length > 0) {
+    logger.warn(`  Orphan plans: ${plan.orphanPlans.length} (no proposal match \u2014 needs decision)`);
+  }
+  console.log("");
+}
+async function detectLegacyArtifacts(cwd) {
+  const adrLegacyDir = path40.join(cwd, ".harness", "architecture");
+  const adrLegacy = fs24.existsSync(adrLegacyDir) && listDirs(adrLegacyDir).length > 0;
+  const planLegacyDir = path40.join(cwd, "docs", "plans");
+  const planLegacy = fs24.existsSync(planLegacyDir) && listFiles(planLegacyDir, (n) => n.endsWith(".md") && n !== "index.md").length > 0;
+  return { adrLegacy, planLegacy };
+}
+async function runMigrate(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const plan = await buildPlan({ ...opts, cwd });
+  summarize(plan);
+  const empty = {
+    movesPlanned: 0,
+    movesApplied: 0,
+    movesFailed: 0,
+    orphansRemaining: 0,
+    references: { files: 0, replacements: 0 },
+    dryRun: opts.dryRun ?? false,
+    cancelled: false
+  };
+  if (plan.adrMoves.length === 0 && plan.planMoves.length === 0 && plan.orphanPlans.length === 0) {
+    return Ok(empty);
+  }
+  const orphanResult = await resolveOrphans(plan, opts);
+  if (!orphanResult.ok) return orphanResult;
+  if (orphanResult.value.bucketed) summarize(plan);
+  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
+    });
+  }
+  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.");
+    }
+  }
+  console.log("");
+  logger.info("  Next: review changes with `git status` / `git diff`, then commit.");
+  return Ok({
+    movesPlanned,
+    movesApplied: moved,
+    movesFailed: failed,
+    orphansRemaining: plan.orphanPlans.length,
+    references,
+    dryRun: false,
+    cancelled: false
+  });
+}
+function createMigrateCommand() {
+  return new Command48("migrate").description("Migrate legacy harness artifact locations to current layout").option("--dry-run", "Show the migration plan without moving files", false).option("--yes", "Skip confirmation prompt", false).option(
+    "--skip-references",
+    "Do not update path references in docs/sessions after moves",
+    false
+  ).option("--orphan-strategy <strategy>", "How to handle orphan plans (ask|skip|bucket)", "ask").option("--orphan-topic <name>", "Stub topic name when --orphan-strategy=bucket").action(async (options) => {
+    const result = await runMigrate({
+      cwd: process.cwd(),
+      dryRun: options.dryRun,
+      yes: options.yes,
+      skipReferences: options.skipReferences,
+      orphanStrategy: options.orphanStrategy,
+      orphanTopic: options.orphanTopic
+    });
+    if (!result.ok) {
+      logger.error(result.error.message);
+      process.exit(result.error.exitCode);
+    }
+    process.exit(result.value.movesFailed === 0 ? ExitCode.SUCCESS : ExitCode.ERROR);
+  });
+}
+
+// src/commands/orchestrator.ts
+import { Command as Command49 } from "commander";
+import * as path41 from "path";
 import { Orchestrator, WorkflowLoader, launchTUI } from "@harness-engineering/orchestrator";
 function createOrchestratorCommand() {
-  const orchestrator = new Command48("orchestrator");
+  const orchestrator = new Command49("orchestrator");
   orchestrator.command("run").description("Run the orchestrator daemon").option("-w, --workflow <path>", "Path to harness.orchestrator.md", "harness.orchestrator.md").option("--headless", "Run without TUI (server-only mode for use with web dashboard)").action(async (opts) => {
-    const workflowPath = path40.resolve(process.cwd(), opts.workflow);
+    const workflowPath = path41.resolve(process.cwd(), opts.workflow);
     const loader = new WorkflowLoader();
     const result = await loader.loadWorkflow(workflowPath);
     if (!result.ok) {
@@ -5696,13 +6128,13 @@ function createOrchestratorCommand() {
 
 // src/commands/perf.ts
 init_dist();
-import { Command as Command49 } from "commander";
-import * as path41 from "path";
+import { Command as Command50 } 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-CPKL5Y2R.js");
+    const { BenchmarkRunner } = await import("./dist-46VOJIG4.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob2);
     if (benchFiles.length === 0) {
@@ -5766,7 +6198,7 @@ async function runBaselinesShow(globalOpts) {
 }
 async function runBaselinesUpdate(globalOpts) {
   const cwd = process.cwd();
-  const { BenchmarkRunner } = await import("./dist-CPKL5Y2R.js");
+  const { BenchmarkRunner } = await import("./dist-46VOJIG4.js");
   const runner = new BenchmarkRunner();
   const manager = new BaselineManager(cwd);
   logger.info("Running benchmarks to update baselines...");
@@ -5807,9 +6239,9 @@ 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-CPKL5Y2R.js");
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-46VOJIG4.js");
     const analyzer = new EntropyAnalyzer2({
-      rootDir: path41.resolve(cwd),
+      rootDir: path42.resolve(cwd),
       analyze: { complexity: true, coupling: true }
     });
     const result = await analyzer.analyze();
@@ -5868,7 +6300,7 @@ function registerCriticalPathsCommand(perf) {
   });
 }
 function createPerfCommand() {
-  const perf = new Command49("perf").description("Performance benchmark and baseline management");
+  const perf = new Command50("perf").description("Performance benchmark and baseline management");
   registerBenchCommand(perf);
   registerBaselinesCommands(perf);
   registerReportCommand(perf);
@@ -5877,10 +6309,10 @@ function createPerfCommand() {
 }
 
 // src/commands/persona/index.ts
-import { Command as Command52 } from "commander";
+import { Command as Command53 } from "commander";
 
 // src/commands/persona/list.ts
-import { Command as Command50 } from "commander";
+import { Command as Command51 } from "commander";
 function printPersonaList(personas) {
   if (personas.length === 0) {
     logger.info("No personas found.");
@@ -5894,7 +6326,7 @@ function printPersonaList(personas) {
   }
 }
 function createListCommand2() {
-  return new Command50("list").description("List available agent personas").action(async (_opts, cmd) => {
+  return new Command51("list").description("List available agent personas").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const personasDir = resolvePersonasDir();
     const result = listPersonas(personasDir);
@@ -5914,51 +6346,51 @@ function createListCommand2() {
 }
 
 // src/commands/persona/generate.ts
-import { Command as Command51 } from "commander";
-import * as fs24 from "fs";
-import * as path42 from "path";
+import { Command as Command52 } from "commander";
+import * as fs25 from "fs";
+import * as path43 from "path";
 function generatePersonaArtifacts(persona, outputDir, only) {
   const slug = toKebabCase(persona.name);
   const generated = [];
   if (!only || only === "runtime") {
     const result = generateRuntime(persona);
     if (result.ok) {
-      const outPath = path42.join(outputDir, `${slug}.runtime.json`);
-      fs24.mkdirSync(path42.dirname(outPath), { recursive: true });
-      fs24.writeFileSync(outPath, result.value);
+      const outPath = path43.join(outputDir, `${slug}.runtime.json`);
+      fs25.mkdirSync(path43.dirname(outPath), { recursive: true });
+      fs25.writeFileSync(outPath, result.value);
       generated.push(outPath);
     }
   }
   if (!only || only === "agents-md") {
     const result = generateAgentsMd(persona);
     if (result.ok) {
-      const outPath = path42.join(outputDir, `${slug}.agents.md`);
-      fs24.writeFileSync(outPath, result.value);
+      const outPath = path43.join(outputDir, `${slug}.agents.md`);
+      fs25.writeFileSync(outPath, result.value);
       generated.push(outPath);
     }
   }
   if (!only || only === "ci") {
     const result = generateCIWorkflow(persona, "github");
     if (result.ok) {
-      const outPath = path42.join(outputDir, ".github", "workflows", `${slug}.yml`);
-      fs24.mkdirSync(path42.dirname(outPath), { recursive: true });
-      fs24.writeFileSync(outPath, result.value);
+      const outPath = path43.join(outputDir, ".github", "workflows", `${slug}.yml`);
+      fs25.mkdirSync(path43.dirname(outPath), { recursive: true });
+      fs25.writeFileSync(outPath, result.value);
       generated.push(outPath);
     }
   }
   return generated;
 }
 function createGenerateCommand3() {
-  return new Command51("generate").description("Generate artifacts from a persona config").argument("<name>", "Persona name (e.g., architecture-enforcer)").option("--output-dir <dir>", "Output directory", ".").option("--only <type>", "Generate only: ci, agents-md, runtime").action(async (name, opts, cmd) => {
+  return new Command52("generate").description("Generate artifacts from a persona config").argument("<name>", "Persona name (e.g., architecture-enforcer)").option("--output-dir <dir>", "Output directory", ".").option("--only <type>", "Generate only: ci, agents-md, runtime").action(async (name, opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
-    const personaResult = loadPersona(path42.join(resolvePersonasDir(), `${name}.yaml`));
+    const personaResult = loadPersona(path43.join(resolvePersonasDir(), `${name}.yaml`));
     if (!personaResult.ok) {
       logger.error(personaResult.error.message);
       process.exit(ExitCode.ERROR);
     }
     const generated = generatePersonaArtifacts(
       personaResult.value,
-      path42.resolve(opts.outputDir),
+      path43.resolve(opts.outputDir),
       opts.only
     );
     if (!globalOpts.quiet) {
@@ -5971,7 +6403,7 @@ function createGenerateCommand3() {
 
 // src/commands/persona/index.ts
 function createPersonaCommand() {
-  const command = new Command52("persona").description("Agent persona management commands");
+  const command = new Command53("persona").description("Agent persona management commands");
   command.addCommand(createListCommand2());
   command.addCommand(createGenerateCommand3());
   return command;
@@ -5979,8 +6411,8 @@ function createPersonaCommand() {
 
 // src/commands/predict.ts
 init_dist();
-import { Command as Command53 } from "commander";
-import chalk7 from "chalk";
+import { Command as Command54 } from "commander";
+import chalk8 from "chalk";
 var CATEGORY_ORDER = [
   "circular-deps",
   "layer-violations",
@@ -6001,11 +6433,11 @@ function crossingLabel(weeks) {
 function severityPrefix(severity) {
   switch (severity) {
     case "critical":
-      return chalk7.red("[critical]");
+      return chalk8.red("[critical]");
     case "warning":
-      return chalk7.yellow("[warning]");
+      return chalk8.yellow("[warning]");
     case "info":
-      return chalk7.blue("[info]");
+      return chalk8.blue("[info]");
   }
 }
 function printCategoryTable(result) {
@@ -6085,7 +6517,7 @@ function handlePredictError(err, mode) {
   process.exit(ExitCode.ERROR);
 }
 function createPredictCommand() {
-  const command = new Command53("predict").description("Predict which architectural constraints will break and when").option("--category <name>", "Filter to a single metric category").option("--no-roadmap", "Baseline only \u2014 skip roadmap spec impact").option("--horizon <weeks>", "Forecast horizon in weeks (default: 12)", "12").action(async (opts, cmd) => {
+  const command = new Command54("predict").description("Predict which architectural constraints will break and when").option("--category <name>", "Filter to a single metric category").option("--no-roadmap", "Baseline only \u2014 skip roadmap spec impact").option("--horizon <weeks>", "Forecast horizon in weeks (default: 12)", "12").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : OutputMode.TEXT;
     try {
@@ -6108,9 +6540,9 @@ function createPredictCommand() {
 }
 
 // src/commands/publish-analyses.ts
-import * as fs25 from "fs";
-import * as path43 from "path";
-import { Command as Command54 } from "commander";
+import * as fs26 from "fs";
+import * as path44 from "path";
+import { Command as Command55 } from "commander";
 init_dist();
 import {
   renderAnalysisComment,
@@ -6118,7 +6550,7 @@ import {
   savePublishedIndex
 } from "@harness-engineering/orchestrator";
 function bootstrapTrackerCommand(opts, verb) {
-  const projectPath = path43.resolve(opts.dir);
+  const projectPath = path44.resolve(opts.dir);
   const trackerConfig = loadTrackerSyncConfig(projectPath);
   if (!trackerConfig) {
     logger.error(`No tracker config found in harness.config.json. Cannot ${verb}.`);
@@ -6130,8 +6562,8 @@ function bootstrapTrackerCommand(opts, verb) {
     );
     return null;
   }
-  const projectEnvPath = path43.join(projectPath, ".env");
-  if (fs25.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
+  const projectEnvPath = path44.join(projectPath, ".env");
+  if (fs26.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
     __require("dotenv").config({ path: projectEnvPath });
   }
   const token = process.env.GITHUB_TOKEN;
@@ -6142,13 +6574,13 @@ function bootstrapTrackerCommand(opts, verb) {
   return { token, projectPath, trackerConfig };
 }
 function buildNameToExternalIdMap(projectPath) {
-  const roadmapFile = path43.join(projectPath, "docs", "roadmap.md");
-  if (!fs25.existsSync(roadmapFile)) {
+  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(fs25.readFileSync(roadmapFile, "utf-8"));
+  const roadmapParsed = parseRoadmap(fs26.readFileSync(roadmapFile, "utf-8"));
   if (!roadmapParsed.ok) {
     logger.error("Failed to parse docs/roadmap.md");
     return null;
@@ -6198,8 +6630,8 @@ async function runPublishAnalyses(opts) {
   const nameToExternalId = buildNameToExternalIdMap(projectPath);
   if (!nameToExternalId) return process.exit(1);
   const { AnalysisArchive } = await import("@harness-engineering/orchestrator");
-  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-CPKL5Y2R.js");
-  const archive = new AnalysisArchive(path43.join(projectPath, ".harness", "analyses"));
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-46VOJIG4.js");
+  const archive = new AnalysisArchive(path44.join(projectPath, ".harness", "analyses"));
   const analyses = await archive.list();
   if (analyses.length === 0) {
     logger.info("No analyses found to publish.");
@@ -6221,7 +6653,7 @@ async function runPublishAnalyses(opts) {
   }
 }
 function createPublishAnalysesCommand() {
-  const command = new Command54("publish-analyses").description(
+  const command = new Command55("publish-analyses").description(
     "Publishes locally generated intelligence analyses to the external issue tracker (e.g., GitHub)"
   ).option("-d, --dir <path>", "Workspace directory", process.cwd()).action(async (opts) => {
     try {
@@ -6237,8 +6669,8 @@ function createPublishAnalysesCommand() {
 }
 
 // src/commands/recommend.ts
-import { Command as Command55 } from "commander";
-import chalk8 from "chalk";
+import { Command as Command56 } from "commander";
+import chalk9 from "chalk";
 async function resolveSnapshot(cwd, noCache) {
   if (!noCache) {
     const cached = loadCachedSnapshot(cwd);
@@ -6272,12 +6704,12 @@ async function runRecommend(options) {
 function formatRecommendation(rec) {
   const lines = [];
   if (rec.urgency === "critical") {
-    lines.push(`  ${chalk8.red("[CRITICAL]")} ${rec.sequence}. ${rec.skillName}`);
+    lines.push(`  ${chalk9.red("[CRITICAL]")} ${rec.sequence}. ${rec.skillName}`);
   } else {
     lines.push(`  ${rec.sequence}. ${rec.skillName} (${rec.score.toFixed(2)})`);
   }
   for (const reason of rec.reasons) {
-    lines.push(`     ${chalk8.dim("\u2192")} ${reason}`);
+    lines.push(`     ${chalk9.dim("\u2192")} ${reason}`);
   }
   return lines.join("\n");
 }
@@ -6301,7 +6733,7 @@ function printRecommendations(result) {
   console.log("");
 }
 function createRecommendCommand() {
-  const command = new Command55("recommend").description("Recommend skills based on codebase health analysis").option("--no-cache", "Force fresh health snapshot").option("--top <n>", "Max recommendations (default 5)", "5").action(async (opts, cmd) => {
+  const command = new Command56("recommend").description("Recommend skills based on codebase health analysis").option("--no-cache", "Force fresh health snapshot").option("--top <n>", "Max recommendations (default 5)", "5").action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const mode = globalOpts.json ? OutputMode.JSON : OutputMode.TEXT;
     try {
@@ -6338,9 +6770,9 @@ function createRecommendCommand() {
 
 // src/commands/scan-config.ts
 init_dist();
-import { Command as Command56 } from "commander";
-import { existsSync as existsSync22, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "fs";
-import { join as join31, relative as relative2 } from "path";
+import { Command as Command57 } from "commander";
+import { existsSync as existsSync23, readFileSync as readFileSync15, writeFileSync as writeFileSync13 } from "fs";
+import { join as join32, 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();
@@ -6366,17 +6798,17 @@ function applyFix(filePath, targetDir, content, injectionFindings) {
   if (!hasHighSeverity) return;
   const { cleaned, linesStripped } = stripHighSeverityPatterns(content, injectionFindings);
   if (linesStripped > 0) {
-    writeFileSync12(filePath, cleaned);
+    writeFileSync13(filePath, cleaned);
     logger.info(
-      `scan-config --fix: stripped ${linesStripped} high-severity line(s) from ${relative2(targetDir, filePath).replaceAll("\\", "/")}`
+      `scan-config --fix: stripped ${linesStripped} high-severity line(s) from ${relative3(targetDir, filePath).replaceAll("\\", "/")}`
     );
   }
 }
 function scanSingleFile(filePath, targetDir, scanner, options) {
-  if (!existsSync22(filePath)) return null;
+  if (!existsSync23(filePath)) return null;
   let content;
   try {
-    content = readFileSync14(filePath, "utf8");
+    content = readFileSync15(filePath, "utf8");
   } catch {
     return null;
   }
@@ -6388,7 +6820,7 @@ function scanSingleFile(filePath, targetDir, scanner, options) {
     applyFix(filePath, targetDir, content, injectionFindings);
   }
   return {
-    file: relative2(targetDir, filePath).replaceAll("\\", "/"),
+    file: relative3(targetDir, filePath).replaceAll("\\", "/"),
     findings,
     overallSeverity: computeOverallSeverity(findings)
   };
@@ -6397,7 +6829,7 @@ async function runScanConfig(targetDir, options) {
   const scanner = new SecurityScanner(parseSecurityConfig({}));
   const results = [];
   for (const configFile of CONFIG_FILES) {
-    const result = scanSingleFile(join31(targetDir, configFile), targetDir, scanner, options);
+    const result = scanSingleFile(join32(targetDir, configFile), targetDir, scanner, options);
     if (result) results.push(result);
   }
   return { exitCode: computeScanExitCode(results), results };
@@ -6427,7 +6859,7 @@ function formatTextOutput(result) {
   }
 }
 function createScanConfigCommand() {
-  const command = new Command56("scan-config").description(
+  const command = new Command57("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();
@@ -6444,24 +6876,24 @@ function createScanConfigCommand() {
 }
 
 // src/commands/setup.ts
-import { Command as Command57 } from "commander";
-import * as fs28 from "fs";
+import { Command as Command58 } from "commander";
+import * as fs29 from "fs";
 import * as os7 from "os";
-import * as path46 from "path";
-import chalk10 from "chalk";
+import * as path47 from "path";
+import chalk11 from "chalk";
 
 // src/utils/first-run.ts
-import * as fs26 from "fs";
+import * as fs27 from "fs";
 import * as os6 from "os";
-import * as path44 from "path";
-var HARNESS_DIR = path44.join(os6.homedir(), ".harness");
-var MARKER_FILE = path44.join(HARNESS_DIR, ".setup-complete");
+import * as path45 from "path";
+var HARNESS_DIR = path45.join(os6.homedir(), ".harness");
+var MARKER_FILE = path45.join(HARNESS_DIR, ".setup-complete");
 function isFirstRun() {
-  return !fs26.existsSync(MARKER_FILE);
+  return !fs27.existsSync(MARKER_FILE);
 }
 function markSetupComplete() {
-  fs26.mkdirSync(HARNESS_DIR, { recursive: true });
-  fs26.writeFileSync(MARKER_FILE, "", "utf-8");
+  fs27.mkdirSync(HARNESS_DIR, { recursive: true });
+  fs27.writeFileSync(MARKER_FILE, "", "utf-8");
 }
 function printFirstRunWelcome() {
   try {
@@ -6474,31 +6906,31 @@ function printFirstRunWelcome() {
 }
 
 // src/commands/telemetry-wizard.ts
-import * as fs27 from "fs";
-import * as path45 from "path";
-import readline from "readline";
-import chalk9 from "chalk";
-function prompt(question) {
-  const rl = readline.createInterface({
+import * as fs28 from "fs";
+import * as path46 from "path";
+import readline2 from "readline";
+import chalk10 from "chalk";
+function prompt2(question) {
+  const rl = readline2.createInterface({
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve36) => {
+  return new Promise((resolve37) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve36(answer.trim().toLowerCase());
+      resolve37(answer.trim().toLowerCase());
     });
   });
 }
 function promptRaw(question) {
-  const rl = readline.createInterface({
+  const rl = readline2.createInterface({
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve36) => {
+  return new Promise((resolve37) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve36(answer.trim());
+      resolve37(answer.trim());
     });
   });
 }
@@ -6506,21 +6938,21 @@ function isNo(answer) {
   return answer === "n" || answer === "no";
 }
 function isTelemetryConfigured(cwd) {
-  const configPath = path45.join(cwd, "harness.config.json");
+  const configPath = path46.join(cwd, "harness.config.json");
   try {
-    const raw = JSON.parse(fs27.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs28.readFileSync(configPath, "utf-8"));
     return raw.telemetry !== void 0 && raw.adoption !== void 0;
   } catch {
     return false;
   }
 }
 function writeTelemetryConfig(cwd, result) {
-  const configPath = path45.join(cwd, "harness.config.json");
+  const configPath = path46.join(cwd, "harness.config.json");
   try {
-    const raw = JSON.parse(fs27.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs28.readFileSync(configPath, "utf-8"));
     raw.telemetry = { enabled: result.telemetryEnabled };
     raw.adoption = { enabled: result.adoptionEnabled };
-    fs27.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
+    fs28.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
   } catch (err) {
     console.warn(
       `\u26A0 Could not update ${configPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -6528,18 +6960,18 @@ function writeTelemetryConfig(cwd, result) {
   }
   const hasIdentity = result.identity.project || result.identity.team || result.identity.alias;
   if (hasIdentity) {
-    const harnessDir = path45.join(cwd, ".harness");
-    fs27.mkdirSync(harnessDir, { recursive: true });
-    const telemetryFile = path45.join(harnessDir, "telemetry.json");
-    fs27.writeFileSync(telemetryFile, JSON.stringify({ identity: result.identity }, null, 2) + "\n");
+    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");
   }
 }
 async function promptIdentity() {
   console.log(
-    `  ${chalk9.cyan("Identity")} (optional) \u2014 tag telemetry with project/team/alias for filtering.`
+    `  ${chalk10.cyan("Identity")} (optional) \u2014 tag telemetry with project/team/alias for filtering.`
   );
   console.log("  Leave blank to keep anonymous.");
-  const answer = await prompt("  Set identity fields? (y/N) ");
+  const answer = await prompt2("  Set identity fields? (y/N) ");
   const identity = {};
   if (answer === "y" || answer === "yes") {
     const projectName = await promptRaw("    Project name: ");
@@ -6554,31 +6986,31 @@ async function promptIdentity() {
 async function runTelemetryWizard() {
   if (!process.stdin.isTTY) return null;
   console.log("");
-  console.log(`  ${chalk9.bold("Telemetry Configuration")}`);
+  console.log(`  ${chalk10.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(
-    `  ${chalk9.cyan("Anonymous telemetry")} \u2014 error rates, command usage, performance metrics.`
+    `  ${chalk10.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 prompt("  Enable anonymous telemetry? (Y/n) ");
+  const telemetryAnswer = await prompt2("  Enable anonymous telemetry? (Y/n) ");
   const telemetryEnabled = !isNo(telemetryAnswer);
   console.log("");
   console.log(
-    `  ${chalk9.cyan("Adoption tracking")} \u2014 which skills are used, how often, and success rates.`
+    `  ${chalk10.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 prompt("  Enable local adoption tracking? (Y/n) ");
+  const adoptionAnswer = await prompt2("  Enable local adoption tracking? (Y/n) ");
   const adoptionEnabled = !isNo(adoptionAnswer);
   console.log("");
   const identity = await promptIdentity();
   return { telemetryEnabled, adoptionEnabled, identity };
 }
 async function ensureTelemetryConfigured(cwd) {
-  const configPath = path45.join(cwd, "harness.config.json");
-  if (!fs27.existsSync(configPath)) {
+  const configPath = path46.join(cwd, "harness.config.json");
+  if (!fs28.existsSync(configPath)) {
     return { status: "warn", message: "Not a harness project \u2014 skipped telemetry configuration" };
   }
   if (isTelemetryConfigured(cwd)) {
@@ -6624,7 +7056,7 @@ function runSlashCommandGeneration() {
   }
 }
 function detectClient(dirName) {
-  return fs28.existsSync(path46.join(os7.homedir(), dirName));
+  return fs29.existsSync(path47.join(os7.homedir(), dirName));
 }
 async function runMcpSetup(cwd) {
   const results = [];
@@ -6661,12 +7093,12 @@ async function runMcpSetup(cwd) {
   return results;
 }
 function formatStep(result) {
-  const icon = result.status === "pass" ? chalk10.green("\u2713") : result.status === "warn" ? chalk10.yellow("\u26A0") : chalk10.red("\u2717");
+  const icon = result.status === "pass" ? chalk11.green("\u2713") : result.status === "warn" ? chalk11.yellow("\u26A0") : chalk11.red("\u2717");
   return `  ${icon} ${result.message}`;
 }
 function configureTier0Integrations(cwd) {
   try {
-    const mcpPath = path46.join(cwd, ".mcp.json");
+    const mcpPath = path47.join(cwd, ".mcp.json");
     const config = readMcpConfig(mcpPath);
     const tier0 = INTEGRATION_REGISTRY.filter((i) => i.tier === 0);
     const added = [];
@@ -6675,9 +7107,9 @@ function configureTier0Integrations(cwd) {
       writeMcpEntry(mcpPath, integration.name, integration.mcpConfig);
       added.push(integration.displayName);
     }
-    const geminiDir = path46.join(cwd, ".gemini");
-    if (fs28.existsSync(geminiDir)) {
-      const geminiPath = path46.join(geminiDir, "settings.json");
+    const geminiDir = path47.join(cwd, ".gemini");
+    if (fs29.existsSync(geminiDir)) {
+      const geminiPath = path47.join(geminiDir, "settings.json");
       const geminiConfig = readMcpConfig(geminiPath);
       for (const integration of tier0) {
         if (!geminiConfig.mcpServers[integration.name]) {
@@ -6698,14 +7130,14 @@ function configureTier0Integrations(cwd) {
   }
 }
 function ensureHooks(cwd) {
-  const configPath = path46.join(cwd, "harness.config.json");
-  if (!fs28.existsSync(configPath)) {
+  const configPath = path47.join(cwd, "harness.config.json");
+  if (!fs29.existsSync(configPath)) {
     return { status: "warn", message: "Not a harness project \u2014 skipped hook installation" };
   }
   let profile = "standard";
-  const profilePath = path46.join(cwd, ".harness", "hooks", "profile.json");
+  const profilePath = path47.join(cwd, ".harness", "hooks", "profile.json");
   try {
-    const data = JSON.parse(fs28.readFileSync(profilePath, "utf-8"));
+    const data = JSON.parse(fs29.readFileSync(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
       profile = data.profile;
     }
@@ -6722,9 +7154,22 @@ function ensureHooks(cwd) {
     return { status: "warn", message: `Hook installation skipped \u2014 ${msg}` };
   }
 }
+async function detectLegacyLayout(cwd) {
+  const { adrLegacy, planLegacy } = await detectLegacyArtifacts(cwd);
+  if (!adrLegacy && !planLegacy) {
+    return { status: "pass", message: "Layout up to date" };
+  }
+  const parts = [];
+  if (adrLegacy) parts.push(".harness/architecture/");
+  if (planLegacy) parts.push("docs/plans/");
+  return {
+    status: "warn",
+    message: `Legacy paths detected (${parts.join(", ")}) \u2014 run \`harness migrate\` to upgrade`
+  };
+}
 async function runInitialGraphScan(cwd) {
   try {
-    const { runScan: runScan2 } = await import("./scan-M4EGDAQ2.js");
+    const { runScan: runScan2 } = await import("./scan-XRGMTO6K.js");
     const result = await runScan2(cwd);
     return {
       status: "pass",
@@ -6754,6 +7199,8 @@ async function runSetup(cwd) {
   steps.push(telemetryResult);
   const graphResult = await runInitialGraphScan(cwd);
   steps.push(graphResult);
+  const legacyResult = await detectLegacyLayout(cwd);
+  steps.push(legacyResult);
   const success = steps.every((s) => s.status !== "fail");
   if (success) {
     markSetupComplete();
@@ -6761,10 +7208,10 @@ async function runSetup(cwd) {
   return { steps, success };
 }
 function createSetupCommand() {
-  return new Command57("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
+  return new Command58("setup").description("Configure harness environment: slash commands, MCP, and more").action(async () => {
     const cwd = process.cwd();
     console.log("");
-    console.log(`  ${chalk10.bold("harness setup")}`);
+    console.log(`  ${chalk11.bold("harness setup")}`);
     console.log("");
     const { steps, success } = await runSetup(cwd);
     for (const step of steps) {
@@ -6784,15 +7231,15 @@ function createSetupCommand() {
 
 // src/commands/share.ts
 init_dist();
-import { Command as Command58 } from "commander";
-import * as fs29 from "fs";
-import * as path47 from "path";
+import { Command as Command59 } from "commander";
+import * as fs30 from "fs";
+import * as path48 from "path";
 import { parse as parseYaml } from "yaml";
 var MANIFEST_FILENAME = "constraints.yaml";
 async function runShareAction(projectPath, options) {
-  const rootDir = path47.resolve(projectPath);
-  const manifestPath = path47.join(rootDir, MANIFEST_FILENAME);
-  if (!fs29.existsSync(manifestPath)) {
+  const rootDir = path48.resolve(projectPath);
+  const manifestPath = path48.join(rootDir, MANIFEST_FILENAME);
+  if (!fs30.existsSync(manifestPath)) {
     logger.error(
       `No ${MANIFEST_FILENAME} found at ${manifestPath}.
 Create a constraints.yaml in your project root to define what to share.`
@@ -6801,7 +7248,7 @@ Create a constraints.yaml in your project root to define what to share.`
   }
   let parsed;
   try {
-    const raw = fs29.readFileSync(manifestPath, "utf-8");
+    const raw = fs30.readFileSync(manifestPath, "utf-8");
     parsed = parseYaml(raw);
   } catch (err) {
     logger.error(
@@ -6815,7 +7262,7 @@ Create a constraints.yaml in your project root to define what to share.`
     process.exit(1);
   }
   const manifest = manifestResult.value;
-  const configResult = resolveConfig(path47.join(rootDir, "harness.config.json"));
+  const configResult = resolveConfig(path48.join(rootDir, "harness.config.json"));
   if (!configResult.ok) {
     logger.error(configResult.error.message);
     process.exit(1);
@@ -6833,8 +7280,8 @@ Create a constraints.yaml in your project root to define what to share.`
     );
     process.exit(1);
   }
-  const outputDir = path47.resolve(options.output);
-  const outputPath = path47.join(outputDir, `${manifest.name}.harness-constraints.json`);
+  const outputDir = path48.resolve(options.output);
+  const outputPath = path48.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}`);
@@ -6843,28 +7290,28 @@ Create a constraints.yaml in your project root to define what to share.`
   logger.success(`Bundle written to ${outputPath}`);
 }
 function createShareCommand() {
-  return new Command58("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 Command59("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 Command66 } from "commander";
+import { Command as Command67 } from "commander";
 
 // src/commands/skill/list.ts
-import { Command as Command59 } from "commander";
-import * as fs30 from "fs";
-import * as path48 from "path";
+import { Command as Command60 } from "commander";
+import * as fs31 from "fs";
+import * as path49 from "path";
 import { parse } from "yaml";
 function scanDirectory(dirPath, source) {
-  if (!fs30.existsSync(dirPath)) return [];
-  const entries = fs30.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  if (!fs31.existsSync(dirPath)) return [];
+  const entries = fs31.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   const skills = [];
   for (const name of entries) {
-    const yamlPath = path48.join(dirPath, name, "skill.yaml");
-    if (!fs30.existsSync(yamlPath)) continue;
+    const yamlPath = path49.join(dirPath, name, "skill.yaml");
+    if (!fs31.existsSync(yamlPath)) continue;
     try {
-      const raw = fs30.readFileSync(yamlPath, "utf-8");
+      const raw = fs31.readFileSync(yamlPath, "utf-8");
       const parsed = parse(raw);
       const result = SkillMetadataSchema.safeParse(parsed);
       if (result.success) {
@@ -6882,10 +7329,10 @@ function scanDirectory(dirPath, source) {
 }
 function collectCommunitySkills(seen, allSkills) {
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path48.dirname(globalDir);
-  const communityBase = path48.join(skillsDir, "community");
-  const communityPlatformDir = path48.join(communityBase, "claude-code");
-  const lockfilePath = path48.join(communityBase, "skills-lock.json");
+  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 lockfile = readLockfile2(lockfilePath);
   const communitySkills = scanDirectory(communityPlatformDir, "community");
   for (const skill of communitySkills) {
@@ -6955,7 +7402,7 @@ function printSkillsVerbose(skills) {
   for (const s of skills) printSkillEntry(s);
 }
 function createListCommand3() {
-  return new Command59("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 Command60("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) {
@@ -6970,13 +7417,13 @@ function createListCommand3() {
 }
 
 // src/commands/skill/run.ts
-import { Command as Command60 } from "commander";
-import * as fs31 from "fs";
-import * as path49 from "path";
+import { Command as Command61 } from "commander";
+import * as fs32 from "fs";
+import * as path50 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/skill/complexity.ts
-import { execFileSync as execFileSync4 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
 function evaluateSignals(signals) {
   if (signals.fileCount >= 3) return "thorough";
   if (signals.newDir) return "thorough";
@@ -6988,17 +7435,17 @@ function evaluateSignals(signals) {
 }
 function detectComplexity(projectPath) {
   try {
-    const base = execFileSync4("git", ["merge-base", "HEAD", "main"], {
+    const base = execFileSync5("git", ["merge-base", "HEAD", "main"], {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const diffFiles = execFileSync4("git", ["diff", "--name-only", base], {
+    const diffFiles = execFileSync5("git", ["diff", "--name-only", base], {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim().split("\n").filter(Boolean);
-    const diffStat = execFileSync4("git", ["diff", "--stat", base], {
+    const diffStat = execFileSync5("git", ["diff", "--stat", base], {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -7068,10 +7515,10 @@ ${options.principles}`);
 
 // src/commands/skill/run.ts
 function loadSkillMetadata(skillDir) {
-  const yamlPath = path49.join(skillDir, "skill.yaml");
-  if (!fs31.existsSync(yamlPath)) return null;
+  const yamlPath = path50.join(skillDir, "skill.yaml");
+  if (!fs32.existsSync(yamlPath)) return null;
   try {
-    const result = SkillMetadataSchema.safeParse(parse2(fs31.readFileSync(yamlPath, "utf-8")));
+    const result = SkillMetadataSchema.safeParse(parse2(fs32.readFileSync(yamlPath, "utf-8")));
     return result.success ? result.data : null;
   } catch {
     return null;
@@ -7083,22 +7530,22 @@ function resolveComplexity(metadata, requested, projectPath) {
   return requested;
 }
 function loadPrinciples(projectPath) {
-  const principlesPath = path49.join(projectPath, "docs", "principles.md");
-  return fs31.existsSync(principlesPath) ? fs31.readFileSync(principlesPath, "utf-8") : void 0;
+  const principlesPath = path50.join(projectPath, "docs", "principles.md");
+  return fs32.existsSync(principlesPath) ? fs32.readFileSync(principlesPath, "utf-8") : void 0;
 }
 function readMostRecentFileInDir(dirPath) {
-  const files = fs31.readdirSync(dirPath).map((f) => ({ name: f, mtime: fs31.statSync(path49.join(dirPath, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
-  if (files.length > 0) return fs31.readFileSync(path49.join(dirPath, files[0].name), "utf-8");
+  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");
   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 = path49.join(projectPath, stateFilePath);
-    if (!fs31.existsSync(fullPath)) continue;
-    const stat = fs31.statSync(fullPath);
+    const fullPath = path50.join(projectPath, stateFilePath);
+    if (!fs32.existsSync(fullPath)) continue;
+    const stat = fs32.statSync(fullPath);
     if (stat.isDirectory()) return readMostRecentFileInDir(fullPath);
-    return fs31.readFileSync(fullPath, "utf-8");
+    return fs32.readFileSync(fullPath, "utf-8");
   }
   return void 0;
 }
@@ -7118,9 +7565,9 @@ function resolvePhaseState(metadata, projectPath, phase) {
 }
 function appendProjectState(content, metadata, projectPath, hasPathOpt) {
   if (!metadata?.state.persistent || !hasPathOpt) return content;
-  const stateFile = path49.join(projectPath, ".harness", "state.json");
-  if (!fs31.existsSync(stateFile)) return content;
-  const stateContent = fs31.readFileSync(stateFile, "utf-8");
+  const stateFile = path50.join(projectPath, ".harness", "state.json");
+  if (!fs32.existsSync(stateFile)) return content;
+  const stateContent = fs32.readFileSync(stateFile, "utf-8");
   return content + `
 
 ---
@@ -7132,14 +7579,14 @@ ${stateContent}
 }
 async function runSkill(name, opts) {
   const skillsDir = resolveSkillsDir();
-  const skillDir = path49.join(skillsDir, name);
-  if (!fs31.existsSync(skillDir)) {
+  const skillDir = path50.join(skillsDir, name);
+  if (!fs32.existsSync(skillDir)) {
     logger.error(`Skill not found: ${name}`);
     process.exit(ExitCode.ERROR);
     return;
   }
   const metadata = loadSkillMetadata(skillDir);
-  const projectPath = opts.path ? path49.resolve(opts.path) : process.cwd();
+  const projectPath = opts.path ? path50.resolve(opts.path) : process.cwd();
   const complexity = resolveComplexity(
     metadata,
     opts.complexity ?? "standard",
@@ -7166,14 +7613,14 @@ async function runSkill(name, opts) {
     ...stateWarning !== void 0 && { stateWarning },
     ...opts.party !== void 0 && { party: opts.party }
   });
-  const skillMdPath = path49.join(skillDir, "SKILL.md");
-  if (!fs31.existsSync(skillMdPath)) {
+  const skillMdPath = path50.join(skillDir, "SKILL.md");
+  if (!fs32.existsSync(skillMdPath)) {
     logger.error(`SKILL.md not found for skill: ${name}`);
     process.exit(ExitCode.ERROR);
     return;
   }
   const content = appendProjectState(
-    fs31.readFileSync(skillMdPath, "utf-8"),
+    fs32.readFileSync(skillMdPath, "utf-8"),
     metadata,
     projectPath,
     !!opts.path
@@ -7182,13 +7629,13 @@ async function runSkill(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createRunCommand2() {
-  return new Command60("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 Command61("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 Command61 } from "commander";
-import * as fs32 from "fs";
-import * as path50 from "path";
+import { Command as Command62 } from "commander";
+import * as fs33 from "fs";
+import * as path51 from "path";
 import { parse as parse3 } from "yaml";
 var BEHAVIORAL_REQUIRED_SECTIONS = [
   "## When to Use",
@@ -7200,11 +7647,11 @@ var BEHAVIORAL_REQUIRED_SECTIONS = [
 ];
 var KNOWLEDGE_REQUIRED_SECTIONS = ["## Instructions"];
 function validateSkillMd(name, skillMdPath, skillType, errors) {
-  if (!fs32.existsSync(skillMdPath)) {
+  if (!fs33.existsSync(skillMdPath)) {
     errors.push(`${name}: missing SKILL.md`);
     return;
   }
-  const mdContent = fs32.readFileSync(skillMdPath, "utf-8");
+  const mdContent = fs33.readFileSync(skillMdPath, "utf-8");
   if (!mdContent.trim().startsWith("# ")) {
     errors.push(`${name}/SKILL.md: must start with an h1 heading`);
   }
@@ -7229,20 +7676,20 @@ function validateSkillMd(name, skillMdPath, skillType, errors) {
   }
 }
 function validateSkillEntry(name, skillsDir, errors) {
-  const skillDir = path50.join(skillsDir, name);
-  const yamlPath = path50.join(skillDir, "skill.yaml");
-  if (!fs32.existsSync(yamlPath)) {
+  const skillDir = path51.join(skillsDir, name);
+  const yamlPath = path51.join(skillDir, "skill.yaml");
+  if (!fs33.existsSync(yamlPath)) {
     errors.push(`${name}: missing skill.yaml`);
     return false;
   }
   try {
-    const raw = fs32.readFileSync(yamlPath, "utf-8");
+    const raw = fs33.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, path50.join(skillDir, "SKILL.md"), result.data.type, errors);
+    validateSkillMd(name, path51.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)}`);
@@ -7250,15 +7697,15 @@ function validateSkillEntry(name, skillsDir, errors) {
   }
 }
 function createValidateCommand2() {
-  return new Command61("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
+  return new Command62("validate").description("Validate all skill.yaml files and SKILL.md structure").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const skillsDir = resolveSkillsDir();
-    if (!fs32.existsSync(skillsDir)) {
+    if (!fs33.existsSync(skillsDir)) {
       logger.info("No skills directory found.");
       process.exit(ExitCode.SUCCESS);
       return;
     }
-    const entries = fs32.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const entries = fs33.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     const errors = [];
     let validated = 0;
     for (const name of entries) {
@@ -7280,24 +7727,24 @@ function createValidateCommand2() {
 }
 
 // src/commands/skill/info.ts
-import { Command as Command62 } from "commander";
-import * as fs33 from "fs";
-import * as path51 from "path";
+import { Command as Command63 } from "commander";
+import * as fs34 from "fs";
+import * as path52 from "path";
 import { parse as parse4 } from "yaml";
 function loadSkillMetadata2(name) {
   const skillsDir = resolveSkillsDir();
-  const skillDir = path51.join(skillsDir, name);
-  if (!fs33.existsSync(skillDir)) {
+  const skillDir = path52.join(skillsDir, name);
+  if (!fs34.existsSync(skillDir)) {
     logger.error(`Skill not found: ${name}`);
     return { ok: false, exitCode: ExitCode.ERROR };
   }
-  const yamlPath = path51.join(skillDir, "skill.yaml");
-  if (!fs33.existsSync(yamlPath)) {
+  const yamlPath = path52.join(skillDir, "skill.yaml");
+  if (!fs34.existsSync(yamlPath)) {
     logger.error(`skill.yaml not found for skill: ${name}`);
     return { ok: false, exitCode: ExitCode.ERROR };
   }
   try {
-    const raw = fs33.readFileSync(yamlPath, "utf-8");
+    const raw = fs34.readFileSync(yamlPath, "utf-8");
     const parsed = parse4(raw);
     const result = SkillMetadataSchema.safeParse(parsed);
     if (!result.success) {
@@ -7326,7 +7773,7 @@ function printSkillInfo(skill) {
   console.log(`Persistent:  ${skill.state.persistent}`);
 }
 function createInfoCommand() {
-  return new Command62("info").description("Show metadata for a skill").argument("<name>", "Skill name (e.g., harness-tdd)").action(async (name, _opts, cmd) => {
+  return new Command63("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) {
@@ -7343,7 +7790,7 @@ function createInfoCommand() {
 }
 
 // src/commands/skill/search.ts
-import { Command as Command63 } from "commander";
+import { Command as Command64 } from "commander";
 async function runSearch(query, opts) {
   const results = await searchNpmRegistry(query, opts.registry);
   return results.filter((r) => {
@@ -7388,15 +7835,15 @@ async function runSearchAction(query, opts, globalOpts) {
   }
 }
 function createSearchCommand() {
-  return new Command63("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 Command64("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 Command64 } from "commander";
-import * as path52 from "path";
-import * as fs34 from "fs";
+import { Command as Command65 } from "commander";
+import * as path53 from "path";
+import * as fs35 from "fs";
 import YAML from "yaml";
 var KEBAB_CASE_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 function buildReadme(name, description) {
@@ -7480,22 +7927,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 ?? path52.join(process.cwd(), "agents", "skills", "claude-code");
-  const skillDir = path52.join(baseDir, name);
-  if (fs34.existsSync(skillDir)) {
+  const baseDir = opts.outputDir ?? path53.join(process.cwd(), "agents", "skills", "claude-code");
+  const skillDir = path53.join(baseDir, name);
+  if (fs35.existsSync(skillDir)) {
     throw new Error(`Skill directory already exists: ${skillDir}`);
   }
-  fs34.mkdirSync(skillDir, { recursive: true });
+  fs35.mkdirSync(skillDir, { recursive: true });
   const description = opts.description || `A community skill: ${name}`;
   const skillYaml = buildSkillYaml(name, opts);
-  const skillYamlPath = path52.join(skillDir, "skill.yaml");
-  fs34.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
+  const skillYamlPath = path53.join(skillDir, "skill.yaml");
+  fs35.writeFileSync(skillYamlPath, YAML.stringify(skillYaml));
   const skillMd = buildSkillMd(name, description);
-  const skillMdPath = path52.join(skillDir, "SKILL.md");
-  fs34.writeFileSync(skillMdPath, skillMd);
+  const skillMdPath = path53.join(skillDir, "SKILL.md");
+  fs35.writeFileSync(skillMdPath, skillMd);
   const readme = buildReadme(name, description);
-  const readmePath = path52.join(skillDir, "README.md");
-  fs34.writeFileSync(readmePath, readme);
+  const readmePath = path53.join(skillDir, "README.md");
+  fs35.writeFileSync(readmePath, readme);
   return {
     name,
     directory: skillDir,
@@ -7509,12 +7956,12 @@ function printCreateResult(name, result) {
   }
   logger.info(`
 Next steps:`);
-  logger.info(`  1. Edit ${path52.join(result.directory, "SKILL.md")} with your skill content`);
+  logger.info(`  1. Edit ${path53.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 Command64("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 Command65("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, {
@@ -7537,26 +7984,26 @@ function createCreateCommand() {
 }
 
 // src/commands/skill/publish.ts
-import { Command as Command65 } from "commander";
-import * as fs36 from "fs";
-import * as path54 from "path";
-import { execFileSync as execFileSync5 } from "child_process";
+import { Command as Command66 } from "commander";
+import * as fs37 from "fs";
+import * as path55 from "path";
+import { execFileSync as execFileSync6 } from "child_process";
 
 // src/registry/validator.ts
-import * as fs35 from "fs";
-import * as path53 from "path";
+import * as fs36 from "fs";
+import * as path54 from "path";
 import { parse as parse5 } from "yaml";
 import semver4 from "semver";
 async function validateForPublish(skillDir, registryUrl) {
   const errors = [];
-  const skillYamlPath = path53.join(skillDir, "skill.yaml");
-  if (!fs35.existsSync(skillYamlPath)) {
+  const skillYamlPath = path54.join(skillDir, "skill.yaml");
+  if (!fs36.existsSync(skillYamlPath)) {
     errors.push("skill.yaml not found. Create one with: harness skill create <name>");
     return { valid: false, errors };
   }
   let skillMeta;
   try {
-    const raw = fs35.readFileSync(skillYamlPath, "utf-8");
+    const raw = fs36.readFileSync(skillYamlPath, "utf-8");
     const parsed = parse5(raw);
     const result = SkillMetadataSchema.safeParse(parsed);
     if (!result.success) {
@@ -7578,11 +8025,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 = path53.join(skillDir, "SKILL.md");
-  if (!fs35.existsSync(skillMdPath)) {
+  const skillMdPath = path54.join(skillDir, "SKILL.md");
+  if (!fs36.existsSync(skillMdPath)) {
     errors.push("SKILL.md not found. Create it with content describing your skill.");
   } else {
-    const content = fs35.readFileSync(skillMdPath, "utf-8");
+    const content = fs36.readFileSync(skillMdPath, "utf-8");
     if (!content.includes("## When to Use")) {
       errors.push('SKILL.md must contain a "## When to Use" section.');
     }
@@ -7662,11 +8109,11 @@ ${errorList}`);
   }
   const meta = validation.skillMeta;
   const pkg = derivePackageJson(meta);
-  const pkgPath = path54.join(skillDir, "package.json");
-  fs36.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-  const readmePath = path54.join(skillDir, "README.md");
-  if (!fs36.existsSync(readmePath)) {
-    const skillMdContent = fs36.readFileSync(path54.join(skillDir, "SKILL.md"), "utf-8");
+  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 readme = `# ${pkg.name}
 
 ${meta.description}
@@ -7680,7 +8127,7 @@ harness install ${meta.name}
 ---
 
 ${skillMdContent}`;
-    fs36.writeFileSync(readmePath, readme);
+    fs37.writeFileSync(readmePath, readme);
   }
   if (opts.dryRun) {
     return {
@@ -7694,7 +8141,7 @@ ${skillMdContent}`;
   if (opts.registry) {
     publishArgs.push("--registry", opts.registry);
   }
-  execFileSync5("npm", publishArgs, {
+  execFileSync6("npm", publishArgs, {
     cwd: skillDir,
     stdio: "pipe",
     timeout: 6e4
@@ -7706,7 +8153,7 @@ ${skillMdContent}`;
   };
 }
 function createPublishCommand() {
-  return new Command65("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 Command66("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 {
@@ -7731,7 +8178,7 @@ function createPublishCommand() {
 
 // src/commands/skill/index.ts
 function createSkillCommand() {
-  const command = new Command66("skill").description("Skill management commands");
+  const command = new Command67("skill").description("Skill management commands");
   command.addCommand(createListCommand3());
   command.addCommand(createRunCommand2());
   command.addCommand(createValidateCommand2());
@@ -7744,9 +8191,9 @@ function createSkillCommand() {
 
 // src/commands/snapshot.ts
 init_dist();
-import { Command as Command67 } from "commander";
+import { Command as Command68 } from "commander";
 import { execSync as execSync5 } from "child_process";
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 function getCommitHash3(cwd) {
   try {
     return execSync5("git rev-parse --short HEAD", { cwd, encoding: "utf-8" }).toString().trim();
@@ -7771,9 +8218,9 @@ function formatDelta(delta) {
 function directionSymbol(direction) {
   switch (direction) {
     case "improving":
-      return chalk11.green("improving");
+      return chalk12.green("improving");
     case "declining":
-      return chalk11.red("declining");
+      return chalk12.red("declining");
     case "stable":
       return "=";
   }
@@ -7926,7 +8373,7 @@ function registerListCommand(parent) {
   });
 }
 function createSnapshotCommand() {
-  const command = new Command67("snapshot").description("Architecture timeline snapshot commands");
+  const command = new Command68("snapshot").description("Architecture timeline snapshot commands");
   registerCaptureCommand(command);
   registerTrendsCommand(command);
   registerListCommand(command);
@@ -7934,12 +8381,12 @@ function createSnapshotCommand() {
 }
 
 // src/commands/state/index.ts
-import { Command as Command72 } from "commander";
+import { Command as Command73 } from "commander";
 
 // src/commands/state/show.ts
 init_dist();
-import { Command as Command68 } from "commander";
-import * as path55 from "path";
+import { Command as Command69 } from "commander";
+import * as path56 from "path";
 function printStateText(state, stream) {
   if (stream) console.log(`Stream:         ${stream}`);
   console.log(`Schema Version: ${state.schemaVersion}`);
@@ -7963,9 +8410,9 @@ function printStateProgress(progress) {
   }
 }
 function createShowCommand() {
-  return new Command68("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 Command69("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(path55.resolve(opts.path), opts.stream);
+    const result = await loadState(path56.resolve(opts.path), opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
       process.exit(ExitCode.ERROR);
@@ -7981,10 +8428,10 @@ function createShowCommand() {
 
 // src/commands/state/reset.ts
 init_dist();
-import { Command as Command69 } from "commander";
-import * as fs37 from "fs";
-import * as path56 from "path";
-import * as readline2 from "readline";
+import { Command as Command70 } from "commander";
+import * as fs38 from "fs";
+import * as path57 from "path";
+import * as readline3 from "readline";
 async function resolveStatePath(projectPath, stream) {
   if (stream) {
     const streamResult = await resolveStreamPath(projectPath, { stream });
@@ -7992,22 +8439,22 @@ async function resolveStatePath(projectPath, stream) {
       logger.error(streamResult.error.message);
       process.exit(ExitCode.ERROR);
     }
-    return path56.join(streamResult.value, "state.json");
+    return path57.join(streamResult.value, "state.json");
   }
-  return path56.join(projectPath, ".harness", "state.json");
+  return path57.join(projectPath, ".harness", "state.json");
 }
 async function confirmReset() {
-  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve36) => {
-    rl.question("Reset project state? This cannot be undone. [y/N] ", resolve36);
+  const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve37) => {
+    rl.question("Reset project state? This cannot be undone. [y/N] ", resolve37);
   });
   rl.close();
   return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
 }
 async function runReset(opts) {
-  const projectPath = path56.resolve(opts.path);
+  const projectPath = path57.resolve(opts.path);
   const statePath = await resolveStatePath(projectPath, opts.stream);
-  if (!fs37.existsSync(statePath)) {
+  if (!fs38.existsSync(statePath)) {
     logger.info("No state file found. Nothing to reset.");
     process.exit(ExitCode.SUCCESS);
   }
@@ -8016,7 +8463,7 @@ async function runReset(opts) {
     process.exit(ExitCode.SUCCESS);
   }
   try {
-    fs37.unlinkSync(statePath);
+    fs38.unlinkSync(statePath);
     logger.success("Project state reset.");
   } catch (e) {
     logger.error(`Failed to reset state: ${e instanceof Error ? e.message : String(e)}`);
@@ -8025,16 +8472,16 @@ async function runReset(opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createResetCommand() {
-  return new Command69("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 Command70("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 Command70 } from "commander";
-import * as path57 from "path";
+import { Command as Command71 } from "commander";
+import * as path58 from "path";
 function createLearnCommand() {
-  return new Command70("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 = path57.resolve(opts.path);
+  return new Command71("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);
     const result = await appendLearning(projectPath, message, void 0, void 0, opts.stream);
     if (!result.ok) {
       logger.error(result.error.message);
@@ -8048,10 +8495,10 @@ function createLearnCommand() {
 
 // src/commands/state/streams.ts
 init_dist();
-import { Command as Command71 } from "commander";
-import * as path58 from "path";
+import { Command as Command72 } from "commander";
+import * as path59 from "path";
 async function runListStreams(opts, globalOpts) {
-  const projectPath = path58.resolve(opts.path);
+  const projectPath = path59.resolve(opts.path);
   const indexResult = await loadStreamIndex(projectPath);
   const result = await listStreams(projectPath);
   if (!result.ok) {
@@ -8072,7 +8519,7 @@ async function runListStreams(opts, globalOpts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runCreateStream(name, opts) {
-  const result = await createStream(path58.resolve(opts.path), name, opts.branch);
+  const result = await createStream(path59.resolve(opts.path), name, opts.branch);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -8081,7 +8528,7 @@ async function runCreateStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runArchiveStream(name, opts) {
-  const result = await archiveStream(path58.resolve(opts.path), name);
+  const result = await archiveStream(path59.resolve(opts.path), name);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -8090,7 +8537,7 @@ async function runArchiveStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 async function runActivateStream(name, opts) {
-  const result = await setActiveStream(path58.resolve(opts.path), name);
+  const result = await setActiveStream(path59.resolve(opts.path), name);
   if (!result.ok) {
     logger.error(result.error.message);
     process.exit(ExitCode.ERROR);
@@ -8099,7 +8546,7 @@ async function runActivateStream(name, opts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createStreamsCommand() {
-  const command = new Command71("streams").description("Manage state streams");
+  const command = new Command72("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));
@@ -8109,7 +8556,7 @@ function createStreamsCommand() {
 
 // src/commands/state/index.ts
 function createStateCommand() {
-  const command = new Command72("state").description("Project state management commands");
+  const command = new Command73("state").description("Project state management commands");
   command.addCommand(createShowCommand());
   command.addCommand(createResetCommand());
   command.addCommand(createLearnCommand());
@@ -8118,9 +8565,9 @@ function createStateCommand() {
 }
 
 // src/commands/sync-analyses.ts
-import * as fs38 from "fs";
-import * as path59 from "path";
-import { Command as Command73 } from "commander";
+import * as fs39 from "fs";
+import * as path60 from "path";
+import { Command as Command74 } from "commander";
 init_dist();
 function isValidRecord(record) {
   return typeof record.issueId === "string" && !!record.issueId && typeof record.identifier === "string" && !!record.identifier && typeof record.analyzedAt === "string" && !/[/\\]/.test(record.issueId);
@@ -8146,7 +8593,7 @@ function extractAnalysisFromComments(comments) {
   return null;
 }
 function bootstrapTrackerCommand2(opts, verb) {
-  const projectPath = path59.resolve(opts.dir);
+  const projectPath = path60.resolve(opts.dir);
   const trackerConfig = loadTrackerSyncConfig(projectPath);
   if (!trackerConfig) {
     logger.error(`No tracker config found in harness.config.json. Cannot ${verb}.`);
@@ -8158,8 +8605,8 @@ function bootstrapTrackerCommand2(opts, verb) {
     );
     return null;
   }
-  const projectEnvPath = path59.join(projectPath, ".env");
-  if (fs38.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
+  const projectEnvPath = path60.join(projectPath, ".env");
+  if (fs39.existsSync(projectEnvPath) && !process.env.GITHUB_TOKEN) {
     __require("dotenv").config({ path: projectEnvPath });
   }
   const token = process.env.GITHUB_TOKEN;
@@ -8170,13 +8617,13 @@ function bootstrapTrackerCommand2(opts, verb) {
   return { token, projectPath, trackerConfig };
 }
 function loadRoadmapFeatures(projectPath) {
-  const roadmapFile = path59.join(projectPath, "docs", "roadmap.md");
-  if (!fs38.existsSync(roadmapFile)) {
+  const roadmapFile = path60.join(projectPath, "docs", "roadmap.md");
+  if (!fs39.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(fs38.readFileSync(roadmapFile, "utf-8"));
+  const roadmapParsed = parseRoadmap(fs39.readFileSync(roadmapFile, "utf-8"));
   if (!roadmapParsed.ok) {
     logger.error("Failed to parse docs/roadmap.md");
     return null;
@@ -8227,9 +8674,9 @@ async function runSyncAnalyses(opts) {
     return;
   }
   const { AnalysisArchive, loadPublishedIndex: loadPublishedIndex2, savePublishedIndex: savePublishedIndex2 } = await import("@harness-engineering/orchestrator");
-  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-CPKL5Y2R.js");
+  const { GitHubIssuesSyncAdapter: GitHubIssuesSyncAdapter2 } = await import("./dist-46VOJIG4.js");
   const adapter = new GitHubIssuesSyncAdapter2({ token, config: trackerConfig });
-  const archive = new AnalysisArchive(path59.join(projectPath, ".harness", "analyses"));
+  const archive = new AnalysisArchive(path60.join(projectPath, ".harness", "analyses"));
   const publishedIndex = loadPublishedIndex2(projectPath);
   const { syncedCount, skippedCount, warnCount } = await syncFeatureAnalyses(
     features,
@@ -8249,7 +8696,7 @@ async function runSyncAnalyses(opts) {
   }
 }
 function createSyncAnalysesCommand() {
-  const command = new Command73("sync-analyses").description(
+  const command = new Command74("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 {
@@ -8264,7 +8711,7 @@ function createSyncAnalysesCommand() {
 
 // src/commands/taint.ts
 init_dist();
-import { Command as Command74 } from "commander";
+import { Command as Command75 } from "commander";
 function getProjectRoot() {
   return process.cwd();
 }
@@ -8336,28 +8783,28 @@ function registerStatusCommand(taint) {
   });
 }
 function createTaintCommand() {
-  const taint = new Command74("taint").description("Manage sentinel session taint state");
+  const taint = new Command75("taint").description("Manage sentinel session taint state");
   registerClearCommand(taint);
   registerStatusCommand(taint);
   return taint;
 }
 
 // src/commands/telemetry/index.ts
-import { Command as Command78 } from "commander";
+import { Command as Command79 } from "commander";
 
 // src/commands/telemetry/identify.ts
 init_dist();
-import { Command as Command75 } from "commander";
-import * as fs39 from "fs";
-import * as path60 from "path";
+import { Command as Command76 } from "commander";
+import * as fs40 from "fs";
+import * as path61 from "path";
 function telemetryFilePath(cwd) {
-  return path60.join(cwd, ".harness", "telemetry.json");
+  return path61.join(cwd, ".harness", "telemetry.json");
 }
 function writeTelemetryFile(cwd, data) {
   const filePath = telemetryFilePath(cwd);
-  const dir = path60.dirname(filePath);
-  fs39.mkdirSync(dir, { recursive: true });
-  fs39.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  const dir = path61.dirname(filePath);
+  fs40.mkdirSync(dir, { recursive: true });
+  fs40.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 var IDENTITY_FIELDS = ["project", "team", "alias"];
 function applyIdentityFields(opts, identity) {
@@ -8371,7 +8818,7 @@ function printIdentity(identity) {
   }
 }
 function createIdentifyCommand() {
-  const cmd = new Command75("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 Command76("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: {} });
@@ -8396,7 +8843,7 @@ function createIdentifyCommand() {
 
 // src/commands/telemetry/status.ts
 init_dist();
-import { Command as Command76 } from "commander";
+import { Command as Command77 } from "commander";
 function gatherEnvOverrides() {
   const overrides = {};
   if (process.env.DO_NOT_TRACK) overrides.DO_NOT_TRACK = process.env.DO_NOT_TRACK;
@@ -8438,7 +8885,7 @@ function printHumanStatus(result) {
   printEnvOverrides(result.envOverrides);
 }
 function createStatusCommand() {
-  const cmd = new Command76("status").description("Show current telemetry consent state, install ID, and identity").option("--json", "Output as JSON").action((opts) => {
+  const cmd = new Command77("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);
@@ -8471,20 +8918,20 @@ function createStatusCommand() {
 
 // src/commands/telemetry/test.ts
 init_dist();
-import { Command as Command77 } from "commander";
+import { Command as Command78 } from "commander";
 
 // src/bin/command-telemetry.ts
-import { existsSync as existsSync36, readFileSync as readFileSync25, mkdirSync as mkdirSync15, appendFileSync, writeFileSync as writeFileSync18 } from "fs";
-import { join as join46, parse as parsePath, resolve as resolve33 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync26, mkdirSync as mkdirSync16, appendFileSync, writeFileSync as writeFileSync19 } from "fs";
+import { join as join47, parse as parsePath, resolve as resolve34 } 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 = resolve33(cwd);
+  let dir = resolve34(cwd);
   const { root } = parsePath(dir);
   while (dir !== root) {
-    if (existsSync36(join46(dir, "harness.config.json"))) return dir;
-    dir = resolve33(dir, "..");
+    if (existsSync37(join47(dir, "harness.config.json"))) return dir;
+    dir = resolve34(dir, "..");
   }
   return cwd;
 }
@@ -8521,8 +8968,8 @@ function resolveCommandName(cmd) {
 }
 function writeCommandRecordSync(cwd, command, duration, outcome) {
   try {
-    const metricsDir = join46(cwd, ".harness", "metrics");
-    mkdirSync15(metricsDir, { recursive: true });
+    const metricsDir = join47(cwd, ".harness", "metrics");
+    mkdirSync16(metricsDir, { recursive: true });
     const record = {
       skill: command,
       session: `cli-${Date.now()}`,
@@ -8531,16 +8978,16 @@ function writeCommandRecordSync(cwd, command, duration, outcome) {
       outcome,
       phasesReached: []
     };
-    const adoptionFile = join46(metricsDir, "adoption.jsonl");
+    const adoptionFile = join47(metricsDir, "adoption.jsonl");
     appendFileSync(adoptionFile, JSON.stringify(record) + "\n");
   } catch {
   }
 }
 function isTelemetryDisabledByConfig(cwd) {
-  const configPath = join46(cwd, "harness.config.json");
-  if (!existsSync36(configPath)) return false;
+  const configPath = join47(cwd, "harness.config.json");
+  if (!existsSync37(configPath)) return false;
   try {
-    const config = JSON.parse(readFileSync25(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync26(configPath, "utf-8"));
     return config?.telemetry?.enabled === false;
   } catch {
     return false;
@@ -8552,11 +8999,11 @@ function isTelemetryOptedOut(cwd) {
 }
 function flushTelemetryBackground(cwd) {
   try {
-    const adoptionFile = join46(cwd, ".harness", "metrics", "adoption.jsonl");
-    if (!existsSync36(adoptionFile)) return;
+    const adoptionFile = join47(cwd, ".harness", "metrics", "adoption.jsonl");
+    if (!existsSync37(adoptionFile)) return;
     if (isTelemetryOptedOut(cwd)) return;
-    const reporterPath = join46(cwd, ".harness", "hooks", "telemetry-reporter.js");
-    if (!existsSync36(reporterPath)) return;
+    const reporterPath = join47(cwd, ".harness", "hooks", "telemetry-reporter.js");
+    if (!existsSync37(reporterPath)) return;
     const child = spawn2(process.execPath, [reporterPath], {
       cwd,
       stdio: ["pipe", "ignore", "ignore"],
@@ -8593,7 +9040,7 @@ function reportTestSuccess(status, distinctId, identity) {
   if (identity.team) logger.info(`  team:        ${identity.team}`);
 }
 function createTestCommand() {
-  return new Command77("test").description("Send a test event to PostHog and verify connectivity").action(async () => {
+  return new Command78("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) {
@@ -8630,7 +9077,7 @@ function createTestCommand() {
 
 // src/commands/telemetry/index.ts
 function createTelemetryCommand() {
-  const command = new Command78("telemetry").description("Telemetry identity and status management");
+  const command = new Command79("telemetry").description("Telemetry identity and status management");
   command.addCommand(createIdentifyCommand());
   command.addCommand(createStatusCommand());
   command.addCommand(createTestCommand());
@@ -8638,8 +9085,8 @@ function createTelemetryCommand() {
 }
 
 // src/commands/traceability.ts
-import { Command as Command79 } from "commander";
-import chalk12 from "chalk";
+import { Command as Command80 } from "commander";
+import chalk13 from "chalk";
 function confidenceLabel(maxConfidence) {
   if (maxConfidence >= 0.8) return "explicit";
   if (maxConfidence > 0) return "inferred";
@@ -8648,13 +9095,13 @@ function confidenceLabel(maxConfidence) {
 function statusIcon(status) {
   switch (status) {
     case "full":
-      return chalk12.green("\u2713 full");
+      return chalk13.green("\u2713 full");
     case "code-only":
-      return chalk12.yellow("\u25D0 code-only");
+      return chalk13.yellow("\u25D0 code-only");
     case "test-only":
-      return chalk12.yellow("\u25D0 test-only");
+      return chalk13.yellow("\u25D0 test-only");
     case "none":
-      return chalk12.red("\u2717 none");
+      return chalk13.red("\u2717 none");
     default:
       return status;
   }
@@ -8701,14 +9148,14 @@ function handleEmptyResults(mode) {
 }
 function printResultTable(result, mode) {
   const specLabel = result.specPath || result.featureName || "Unknown";
-  console.log(`  ${chalk12.cyan(specLabel)} ${chalk12.dim(`(${result.summary.total} requirements)`)}`);
+  console.log(`  ${chalk13.cyan(specLabel)} ${chalk13.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 = chalk12.dim(
+  const header = chalk13.dim(
     `  ${pad("#", numWidth)}${pad("Requirement", nameWidth)}${pad("Code", codeWidth)}${pad("Tests", testWidth)}${pad("Confidence", confWidth)}Status`
   );
   console.log(header);
@@ -8737,10 +9184,10 @@ function printRequirementRows(requirements, mode, cols) {
     );
     if (mode === OutputMode.VERBOSE) {
       for (const f of req.codeFiles) {
-        console.log(chalk12.dim(`        code: ${f.path} (${f.method})`));
+        console.log(chalk13.dim(`        code: ${f.path} (${f.method})`));
       }
       for (const f of req.testFiles) {
-        console.log(chalk12.dim(`        test: ${f.path} (${f.method})`));
+        console.log(chalk13.dim(`        test: ${f.path} (${f.method})`));
       }
     }
   }
@@ -8751,7 +9198,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(
-    `  ${chalk12.bold("Coverage:")} ${fullyPct}% fully traced (${s.fullyTraced}/${s.total}), ${codePct}% with code (${s.withCode}/${s.total}), ${testPct}% with tests (${s.withTests}/${s.total})`
+    `  ${chalk13.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) {
@@ -8759,7 +9206,7 @@ async function runTraceability(options) {
   const projectPath = process.cwd();
   const store = await loadGraphStore(projectPath);
   if (!store) handleNoStore(mode);
-  const graphModule = await import("./dist-BZS2XRLG.js");
+  const graphModule = await import("./dist-BP6E6QGG.js");
   const filterOptions = buildFilterOptions(options);
   const results = graphModule.queryTraceability(store, filterOptions);
   if (results.length === 0) handleEmptyResults(mode);
@@ -8767,14 +9214,14 @@ async function runTraceability(options) {
     console.log(JSON.stringify(results, null, 2));
   } else {
     console.log("");
-    console.log(chalk12.bold("Spec-to-Implementation Traceability"));
+    console.log(chalk13.bold("Spec-to-Implementation Traceability"));
     console.log("");
     for (const result of results) printResultTable(result, mode);
   }
   process.exit(ExitCode.SUCCESS);
 }
 function createTraceabilityCommand() {
-  return new Command79("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 Command80("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,
@@ -8787,15 +9234,15 @@ function createTraceabilityCommand() {
 }
 
 // src/commands/uninstall.ts
-import * as path61 from "path";
-import { Command as Command80 } from "commander";
+import * as path62 from "path";
+import { Command as Command81 } from "commander";
 async function runUninstall(skillName, options) {
   const packageName = resolvePackageName(skillName);
   const shortName = extractSkillName(packageName);
   const globalDir = resolveGlobalSkillsDir();
-  const skillsDir = path61.dirname(globalDir);
-  const communityBase = path61.join(skillsDir, "community");
-  const lockfilePath = path61.join(communityBase, "skills-lock.json");
+  const skillsDir = path62.dirname(globalDir);
+  const communityBase = path62.join(skillsDir, "community");
+  const lockfilePath = path62.join(communityBase, "skills-lock.json");
   const lockfile = readLockfile2(lockfilePath);
   const entry = lockfile.skills[packageName];
   if (!entry) {
@@ -8825,7 +9272,7 @@ async function runUninstall(skillName, options) {
   return result;
 }
 function createUninstallCommand() {
-  const cmd = new Command80("uninstall");
+  const cmd = new Command81("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);
@@ -8845,9 +9292,9 @@ function createUninstallCommand() {
 
 // src/commands/uninstall-constraints.ts
 init_dist();
-import * as fs40 from "fs/promises";
-import * as path62 from "path";
-import { Command as Command81 } from "commander";
+import * as fs41 from "fs/promises";
+import * as path63 from "path";
+import { Command as Command82 } from "commander";
 async function runUninstallConstraints(options) {
   const { packageName, configPath, lockfilePath } = options;
   const lockfileResult = await readLockfile(lockfilePath);
@@ -8867,7 +9314,7 @@ async function runUninstallConstraints(options) {
   }
   let localConfig;
   try {
-    const raw = await fs40.readFile(configPath, "utf-8");
+    const raw = await fs41.readFile(configPath, "utf-8");
     localConfig = JSON.parse(raw);
   } catch (err) {
     return {
@@ -8904,11 +9351,11 @@ async function runUninstallConstraints(options) {
   };
 }
 function createUninstallConstraintsCommand() {
-  const cmd = new Command81("uninstall-constraints");
+  const cmd = new Command82("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 = path62.resolve(opts.config);
+      configPath = path63.resolve(opts.config);
     } else {
       const found = findConfigFile();
       if (!found.ok) {
@@ -8917,8 +9364,8 @@ function createUninstallConstraintsCommand() {
       }
       configPath = found.value;
     }
-    const projectRoot = path62.dirname(configPath);
-    const lockfilePath = path62.join(projectRoot, ".harness", "constraints.lock.json");
+    const projectRoot = path63.dirname(configPath);
+    const lockfilePath = path63.join(projectRoot, ".harness", "constraints.lock.json");
     const result = await runUninstallConstraints({
       packageName: name,
       configPath,
@@ -8943,13 +9390,13 @@ function createUninstallConstraintsCommand() {
 }
 
 // src/commands/update.ts
-import { Command as Command82 } from "commander";
-import { execFile, execFileSync as execFileSync6 } from "child_process";
-import { realpathSync, existsSync as existsSync37, readFileSync as readFileSync26 } from "fs";
-import { join as join49 } from "path";
+import { Command as Command83 } from "commander";
+import { execFile, execFileSync as execFileSync7 } from "child_process";
+import { realpathSync, existsSync as existsSync38, readFileSync as readFileSync27 } from "fs";
+import { join as join50 } from "path";
 import { promisify } from "util";
-import readline3 from "readline";
-import chalk13 from "chalk";
+import readline4 from "readline";
+import chalk14 from "chalk";
 function detectPackageManager() {
   try {
     const argv1 = process.argv[1];
@@ -8978,7 +9425,7 @@ async function getLatestVersionAsync(pkg) {
 function getInstalledVersions(pm, packages) {
   const versions = {};
   try {
-    const output = execFileSync6(pm, ["list", "-g", "--json"], {
+    const output = execFileSync7(pm, ["list", "-g", "--json"], {
       encoding: "utf-8",
       timeout: 15e3
     });
@@ -8996,7 +9443,7 @@ function getInstalledVersions(pm, packages) {
 }
 function getInstalledPackages(pm) {
   try {
-    const output = execFileSync6(pm, ["list", "-g", "--json"], {
+    const output = execFileSync7(pm, ["list", "-g", "--json"], {
       encoding: "utf-8",
       timeout: 15e3
     });
@@ -9007,15 +9454,15 @@ function getInstalledPackages(pm) {
     return ["@harness-engineering/cli", "@harness-engineering/core"];
   }
 }
-function prompt2(question) {
-  const rl = readline3.createInterface({
+function prompt3(question) {
+  const rl = readline4.createInterface({
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve36) => {
+  return new Promise((resolve37) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve36(answer.trim().toLowerCase());
+      resolve37(answer.trim().toLowerCase());
     });
   });
 }
@@ -9030,12 +9477,12 @@ async function ensureTelemetryIfNeeded() {
 }
 function refreshHooks() {
   const cwd = process.cwd();
-  const configPath = join49(cwd, "harness.config.json");
-  if (!existsSync37(configPath)) return;
+  const configPath = join50(cwd, "harness.config.json");
+  if (!existsSync38(configPath)) return;
   let profile = "standard";
-  const profilePath = join49(cwd, ".harness", "hooks", "profile.json");
+  const profilePath = join50(cwd, ".harness", "hooks", "profile.json");
   try {
-    const data = JSON.parse(readFileSync26(profilePath, "utf-8"));
+    const data = JSON.parse(readFileSync27(profilePath, "utf-8"));
     if (data.profile && ["minimal", "standard", "strict"].includes(data.profile)) {
       profile = data.profile;
     }
@@ -9052,27 +9499,27 @@ function refreshHooks() {
 function runLocalGraphScan() {
   try {
     logger.info("Scanning codebase to rebuild knowledge graph...");
-    execFileSync6("harness", ["graph", "scan", "."], { stdio: "inherit" });
+    execFileSync7("harness", ["graph", "scan", "."], { stdio: "inherit" });
   } catch {
     logger.warn("Graph scan failed. Run manually:");
-    console.log(`  ${chalk13.cyan("harness graph scan .")}`);
+    console.log(`  ${chalk14.cyan("harness graph scan .")}`);
   }
 }
 async function offerRegeneration() {
   console.log("");
-  const regenAnswer = await prompt2(
+  const regenAnswer = await prompt3(
     "Regenerate slash commands, agent definitions, and knowledge graph? (Y/n) "
   );
   if (regenAnswer === "n" || regenAnswer === "no") return;
-  const scopeAnswer = await prompt2("Generate for (G)lobal or (l)ocal project? (G/l) ");
+  const scopeAnswer = await prompt3("Generate for (G)lobal or (l)ocal project? (G/l) ");
   const isGlobal = scopeAnswer !== "l" && scopeAnswer !== "local";
   try {
-    execFileSync6("harness", ["generate", ...isGlobal ? ["--global"] : []], {
+    execFileSync7("harness", ["generate", ...isGlobal ? ["--global"] : []], {
       stdio: "inherit"
     });
   } catch {
     logger.warn("Generation failed. Run manually:");
-    console.log(`  ${chalk13.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
+    console.log(`  ${chalk14.cyan(`harness generate${isGlobal ? " --global" : ""}`)}`);
   }
   if (!isGlobal) {
     runLocalGraphScan();
@@ -9135,8 +9582,8 @@ async function runUpdateAction(opts, globalOpts) {
     console.log("");
     for (const { pkg, current, latest } of outdated) {
       const shortName = pkg.replace("@harness-engineering/", "");
-      const currentStr = current ? chalk13.dim(`v${current}`) : chalk13.dim("not installed");
-      logger.info(`${shortName}: ${currentStr} \u2192 ${chalk13.green(`v${latest}`)}`);
+      const currentStr = current ? chalk14.dim(`v${current}`) : chalk14.dim("not installed");
+      logger.info(`${shortName}: ${currentStr} \u2192 ${chalk14.green(`v${latest}`)}`);
     }
     console.log("");
   }
@@ -9146,13 +9593,13 @@ async function runUpdateAction(opts, globalOpts) {
   }
   try {
     logger.info("Updating packages...");
-    execFileSync6(pm, ["install", "-g", ...installPkgs], { stdio: "inherit", timeout: 12e4 });
+    execFileSync7(pm, ["install", "-g", ...installPkgs], { stdio: "inherit", timeout: 12e4 });
     console.log("");
     logger.success("Update complete");
   } catch {
     console.log("");
     logger.error("Update failed. You can try manually:");
-    console.log(`  ${chalk13.cyan(installCmd)}`);
+    console.log(`  ${chalk14.cyan(installCmd)}`);
     process.exit(ExitCode.ERROR);
   }
   refreshHooks();
@@ -9161,7 +9608,7 @@ async function runUpdateAction(opts, globalOpts) {
   process.exit(ExitCode.SUCCESS);
 }
 function createUpdateCommand() {
-  return new Command82("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 Command83("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) => {
@@ -9171,9 +9618,9 @@ function createUpdateCommand() {
 }
 
 // src/commands/usage.ts
-import { Command as Command83 } from "commander";
+import { Command as Command84 } from "commander";
 async function loadAndPriceRecords(cwd, includeClaudeSessions = false) {
-  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-CPKL5Y2R.js");
+  const { readCostRecords, loadPricingData, calculateCost, parseCCRecords } = await import("./dist-46VOJIG4.js");
   const records = readCostRecords(cwd);
   if (includeClaudeSessions) {
     const ccRecords = parseCCRecords();
@@ -9266,7 +9713,7 @@ function registerDailyCommand(usage) {
       else logger.info("No usage data found. Run some harness sessions first.");
       return;
     }
-    const { aggregateByDay } = await import("./dist-CPKL5Y2R.js");
+    const { aggregateByDay } = await import("./dist-46VOJIG4.js");
     const limited = aggregateByDay(records).slice(0, days);
     if (globalOpts.json) {
       console.log(
@@ -9295,7 +9742,7 @@ function registerSessionsCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-CPKL5Y2R.js");
+    const { aggregateBySession } = await import("./dist-46VOJIG4.js");
     const sessionData = aggregateBySession(records);
     const limited = sessionData.slice(0, limit);
     if (globalOpts.json) {
@@ -9375,7 +9822,7 @@ function registerSessionCommand(usage) {
       cwd,
       globalOpts.includeClaudeSessions
     );
-    const { aggregateBySession } = await import("./dist-CPKL5Y2R.js");
+    const { aggregateBySession } = await import("./dist-46VOJIG4.js");
     const sessionData = aggregateBySession(records);
     const match = sessionData.find((s) => s.sessionId === id);
     if (!match) {
@@ -9410,7 +9857,7 @@ function registerLatestCommand(usage) {
       }
       return;
     }
-    const { aggregateBySession } = await import("./dist-CPKL5Y2R.js");
+    const { aggregateBySession } = await import("./dist-46VOJIG4.js");
     const sessionData = aggregateBySession(records);
     const latest = sessionData[0];
     if (!latest) {
@@ -9436,7 +9883,7 @@ function registerLatestCommand(usage) {
   });
 }
 function createUsageCommand() {
-  const usage = new Command83("usage").description("Token usage and cost tracking");
+  const usage = new Command84("usage").description("Token usage and cost tracking");
   usage.option(
     "--include-claude-sessions",
     "Include Claude Code session data from ~/.claude/projects/"
@@ -9451,15 +9898,15 @@ function createUsageCommand() {
 // src/commands/validate.ts
 init_dist();
 init_dist();
-import { Command as Command84 } from "commander";
-import * as path63 from "path";
+import { Command as Command85 } from "commander";
+import * as path64 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 ? path63.dirname(path63.resolve(options.configPath)) : process.cwd());
+  const cwd = options.cwd ?? (options.configPath ? path64.dirname(path64.resolve(options.configPath)) : process.cwd());
   const result = {
     valid: true,
     checks: {
@@ -9469,7 +9916,7 @@ async function runValidate(options) {
     },
     issues: []
   };
-  const agentsMapPath = path63.resolve(cwd, config.agentsMapPath);
+  const agentsMapPath = path64.resolve(cwd, config.agentsMapPath);
   const agentsResult = await validateAgentsMap(agentsMapPath);
   if (agentsResult.ok) {
     result.checks.agentsMap = true;
@@ -9534,11 +9981,11 @@ function resolveValidateMode(globalOpts) {
   return OutputMode.TEXT;
 }
 async function printCrossCheckWarnings(mode) {
-  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-SPL3H4O5.js");
+  const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-LUQYIA46.js");
   const cwd = process.cwd();
   const crossResult = await runCrossCheck2({
-    specsDir: path63.join(cwd, "docs", "specs"),
-    plansDir: path63.join(cwd, "docs", "plans"),
+    specsDir: path64.join(cwd, "docs", "specs"),
+    plansDir: path64.join(cwd, "docs", "plans"),
     projectPath: cwd
   });
   if (!crossResult.ok || crossResult.value.warnings === 0) return;
@@ -9550,7 +9997,7 @@ async function printCrossCheckWarnings(mode) {
   ${crossResult.value.warnings} warnings`);
 }
 function createValidateCommand3() {
-  const command = new Command84("validate").description("Run all validation checks").option("--cross-check", "Run cross-artifact consistency validation").option(
+  const command = new Command85("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()));
@@ -9600,8 +10047,8 @@ Agent configs checked via ${engineLabel}${note}`);
 // src/commands/_registry.ts
 var commandCreators = [
   createAddCommand,
-  createAdviseSkillsCommand,
   createAdoptionCommand,
+  createAdviseSkillsCommand,
   createAgentCommand,
   createAuditProtectedCommand,
   createBlueprintCommand,
@@ -9633,6 +10080,7 @@ var commandCreators = [
   createLearningsCommand,
   createLinterCommand,
   createMcpCommand,
+  createMigrateCommand,
   createOrchestratorCommand,
   createPerfCommand,
   createPersonaCommand,
@@ -9661,7 +10109,7 @@ var commandCreators = [
 
 // src/index.ts
 function createProgram() {
-  const program = new Command85();
+  const program = new Command86();
   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());