@harness-engineering/cli 2.2.0 → 2.3.0

package/dist/{chunk-K4WRQTEF.js → chunk-4DWOMGUM.js}

@@ -19,7 +19,7 @@ import {
   __export
 } from "./chunk-KFQGP6VL.js";
 
-// ../core/dist/chunk-CE225WRK.mjs
+// ../core/dist/chunk-NC4RPKD4.mjs
 import { z } from "zod";
 import { createHash } from "crypto";
 import { minimatch } from "minimatch";
@@ -69,17 +69,17 @@ function resolveFileToLayer(file, layers) {
   }
   return void 0;
 }
-async function fileExists(path42) {
+async function fileExists(path46) {
   try {
-    await accessAsync(path42, constants.F_OK);
+    await accessAsync(path46, constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function readFileContent(path42) {
+async function readFileContent(path46) {
   try {
-    const content = await readFileAsync(path42, "utf-8");
+    const content = await readFileAsync(path46, "utf-8");
     return Ok(content);
   } catch (error) {
     return Err(error);
@@ -485,9 +485,9 @@ async function resolveWasmPath(grammarName) {
   const { createRequire } = await import("module");
   const require2 = createRequire(import.meta.url ?? __filename);
   const pkgPath = require2.resolve("tree-sitter-wasms/package.json");
-  const path42 = await import("path");
-  const pkgDir = path42.dirname(pkgPath);
-  return path42.join(pkgDir, "out", `${grammarName}.wasm`);
+  const path46 = await import("path");
+  const pkgDir = path46.dirname(pkgPath);
+  return path46.join(pkgDir, "out", `${grammarName}.wasm`);
 }
 async function loadLanguage(lang) {
   const grammarName = GRAMMAR_MAP[lang];
@@ -1745,11 +1745,16 @@ async function toHaveMaxDepDepth(received, maxDepth) {
     message: () => pass ? `Expected dependency depth in '${received.scope}' to exceed ${maxDepth} but it was ${maxActual}` : `Module '${received.scope}' has dependency depth ${maxActual} (limit: ${maxDepth})`
   };
 }
-var ArchMetricCategorySchema, ViolationSchema, MetricResultSchema, CategoryBaselineSchema, ArchBaselineSchema, CategoryRegressionSchema, ArchDiffResultSchema, ThresholdConfigSchema, ArchConfigSchema, ConstraintRuleSchema, ViolationSnapshotSchema, ViolationHistorySchema, EmergenceConfidenceSchema, EmergentConstraintSuggestionSchema, EmergenceResultSchema, accessAsync, readFileAsync, EXTENSION_BY_LANG, JS_EXT_FALLBACKS, CircularDepsCollector, TypeScriptParser, EXTENSION_MAP, parserCache, initialized, GRAMMAR_MAP, TOP_LEVEL_TYPES, METHOD_TYPES, IDENTIFIER_TYPES, NAME_EXTRACTORS, pythonStrategy, goStrategy, RUST_USE_ARG_TYPES, RUST_PUB_ITEM_TYPES, rustStrategy, JAVA_IMPORT_TYPES, JAVA_EXPORT_TYPES, javaStrategy, STRATEGIES, TreeSitterParser, ParserRegistry, defaultRegistry, LayerViolationCollector, ArchBaselineManager, DEFAULT_THRESHOLDS, FUNCTION_PATTERNS, DECISION_PATTERNS, ComplexityCollector, DEFAULT_THRESHOLDS2, CouplingCollector, ForbiddenImportCollector, ModuleSizeCollector, DepDepthCollector, defaultCollectors, archMatchers;
-var init_chunk_CE225WRK = __esm({
-  "../core/dist/chunk-CE225WRK.mjs"() {
+var __defProp, __export2, ArchMetricCategorySchema, ViolationSchema, MetricResultSchema, CategoryBaselineSchema, ArchBaselineSchema, CategoryRegressionSchema, ArchDiffResultSchema, ThresholdConfigSchema, ArchConfigSchema, ConstraintRuleSchema, ViolationSnapshotSchema, ViolationHistorySchema, EmergenceConfidenceSchema, EmergentConstraintSuggestionSchema, EmergenceResultSchema, accessAsync, readFileAsync, EXTENSION_BY_LANG, JS_EXT_FALLBACKS, CircularDepsCollector, TypeScriptParser, EXTENSION_MAP, parserCache, initialized, GRAMMAR_MAP, TOP_LEVEL_TYPES, METHOD_TYPES, IDENTIFIER_TYPES, NAME_EXTRACTORS, pythonStrategy, goStrategy, RUST_USE_ARG_TYPES, RUST_PUB_ITEM_TYPES, rustStrategy, JAVA_IMPORT_TYPES, JAVA_EXPORT_TYPES, javaStrategy, STRATEGIES, TreeSitterParser, ParserRegistry, defaultRegistry, LayerViolationCollector, ArchBaselineManager, DEFAULT_THRESHOLDS, FUNCTION_PATTERNS, DECISION_PATTERNS, ComplexityCollector, DEFAULT_THRESHOLDS2, CouplingCollector, ForbiddenImportCollector, ModuleSizeCollector, DepDepthCollector, defaultCollectors, archMatchers;
+var init_chunk_NC4RPKD4 = __esm({
+  "../core/dist/chunk-NC4RPKD4.mjs"() {
     "use strict";
     init_dist();
+    __defProp = Object.defineProperty;
+    __export2 = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
     ArchMetricCategorySchema = z.enum([
       "circular-deps",
       "layer-violations",
@@ -1926,11 +1931,11 @@ var init_chunk_CE225WRK = __esm({
     TypeScriptParser = class {
       name = "typescript";
       extensions = [".ts", ".tsx", ".mts", ".cts"];
-      async parseFile(path42) {
-        const contentResult = await readFileContent(path42);
+      async parseFile(path46) {
+        const contentResult = await readFileContent(path46);
         if (!contentResult.ok) {
           return Err(
-            createParseError("NOT_FOUND", `File not found: ${path42}`, { path: path42 }, [
+            createParseError("NOT_FOUND", `File not found: ${path46}`, { path: path46 }, [
               "Check that the file exists",
               "Verify the path is correct"
             ])
@@ -1940,7 +1945,7 @@ var init_chunk_CE225WRK = __esm({
           const ast = parse(contentResult.value, {
             loc: true,
             range: true,
-            jsx: path42.endsWith(".tsx"),
+            jsx: path46.endsWith(".tsx"),
             errorOnUnknownASTType: false
           });
           return Ok({
@@ -1951,7 +1956,7 @@ var init_chunk_CE225WRK = __esm({
         } catch (e) {
           const error = e;
           return Err(
-            createParseError("SYNTAX_ERROR", `Failed to parse ${path42}: ${error.message}`, { path: path42 }, [
+            createParseError("SYNTAX_ERROR", `Failed to parse ${path46}: ${error.message}`, { path: path46 }, [
               "Check for syntax errors in the file",
               "Ensure valid TypeScript syntax"
             ])
@@ -2266,11 +2271,11 @@ var init_chunk_CE225WRK = __esm({
         this.extensions = extensions;
         this.strategy = strategy;
       }
-      async parseFile(path42) {
-        const contentResult = await readFileContent(path42);
+      async parseFile(path46) {
+        const contentResult = await readFileContent(path46);
         if (!contentResult.ok) {
           return Err(
-            createParseError("NOT_FOUND", `File not found: ${path42}`, { path: path42 }, [
+            createParseError("NOT_FOUND", `File not found: ${path46}`, { path: path46 }, [
               "Check that the file exists"
             ])
           );
@@ -2286,7 +2291,7 @@ var init_chunk_CE225WRK = __esm({
         } catch (e) {
           const error = e;
           return Err(
-            createParseError("SYNTAX_ERROR", `Failed to parse ${path42}: ${error.message}`, { path: path42 }, [
+            createParseError("SYNTAX_ERROR", `Failed to parse ${path46}: ${error.message}`, { path: path46 }, [
               "Check for syntax errors in the file"
             ])
           );
@@ -2854,6 +2859,7 @@ __export(dist_exports, {
   CompoundLockHeldError: () => CompoundLockHeldError,
   ConfidenceTierSchema: () => ConfidenceTierSchema,
   ConfirmationSchema: () => ConfirmationSchema,
+  ConflictError: () => ConflictError,
   ConsoleSink: () => ConsoleSink,
   ConstraintRuleSchema: () => ConstraintRuleSchema,
   ContributingFeatureSchema: () => ContributingFeatureSchema,
@@ -2873,6 +2879,7 @@ __export(dist_exports, {
   DepDepthCollector: () => DepDepthCollector,
   DirectionSchema: () => DirectionSchema,
   EMPTY_SUPPLY_CHAIN: () => EMPTY_SUPPLY_CHAIN,
+  ETagStore: () => ETagStore,
   EVIDENCE_SATURATION: () => EVIDENCE_SATURATION,
   EXTENSION_MAP: () => EXTENSION_MAP,
   EmergenceConfidenceSchema: () => EmergenceConfidenceSchema,
@@ -3044,6 +3051,7 @@ __export(dist_exports, {
   createRegionMap: () => createRegionMap,
   createSelfReview: () => createSelfReview,
   createStream: () => createStream,
+  createTrackerClient: () => createTrackerClient,
   crossReferenceUndocumentedFixes: () => crossReferenceUndocumentedFixes,
   cryptoRules: () => cryptoRules,
   deduplicateCleanupFindings: () => deduplicateCleanupFindings,
@@ -3104,6 +3112,7 @@ __export(dist_exports, {
   getParser: () => getParser,
   getPhaseCategories: () => getPhaseCategories,
   getPulseAdapter: () => getPulseAdapter,
+  getRoadmapMode: () => getRoadmapMode,
   getStreamForBranch: () => getStreamForBranch,
   getTaintFilePath: () => getTaintFilePath,
   getTrustLevel: () => getTrustLevel,
@@ -3130,17 +3139,21 @@ __export(dist_exports, {
   loadHandoff: () => loadHandoff,
   loadIndexEntries: () => loadIndexEntries,
   loadPricingData: () => loadPricingData,
+  loadProjectRoadmapMode: () => loadProjectRoadmapMode,
   loadRelevantLearnings: () => loadRelevantLearnings,
   loadSessionSummary: () => loadSessionSummary,
   loadState: () => loadState,
   loadStreamIndex: () => loadStreamIndex,
+  loadTrackerClientConfigFromProject: () => loadTrackerClientConfigFromProject,
   loadTrackerSyncConfig: () => loadTrackerSyncConfig,
   logAgentAction: () => logAgentAction,
+  makeTrackerConflictBody: () => makeTrackerConflictBody,
   mapInjectionFindings: () => mapInjectionFindings,
   mapSecurityFindings: () => mapSecurityFindings,
   mapSecuritySeverity: () => mapSecuritySeverity,
   markProtectedFindings: () => markProtectedFindings,
   mcpRules: () => mcpRules,
+  migrate: () => migrate_exports,
   migrateToStreams: () => migrateToStreams,
   networkRules: () => networkRules,
   nodeRules: () => nodeRules,
@@ -3212,6 +3225,8 @@ __export(dist_exports, {
   scanForInjection: () => scanForInjection,
   scopeContext: () => scopeContext,
   scoreRoadmapCandidates: () => scoreRoadmapCandidates,
+  scoreRoadmapCandidatesFileLess: () => scoreRoadmapCandidatesFileLess,
+  scoreRoadmapCandidatesForMode: () => scoreRoadmapCandidatesForMode,
   searchSymbols: () => searchSymbols,
   secretRules: () => secretRules,
   securityFindingId: () => securityFindingId,
@@ -3249,6 +3264,7 @@ __export(dist_exports, {
   validateKnowledgeMap: () => validateKnowledgeMap,
   validatePatternConfig: () => validatePatternConfig,
   validatePulseConfig: () => validatePulseConfig,
+  validateRoadmapMode: () => validateRoadmapMode,
   validateSolutionsDir: () => validateSolutionsDir,
   violationId: () => violationId,
   weeksUntilThreshold: () => weeksUntilThreshold,
@@ -3294,63 +3310,63 @@ import { existsSync as existsSync9 } from "fs";
 import { join as join11 } from "path";
 import { existsSync as existsSync10 } from "fs";
 import { join as join12 } from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 import { minimatch as minimatch2 } from "minimatch";
 import { basename as basename2 } from "path";
-import { join as join13, basename as basename3 } from "path";
+import { join as join14, basename as basename3 } from "path";
 import { basename as basename4, dirname as dirname42 } from "path";
 import { z as z3 } from "zod";
-import * as fs3 from "fs/promises";
 import * as fs4 from "fs/promises";
-import { join as join14, resolve as resolve32 } from "path";
+import * as fs5 from "fs/promises";
+import { join as join15, resolve as resolve42 } from "path";
 import { minimatch as minimatch22 } from "minimatch";
-import { dirname as dirname5, resolve as resolve4 } from "path";
-import { dirname as dirname6, extname as extname2, resolve as resolve5 } from "path";
+import { dirname as dirname5, resolve as resolve5 } from "path";
+import { dirname as dirname6, extname as extname2, resolve as resolve6 } from "path";
 import { minimatch as minimatch3 } from "minimatch";
 import { readdirSync, statSync as statSync2 } from "fs";
-import { join as join15 } from "path";
-import * as fs5 from "fs";
+import { join as join16 } from "path";
+import * as fs6 from "fs";
 import { promisify as promisify2 } from "util";
-import { dirname as dirname7, basename as basename5, join as join16 } from "path";
+import { dirname as dirname7, basename as basename5, join as join17 } from "path";
 import { z as z4 } from "zod";
-import { readFileSync as readFileSync22, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync11 } from "fs";
-import { join as join17, dirname as dirname8 } from "path";
+import { readFileSync as readFileSync22, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync12 } from "fs";
+import { join as join18, dirname as dirname8 } from "path";
 import { execFileSync } from "child_process";
-import * as fs6 from "fs";
-import * as path3 from "path";
-import { appendFileSync, writeFileSync as writeFileSync22, existsSync as existsSync12, mkdirSync as mkdirSync22 } from "fs";
+import * as fs7 from "fs";
+import * as path4 from "path";
+import { appendFileSync, writeFileSync as writeFileSync22, existsSync as existsSync13, mkdirSync as mkdirSync22 } from "fs";
 import { dirname as dirname9 } from "path";
 import { z as z5 } from "zod";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync as renameSync2, mkdirSync as mkdirSync3, existsSync as existsSync13 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync as renameSync2, mkdirSync as mkdirSync3, existsSync as existsSync14 } from "fs";
 import { randomBytes as randomBytes2 } from "crypto";
-import { join as join19, dirname as dirname10 } from "path";
+import { join as join20, dirname as dirname10 } from "path";
 import { z as z6 } from "zod";
-import * as fs7 from "fs";
-import * as path4 from "path";
 import * as fs8 from "fs";
 import * as path5 from "path";
 import * as fs9 from "fs";
 import * as path6 from "path";
+import * as fs10 from "fs";
+import * as path7 from "path";
 import { z as z7 } from "zod";
+import * as fs14 from "fs";
+import * as path11 from "path";
 import * as fs13 from "fs";
 import * as path10 from "path";
-import * as fs12 from "fs";
-import * as path9 from "path";
-import * as fs10 from "fs";
-import * as path7 from "path";
-import { execSync } from "child_process";
-import { z as z8 } from "zod";
 import * as fs11 from "fs";
 import * as path8 from "path";
-import * as fs14 from "fs";
-import * as path11 from "path";
-import * as crypto2 from "crypto";
+import { execSync } from "child_process";
+import { z as z8 } from "zod";
+import * as fs12 from "fs";
+import * as path9 from "path";
 import * as fs15 from "fs";
 import * as path12 from "path";
+import * as crypto2 from "crypto";
 import * as fs16 from "fs";
 import * as path13 from "path";
-import * as crypto3 from "crypto";
 import * as fs17 from "fs";
 import * as path14 from "path";
+import * as crypto3 from "crypto";
 import * as fs18 from "fs";
 import * as path15 from "path";
 import * as fs19 from "fs";
@@ -3359,77 +3375,86 @@ import * as fs20 from "fs";
 import * as path17 from "path";
 import * as fs21 from "fs";
 import * as path18 from "path";
-import { execSync as execSync2 } from "child_process";
 import * as fs22 from "fs";
 import * as path19 from "path";
+import { execSync as execSync2 } from "child_process";
 import * as fs23 from "fs";
 import * as path20 from "path";
 import * as fs24 from "fs";
 import * as path21 from "path";
 import * as fs25 from "fs";
 import * as path22 from "path";
+import * as fs26 from "fs";
+import * as path23 from "path";
 import { z as z9 } from "zod";
-import * as fs27 from "fs/promises";
+import * as fs28 from "fs/promises";
 import { minimatch as minimatch4 } from "minimatch";
 import { z as z10 } from "zod";
-import * as fs26 from "fs";
-import * as path23 from "path";
+import * as fs27 from "fs";
+import * as path24 from "path";
 import { readFileSync as readFileSync222, writeFileSync as writeFileSync15, unlinkSync as unlinkSync2, mkdirSync as mkdirSync14, readdirSync as readdirSync3 } from "fs";
-import { join as join382, dirname as dirname12 } from "path";
+import { join as join392, dirname as dirname12 } from "path";
 import { createHash as createHash32 } from "crypto";
 import { z as z11 } from "zod";
-import { readFileSync as readFileSync23, writeFileSync as writeFileSync16, renameSync as renameSync82, mkdirSync as mkdirSync15, existsSync as existsSync332 } from "fs";
+import { readFileSync as readFileSync23, writeFileSync as writeFileSync16, renameSync as renameSync82, mkdirSync as mkdirSync15, existsSync as existsSync342 } from "fs";
 import { execSync as execSync3 } from "child_process";
 import { randomBytes as randomBytes22 } from "crypto";
-import { isAbsolute as isAbsolute4, join as join39, relative as relative32, dirname as dirname13 } from "path";
-import * as path24 from "path";
+import { isAbsolute as isAbsolute4, join as join40, relative as relative32, dirname as dirname13 } from "path";
 import * as path25 from "path";
 import * as path26 from "path";
 import * as path27 from "path";
-import * as fs28 from "fs";
 import * as path28 from "path";
 import * as fs29 from "fs";
 import * as path29 from "path";
 import * as fs30 from "fs";
-import { z as z12 } from "zod";
-import * as fs31 from "fs/promises";
 import * as path30 from "path";
-import * as fs32 from "fs/promises";
+import * as fs31 from "fs";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import * as fs32 from "fs";
 import * as path31 from "path";
-import * as ejs from "ejs";
 import * as fs33 from "fs";
 import * as path32 from "path";
-import * as os from "os";
-import { spawn as spawn2 } from "child_process";
-import * as fs34 from "fs/promises";
+import { createHash as createHash4 } from "crypto";
 import * as path33 from "path";
-import * as fs35 from "fs";
+import { z as z12 } from "zod";
+import * as fs34 from "fs/promises";
 import * as path34 from "path";
-import * as fs36 from "fs";
+import * as fs35 from "fs/promises";
 import * as path35 from "path";
-import * as os2 from "os";
-import * as fs37 from "fs";
+import * as ejs from "ejs";
+import * as fs36 from "fs";
 import * as path36 from "path";
-import * as fs39 from "fs";
-import * as path38 from "path";
-import { execFileSync as execFileSync2 } from "child_process";
-import * as fs38 from "fs";
+import * as os from "os";
+import { spawn as spawn2 } from "child_process";
+import * as fs37 from "fs/promises";
 import * as path37 from "path";
-import * as crypto4 from "crypto";
-import * as fs40 from "fs";
+import * as fs38 from "fs";
+import * as path38 from "path";
+import * as fs39 from "fs";
 import * as path39 from "path";
-import * as fs41 from "fs";
-import * as fs42 from "fs";
+import * as os2 from "os";
+import * as fs40 from "fs";
 import * as path40 from "path";
-import { readFileSync as readFileSync36 } from "fs";
+import * as fs42 from "fs";
+import * as path42 from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+import * as fs41 from "fs";
+import * as path41 from "path";
+import * as crypto4 from "crypto";
+import * as fs43 from "fs";
+import * as path43 from "path";
+import * as fs44 from "fs";
+import * as fs45 from "fs";
+import * as path44 from "path";
+import { readFileSync as readFileSync38 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname18, join as join572 } from "path";
+import { dirname as dirname18, join as join612 } from "path";
 import { execFile } from "child_process";
 import { promisify as promisify22 } from "util";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify3 } from "util";
-import * as fs43 from "fs/promises";
-import * as path41 from "path";
+import * as fs46 from "fs/promises";
+import * as path45 from "path";
 async function validateFileStructure(projectPath, conventions) {
   const missing = [];
   const unexpected = [];
@@ -3465,15 +3490,15 @@ function validateConfig(data, schema) {
   let message = "Configuration validation failed";
   const suggestions = [];
   if (firstError) {
-    const path42 = firstError.path.join(".");
-    const pathDisplay = path42 ? ` at "${path42}"` : "";
+    const path46 = firstError.path.join(".");
+    const pathDisplay = path46 ? ` at "${path46}"` : "";
     if (firstError.code === "invalid_type") {
       const received = firstError.received;
       const expected = firstError.expected;
       if (received === "undefined") {
         code = "MISSING_FIELD";
         message = `Missing required field${pathDisplay}: ${firstError.message}`;
-        suggestions.push(`Field "${path42}" is required and must be of type "${expected}"`);
+        suggestions.push(`Field "${path46}" is required and must be of type "${expected}"`);
       } else {
         code = "INVALID_TYPE";
         message = `Invalid type${pathDisplay}: ${firstError.message}`;
@@ -3689,7 +3714,7 @@ function isAgnixDisabled() {
   return v === "1" || v === "true";
 }
 function runAgnix(cwd, strict, binPath, timeoutMs = DEFAULT_AGNIX_TIMEOUT_MS, spawnFn = spawn) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const args = ["--format", "json"];
     if (strict) args.push("--strict");
     args.push(cwd);
@@ -3703,7 +3728,7 @@ function runAgnix(cwd, strict, binPath, timeoutMs = DEFAULT_AGNIX_TIMEOUT_MS, sp
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve8(outcome);
+      resolve9(outcome);
     };
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
@@ -3807,16 +3832,16 @@ function makeFinding(input) {
   if (input.suggestion) finding.suggestion = input.suggestion;
   return finding;
 }
-function readTextSafe(path42) {
+function readTextSafe(path46) {
   try {
-    return readFileSync2(path42, "utf-8");
+    return readFileSync2(path46, "utf-8");
   } catch {
     return null;
   }
 }
-function safeFileSize(path42) {
+function safeFileSize(path46) {
   try {
-    return statSync(path42).size;
+    return statSync(path46).size;
   } catch {
     return null;
   }
@@ -4361,27 +4386,27 @@ function extractSections(content) {
   }
   return sections.map((section) => buildAgentMapSection(section, lines));
 }
-function isExternalLink(path42) {
-  return path42.startsWith("http://") || path42.startsWith("https://") || path42.startsWith("#") || path42.startsWith("mailto:");
+function isExternalLink(path46) {
+  return path46.startsWith("http://") || path46.startsWith("https://") || path46.startsWith("#") || path46.startsWith("mailto:");
 }
 function resolveLinkPath(linkPath, baseDir) {
   return linkPath.startsWith(".") ? join8(baseDir, linkPath) : linkPath;
 }
-async function validateAgentsMap(path42 = "./AGENTS.md") {
-  const contentResult = await readFileContent(path42);
+async function validateAgentsMap(path46 = "./AGENTS.md") {
+  const contentResult = await readFileContent(path46);
   if (!contentResult.ok) {
     return Err(
       createError(
         "PARSE_ERROR",
         `Failed to read AGENTS.md: ${contentResult.error.message}`,
-        { path: path42 },
+        { path: path46 },
         ["Ensure the file exists", "Check file permissions"]
       )
     );
   }
   const content = contentResult.value;
   const sections = extractSections(content);
-  const baseDir = dirname22(path42);
+  const baseDir = dirname22(path46);
   const sectionTitles = sections.map((s) => s.title);
   const missingSections = REQUIRED_SECTIONS.filter(
     (required) => !sectionTitles.some((title) => title.toLowerCase().includes(required.toLowerCase()))
@@ -4725,6 +4750,45 @@ function promoteWarningsToErrors(findings) {
 function hasErrors(findings) {
   return findings.some((f) => f.severity === "error");
 }
+function getRoadmapMode(config) {
+  if (!config || !config.roadmap) return "file-backed";
+  const mode = config.roadmap.mode;
+  return mode === "file-less" ? "file-less" : "file-backed";
+}
+function validateRoadmapMode(config, projectRoot) {
+  const root = path3.resolve(projectRoot);
+  const mode = getRoadmapMode(config);
+  if (mode === "file-backed") return Ok(void 0);
+  const tracker = config.roadmap?.tracker;
+  if (!tracker || typeof tracker !== "object") {
+    return Err(
+      createError(
+        "ROADMAP_MODE_MISSING_TRACKER",
+        'roadmap.mode is "file-less" but roadmap.tracker is not configured. File-less mode requires an external tracker as the source of truth.',
+        { mode },
+        [
+          'Configure roadmap.tracker in harness.config.json (e.g., kind: "github", repo: "owner/name").',
+          'Or set roadmap.mode to "file-backed" if you want to keep using docs/roadmap.md.'
+        ]
+      )
+    );
+  }
+  const roadmapPath = path3.join(root, "docs", "roadmap.md");
+  if (fs3.existsSync(roadmapPath)) {
+    return Err(
+      createError(
+        "ROADMAP_MODE_FILE_PRESENT",
+        'roadmap.mode is "file-less" but docs/roadmap.md still exists. In file-less mode the tracker is canonical; the markdown file must be migrated. Run `harness roadmap migrate --to=file-less` to migrate features into the tracker.',
+        { mode, roadmapPath },
+        [
+          "Run `harness roadmap migrate --to=file-less` to migrate features into the tracker.",
+          'Or set roadmap.mode to "file-backed" if you want to keep docs/roadmap.md.'
+        ]
+      )
+    );
+  }
+  return Ok(void 0);
+}
 function determineImportance(filePath) {
   const name = basename2(filePath).toLowerCase();
   if (name === "index.ts" || name === "index.js" || name === "main.ts") {
@@ -4821,8 +4885,8 @@ async function checkDocCoverage(domain, options = {}) {
     );
   }
 }
-function suggestFix(path42, existingFiles) {
-  const targetName = basename3(path42).toLowerCase();
+function suggestFix(path46, existingFiles) {
+  const targetName = basename3(path46).toLowerCase();
   const similar = existingFiles.find((file) => {
     const fileName = basename3(file).toLowerCase();
     return fileName.includes(targetName) || targetName.includes(fileName);
@@ -4830,10 +4894,10 @@ function suggestFix(path42, existingFiles) {
   if (similar) {
     return `Did you mean "${similar}"?`;
   }
-  return `Create the file "${path42}" or remove the link`;
+  return `Create the file "${path46}" or remove the link`;
 }
 async function validateKnowledgeMap(rootDir = process.cwd()) {
-  const agentsPath = join13(rootDir, "AGENTS.md");
+  const agentsPath = join14(rootDir, "AGENTS.md");
   const agentsResult = await validateAgentsMap(agentsPath);
   if (!agentsResult.ok) {
     return Err(agentsResult.error);
@@ -5188,8 +5252,8 @@ function createBoundaryValidator(schema, name) {
         return Ok(result.data);
       }
       const suggestions = result.error.issues.map((issue) => {
-        const path42 = issue.path.join(".");
-        return path42 ? `${path42}: ${issue.message}` : issue.message;
+        const path46 = issue.path.join(".");
+        return path46 ? `${path46}: ${issue.message}` : issue.message;
       });
       return Err(
         createError(
@@ -5235,7 +5299,7 @@ function validateBoundaries(boundaries, data) {
 async function writeConfig(filePath, content) {
   try {
     const json = JSON.stringify(content, null, 2) + "\n";
-    await fs3.writeFile(filePath, json, "utf-8");
+    await fs4.writeFile(filePath, json, "utf-8");
     return Ok(void 0);
   } catch (error) {
     return Err(error instanceof Error ? error : new Error(String(error)));
@@ -5509,7 +5573,7 @@ function deepMergeConstraints(localConfig, bundleConstraints, _existingContribut
 async function readLockfile(lockfilePath) {
   let raw;
   try {
-    raw = await fs4.readFile(lockfilePath, "utf-8");
+    raw = await fs5.readFile(lockfilePath, "utf-8");
   } catch (err) {
     if (isNodeError(err) && err.code === "ENOENT") {
       return { ok: true, value: null };
@@ -5791,9 +5855,9 @@ function parseProtectedRegions(files) {
   };
 }
 function collectFieldEntries(rootDir, field) {
-  if (typeof field === "string") return [resolve32(rootDir, field)];
+  if (typeof field === "string") return [resolve42(rootDir, field)];
   if (typeof field === "object" && field !== null) {
-    return Object.values(field).filter((v) => typeof v === "string").map((v) => resolve32(rootDir, v));
+    return Object.values(field).filter((v) => typeof v === "string").map((v) => resolve42(rootDir, v));
   }
   return [];
 }
@@ -5801,7 +5865,7 @@ function extractPackageEntries(rootDir, pkg) {
   const entries = [];
   entries.push(...collectFieldEntries(rootDir, pkg["exports"]));
   if (entries.length === 0 && typeof pkg["main"] === "string") {
-    entries.push(resolve32(rootDir, pkg["main"]));
+    entries.push(resolve42(rootDir, pkg["main"]));
   }
   if (pkg["bin"]) {
     entries.push(...collectFieldEntries(rootDir, pkg["bin"]));
@@ -5810,9 +5874,9 @@ function extractPackageEntries(rootDir, pkg) {
 }
 async function resolveEntryPoints(rootDir, explicitEntries) {
   if (explicitEntries && explicitEntries.length > 0) {
-    return Ok(explicitEntries.map((e) => resolve32(rootDir, e)));
+    return Ok(explicitEntries.map((e) => resolve42(rootDir, e)));
   }
-  const pkgPath = join14(rootDir, "package.json");
+  const pkgPath = join15(rootDir, "package.json");
   if (await fileExists(pkgPath)) {
     const pkgContent = await readFileContent(pkgPath);
     if (pkgContent.ok) {
@@ -5826,7 +5890,7 @@ async function resolveEntryPoints(rootDir, explicitEntries) {
   }
   const conventions = ["src/index.ts", "src/main.ts", "index.ts", "main.ts"];
   for (const conv of conventions) {
-    const convPath = join14(rootDir, conv);
+    const convPath = join15(rootDir, conv);
     if (await fileExists(convPath)) {
       return Ok([convPath]);
     }
@@ -5893,22 +5957,22 @@ function extractInlineRefs(content) {
   }
   return refs;
 }
-async function parseDocumentationFile(path42) {
-  const contentResult = await readFileContent(path42);
+async function parseDocumentationFile(path46) {
+  const contentResult = await readFileContent(path46);
   if (!contentResult.ok) {
     return Err(
       createEntropyError(
         "PARSE_ERROR",
-        `Failed to read documentation file: ${path42}`,
-        { file: path42 },
+        `Failed to read documentation file: ${path46}`,
+        { file: path46 },
         ["Check that the file exists"]
       )
     );
   }
   const content = contentResult.value;
-  const type = path42.endsWith(".md") ? "markdown" : "text";
+  const type = path46.endsWith(".md") ? "markdown" : "text";
   return Ok({
-    path: path42,
+    path: path46,
     type,
     content,
     codeBlocks: extractCodeBlocks(content),
@@ -6005,7 +6069,7 @@ function extractAllCodeReferences(docs) {
 async function buildSnapshot2(config) {
   const startTime = Date.now();
   const parser = config.parser || new TypeScriptParser();
-  const rootDir = resolve32(config.rootDir);
+  const rootDir = resolve42(config.rootDir);
   const entryPointsResult = await resolveEntryPoints(rootDir, config.entryPoints);
   if (!entryPointsResult.ok) {
     return Err(entryPointsResult.error);
@@ -6178,7 +6242,7 @@ async function checkStructureDrift(snapshot, _config) {
   for (const doc of snapshot.docs) {
     const fileLinks = extractFileLinks(doc.content);
     for (const { link, line } of fileLinks) {
-      const resolvedPath = resolve4(dirname5(doc.path), link);
+      const resolvedPath = resolve5(dirname5(doc.path), link);
       const exists = await fileExists(resolvedPath);
       if (!exists) {
         drifts.push({
@@ -6280,7 +6344,7 @@ function resolveImportToFile(importSource, fromFile, snapshot, fileIndex) {
   }
   const hasFile = fileIndex ? (p) => fileIndex.has(p) : (p) => snapshot.files.some((f) => f.path === p);
   const fromDir = dirname6(fromFile);
-  const resolved = resolve5(fromDir, importSource);
+  const resolved = resolve6(fromDir, importSource);
   const sourceExt = extname2(resolved);
   const fallbacks = JS_EXT_FALLBACKS2[sourceExt];
   if (fallbacks) {
@@ -6290,7 +6354,7 @@ function resolveImportToFile(importSource, fromFile, snapshot, fileIndex) {
       if (hasFile(candidate)) return candidate;
     }
     for (const indexExt of [".ts", ".tsx", ".jsx"]) {
-      const indexPath2 = resolve5(base, "index" + indexExt);
+      const indexPath2 = resolve6(base, "index" + indexExt);
       if (hasFile(indexPath2)) return indexPath2;
     }
   }
@@ -6301,7 +6365,7 @@ function resolveImportToFile(importSource, fromFile, snapshot, fileIndex) {
       if (hasFile(candidate)) return candidate;
     }
     for (const indexExt of [".ts", ".tsx"]) {
-      const indexPath2 = resolve5(resolved, "index" + indexExt);
+      const indexPath2 = resolve6(resolved, "index" + indexExt);
       if (hasFile(indexPath2)) return indexPath2;
     }
   }
@@ -6818,7 +6882,7 @@ function dirSize(dirPath) {
   }
   for (const entry of entries) {
     if (entry === "node_modules" || entry === ".git") continue;
-    const fullPath = join15(dirPath, entry);
+    const fullPath = join16(dirPath, entry);
     try {
       const stat2 = statSync2(fullPath);
       if (stat2.isDirectory()) {
@@ -6838,7 +6902,7 @@ async function detectSizeBudgetViolations(rootDir, config) {
   let packagesChecked = 0;
   for (const [pkgPath, budget] of Object.entries(budgets)) {
     packagesChecked++;
-    const distPath = join15(rootDir, pkgPath, "dist");
+    const distPath = join16(rootDir, pkgPath, "dist");
     const currentSize = dirSize(distPath);
     if (budget.warn) {
       const budgetBytes = parseSize(budget.warn);
@@ -7082,7 +7146,7 @@ function previewFix(fix) {
   }
 }
 async function createBackup(filePath, backupDir) {
-  const backupPath = join16(backupDir, `${Date.now()}-${basename5(filePath)}`);
+  const backupPath = join17(backupDir, `${Date.now()}-${basename5(filePath)}`);
   try {
     await mkdir22(dirname7(backupPath), { recursive: true });
     await copyFile2(filePath, backupPath);
@@ -7457,12 +7521,12 @@ function parseDiffHeader(part) {
   return headerMatch[2];
 }
 function parseDiffPart(part) {
-  const path42 = parseDiffHeader(part);
-  if (!path42) return null;
+  const path46 = parseDiffHeader(part);
+  if (!path46) return null;
   const additionRegex = /^\+(?!\+\+)/gm;
   const deletionRegex = /^-(?!--)/gm;
   return {
-    path: path42,
+    path: path46,
     status: detectFileStatus(part),
     additions: (part.match(additionRegex) || []).length,
     deletions: (part.match(deletionRegex) || []).length
@@ -8247,10 +8311,10 @@ function detectEmergentConstraints(history, options) {
   return { suggestions, totalViolationsAnalyzed, windowWeeks, minOccurrences };
 }
 function streamsDir(projectPath) {
-  return path7.join(projectPath, HARNESS_DIR, STREAMS_DIR);
+  return path8.join(projectPath, HARNESS_DIR, STREAMS_DIR);
 }
 function indexPath(projectPath) {
-  return path7.join(streamsDir(projectPath), INDEX_FILE);
+  return path8.join(streamsDir(projectPath), INDEX_FILE);
 }
 function validateStreamName(name) {
   if (!STREAM_NAME_REGEX.test(name)) {
@@ -8264,11 +8328,11 @@ function validateStreamName(name) {
 }
 async function loadStreamIndex(projectPath) {
   const idxPath = indexPath(projectPath);
-  if (!fs10.existsSync(idxPath)) {
+  if (!fs11.existsSync(idxPath)) {
     return Ok({ ...DEFAULT_STREAM_INDEX, streams: {} });
   }
   try {
-    const raw = fs10.readFileSync(idxPath, "utf-8");
+    const raw = fs11.readFileSync(idxPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = StreamIndexSchema.safeParse(parsed);
     if (!result.success) {
@@ -8286,8 +8350,8 @@ async function loadStreamIndex(projectPath) {
 async function saveStreamIndex(projectPath, index) {
   const dir = streamsDir(projectPath);
   try {
-    fs10.mkdirSync(dir, { recursive: true });
-    fs10.writeFileSync(indexPath(projectPath), JSON.stringify(index, null, 2));
+    fs11.mkdirSync(dir, { recursive: true });
+    fs11.writeFileSync(indexPath(projectPath), JSON.stringify(index, null, 2));
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -8326,18 +8390,18 @@ async function resolveStreamPath(projectPath, options) {
         )
       );
     }
-    return Ok(path7.join(streamsDir(projectPath), options.stream));
+    return Ok(path8.join(streamsDir(projectPath), options.stream));
   }
   const branch = getCurrentBranch(projectPath);
   if (branch && branch !== "main" && branch !== "master") {
     for (const [name, info] of Object.entries(index.streams)) {
       if (info.branch === branch) {
-        return Ok(path7.join(streamsDir(projectPath), name));
+        return Ok(path8.join(streamsDir(projectPath), name));
       }
     }
   }
   if (index.activeStream && index.streams[index.activeStream]) {
-    return Ok(path7.join(streamsDir(projectPath), index.activeStream));
+    return Ok(path8.join(streamsDir(projectPath), index.activeStream));
   }
   return Err(
     new Error(
@@ -8365,9 +8429,9 @@ async function createStream(projectPath, name, branch) {
   if (index.streams[name]) {
     return Err(new Error(`Stream '${name}' already exists`));
   }
-  const streamPath = path7.join(streamsDir(projectPath), name);
+  const streamPath = path8.join(streamsDir(projectPath), name);
   try {
-    fs10.mkdirSync(streamPath, { recursive: true });
+    fs11.mkdirSync(streamPath, { recursive: true });
   } catch (error) {
     return Err(
       new Error(
@@ -8408,12 +8472,12 @@ async function archiveStream(projectPath, name) {
   if (!index.streams[name]) {
     return Err(new Error(`Stream '${name}' not found`));
   }
-  const streamPath = path7.join(streamsDir(projectPath), name);
-  const archiveDir = path7.join(projectPath, HARNESS_DIR, "archive", "streams");
+  const streamPath = path8.join(streamsDir(projectPath), name);
+  const archiveDir = path8.join(projectPath, HARNESS_DIR, "archive", "streams");
   try {
-    fs10.mkdirSync(archiveDir, { recursive: true });
+    fs11.mkdirSync(archiveDir, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    fs10.renameSync(streamPath, path7.join(archiveDir, `${name}-${date}`));
+    fs11.renameSync(streamPath, path8.join(archiveDir, `${name}-${date}`));
   } catch (error) {
     return Err(
       new Error(
@@ -8434,19 +8498,19 @@ function getStreamForBranch(index, branch) {
   return null;
 }
 async function migrateToStreams(projectPath) {
-  const harnessDir = path7.join(projectPath, HARNESS_DIR);
-  if (fs10.existsSync(indexPath(projectPath))) {
+  const harnessDir = path8.join(projectPath, HARNESS_DIR);
+  if (fs11.existsSync(indexPath(projectPath))) {
     return Ok(void 0);
   }
-  const filesToMove = STATE_FILES.filter((f) => fs10.existsSync(path7.join(harnessDir, f)));
+  const filesToMove = STATE_FILES.filter((f) => fs11.existsSync(path8.join(harnessDir, f)));
   if (filesToMove.length === 0) {
     return Ok(void 0);
   }
-  const defaultDir = path7.join(streamsDir(projectPath), "default");
+  const defaultDir = path8.join(streamsDir(projectPath), "default");
   try {
-    fs10.mkdirSync(defaultDir, { recursive: true });
+    fs11.mkdirSync(defaultDir, { recursive: true });
     for (const file of filesToMove) {
-      fs10.renameSync(path7.join(harnessDir, file), path7.join(defaultDir, file));
+      fs11.renameSync(path8.join(harnessDir, file), path8.join(defaultDir, file));
     }
   } catch (error) {
     return Err(
@@ -8476,26 +8540,26 @@ function resolveSessionDir(projectPath, sessionSlug, options) {
       new Error(`Invalid session slug '${sessionSlug}': must not contain path traversal characters`)
     );
   }
-  const sessionDir = path8.join(projectPath, HARNESS_DIR, SESSIONS_DIR, sessionSlug);
+  const sessionDir = path9.join(projectPath, HARNESS_DIR, SESSIONS_DIR, sessionSlug);
   if (options?.create) {
-    fs11.mkdirSync(sessionDir, { recursive: true });
+    fs12.mkdirSync(sessionDir, { recursive: true });
   }
   return Ok(sessionDir);
 }
 function updateSessionIndex(projectPath, sessionSlug, description) {
-  const sessionsDir = path8.join(projectPath, HARNESS_DIR, SESSIONS_DIR);
-  fs11.mkdirSync(sessionsDir, { recursive: true });
-  const indexPath2 = path8.join(sessionsDir, SESSION_INDEX_FILE);
+  const sessionsDir = path9.join(projectPath, HARNESS_DIR, SESSIONS_DIR);
+  fs12.mkdirSync(sessionsDir, { recursive: true });
+  const indexPath2 = path9.join(sessionsDir, SESSION_INDEX_FILE);
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const newLine = `- [${sessionSlug}](${sessionSlug}/summary.md) \u2014 ${description} (${date})`;
-  if (!fs11.existsSync(indexPath2)) {
-    fs11.writeFileSync(indexPath2, `## Active Sessions
+  if (!fs12.existsSync(indexPath2)) {
+    fs12.writeFileSync(indexPath2, `## Active Sessions
 
 ${newLine}
 `);
     return;
   }
-  const content = fs11.readFileSync(indexPath2, "utf-8");
+  const content = fs12.readFileSync(indexPath2, "utf-8");
   const lines = content.split("\n");
   const slugPattern = `- [${sessionSlug}]`;
   const existingIdx = lines.findIndex((l) => l.startsWith(slugPattern));
@@ -8505,7 +8569,7 @@ ${newLine}
     const lastNonEmpty = lines.reduce((last, line, i) => line.trim() !== "" ? i : last, 0);
     lines.splice(lastNonEmpty + 1, 0, newLine);
   }
-  fs11.writeFileSync(indexPath2, lines.join("\n"));
+  fs12.writeFileSync(indexPath2, lines.join("\n"));
 }
 function evictIfNeeded(map) {
   if (map.size > MAX_CACHE_ENTRIES) {
@@ -8518,8 +8582,8 @@ async function getStateDir(projectPath, stream, session) {
     const sessionResult = resolveSessionDir(projectPath, session, { create: true });
     return sessionResult;
   }
-  const streamsIndexPath = path9.join(projectPath, HARNESS_DIR, "streams", INDEX_FILE);
-  const hasStreams = fs12.existsSync(streamsIndexPath);
+  const streamsIndexPath = path10.join(projectPath, HARNESS_DIR, "streams", INDEX_FILE);
+  const hasStreams = fs13.existsSync(streamsIndexPath);
   if (stream || hasStreams) {
     const result = await resolveStreamPath(projectPath, stream ? { stream } : void 0);
     if (result.ok) {
@@ -8529,18 +8593,18 @@ async function getStateDir(projectPath, stream, session) {
       return result;
     }
   }
-  return Ok(path9.join(projectPath, HARNESS_DIR));
+  return Ok(path10.join(projectPath, HARNESS_DIR));
 }
 async function loadState(projectPath, stream, session) {
   try {
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const statePath = path10.join(stateDir, STATE_FILE);
-    if (!fs13.existsSync(statePath)) {
+    const statePath = path11.join(stateDir, STATE_FILE);
+    if (!fs14.existsSync(statePath)) {
       return Ok({ ...DEFAULT_STATE });
     }
-    const raw = fs13.readFileSync(statePath, "utf-8");
+    const raw = fs14.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = HarnessStateSchema.safeParse(parsed);
     if (!result.success) {
@@ -8558,11 +8622,11 @@ async function saveState(projectPath, state, stream, session) {
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const statePath = path10.join(stateDir, STATE_FILE);
-    fs13.mkdirSync(stateDir, { recursive: true });
+    const statePath = path11.join(stateDir, STATE_FILE);
+    fs14.mkdirSync(stateDir, { recursive: true });
     const tmpPath = statePath + ".tmp";
-    fs13.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
-    fs13.renameSync(tmpPath, statePath);
+    fs14.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
+    fs14.renameSync(tmpPath, statePath);
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -8648,10 +8712,10 @@ function computeContentHash(text) {
   return crypto2.createHash("sha256").update(text).digest("hex").slice(0, 16);
 }
 function loadContentHashes(stateDir) {
-  const hashesPath = path11.join(stateDir, CONTENT_HASHES_FILE);
-  if (!fs14.existsSync(hashesPath)) return {};
+  const hashesPath = path12.join(stateDir, CONTENT_HASHES_FILE);
+  if (!fs15.existsSync(hashesPath)) return {};
   try {
-    const raw = fs14.readFileSync(hashesPath, "utf-8");
+    const raw = fs15.readFileSync(hashesPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
     return parsed;
@@ -8660,15 +8724,15 @@ function loadContentHashes(stateDir) {
   }
 }
 function saveContentHashes(stateDir, index) {
-  const hashesPath = path11.join(stateDir, CONTENT_HASHES_FILE);
+  const hashesPath = path12.join(stateDir, CONTENT_HASHES_FILE);
   const tmpPath = hashesPath + ".tmp";
-  fs14.writeFileSync(tmpPath, JSON.stringify(index, null, 2) + "\n");
-  fs14.renameSync(tmpPath, hashesPath);
+  fs15.writeFileSync(tmpPath, JSON.stringify(index, null, 2) + "\n");
+  fs15.renameSync(tmpPath, hashesPath);
 }
 function rebuildContentHashes(stateDir, learningsFile) {
-  const learningsPath = path11.join(stateDir, learningsFile);
-  if (!fs14.existsSync(learningsPath)) return {};
-  const content = fs14.readFileSync(learningsPath, "utf-8");
+  const learningsPath = path12.join(stateDir, learningsFile);
+  if (!fs15.existsSync(learningsPath)) return {};
+  const content = fs15.readFileSync(learningsPath, "utf-8");
   const lines = content.split("\n");
   const index = {};
   for (let i = 0; i < lines.length; i++) {
@@ -8727,18 +8791,18 @@ async function loadRelevantLearnings(projectPath, skillName, stream, session) {
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const learningsPath = path12.join(stateDir, LEARNINGS_FILE);
-    if (!fs15.existsSync(learningsPath)) {
+    const learningsPath = path13.join(stateDir, LEARNINGS_FILE);
+    if (!fs16.existsSync(learningsPath)) {
       return Ok([]);
     }
-    const stats = fs15.statSync(learningsPath);
+    const stats = fs16.statSync(learningsPath);
     const cacheKey = learningsPath;
     const cached = learningsCacheMap.get(cacheKey);
     let entries;
     if (cached && cached.mtimeMs === stats.mtimeMs) {
       entries = cached.entries;
     } else {
-      const content = fs15.readFileSync(learningsPath, "utf-8");
+      const content = fs16.readFileSync(learningsPath, "utf-8");
       const lines = content.split("\n");
       entries = [];
       let currentBlock = [];
@@ -8874,16 +8938,16 @@ function checkOverlap(newEntry, existingEntries, options) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 async function acquireFileLock(lockPath) {
   for (let attempt = 0; attempt < LOCK_RETRIES; attempt++) {
     try {
-      const fd = fs16.openSync(
+      const fd = fs17.openSync(
         lockPath,
-        fs16.constants.O_CREAT | fs16.constants.O_EXCL | fs16.constants.O_WRONLY
+        fs17.constants.O_CREAT | fs17.constants.O_EXCL | fs17.constants.O_WRONLY
       );
-      fs16.closeSync(fd);
+      fs17.closeSync(fd);
       return;
     } catch (err) {
       const isExist = err instanceof Error && "code" in err && err.code === "EEXIST";
@@ -8897,20 +8961,20 @@ async function acquireFileLock(lockPath) {
 }
 function releaseFileLock(lockPath) {
   try {
-    fs16.unlinkSync(lockPath);
+    fs17.unlinkSync(lockPath);
   } catch {
   }
 }
 function loadOrRebuildHashes(stateDir, learningsPath) {
-  const hashesPath = path13.join(stateDir, CONTENT_HASHES_FILE);
-  if (fs16.existsSync(hashesPath)) {
+  const hashesPath = path14.join(stateDir, CONTENT_HASHES_FILE);
+  if (fs17.existsSync(hashesPath)) {
     const hashes = loadContentHashes(stateDir);
-    if (Object.keys(hashes).length === 0 && fs16.existsSync(learningsPath)) {
+    if (Object.keys(hashes).length === 0 && fs17.existsSync(learningsPath)) {
       return rebuildContentHashes(stateDir, LEARNINGS_FILE);
     }
     return hashes;
   }
-  if (fs16.existsSync(learningsPath)) {
+  if (fs17.existsSync(learningsPath)) {
     return rebuildContentHashes(stateDir, LEARNINGS_FILE);
   }
   return {};
@@ -8934,8 +8998,8 @@ async function appendLearning(projectPath, learning, skillName, outcome, stream,
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const learningsPath = path13.join(stateDir, LEARNINGS_FILE);
-    fs16.mkdirSync(stateDir, { recursive: true });
+    const learningsPath = path14.join(stateDir, LEARNINGS_FILE);
+    fs17.mkdirSync(stateDir, { recursive: true });
     const lockPath = learningsPath + ".lock";
     await acquireFileLock(lockPath);
     try {
@@ -8965,17 +9029,17 @@ ${bulletLine}
 `;
       let overlapResult;
       let existingLineCount;
-      if (!fs16.existsSync(learningsPath)) {
-        fs16.writeFileSync(learningsPath, `# Learnings
+      if (!fs17.existsSync(learningsPath)) {
+        fs17.writeFileSync(learningsPath, `# Learnings
 ${entry}`);
         existingLineCount = 1;
       } else {
-        const existingContent = fs16.readFileSync(learningsPath, "utf-8");
+        const existingContent = fs17.readFileSync(learningsPath, "utf-8");
         const existingEntries = existingContent.split("\n").filter((line) => /^- \*\*\d{4}-\d{2}-\d{2}/.test(line));
         const overlap = checkOverlap(bulletLine, existingEntries);
         if (overlap.score >= 0.7) overlapResult = overlap;
         existingLineCount = existingContent.split("\n").length;
-        fs16.appendFileSync(learningsPath, entry);
+        fs17.appendFileSync(learningsPath, entry);
       }
       const bulletLineNum = existingLineCount + 2;
       contentHashes[contentHash] = { date: timestamp ?? "", line: bulletLineNum };
@@ -9080,11 +9144,11 @@ async function loadIndexEntries(projectPath, skillName, stream, session) {
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const learningsPath = path13.join(stateDir, LEARNINGS_FILE);
-    if (!fs16.existsSync(learningsPath)) {
+    const learningsPath = path14.join(stateDir, LEARNINGS_FILE);
+    if (!fs17.existsSync(learningsPath)) {
       return Ok([]);
     }
-    const content = fs16.readFileSync(learningsPath, "utf-8");
+    const content = fs17.readFileSync(learningsPath, "utf-8");
     const lines = content.split("\n");
     const indexEntries = [];
     let pendingFrontmatter = null;
@@ -9126,16 +9190,16 @@ async function archiveLearnings(projectPath, entries, stream) {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const archiveDir = path14.join(stateDir, "learnings-archive");
-    fs17.mkdirSync(archiveDir, { recursive: true });
+    const archiveDir = path15.join(stateDir, "learnings-archive");
+    fs18.mkdirSync(archiveDir, { recursive: true });
     const now = /* @__PURE__ */ new Date();
     const yearMonth = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
-    const archivePath = path14.join(archiveDir, `${yearMonth}.md`);
+    const archivePath = path15.join(archiveDir, `${yearMonth}.md`);
     const archiveContent = entries.join("\n\n") + "\n";
-    if (fs17.existsSync(archivePath)) {
-      fs17.appendFileSync(archivePath, "\n" + archiveContent);
+    if (fs18.existsSync(archivePath)) {
+      fs18.appendFileSync(archivePath, "\n" + archiveContent);
     } else {
-      fs17.writeFileSync(archivePath, `# Learnings Archive
+      fs18.writeFileSync(archivePath, `# Learnings Archive
 
 ${archiveContent}`);
     }
@@ -9153,8 +9217,8 @@ async function pruneLearnings(projectPath, stream) {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const learningsPath = path14.join(stateDir, LEARNINGS_FILE);
-    if (!fs17.existsSync(learningsPath)) {
+    const learningsPath = path15.join(stateDir, LEARNINGS_FILE);
+    if (!fs18.existsSync(learningsPath)) {
       return Ok({ kept: 0, archived: 0, patterns: [] });
     }
     const loadResult = await loadRelevantLearnings(projectPath, void 0, stream);
@@ -9185,7 +9249,7 @@ async function pruneLearnings(projectPath, stream) {
       if (!archiveResult.ok) return archiveResult;
     }
     const newContent = "# Learnings\n\n" + toKeep.join("\n\n") + "\n";
-    fs17.writeFileSync(learningsPath, newContent);
+    fs18.writeFileSync(learningsPath, newContent);
     invalidateLearningsCacheEntry(learningsPath);
     return Ok({
       kept: toKeep.length,
@@ -9229,19 +9293,19 @@ async function promoteSessionLearnings(projectPath, sessionSlug, stream) {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const globalPath = path14.join(stateDir, LEARNINGS_FILE);
-    const existingGlobal = fs17.existsSync(globalPath) ? fs17.readFileSync(globalPath, "utf-8") : "";
+    const globalPath = path15.join(stateDir, LEARNINGS_FILE);
+    const existingGlobal = fs18.existsSync(globalPath) ? fs18.readFileSync(globalPath, "utf-8") : "";
     const newEntries = toPromote.filter((entry) => !existingGlobal.includes(entry.trim()));
     if (newEntries.length === 0) {
       return Ok({ promoted: 0, skipped: skipped + toPromote.length });
     }
     const promotedContent = newEntries.join("\n\n") + "\n";
     if (!existingGlobal) {
-      fs17.writeFileSync(globalPath, `# Learnings
+      fs18.writeFileSync(globalPath, `# Learnings
 
 ${promotedContent}`);
     } else {
-      fs17.appendFileSync(globalPath, "\n\n" + promotedContent);
+      fs18.appendFileSync(globalPath, "\n\n" + promotedContent);
     }
     invalidateLearningsCacheEntry(globalPath);
     return Ok({
@@ -9277,13 +9341,13 @@ async function detectStaleLearnings(projectPath, stream, session) {
         freshCount++;
         continue;
       }
-      const resolvedRoot = path15.resolve(projectPath);
+      const resolvedRoot = path16.resolve(projectPath);
       const missing = refs.filter((ref) => {
-        const absPath = path15.resolve(projectPath, ref);
-        if (!absPath.startsWith(resolvedRoot + path15.sep) && absPath !== resolvedRoot) {
+        const absPath = path16.resolve(projectPath, ref);
+        if (!absPath.startsWith(resolvedRoot + path16.sep) && absPath !== resolvedRoot) {
           return false;
         }
-        return !fs18.existsSync(absPath);
+        return !fs19.existsSync(absPath);
       });
       if (missing.length > 0) {
         const idx = extractIndexEntry(entry);
@@ -9318,17 +9382,17 @@ async function appendFailure(projectPath, description, skillName, type, stream,
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const failuresPath = path16.join(stateDir, FAILURES_FILE);
-    fs19.mkdirSync(stateDir, { recursive: true });
+    const failuresPath = path17.join(stateDir, FAILURES_FILE);
+    fs20.mkdirSync(stateDir, { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const entry = `
 - **${timestamp} [skill:${skillName}] [type:${type}]:** ${description}
 `;
-    if (!fs19.existsSync(failuresPath)) {
-      fs19.writeFileSync(failuresPath, `# Failures
+    if (!fs20.existsSync(failuresPath)) {
+      fs20.writeFileSync(failuresPath, `# Failures
 ${entry}`);
     } else {
-      fs19.appendFileSync(failuresPath, entry);
+      fs20.appendFileSync(failuresPath, entry);
     }
     failuresCacheMap.delete(failuresPath);
     return Ok(void 0);
@@ -9345,17 +9409,17 @@ async function loadFailures(projectPath, stream, session) {
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const failuresPath = path16.join(stateDir, FAILURES_FILE);
-    if (!fs19.existsSync(failuresPath)) {
+    const failuresPath = path17.join(stateDir, FAILURES_FILE);
+    if (!fs20.existsSync(failuresPath)) {
       return Ok([]);
     }
-    const stats = fs19.statSync(failuresPath);
+    const stats = fs20.statSync(failuresPath);
     const cacheKey = failuresPath;
     const cached = failuresCacheMap.get(cacheKey);
     if (cached && cached.mtimeMs === stats.mtimeMs) {
       return Ok(cached.entries);
     }
-    const content = fs19.readFileSync(failuresPath, "utf-8");
+    const content = fs20.readFileSync(failuresPath, "utf-8");
     const entries = [];
     for (const line of content.split("\n")) {
       const match = line.match(FAILURE_LINE_REGEX);
@@ -9384,20 +9448,20 @@ async function archiveFailures(projectPath, stream, session) {
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const failuresPath = path16.join(stateDir, FAILURES_FILE);
-    if (!fs19.existsSync(failuresPath)) {
+    const failuresPath = path17.join(stateDir, FAILURES_FILE);
+    if (!fs20.existsSync(failuresPath)) {
       return Ok(void 0);
     }
-    const archiveDir = path16.join(stateDir, "archive");
-    fs19.mkdirSync(archiveDir, { recursive: true });
+    const archiveDir = path17.join(stateDir, "archive");
+    fs20.mkdirSync(archiveDir, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     let archiveName = `failures-${date}.md`;
     let counter = 2;
-    while (fs19.existsSync(path16.join(archiveDir, archiveName))) {
+    while (fs20.existsSync(path17.join(archiveDir, archiveName))) {
       archiveName = `failures-${date}-${counter}.md`;
       counter++;
     }
-    fs19.renameSync(failuresPath, path16.join(archiveDir, archiveName));
+    fs20.renameSync(failuresPath, path17.join(archiveDir, archiveName));
     failuresCacheMap.delete(failuresPath);
     return Ok(void 0);
   } catch (error) {
@@ -9413,11 +9477,11 @@ async function saveHandoff(projectPath, handoff, stream, session) {
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const handoffPath = path17.join(stateDir, HANDOFF_FILE);
-    fs20.mkdirSync(stateDir, { recursive: true });
+    const handoffPath = path18.join(stateDir, HANDOFF_FILE);
+    fs21.mkdirSync(stateDir, { recursive: true });
     const tmpPath = handoffPath + ".tmp";
-    fs20.writeFileSync(tmpPath, JSON.stringify(handoff, null, 2));
-    fs20.renameSync(tmpPath, handoffPath);
+    fs21.writeFileSync(tmpPath, JSON.stringify(handoff, null, 2));
+    fs21.renameSync(tmpPath, handoffPath);
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -9430,11 +9494,11 @@ async function loadHandoff(projectPath, stream, session) {
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const handoffPath = path17.join(stateDir, HANDOFF_FILE);
-    if (!fs20.existsSync(handoffPath)) {
+    const handoffPath = path18.join(stateDir, HANDOFF_FILE);
+    if (!fs21.existsSync(handoffPath)) {
       return Ok(null);
     }
-    const raw = fs20.readFileSync(handoffPath, "utf-8");
+    const raw = fs21.readFileSync(handoffPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = HandoffSchema.safeParse(parsed);
     if (!result.success) {
@@ -9448,28 +9512,28 @@ async function loadHandoff(projectPath, stream, session) {
   }
 }
 function loadChecksFromConfig(gateConfigPath) {
-  if (!fs21.existsSync(gateConfigPath)) return [];
-  const raw = JSON.parse(fs21.readFileSync(gateConfigPath, "utf-8"));
+  if (!fs22.existsSync(gateConfigPath)) return [];
+  const raw = JSON.parse(fs22.readFileSync(gateConfigPath, "utf-8"));
   const config = GateConfigSchema.safeParse(raw);
   if (config.success && config.data.checks) return config.data.checks;
   return [];
 }
 function discoverChecksFromProject(projectPath) {
   const checks = [];
-  const packageJsonPath = path18.join(projectPath, "package.json");
-  if (fs21.existsSync(packageJsonPath)) {
-    const pkg = JSON.parse(fs21.readFileSync(packageJsonPath, "utf-8"));
+  const packageJsonPath = path19.join(projectPath, "package.json");
+  if (fs22.existsSync(packageJsonPath)) {
+    const pkg = JSON.parse(fs22.readFileSync(packageJsonPath, "utf-8"));
     const scripts = pkg.scripts || {};
     if (scripts.test) checks.push({ name: "test", command: "npm test" });
     if (scripts.lint) checks.push({ name: "lint", command: "npm run lint" });
     if (scripts.typecheck) checks.push({ name: "typecheck", command: "npm run typecheck" });
     if (scripts.build) checks.push({ name: "build", command: "npm run build" });
   }
-  if (fs21.existsSync(path18.join(projectPath, "go.mod"))) {
+  if (fs22.existsSync(path19.join(projectPath, "go.mod"))) {
     checks.push({ name: "test", command: "go test ./..." });
     checks.push({ name: "build", command: "go build ./..." });
   }
-  if (fs21.existsSync(path18.join(projectPath, "pyproject.toml")) || fs21.existsSync(path18.join(projectPath, "setup.py"))) {
+  if (fs22.existsSync(path19.join(projectPath, "pyproject.toml")) || fs22.existsSync(path19.join(projectPath, "setup.py"))) {
     checks.push({ name: "test", command: "python -m pytest" });
   }
   return checks;
@@ -9509,8 +9573,8 @@ function executeCheck(check, projectPath) {
   }
 }
 async function runMechanicalGate(projectPath) {
-  const harnessDir = path18.join(projectPath, HARNESS_DIR);
-  const gateConfigPath = path18.join(harnessDir, GATE_CONFIG_FILE);
+  const harnessDir = path19.join(projectPath, HARNESS_DIR);
+  const gateConfigPath = path19.join(harnessDir, GATE_CONFIG_FILE);
   try {
     let checks = loadChecksFromConfig(gateConfigPath);
     if (checks.length === 0) {
@@ -9566,9 +9630,9 @@ function writeSessionSummary(projectPath, sessionSlug, data) {
     const dirResult = resolveSessionDir(projectPath, sessionSlug, { create: true });
     if (!dirResult.ok) return dirResult;
     const sessionDir = dirResult.value;
-    const summaryPath = path19.join(sessionDir, SUMMARY_FILE);
+    const summaryPath = path20.join(sessionDir, SUMMARY_FILE);
     const content = formatSummary(data);
-    fs22.writeFileSync(summaryPath, content);
+    fs23.writeFileSync(summaryPath, content);
     const description = deriveIndexDescription(data);
     updateSessionIndex(projectPath, sessionSlug, description);
     return Ok(void 0);
@@ -9585,11 +9649,11 @@ function loadSessionSummary(projectPath, sessionSlug) {
     const dirResult = resolveSessionDir(projectPath, sessionSlug);
     if (!dirResult.ok) return dirResult;
     const sessionDir = dirResult.value;
-    const summaryPath = path19.join(sessionDir, SUMMARY_FILE);
-    if (!fs22.existsSync(summaryPath)) {
+    const summaryPath = path20.join(sessionDir, SUMMARY_FILE);
+    if (!fs23.existsSync(summaryPath)) {
       return Ok(null);
     }
-    const content = fs22.readFileSync(summaryPath, "utf-8");
+    const content = fs23.readFileSync(summaryPath, "utf-8");
     return Ok(content);
   } catch (error) {
     return Err(
@@ -9601,11 +9665,11 @@ function loadSessionSummary(projectPath, sessionSlug) {
 }
 function listActiveSessions(projectPath) {
   try {
-    const indexPath2 = path19.join(projectPath, HARNESS_DIR, SESSIONS_DIR, SESSION_INDEX_FILE);
-    if (!fs22.existsSync(indexPath2)) {
+    const indexPath2 = path20.join(projectPath, HARNESS_DIR, SESSIONS_DIR, SESSION_INDEX_FILE);
+    if (!fs23.existsSync(indexPath2)) {
       return Ok(null);
     }
-    const content = fs22.readFileSync(indexPath2, "utf-8");
+    const content = fs23.readFileSync(indexPath2, "utf-8");
     return Ok(content);
   } catch (error) {
     return Err(
@@ -9626,12 +9690,12 @@ async function loadSessionState(projectPath, sessionSlug) {
   const dirResult = resolveSessionDir(projectPath, sessionSlug);
   if (!dirResult.ok) return dirResult;
   const sessionDir = dirResult.value;
-  const filePath = path20.join(sessionDir, SESSION_STATE_FILE);
-  if (!fs23.existsSync(filePath)) {
+  const filePath = path21.join(sessionDir, SESSION_STATE_FILE);
+  if (!fs24.existsSync(filePath)) {
     return Ok(emptySections());
   }
   try {
-    const raw = fs23.readFileSync(filePath, "utf-8");
+    const raw = fs24.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     const sections = emptySections();
     for (const name of SESSION_SECTION_NAMES) {
@@ -9652,9 +9716,9 @@ async function saveSessionState(projectPath, sessionSlug, sections) {
   const dirResult = resolveSessionDir(projectPath, sessionSlug, { create: true });
   if (!dirResult.ok) return dirResult;
   const sessionDir = dirResult.value;
-  const filePath = path20.join(sessionDir, SESSION_STATE_FILE);
+  const filePath = path21.join(sessionDir, SESSION_STATE_FILE);
   try {
-    fs23.writeFileSync(filePath, JSON.stringify(sections, null, 2));
+    fs24.writeFileSync(filePath, JSON.stringify(sections, null, 2));
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -9710,26 +9774,26 @@ async function archiveSession(projectPath, sessionSlug) {
   const dirResult = resolveSessionDir(projectPath, sessionSlug);
   if (!dirResult.ok) return dirResult;
   const sessionDir = dirResult.value;
-  if (!fs24.existsSync(sessionDir)) {
+  if (!fs25.existsSync(sessionDir)) {
     return Err(new Error(`Session '${sessionSlug}' not found at ${sessionDir}`));
   }
-  const archiveBase = path21.join(projectPath, HARNESS_DIR, ARCHIVE_DIR, "sessions");
+  const archiveBase = path22.join(projectPath, HARNESS_DIR, ARCHIVE_DIR, "sessions");
   try {
-    fs24.mkdirSync(archiveBase, { recursive: true });
+    fs25.mkdirSync(archiveBase, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     let archiveName = `${sessionSlug}-${date}`;
     let counter = 1;
-    while (fs24.existsSync(path21.join(archiveBase, archiveName))) {
+    while (fs25.existsSync(path22.join(archiveBase, archiveName))) {
       archiveName = `${sessionSlug}-${date}-${counter}`;
       counter++;
     }
-    const dest = path21.join(archiveBase, archiveName);
+    const dest = path22.join(archiveBase, archiveName);
     try {
-      fs24.renameSync(sessionDir, dest);
+      fs25.renameSync(sessionDir, dest);
     } catch (renameErr) {
       if (renameErr instanceof Error && "code" in renameErr && renameErr.code === "EXDEV") {
-        fs24.cpSync(sessionDir, dest, { recursive: true });
-        fs24.rmSync(sessionDir, { recursive: true });
+        fs25.cpSync(sessionDir, dest, { recursive: true });
+        fs25.rmSync(sessionDir, { recursive: true });
       } else {
         throw renameErr;
       }
@@ -9751,8 +9815,8 @@ function loadKnownHashes(eventsPath) {
   const cached = knownHashesCache.get(eventsPath);
   if (cached) return cached;
   const hashes = /* @__PURE__ */ new Set();
-  if (fs25.existsSync(eventsPath)) {
-    const content = fs25.readFileSync(eventsPath, "utf-8");
+  if (fs26.existsSync(eventsPath)) {
+    const content = fs26.readFileSync(eventsPath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim() !== "");
     for (const line of lines) {
       try {
@@ -9775,8 +9839,8 @@ async function emitEvent(projectPath, event, options) {
     const dirResult = await getStateDir(projectPath, options?.stream, options?.session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const eventsPath = path22.join(stateDir, EVENTS_FILE);
-    fs25.mkdirSync(stateDir, { recursive: true });
+    const eventsPath = path23.join(stateDir, EVENTS_FILE);
+    fs26.mkdirSync(stateDir, { recursive: true });
     const contentHash = computeEventHash(event, options?.session);
     const knownHashes = loadKnownHashes(eventsPath);
     if (knownHashes.has(contentHash)) {
@@ -9790,7 +9854,7 @@ async function emitEvent(projectPath, event, options) {
     if (options?.session) {
       fullEvent.session = options.session;
     }
-    fs25.appendFileSync(eventsPath, JSON.stringify(fullEvent) + "\n");
+    fs26.appendFileSync(eventsPath, JSON.stringify(fullEvent) + "\n");
     knownHashes.add(contentHash);
     return Ok({ written: true });
   } catch (error) {
@@ -9804,11 +9868,11 @@ async function loadEvents(projectPath, options) {
     const dirResult = await getStateDir(projectPath, options?.stream, options?.session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const eventsPath = path22.join(stateDir, EVENTS_FILE);
-    if (!fs25.existsSync(eventsPath)) {
+    const eventsPath = path23.join(stateDir, EVENTS_FILE);
+    if (!fs26.existsSync(eventsPath)) {
       return Ok([]);
     }
-    const content = fs25.readFileSync(eventsPath, "utf-8");
+    const content = fs26.readFileSync(eventsPath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim() !== "");
     const events = [];
     for (const line of lines) {
@@ -10057,11 +10121,11 @@ function nodeSubStacks(allDeps) {
   return found;
 }
 function detectNodeStacks(projectRoot) {
-  const pkgJsonPath = path23.join(projectRoot, "package.json");
-  if (!fs26.existsSync(pkgJsonPath)) return [];
+  const pkgJsonPath = path24.join(projectRoot, "package.json");
+  if (!fs27.existsSync(pkgJsonPath)) return [];
   const stacks = ["node"];
   try {
-    const pkgJson = JSON.parse(fs26.readFileSync(pkgJsonPath, "utf-8"));
+    const pkgJson = JSON.parse(fs27.readFileSync(pkgJsonPath, "utf-8"));
     const allDeps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
     stacks.push(...nodeSubStacks(allDeps));
   } catch {
@@ -10070,10 +10134,10 @@ function detectNodeStacks(projectRoot) {
 }
 function detectStack(projectRoot) {
   const stacks = [...detectNodeStacks(projectRoot)];
-  if (fs26.existsSync(path23.join(projectRoot, "go.mod"))) {
+  if (fs27.existsSync(path24.join(projectRoot, "go.mod"))) {
     stacks.push("go");
   }
-  const hasPython = fs26.existsSync(path23.join(projectRoot, "requirements.txt")) || fs26.existsSync(path23.join(projectRoot, "pyproject.toml"));
+  const hasPython = fs27.existsSync(path24.join(projectRoot, "requirements.txt")) || fs27.existsSync(path24.join(projectRoot, "pyproject.toml"));
   if (hasPython) {
     stacks.push("python");
   }
@@ -10116,7 +10180,7 @@ function getInjectionPatterns() {
 }
 function getTaintFilePath(projectRoot, sessionId) {
   const id = sessionId || DEFAULT_SESSION_ID;
-  return join382(projectRoot, ".harness", `session-taint-${id}.json`);
+  return join392(projectRoot, ".harness", `session-taint-${id}.json`);
 }
 function readTaint(projectRoot, sessionId) {
   const filePath = getTaintFilePath(projectRoot, sessionId);
@@ -10198,14 +10262,14 @@ function clearTaint(projectRoot, sessionId) {
       return 0;
     }
   }
-  const harnessDir = join382(projectRoot, ".harness");
+  const harnessDir = join392(projectRoot, ".harness");
   let count = 0;
   try {
     const files = readdirSync3(harnessDir);
     for (const file of files) {
       if (file.startsWith("session-taint-") && file.endsWith(".json")) {
         try {
-          unlinkSync2(join382(harnessDir, file));
+          unlinkSync2(join392(harnessDir, file));
           count++;
         } catch {
         }
@@ -10216,7 +10280,7 @@ function clearTaint(projectRoot, sessionId) {
   return count;
 }
 function listTaintedSessions(projectRoot) {
-  const harnessDir = join382(projectRoot, ".harness");
+  const harnessDir = join392(projectRoot, ".harness");
   const sessions = [];
   try {
     const files = readdirSync3(harnessDir);
@@ -10288,7 +10352,7 @@ function securityFindingId(finding) {
 }
 async function runValidateCheck(projectRoot, config) {
   const issues = [];
-  const agentsPath = path24.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
+  const agentsPath = path25.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
   const result = await validateAgentsMap(agentsPath);
   if (!result.ok) {
     issues.push({ severity: "error", message: result.error.message });
@@ -10345,7 +10409,7 @@ async function runDepsCheck(projectRoot, config) {
 }
 async function runDocsCheck(projectRoot, config) {
   const issues = [];
-  const docsDir = path24.join(projectRoot, config.docsDir ?? "docs");
+  const docsDir = path25.join(projectRoot, config.docsDir ?? "docs");
   const entropyConfig = config.entropy || {};
   const result = await checkDocCoverage("project", {
     docsDir,
@@ -10530,7 +10594,7 @@ async function runTraceabilityCheck(projectRoot, config) {
   const issues = [];
   const traceConfig = config.traceability || {};
   if (traceConfig.enabled === false) return issues;
-  const graphDir = path24.join(projectRoot, ".harness", "graph");
+  const graphDir = path25.join(projectRoot, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);
   if (!loaded) {
@@ -10708,7 +10772,7 @@ async function runMechanicalChecks(options) {
   };
   if (!skip.includes("validate")) {
     try {
-      const agentsPath = path25.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
+      const agentsPath = path26.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
       const result = await validateAgentsMap(agentsPath);
       if (!result.ok) {
         statuses.validate = "fail";
@@ -10745,7 +10809,7 @@ async function runMechanicalChecks(options) {
       statuses.validate = "fail";
       findings.push({
         tool: "validate",
-        file: path25.join(projectRoot, "AGENTS.md"),
+        file: path26.join(projectRoot, "AGENTS.md"),
         message: err instanceof Error ? err.message : String(err),
         severity: "error"
       });
@@ -10809,7 +10873,7 @@ async function runMechanicalChecks(options) {
       (async () => {
         const localFindings = [];
         try {
-          const docsDir = path25.join(projectRoot, config.docsDir ?? "docs");
+          const docsDir = path26.join(projectRoot, config.docsDir ?? "docs");
           const result = await checkDocCoverage("project", { docsDir });
           if (!result.ok) {
             statuses["check-docs"] = "warn";
@@ -10836,7 +10900,7 @@ async function runMechanicalChecks(options) {
           statuses["check-docs"] = "warn";
           localFindings.push({
             tool: "check-docs",
-            file: path25.join(projectRoot, "docs"),
+            file: path26.join(projectRoot, "docs"),
             message: err instanceof Error ? err.message : String(err),
             severity: "warning"
           });
@@ -10933,18 +10997,18 @@ function computeContextBudget(diffLines) {
   return diffLines;
 }
 function isWithinProject(absPath, projectRoot) {
-  const resolvedRoot = path26.resolve(projectRoot) + path26.sep;
-  const resolvedPath = path26.resolve(absPath);
-  return resolvedPath.startsWith(resolvedRoot) || resolvedPath === path26.resolve(projectRoot);
+  const resolvedRoot = path27.resolve(projectRoot) + path27.sep;
+  const resolvedPath = path27.resolve(absPath);
+  return resolvedPath.startsWith(resolvedRoot) || resolvedPath === path27.resolve(projectRoot);
 }
 async function readContextFile(projectRoot, filePath, reason) {
-  const absPath = path26.isAbsolute(filePath) ? filePath : path26.join(projectRoot, filePath);
+  const absPath = path27.isAbsolute(filePath) ? filePath : path27.join(projectRoot, filePath);
   if (!isWithinProject(absPath, projectRoot)) return null;
   const result = await readFileContent(absPath);
   if (!result.ok) return null;
   const content = result.value;
   const lines = content.split("\n").length;
-  const relPath2 = path26.isAbsolute(filePath) ? relativePosix(projectRoot, filePath) : filePath;
+  const relPath2 = path27.isAbsolute(filePath) ? relativePosix(projectRoot, filePath) : filePath;
   return { path: relPath2, content, reason, lines };
 }
 function extractImportSources2(content) {
@@ -10959,24 +11023,24 @@ function extractImportSources2(content) {
 }
 async function resolveImportPath2(projectRoot, fromFile, importSource) {
   if (!importSource.startsWith(".")) return null;
-  const fromDir = path26.dirname(path26.join(projectRoot, fromFile));
-  const basePath = path26.resolve(fromDir, importSource);
+  const fromDir = path27.dirname(path27.join(projectRoot, fromFile));
+  const basePath = path27.resolve(fromDir, importSource);
   if (!isWithinProject(basePath, projectRoot)) return null;
   const relBase = relativePosix(projectRoot, basePath);
-  const sourceExt = path26.extname(relBase);
+  const sourceExt = path27.extname(relBase);
   const candidates = [];
   const fallbacks = JS_EXT_FALLBACKS22[sourceExt];
   if (fallbacks) {
     const stripped = relBase.slice(0, -sourceExt.length);
     for (const ext of fallbacks) candidates.push(stripped + ext);
-    candidates.push(path26.join(stripped, "index.ts"));
-    candidates.push(path26.join(stripped, "index.tsx"));
-    candidates.push(path26.join(stripped, "index.jsx"));
+    candidates.push(path27.join(stripped, "index.ts"));
+    candidates.push(path27.join(stripped, "index.tsx"));
+    candidates.push(path27.join(stripped, "index.jsx"));
   }
   candidates.push(relBase + ".ts", relBase + ".tsx", relBase + ".mts");
-  candidates.push(path26.join(relBase, "index.ts"));
+  candidates.push(path27.join(relBase, "index.ts"));
   for (const candidate of candidates) {
-    const absCandidate = path26.join(projectRoot, candidate);
+    const absCandidate = path27.join(projectRoot, candidate);
     if (await fileExists(absCandidate)) {
       return candidate;
     }
@@ -10984,7 +11048,7 @@ async function resolveImportPath2(projectRoot, fromFile, importSource) {
   return null;
 }
 async function findTestFiles(projectRoot, sourceFile) {
-  const baseName = path26.basename(sourceFile, path26.extname(sourceFile));
+  const baseName = path27.basename(sourceFile, path27.extname(sourceFile));
   const pattern = `**/${baseName}.{test,spec}.{ts,tsx,mts}`;
   const results = await findFiles(pattern, projectRoot);
   return results.map((f) => relativePosix(projectRoot, f));
@@ -11752,7 +11816,7 @@ function normalizePath(filePath, projectRoot) {
   let normalized = filePath;
   normalized = normalized.replace(/\\/g, "/");
   const normalizedRoot = projectRoot.replace(/\\/g, "/");
-  if (path27.isAbsolute(normalized)) {
+  if (path28.isAbsolute(normalized)) {
     const root = normalizedRoot.endsWith("/") ? normalizedRoot : normalizedRoot + "/";
     if (normalized.startsWith(root)) {
       normalized = normalized.slice(root.length);
@@ -11764,12 +11828,12 @@ function normalizePath(filePath, projectRoot) {
   return normalized;
 }
 function resolveImportPath22(currentFile, importPath) {
-  const dir = path27.dirname(currentFile);
-  let resolved = path27.join(dir, importPath).replace(/\\/g, "/");
+  const dir = path28.dirname(currentFile);
+  let resolved = path28.join(dir, importPath).replace(/\\/g, "/");
   if (!resolved.match(/\.(ts|tsx|js|jsx)$/)) {
     resolved += ".ts";
   }
-  return path27.normalize(resolved).replace(/\\/g, "/");
+  return path28.normalize(resolved).replace(/\\/g, "/");
 }
 function enqueueImports(content, current, visited, queue, maxDepth) {
   const importRegex = /import\s+.*?from\s+['"]([^'"]+)['"]/g;
@@ -11801,7 +11865,7 @@ function isMechanicallyExcluded(finding, exclusionSet, projectRoot) {
   const normalizedFile = normalizePath(finding.file, projectRoot);
   if (exclusionSet.isExcluded(normalizedFile, finding.lineRange)) return true;
   if (exclusionSet.isExcluded(finding.file, finding.lineRange)) return true;
-  const absoluteFile = path27.isAbsolute(finding.file) ? finding.file : path27.join(projectRoot, finding.file).replace(/\\/g, "/");
+  const absoluteFile = path28.isAbsolute(finding.file) ? finding.file : path28.join(projectRoot, finding.file).replace(/\\/g, "/");
   return exclusionSet.isExcluded(absoluteFile, finding.lineRange);
 }
 async function validateWithGraph(crossFileRefs, graph) {
@@ -12809,7 +12873,7 @@ function isRegression(from, to) {
 }
 function collectAutopilotStatuses(autopilotPath, featurePlans, allTaskStatuses) {
   try {
-    const raw = fs28.readFileSync(autopilotPath, "utf-8");
+    const raw = fs29.readFileSync(autopilotPath, "utf-8");
     const autopilot = JSON.parse(raw);
     if (!autopilot.phases) return;
     const linkedPhases = autopilot.phases.filter(
@@ -12841,10 +12905,10 @@ function inferStatus(feature, projectPath, allFeatures) {
   const featuresWithPlans = allFeatures.filter((f) => f.plans.length > 0);
   const useRootState = featuresWithPlans.length <= 1;
   if (useRootState) {
-    const rootStatePath = path28.join(projectPath, ".harness", "state.json");
-    if (fs28.existsSync(rootStatePath)) {
+    const rootStatePath = path29.join(projectPath, ".harness", "state.json");
+    if (fs29.existsSync(rootStatePath)) {
       try {
-        const raw = fs28.readFileSync(rootStatePath, "utf-8");
+        const raw = fs29.readFileSync(rootStatePath, "utf-8");
         const state = JSON.parse(raw);
         if (state.progress) {
           for (const status of Object.values(state.progress)) {
@@ -12855,14 +12919,14 @@ function inferStatus(feature, projectPath, allFeatures) {
       }
     }
   }
-  const sessionsDir = path28.join(projectPath, ".harness", "sessions");
-  if (fs28.existsSync(sessionsDir)) {
+  const sessionsDir = path29.join(projectPath, ".harness", "sessions");
+  if (fs29.existsSync(sessionsDir)) {
     try {
-      const sessionDirs = fs28.readdirSync(sessionsDir, { withFileTypes: true });
+      const sessionDirs = fs29.readdirSync(sessionsDir, { withFileTypes: true });
       for (const entry of sessionDirs) {
         if (!entry.isDirectory()) continue;
-        const autopilotPath = path28.join(sessionsDir, entry.name, "autopilot-state.json");
-        if (!fs28.existsSync(autopilotPath)) continue;
+        const autopilotPath = path29.join(sessionsDir, entry.name, "autopilot-state.json");
+        if (!fs29.existsSync(autopilotPath)) continue;
         collectAutopilotStatuses(autopilotPath, feature.plans, allTaskStatuses);
       }
     } catch {
@@ -12944,7 +13008,7 @@ function parseRepoParts(repo) {
   return { owner: parts[0], repo: parts[1] };
 }
 function sleep2(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 async function fetchWithRetry(fetchFn, input, init, opts = RETRY_DEFAULTS) {
   let lastResponse;
@@ -12977,9 +13041,9 @@ function isValidTrackerShape(tracker) {
 }
 function loadTrackerSyncConfig(projectRoot) {
   try {
-    const configPath = path29.join(projectRoot, "harness.config.json");
-    if (!fs29.existsSync(configPath)) return null;
-    const raw = fs29.readFileSync(configPath, "utf-8");
+    const configPath = path30.join(projectRoot, "harness.config.json");
+    if (!fs30.existsSync(configPath)) return null;
+    const raw = fs30.readFileSync(configPath, "utf-8");
     const config = JSON.parse(raw);
     const tracker = config.roadmap?.tracker;
     if (!isValidTrackerShape(tracker)) return null;
@@ -13094,12 +13158,12 @@ async function syncFromExternal(roadmap, adapter2, config, options, prefetchedTi
 async function fullSync(roadmapPath, adapter2, config, options) {
   const previousSync = syncMutex;
   let releaseMutex;
-  syncMutex = new Promise((resolve8) => {
-    releaseMutex = resolve8;
+  syncMutex = new Promise((resolve9) => {
+    releaseMutex = resolve9;
   });
   await previousSync;
   try {
-    const raw = fs30.readFileSync(roadmapPath, "utf-8");
+    const raw = fs31.readFileSync(roadmapPath, "utf-8");
     const parseResult = parseRoadmap(raw);
     if (!parseResult.ok) {
       return {
@@ -13112,7 +13176,7 @@ async function fullSync(roadmapPath, adapter2, config, options) {
     const tickets = fetchResult.ok ? fetchResult.value : void 0;
     const pushResult = await syncToExternal(roadmap, adapter2, config, tickets);
     const pullResult = await syncFromExternal(roadmap, adapter2, config, options);
-    fs30.writeFileSync(roadmapPath, serializeRoadmap(roadmap), "utf-8");
+    fs31.writeFileSync(roadmapPath, serializeRoadmap(roadmap), "utf-8");
     return {
       created: pushResult.created,
       updated: pushResult.updated,
@@ -13123,6 +13187,32 @@ async function fullSync(roadmapPath, adapter2, config, options) {
     releaseMutex();
   }
 }
+function scoreRoadmapCandidatesFileLess(features, _options) {
+  const allNames = new Set(features.map((f) => f.name.toLowerCase()));
+  const doneNames = new Set(
+    features.filter((f) => f.status === "done").map((f) => f.name.toLowerCase())
+  );
+  const eligible = features.filter((f) => {
+    if (f.status !== "planned" && f.status !== "backlog") return false;
+    return !f.blockedBy.some((b) => {
+      const k = b.toLowerCase();
+      return allNames.has(k) && !doneNames.has(k);
+    });
+  });
+  const candidates = eligible.map((f) => ({
+    feature: f,
+    priorityTier: f.priority ? PRIORITY_RANK[f.priority] : null
+  }));
+  candidates.sort((a, b) => {
+    const ap = a.priorityTier;
+    const bp = b.priorityTier;
+    if (ap !== null && bp === null) return -1;
+    if (ap === null && bp !== null) return 1;
+    if (ap !== null && bp !== null && ap !== bp) return ap - bp;
+    return a.feature.createdAt.localeCompare(b.feature.createdAt);
+  });
+  return candidates;
+}
 function isEligibleCandidate(feature, allFeatureNames, doneFeatures) {
   if (feature.status !== "planned" && feature.status !== "backlog") return false;
   const isBlocked = feature.blockedBy.some((blocker) => {
@@ -13192,7 +13282,7 @@ function scoreRoadmapCandidates(roadmap, options) {
         userCompletedFeatures
       );
       const weightedScore = POSITION_WEIGHT * positionScore + DEPENDENTS_WEIGHT * dependentsScore + AFFINITY_WEIGHT * affinityScore;
-      const priorityTier = feature.priority ? PRIORITY_RANK[feature.priority] : null;
+      const priorityTier = feature.priority ? PRIORITY_RANK2[feature.priority] : null;
       candidates.push({
         feature,
         milestone: ms.name,
@@ -13232,9 +13322,550 @@ function assignFeature(roadmap, feature, assignee, date) {
     date
   });
 }
+function scoreRoadmapCandidatesForMode(roadmap, options, config) {
+  const mode = getRoadmapMode(config);
+  if (mode === "file-less") {
+    const flatFeatures = roadmap.milestones.flatMap((m) => m.features);
+    const tracked = flatFeatures.map(featureToTrackedFeature);
+    const fileLess = scoreRoadmapCandidatesFileLess(tracked, options);
+    const featuresByName = new Map(flatFeatures.map((f) => [f.name, f]));
+    return fileLess.map((c) => {
+      const feature = featuresByName.get(c.feature.name);
+      if (!feature) {
+        throw new Error(`Internal: feature ${c.feature.name} lost during mode dispatch`);
+      }
+      return {
+        feature,
+        milestone: "",
+        positionScore: 0,
+        dependentsScore: 0,
+        affinityScore: 0,
+        weightedScore: 0,
+        priorityTier: c.priorityTier
+      };
+    });
+  }
+  return scoreRoadmapCandidates(roadmap, options);
+}
+function featureToTrackedFeature(f) {
+  return {
+    externalId: f.externalId ?? "",
+    name: f.name,
+    status: f.status,
+    summary: f.summary,
+    spec: f.spec,
+    plans: f.plans,
+    blockedBy: f.blockedBy,
+    assignee: f.assignee,
+    priority: f.priority,
+    milestone: null,
+    createdAt: "1970-01-01T00:00:00Z",
+    updatedAt: f.updatedAt
+  };
+}
+function parseExternalId2(externalId) {
+  const m = externalId.match(/^github:([^/]+)\/([^#]+)#(\d+)$/);
+  if (!m) return null;
+  return { owner: m[1], repo: m[2], number: parseInt(m[3], 10) };
+}
+function buildExternalId2(owner, repo, n) {
+  return `github:${owner}/${repo}#${n}`;
+}
+function parseBodyBlock(body) {
+  const startIdx = body.indexOf(START_MARKER);
+  if (startIdx === -1) return { summary: body.trim(), meta: {} };
+  const endIdx = body.indexOf(END_MARKER, startIdx + START_MARKER.length);
+  if (endIdx === -1) return { summary: body.trim(), meta: {} };
+  const secondStart = body.indexOf(START_MARKER, endIdx + END_MARKER.length);
+  if (secondStart !== -1) {
+    console.warn("harness-meta: multiple blocks found; first wins.");
+  }
+  const yamlText = body.slice(startIdx + START_MARKER.length, endIdx).trim();
+  let meta = {};
+  try {
+    const parsed = parseYaml(yamlText);
+    if (parsed && typeof parsed === "object") {
+      meta = normalizeBodyMeta(parsed);
+    }
+  } catch (e) {
+    console.warn(
+      `harness-meta: malformed YAML, treating block as missing: ${e.message}`
+    );
+    meta = {};
+  }
+  const summary = body.slice(0, startIdx).trim();
+  return { summary, meta };
+}
+function normalizeBodyMeta(raw) {
+  const out = {};
+  if (typeof raw.spec === "string") out.spec = raw.spec;
+  if (typeof raw.plan === "string") out.plan = raw.plan;
+  if (typeof raw.blocked_by === "string") {
+    out.blocked_by = raw.blocked_by.split(",").map((s) => s.trim()).filter(Boolean);
+  } else if (Array.isArray(raw.blocked_by)) {
+    out.blocked_by = raw.blocked_by.filter(
+      (v) => typeof v === "string"
+    );
+  }
+  if (typeof raw.priority === "string" && ["P0", "P1", "P2", "P3"].includes(raw.priority)) {
+    out.priority = raw.priority;
+  }
+  if (typeof raw.milestone === "string") out.milestone = raw.milestone;
+  return out;
+}
+function serializeBodyBlock(summary, meta) {
+  const ordered = {};
+  for (const [key, yamlKey, mapValue] of SERIALIZER_FIELDS) {
+    const raw = meta[key];
+    if (raw === void 0 || raw === null) continue;
+    const out = mapValue(raw);
+    if (out === void 0) continue;
+    ordered[yamlKey] = out;
+  }
+  const trimmed = summary.trim();
+  if (Object.keys(ordered).length === 0) return trimmed;
+  const yamlBody = stringifyYaml(ordered).trimEnd();
+  const block = `${START_MARKER}
+${yamlBody}
+${END_MARKER}`;
+  return trimmed.length > 0 ? `${trimmed}
+
+${block}` : block;
+}
+function compareStatus(server, patch) {
+  if (patch.status === void 0) return { idempotent: true };
+  if (server.status === "done" && patch.status !== "done") {
+    return { diff: { ours: patch.status, theirs: server.status }, idempotent: false };
+  }
+  return { idempotent: server.status === patch.status };
+}
+function compareAssignee(server, patch) {
+  if (patch.assignee === void 0) return { idempotent: true };
+  if (server.assignee !== null && server.assignee !== patch.assignee) {
+    return { diff: { ours: patch.assignee, theirs: server.assignee }, idempotent: false };
+  }
+  return { idempotent: server.assignee === patch.assignee };
+}
+function compareScalar(field, server, patch) {
+  const next = patch[field];
+  if (next === void 0) return { idempotent: true };
+  const cur = server[field];
+  if (cur !== null && cur !== next) {
+    return { diff: { ours: next, theirs: cur }, idempotent: false };
+  }
+  return { idempotent: cur === next };
+}
+function compareArray(field, server, patch) {
+  const next = patch[field];
+  if (next === void 0) return { idempotent: true };
+  const cur = server[field];
+  if (arraysEqual2(next, cur)) return { idempotent: true };
+  if (cur.length > 0 && cur.some((v) => !next.includes(v))) {
+    return { diff: { ours: next, theirs: cur }, idempotent: false };
+  }
+  return { idempotent: false };
+}
+function refetchAndCompare(server, patch) {
+  const verdicts = [
+    ["status", compareStatus(server, patch)],
+    ["assignee", compareAssignee(server, patch)],
+    ["priority", compareScalar("priority", server, patch)],
+    ["milestone", compareScalar("milestone", server, patch)],
+    ["spec", compareScalar("spec", server, patch)],
+    ["plans", compareArray("plans", server, patch)],
+    ["blockedBy", compareArray("blockedBy", server, patch)]
+  ];
+  const diff2 = {};
+  let idempotent = true;
+  for (const [field, verdict] of verdicts) {
+    if (verdict.diff) diff2[field] = verdict.diff;
+    if (!verdict.idempotent) idempotent = false;
+  }
+  if (Object.keys(diff2).length > 0) return { ok: false, diff: diff2 };
+  return { ok: true, idempotent };
+}
+function arraysEqual2(a, b) {
+  if (a.length !== b.length) return false;
+  const sa = [...a].sort();
+  const sb = [...b].sort();
+  return sa.every((v, i) => v === sb[i]);
+}
+function metaFromFeatureFields(src) {
+  const meta = {};
+  if (src.spec !== void 0 && src.spec !== null) meta.spec = src.spec;
+  if (src.plans && src.plans.length > 0) meta.plan = src.plans[0];
+  if (src.blockedBy && src.blockedBy.length > 0) meta.blocked_by = src.blockedBy;
+  if (src.priority !== void 0 && src.priority !== null) meta.priority = src.priority;
+  if (src.milestone !== void 0 && src.milestone !== null) meta.milestone = src.milestone;
+  return meta;
+}
+function buildCreateMeta(feature) {
+  return metaFromFeatureFields(feature);
+}
+function createTrackerClient(config) {
+  if (config.kind !== "github-issues") {
+    return Err(new Error(`Unsupported tracker kind: "${String(config.kind)}"`));
+  }
+  const token = config.token ?? process.env.GITHUB_TOKEN;
+  if (!token) {
+    return Err(
+      new Error("createTrackerClient: missing GitHub token (config.token or GITHUB_TOKEN env)")
+    );
+  }
+  const opts = { token, repo: config.repo };
+  if (config.apiBase !== void 0) opts.apiBase = config.apiBase;
+  if (config.selectorLabel !== void 0) opts.selectorLabel = config.selectorLabel;
+  if (config.etagStore !== void 0) opts.etagStore = config.etagStore;
+  return Ok(new GitHubIssuesTrackerAdapter(opts));
+}
+function makeTrackerConflictBody(err, opts = {}) {
+  return {
+    error: err.message,
+    code: "TRACKER_CONFLICT",
+    externalId: err.externalId,
+    conflictedWith: opts.conflictedWith ?? err.diff,
+    refreshHint: "reload-roadmap"
+  };
+}
+function loadProjectRoadmapMode(projectRoot) {
+  try {
+    const configPath = path31.join(projectRoot, "harness.config.json");
+    if (!fs32.existsSync(configPath)) return getRoadmapMode(null);
+    const raw = fs32.readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return getRoadmapMode(parsed);
+  } catch {
+    return getRoadmapMode(null);
+  }
+}
+function loadTrackerClientConfigFromProject(projectRoot) {
+  try {
+    const configPath = path32.join(projectRoot, "harness.config.json");
+    if (!fs33.existsSync(configPath)) {
+      return Err(new Error("harness.config.json not found"));
+    }
+    const cfg = JSON.parse(fs33.readFileSync(configPath, "utf-8"));
+    const tracker = cfg.roadmap?.tracker;
+    if (!tracker) {
+      return Err(
+        new Error(
+          "file-less tracker config missing: set roadmap.tracker.kind in harness.config.json"
+        )
+      );
+    }
+    if (tracker.kind !== "github") {
+      return Err(
+        new Error(`file-less tracker only supports kind: "github" today; got "${tracker.kind}"`)
+      );
+    }
+    if (!tracker.repo) {
+      return Err(
+        new Error(
+          "roadmap.tracker.repo is required for file-less mode (set it in harness.config.json)"
+        )
+      );
+    }
+    return Ok({ kind: "github-issues", repo: tracker.repo });
+  } catch (e) {
+    return Err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+function bodyMetaMatches(a, b) {
+  return eqOpt(a.spec, b.spec) && eqOpt(a.plan, b.plan) && eqOpt(a.priority, b.priority) && eqOpt(a.milestone, b.milestone) && eqList(a.blocked_by, b.blocked_by);
+}
+function eqOpt(x, y) {
+  const xx = x ?? null;
+  const yy = y ?? null;
+  return xx === yy;
+}
+function eqList(x, y) {
+  const xx = (x ?? []).slice().sort();
+  const yy = (y ?? []).slice().sort();
+  if (xx.length !== yy.length) return false;
+  for (let i = 0; i < xx.length; i++) if (xx[i] !== yy[i]) return false;
+  return true;
+}
+function normalizeAt(at) {
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/.test(at)) return at;
+  const d = new Date(at);
+  if (Number.isNaN(d.getTime())) return at;
+  const seconds = Math.floor(d.getTime() / 1e3) * 1e3;
+  return new Date(seconds).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function hashHistoryEvent(event) {
+  const detailsStr = JSON.stringify(event.details ?? {});
+  const at = normalizeAt(event.at);
+  const input = `${event.type}|${event.actor}|${at}|${detailsStr}`;
+  return createHash4("sha256").update(input).digest("hex").slice(0, 8);
+}
+function parseHashFromCommentBody(commentBody) {
+  const match = commentBody.match(HASH_RE);
+  return match ? match[1] : null;
+}
+function buildHistoryCommentBody(event) {
+  const hash = hashHistoryEvent(event);
+  return `<!-- harness-history hash:${hash} -->
+${JSON.stringify(event)}`;
+}
+async function buildMigrationPlan(roadmap, existingFeatures, fetchHistoryHashes, getRawBodyForExternalId) {
+  const plan = {
+    toCreate: [],
+    toUpdate: [],
+    unchanged: [],
+    historyToAppend: [],
+    ambiguous: []
+  };
+  const byExternalId = /* @__PURE__ */ new Map();
+  const byNameLower = /* @__PURE__ */ new Map();
+  for (const t of existingFeatures) {
+    byExternalId.set(t.externalId, t);
+    byNameLower.set(t.name.toLowerCase(), t);
+  }
+  const featureToExternalId = /* @__PURE__ */ new Map();
+  for (const ms of roadmap.milestones) {
+    for (const f of ms.features) {
+      if (f.externalId) featureToExternalId.set(f.name, f.externalId);
+    }
+  }
+  for (const ms of roadmap.milestones) {
+    for (const feature of ms.features) {
+      if (feature.externalId == null) {
+        const existing = byNameLower.get(feature.name.toLowerCase());
+        if (existing) {
+          plan.ambiguous.push({ name: feature.name, existingIssueRef: existing.externalId });
+        } else {
+          plan.toCreate.push({
+            name: feature.name,
+            input: featureToNewInput(feature, ms)
+          });
+        }
+        continue;
+      }
+      const tracked = byExternalId.get(feature.externalId);
+      if (!tracked) {
+        plan.ambiguous.push({
+          name: feature.name,
+          existingIssueRef: `${feature.externalId} (recorded external id not found)`
+        });
+        continue;
+      }
+      const expectedMeta = featureToExpectedMeta(feature, ms);
+      const rawBody = await getRawBodyForExternalId(feature.externalId);
+      const actualMeta = rawBody == null ? {} : parseBodyBlock(rawBody).meta;
+      if (rawBody != null && bodyMetaMatches(actualMeta, expectedMeta)) {
+        plan.unchanged.push({ externalId: feature.externalId, name: feature.name });
+      } else {
+        const diff2 = formatDiff(actualMeta, expectedMeta);
+        const patch = metaToPatch(feature, expectedMeta);
+        plan.toUpdate.push({
+          externalId: feature.externalId,
+          name: feature.name,
+          patch,
+          diff: diff2
+        });
+      }
+    }
+  }
+  for (const record of roadmap.assignmentHistory) {
+    const externalId = featureToExternalId.get(record.feature);
+    if (!externalId) {
+      console.warn(
+        `harness-migrate: cannot resolve external id for assignment-history feature "${record.feature}"; skipping.`
+      );
+      continue;
+    }
+    const type = mapAction(record.action);
+    const event = {
+      type,
+      actor: record.assignee,
+      at: record.date
+    };
+    const hash = hashHistoryEvent(event);
+    const existingHashes = await fetchHistoryHashes(externalId);
+    if (existingHashes.has(hash)) continue;
+    plan.historyToAppend.push({ externalId, event, hash });
+  }
+  return plan;
+}
+function featureToExpectedMeta(feature, milestone) {
+  const meta = {};
+  if (feature.spec != null) meta.spec = feature.spec;
+  if (feature.plans.length > 0) meta.plan = feature.plans[0] ?? null;
+  if (feature.blockedBy.length > 0) meta.blocked_by = feature.blockedBy.slice().sort();
+  if (feature.priority != null) meta.priority = feature.priority;
+  if (!milestone.isBacklog) meta.milestone = milestone.name;
+  return meta;
+}
+function featureToNewInput(feature, milestone) {
+  const input = {
+    name: feature.name,
+    summary: feature.summary,
+    status: feature.status,
+    spec: feature.spec,
+    plans: feature.plans,
+    blockedBy: feature.blockedBy,
+    priority: feature.priority,
+    milestone: milestone.isBacklog ? null : milestone.name,
+    assignee: feature.assignee
+  };
+  return input;
+}
+function metaToPatch(feature, expected) {
+  const patch = {};
+  patch.summary = feature.summary;
+  if (expected.spec !== void 0) patch.spec = expected.spec ?? null;
+  if (expected.plan !== void 0 && expected.plan != null) patch.plans = [expected.plan];
+  if (expected.blocked_by !== void 0) patch.blockedBy = expected.blocked_by ?? [];
+  if (expected.priority !== void 0) patch.priority = expected.priority ?? null;
+  if (expected.milestone !== void 0) patch.milestone = expected.milestone ?? null;
+  return patch;
+}
+function formatDiff(actual, expected) {
+  const keys = /* @__PURE__ */ new Set();
+  const collect = (m) => {
+    for (const k of Object.keys(m)) {
+      const v = m[k];
+      if (v !== void 0 && v !== null && !(Array.isArray(v) && v.length === 0)) keys.add(k);
+    }
+  };
+  collect(actual);
+  collect(expected);
+  const changed = [];
+  for (const key of [...keys].sort()) {
+    const a = actual[key];
+    const e = expected[key];
+    if (JSON.stringify(a ?? null) !== JSON.stringify(e ?? null)) changed.push(key);
+  }
+  return changed.join(",");
+}
+function mapAction(action) {
+  switch (action) {
+    case "assigned":
+      return "claimed";
+    case "completed":
+      return "completed";
+    case "unassigned":
+      return "released";
+  }
+}
+async function runMigrationPlan(plan, deps, opts) {
+  const projectRoot = opts.projectRoot;
+  const roadmapPath = path33.join(projectRoot, "docs", "roadmap.md");
+  const archivedPath = path33.join(projectRoot, "docs", "roadmap.md.archived");
+  const configPath = path33.join(projectRoot, "harness.config.json");
+  const configBackupPath = path33.join(projectRoot, "harness.config.json.pre-migration");
+  const createdSoFar = [];
+  const report = {
+    created: 0,
+    updated: 0,
+    unchanged: plan.unchanged.length,
+    historyAppended: 0,
+    archivedFrom: null,
+    archivedTo: null,
+    configBackup: null,
+    mode: "applied"
+  };
+  if (plan.ambiguous.length > 0) {
+    const names = plan.ambiguous.map((a) => a.name).join(", ");
+    return Ok({
+      ...report,
+      mode: "aborted",
+      abortReason: `ambiguous features (title-collision or dangling external-id): ${names}`
+    });
+  }
+  if (opts.dryRun) {
+    return Ok({ ...report, mode: "dry-run" });
+  }
+  for (const entry of plan.toCreate) {
+    const r = await deps.client.create(entry.input);
+    if (!r.ok) {
+      return Ok({
+        ...report,
+        created: createdSoFar.length,
+        createdSoFar,
+        mode: "aborted",
+        abortReason: `create failed for "${entry.name}": ${r.error.message}`
+      });
+    }
+    createdSoFar.push({ name: entry.name, externalId: r.value.externalId });
+  }
+  report.created = createdSoFar.length;
+  for (const entry of plan.toUpdate) {
+    const r = await deps.client.update(entry.externalId, entry.patch);
+    if (!r.ok) {
+      return Ok({
+        ...report,
+        createdSoFar,
+        mode: "aborted",
+        abortReason: `update failed for "${entry.name}" (${entry.externalId}): ${r.error.message}`
+      });
+    }
+    report.updated++;
+  }
+  for (const entry of plan.historyToAppend) {
+    const r = await deps.client.appendHistory(entry.externalId, entry.event);
+    if (!r.ok) {
+      return Ok({
+        ...report,
+        createdSoFar,
+        mode: "aborted",
+        abortReason: `appendHistory failed for ${entry.externalId} (${entry.event.type}): ${r.error.message}`
+      });
+    }
+    report.historyAppended++;
+  }
+  if (deps.existsFile(archivedPath)) {
+    return Ok({
+      ...report,
+      createdSoFar,
+      mode: "aborted",
+      abortReason: `archive-collision: ${archivedPath} already exists; refusing to overwrite`
+    });
+  }
+  if (deps.existsFile(roadmapPath)) {
+    try {
+      deps.renameFile(roadmapPath, archivedPath);
+      report.archivedFrom = roadmapPath;
+      report.archivedTo = archivedPath;
+    } catch (err) {
+      return Ok({
+        ...report,
+        createdSoFar,
+        mode: "aborted",
+        abortReason: `archive failed: ${err.message}`
+      });
+    }
+  }
+  try {
+    if (!deps.existsFile(configPath)) {
+      return Ok({
+        ...report,
+        createdSoFar,
+        mode: "aborted",
+        abortReason: `config rewrite failed: ${configPath} not found`
+      });
+    }
+    const original = deps.readFile(configPath);
+    deps.writeFile(configBackupPath, original);
+    report.configBackup = configBackupPath;
+    const parsed = JSON.parse(original);
+    const roadmapSection = parsed.roadmap ?? {};
+    roadmapSection.mode = "file-less";
+    parsed.roadmap = roadmapSection;
+    deps.writeFile(configPath, JSON.stringify(parsed, null, 2) + "\n");
+  } catch (err) {
+    return Ok({
+      ...report,
+      createdSoFar,
+      mode: "aborted",
+      abortReason: `config rewrite failed: ${err.message}`
+    });
+  }
+  return Ok(report);
+}
 function getStatePath() {
   const home = process.env["HOME"] || os.homedir();
-  return path32.join(home, ".harness", "update-check.json");
+  return path36.join(home, ".harness", "update-check.json");
 }
 function isUpdateCheckEnabled(configInterval) {
   if (process.env["HARNESS_NO_UPDATE_CHECK"] === "1") return false;
@@ -13247,7 +13878,7 @@ function shouldRunCheck(state, intervalMs) {
 }
 function readCheckState() {
   try {
-    const raw = fs33.readFileSync(getStatePath(), "utf-8");
+    const raw = fs36.readFileSync(getStatePath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && "lastCheckTime" in parsed && typeof parsed.lastCheckTime === "number" && "currentVersion" in parsed && typeof parsed.currentVersion === "string") {
       const state = parsed;
@@ -13264,7 +13895,7 @@ function readCheckState() {
 }
 function spawnBackgroundCheck(currentVersion) {
   const statePath = getStatePath();
-  const stateDir = path32.dirname(statePath);
+  const stateDir = path36.dirname(statePath);
   const script = `
 const { execSync } = require('child_process');
 const fs = require('fs');
@@ -13507,14 +14138,14 @@ function getModelPrice(model, dataset) {
   return pricing;
 }
 function getCachePath(projectRoot) {
-  return path33.join(projectRoot, ".harness", "cache", "pricing.json");
+  return path37.join(projectRoot, ".harness", "cache", "pricing.json");
 }
 function getStalenessMarkerPath(projectRoot) {
-  return path33.join(projectRoot, ".harness", "cache", "staleness-marker.json");
+  return path37.join(projectRoot, ".harness", "cache", "staleness-marker.json");
 }
 async function readDiskCache(projectRoot) {
   try {
-    const raw = await fs34.readFile(getCachePath(projectRoot), "utf-8");
+    const raw = await fs37.readFile(getCachePath(projectRoot), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -13522,8 +14153,8 @@ async function readDiskCache(projectRoot) {
 }
 async function writeDiskCache(projectRoot, data) {
   const cachePath = getCachePath(projectRoot);
-  await fs34.mkdir(path33.dirname(cachePath), { recursive: true });
-  await fs34.writeFile(cachePath, JSON.stringify(data, null, 2));
+  await fs37.mkdir(path37.dirname(cachePath), { recursive: true });
+  await fs37.writeFile(cachePath, JSON.stringify(data, null, 2));
 }
 async function fetchFromNetwork() {
   try {
@@ -13550,7 +14181,7 @@ function loadFallbackDataset() {
 async function checkAndWarnStaleness(projectRoot) {
   const markerPath = getStalenessMarkerPath(projectRoot);
   try {
-    const raw = await fs34.readFile(markerPath, "utf-8");
+    const raw = await fs37.readFile(markerPath, "utf-8");
     const marker = JSON.parse(raw);
     const firstUse = new Date(marker.firstFallbackUse).getTime();
     const now = Date.now();
@@ -13562,8 +14193,8 @@ async function checkAndWarnStaleness(projectRoot) {
     }
   } catch {
     try {
-      await fs34.mkdir(path33.dirname(markerPath), { recursive: true });
-      await fs34.writeFile(
+      await fs37.mkdir(path37.dirname(markerPath), { recursive: true });
+      await fs37.writeFile(
         markerPath,
         JSON.stringify({ firstFallbackUse: (/* @__PURE__ */ new Date()).toISOString() })
       );
@@ -13573,7 +14204,7 @@ async function checkAndWarnStaleness(projectRoot) {
 }
 async function clearStalenessMarker(projectRoot) {
   try {
-    await fs34.unlink(getStalenessMarkerPath(projectRoot));
+    await fs37.unlink(getStalenessMarkerPath(projectRoot));
   } catch {
   }
 }
@@ -13810,10 +14441,10 @@ function parseLine(line, lineNumber) {
   return record;
 }
 function readCostRecords(projectRoot) {
-  const costsFile = path34.join(projectRoot, ".harness", "metrics", "costs.jsonl");
+  const costsFile = path38.join(projectRoot, ".harness", "metrics", "costs.jsonl");
   let raw;
   try {
-    raw = fs35.readFileSync(costsFile, "utf-8");
+    raw = fs38.readFileSync(costsFile, "utf-8");
   } catch {
     return [];
   }
@@ -13863,7 +14494,7 @@ function parseCCLine(line, filePath, lineNumber) {
     entry = JSON.parse(line);
   } catch {
     console.warn(
-      `[harness usage] Skipping malformed CC JSONL line ${lineNumber} in ${path35.basename(filePath)}`
+      `[harness usage] Skipping malformed CC JSONL line ${lineNumber} in ${path39.basename(filePath)}`
     );
     return null;
   }
@@ -13877,7 +14508,7 @@ function parseCCLine(line, filePath, lineNumber) {
 function readCCFile(filePath) {
   let raw;
   try {
-    raw = fs36.readFileSync(filePath, "utf-8");
+    raw = fs39.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -13899,10 +14530,10 @@ function readCCFile(filePath) {
 }
 function parseCCRecords() {
   const homeDir = process.env.HOME ?? os2.homedir();
-  const projectsDir = path35.join(homeDir, ".claude", "projects");
+  const projectsDir = path39.join(homeDir, ".claude", "projects");
   let projectDirs;
   try {
-    projectDirs = fs36.readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path35.join(projectsDir, d.name));
+    projectDirs = fs39.readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path39.join(projectsDir, d.name));
   } catch {
     return [];
   }
@@ -13910,7 +14541,7 @@ function parseCCRecords() {
   for (const dir of projectDirs) {
     let files;
     try {
-      files = fs36.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path35.join(dir, f));
+      files = fs39.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path39.join(dir, f));
     } catch {
       continue;
     }
@@ -13938,10 +14569,10 @@ function parseLine2(line, lineNumber) {
   }
 }
 function readAdoptionRecords(projectRoot) {
-  const adoptionFile = path36.join(projectRoot, ".harness", "metrics", "adoption.jsonl");
+  const adoptionFile = path40.join(projectRoot, ".harness", "metrics", "adoption.jsonl");
   let raw;
   try {
-    raw = fs37.readFileSync(adoptionFile, "utf-8");
+    raw = fs40.readFileSync(adoptionFile, "utf-8");
   } catch {
     return [];
   }
@@ -14089,25 +14720,25 @@ function resolveStability(contentType) {
   return STABILITY_LOOKUP[contentType] ?? "ephemeral";
 }
 function getOrCreateInstallId(projectRoot) {
-  const harnessDir = path37.join(projectRoot, ".harness");
-  const installIdFile = path37.join(harnessDir, ".install-id");
+  const harnessDir = path41.join(projectRoot, ".harness");
+  const installIdFile = path41.join(harnessDir, ".install-id");
   const UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
   try {
-    const existing = fs38.readFileSync(installIdFile, "utf-8").trim();
+    const existing = fs41.readFileSync(installIdFile, "utf-8").trim();
     if (UUID_V4_RE.test(existing)) {
       return existing;
     }
   } catch {
   }
   const id = crypto4.randomUUID();
-  fs38.mkdirSync(harnessDir, { recursive: true });
-  fs38.writeFileSync(installIdFile, id, { encoding: "utf-8", mode: 384 });
+  fs41.mkdirSync(harnessDir, { recursive: true });
+  fs41.writeFileSync(installIdFile, id, { encoding: "utf-8", mode: 384 });
   return id;
 }
 function parseIdentityFromTelemetryFile(filePath) {
   const identity = {};
   try {
-    const raw = fs39.readFileSync(filePath, "utf-8");
+    const raw = fs42.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     const src = parsed?.identity;
     if (!src || typeof src !== "object") return identity;
@@ -14120,7 +14751,7 @@ function parseIdentityFromTelemetryFile(filePath) {
 }
 function readProjectNameFallback(configPath) {
   try {
-    const raw = fs39.readFileSync(configPath, "utf-8");
+    const raw = fs42.readFileSync(configPath, "utf-8");
     const config = JSON.parse(raw);
     return typeof config?.name === "string" ? config.name : void 0;
   } catch {
@@ -14141,10 +14772,10 @@ function readGitAliasFallback(cwd) {
   }
 }
 function readIdentity(projectRoot) {
-  const filePath = path38.join(projectRoot, ".harness", "telemetry.json");
+  const filePath = path42.join(projectRoot, ".harness", "telemetry.json");
   const identity = parseIdentityFromTelemetryFile(filePath);
   if (!identity.project) {
-    const fallbackProject = readProjectNameFallback(path38.join(projectRoot, "harness.config.json"));
+    const fallbackProject = readProjectNameFallback(path42.join(projectRoot, "harness.config.json"));
     if (fallbackProject) identity.project = fallbackProject;
   }
   if (!identity.alias) {
@@ -14191,7 +14822,7 @@ function collectEvents(projectRoot, consent) {
   );
 }
 function sleep3(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 async function send(events, apiKey) {
   if (events.length === 0) return;
@@ -14221,12 +14852,12 @@ function acquireCompoundLock(category, opts = {}) {
     );
   }
   const cwd = opts.cwd ?? process.cwd();
-  const lockDir = path39.join(cwd, ".harness", "locks");
-  fs40.mkdirSync(lockDir, { recursive: true });
-  const lockPath = path39.join(lockDir, `compound-${category}.lock`);
+  const lockDir = path43.join(cwd, ".harness", "locks");
+  fs43.mkdirSync(lockDir, { recursive: true });
+  const lockPath = path43.join(lockDir, `compound-${category}.lock`);
   let fd;
   try {
-    fd = fs40.openSync(lockPath, "wx");
+    fd = fs43.openSync(lockPath, "wx");
   } catch (e) {
     const err = e;
     if (err.code === "EEXIST") {
@@ -14235,14 +14866,14 @@ function acquireCompoundLock(category, opts = {}) {
     }
     throw err;
   }
-  fs40.writeSync(fd, String(process.pid));
-  fs40.closeSync(fd);
+  fs43.writeSync(fd, String(process.pid));
+  fs43.closeSync(fd);
   let released = false;
   const release = () => {
     if (released) return;
     released = true;
     try {
-      fs40.unlinkSync(lockPath);
+      fs43.unlinkSync(lockPath);
     } catch {
     }
     process.removeListener("exit", onExit);
@@ -14268,7 +14899,7 @@ function acquireCompoundLock(category, opts = {}) {
 }
 function readHolderPid(lockPath) {
   try {
-    const raw = fs40.readFileSync(lockPath, "utf-8").trim();
+    const raw = fs43.readFileSync(lockPath, "utf-8").trim();
     const n = Number.parseInt(raw, 10);
     return Number.isFinite(n) ? n : -1;
   } catch {
@@ -14293,10 +14924,10 @@ function assertSanitized(value) {
 }
 function writePulseConfig(config, opts) {
   PulseConfigSchema.parse(config);
-  if (!fs41.existsSync(opts.configPath)) {
+  if (!fs44.existsSync(opts.configPath)) {
     throw new Error(`harness.config.json not found at ${opts.configPath}`);
   }
-  const raw = fs41.readFileSync(opts.configPath, "utf-8");
+  const raw = fs44.readFileSync(opts.configPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -14304,18 +14935,18 @@ function writePulseConfig(config, opts) {
     throw new Error(`Invalid JSON in ${opts.configPath}: ${e.message}`, { cause: e });
   }
   const bakPath = `${opts.configPath}.bak`;
-  if (!opts.skipBackup && !fs41.existsSync(bakPath)) {
-    fs41.writeFileSync(bakPath, raw, "utf-8");
+  if (!opts.skipBackup && !fs44.existsSync(bakPath)) {
+    fs44.writeFileSync(bakPath, raw, "utf-8");
   }
   parsed.pulse = config;
   const serialized = JSON.stringify(parsed, null, 2) + "\n";
   const tmpPath = `${opts.configPath}.tmp-${process.pid}`;
-  fs41.writeFileSync(tmpPath, serialized, "utf-8");
+  fs44.writeFileSync(tmpPath, serialized, "utf-8");
   try {
-    fs41.renameSync(tmpPath, opts.configPath);
+    fs44.renameSync(tmpPath, opts.configPath);
   } catch (e) {
     try {
-      fs41.unlinkSync(tmpPath);
+      fs44.unlinkSync(tmpPath);
     } catch {
     }
     throw e;
@@ -14323,12 +14954,12 @@ function writePulseConfig(config, opts) {
 }
 function seedFromStrategy(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const strategyPath = path40.join(cwd, "STRATEGY.md");
+  const strategyPath = path44.join(cwd, "STRATEGY.md");
   const warnings = [];
-  if (!fs42.existsSync(strategyPath)) {
+  if (!fs45.existsSync(strategyPath)) {
     return { name: null, keyMetrics: [], warnings: ["STRATEGY.md not found"] };
   }
-  const raw = fs42.readFileSync(strategyPath, "utf-8");
+  const raw = fs45.readFileSync(strategyPath, "utf-8");
   let name = null;
   const fmMatch = /^---\s*\n([\s\S]*?)\n---\s*\n/.exec(raw);
   const fm = fmMatch?.[1];
@@ -14480,7 +15111,7 @@ function loadTemplate() {
     const url = import.meta?.url;
     if (!url) return INLINE_TEMPLATE;
     const here = dirname18(fileURLToPath(url));
-    return readFileSync36(join572(here, "template.md"), "utf-8");
+    return readFileSync38(join612(here, "template.md"), "utf-8");
   } catch {
     return INLINE_TEMPLATE;
   }
@@ -14669,11 +15300,11 @@ async function computeHotspots(opts) {
   }
   const counts = /* @__PURE__ */ new Map();
   for (const line of stdout.split("\n")) {
-    const path42 = line.trim();
-    if (path42.length === 0) continue;
-    counts.set(path42, (counts.get(path42) ?? 0) + 1);
+    const path46 = line.trim();
+    if (path46.length === 0) continue;
+    counts.set(path46, (counts.get(path46) ?? 0) + 1);
   }
-  return [...counts.entries()].filter(([, c]) => c > opts.threshold).map(([path42, churn]) => ({ path: path42, churn })).sort((a, b) => b.churn - a.churn);
+  return [...counts.entries()].filter(([, c]) => c > opts.threshold).map(([path46, churn]) => ({ path: path46, churn })).sort((a, b) => b.churn - a.churn);
 }
 function tokenize(text) {
   return new Set(
@@ -14683,12 +15314,12 @@ function tokenize(text) {
 async function* walk22(dir) {
   let entries;
   try {
-    entries = await fs43.readdir(dir, { withFileTypes: true });
+    entries = await fs46.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
-    const p = path41.join(dir, e.name);
+    const p = path45.join(dir, e.name);
     if (e.isDirectory()) yield* walk22(p);
     else if (e.isFile() && e.name.endsWith(".md")) yield p;
   }
@@ -14697,11 +15328,11 @@ async function readDocumentedTokens(solutionsDir) {
   const docs = [];
   for (const [track, categories] of TRACK_CATEGORIES2) {
     for (const category of categories) {
-      const dir = path41.join(solutionsDir, track, category);
+      const dir = path45.join(solutionsDir, track, category);
       for await (const file of walk22(dir)) {
-        const raw = await fs43.readFile(file, "utf-8");
+        const raw = await fs46.readFile(file, "utf-8");
         const m = /^#\s+(.+)$/m.exec(raw);
-        const title = m?.[1] ?? path41.basename(file, ".md");
+        const title = m?.[1] ?? path45.basename(file, ".md");
         docs.push(tokenize(title));
       }
     }
@@ -14764,16 +15395,20 @@ function assembleCandidateReport(input) {
   }
   return lines.join("\n");
 }
-var VALID_TYPES, CONVENTIONAL_PATTERN, LOOKBACK_PATTERN, PulseDbSourceSchema, PulseSourcesSchema, PulseConfigSchema, BUG_TRACK_CATEGORIES, KNOWLEDGE_TRACK_CATEGORIES, ALL_SOLUTION_CATEGORIES, ISO_DATE, BugTrackSchema, KnowledgeTrackSchema, BaseFrontmatter, SolutionDocFrontmatterSchema, TRACK_CATEGORIES, DEFAULT_AGNIX_TIMEOUT_MS, HARNESS_AGNIX_DISABLE, HARNESS_AGNIX_BIN, CLAUDE_MD_WARN_BYTES, CLAUDE_MD_ERROR_BYTES, CONTEXT_FILES, MIN_DESCRIPTION_LENGTH, SETTINGS_PATHS, KNOWN_HOOK_EVENTS, MCP_SETTINGS_FILES, REQUIRED_SECTIONS, SETTINGS_FILES, KNOWN_AGNIX_TOOLS, DEFAULT_SECTIONS, DEFAULT_RATIOS, NODE_TYPE_TO_CATEGORY, SECTION_LEVEL_MAP, DEFAULT_LEVEL, DEFAULT_BUDGET, DEFAULT_LOADER_CONFIG, LEVEL_FRACTIONS, PHASE_PRIORITIES, ManifestSchema, BundleConstraintsSchema, BundleSchema, ContributionsSchema, LockfilePackageSchema, LockfileSchema, SharableLayerSchema, SharableForbiddenImportSchema, SharableBoundaryConfigSchema, SharableSecurityRulesSchema, VALID_SCOPES, LINE_PATTERN, START_PATTERN, END_PATTERN, CODE_BLOCK_LANGUAGES, DEFAULT_DRIFT_CONFIG, JS_EXT_FALLBACKS2, FILE_TYPES, EXPORT_TYPES, CONVENTION_DESCRIPTIONS, RULE_CHECKERS, EntropyAnalyzer, readFile62, writeFile32, unlink22, mkdir22, copyFile2, DEFAULT_FIX_CONFIG, EXPORT_TYPE_KEYWORD, ALWAYS_UNSAFE_TYPES, idCounter, DEAD_CODE_FIX_ACTIONS, MustExportRuleSchema, MustExportDefaultRuleSchema, NoExportRuleSchema, MustImportRuleSchema, NoImportRuleSchema, NamingRuleSchema, MaxExportsRuleSchema, MaxLinesRuleSchema, RequireJSDocRuleSchema, RuleSchema, ConfigPatternSchema, PatternConfigSchema, DriftConfigSchema, DeadCodeConfigSchema, EntropyConfigSchema, BaselineManager, BenchmarkRunner, RegressionDetector, SKIP_DIRS, SOURCE_EXTENSIONS, FUNCTION_DECL_RE, CONST_DECL_RE, CriticalPathResolver, NoOpTelemetryAdapter, NoOpExecutor, ConsoleSink, feedbackConfig, ChecklistBuilder, AgentActionEmitter, globalEmitter, FileSink, NoOpSink, CategorySnapshotSchema, TimelineSnapshotSchema, TimelineFileSchema, TrendLineSchema, TrendResultSchema, DEFAULT_STABILITY_THRESHOLDS, ALL_CATEGORIES, TimelineManager, ConfidenceTierSchema, RegressionResultSchema, DirectionSchema, CategoryForecastSchema, SpecImpactSignalsSchema, SpecImpactEstimateSchema, ContributingFeatureSchema, AdjustedForecastSchema, PredictionWarningSchema, StabilityForecastSchema, PredictionResultSchema, PredictionOptionsSchema, VALID_STATUSES, EM_DASH, VALID_PRIORITIES, ALL_CATEGORIES2, DIRECTION_THRESHOLD, PredictionEngine, DEFAULT_COEFFICIENTS, SpecImpactEstimator, EMPTY_HISTORY, ViolationHistoryManager, NORMALIZERS, MAX_SAMPLES, DEFAULT_WINDOW_WEEKS, DEFAULT_MIN_OCCURRENCES, FailureEntrySchema, HandoffSchema, GateCheckSchema, GateResultSchema, GateConfigSchema, HarnessStateSchema, DEFAULT_STATE, StreamInfoSchema, StreamIndexSchema, DEFAULT_STREAM_INDEX, HARNESS_DIR, STATE_FILE, LEARNINGS_FILE, FAILURES_FILE, HANDOFF_FILE, GATE_CONFIG_FILE, INDEX_FILE, SESSIONS_DIR, SESSION_INDEX_FILE, SUMMARY_FILE, SESSION_STATE_FILE, ARCHIVE_DIR, CONTENT_HASHES_FILE, EVENTS_FILE, STREAMS_DIR, STREAM_NAME_REGEX, branchCache, BRANCH_CACHE_TTL_MS, STATE_FILES, MAX_CACHE_ENTRIES, learningsCacheMap, WEIGHTS, LOCK_RETRIES, LOCK_BACKOFFS, PROMOTABLE_OUTCOMES, failuresCacheMap, FAILURE_LINE_REGEX, SAFE_GATE_COMMAND, SkillEventSchema, knownHashesCache, EVENT_FORMATTERS, RuleRegistry, DEFAULT_SECURITY_CONFIG, RuleOverrideSchema, SecurityConfigSchema, secretRules, injectionRules, xssRules, cryptoRules, pathTraversalRules, networkRules, deserializationRules, agentConfigRules, mcpRules, insecureDefaultsRules, sharpEdgesRules, nodeRules, expressRules, reactRules, goRules, SecurityScanner, hiddenUnicodePatterns, reRolingPatterns, permissionEscalationPatterns, encodedPayloadPatterns, indirectInjectionPatterns, contextManipulationPatterns, socialEngineeringPatterns, suspiciousPatterns, ALL_PATTERNS, DESTRUCTIVE_BASH, TAINT_DURATION_MS, DEFAULT_SESSION_ID, SecurityCategorySnapshotSchema, SupplyChainSnapshotSchema, SecurityTimelineSnapshotSchema, FindingLifecycleSchema, SecurityTimelineFileSchema, DirectionSchema2, SecurityTrendLineSchema, TrendAttributionSchema, SecurityTrendResultSchema, TimeToFixStatsSchema, TimeToFixResultSchema, EMPTY_SUPPLY_CHAIN, SecurityTimelineManager, ALL_CHECKS, STATUS_ICONS, CINotifier, ExclusionSet, PREFIX_PATTERNS, TEST_FILE_PATTERN, MD_FILE_PATTERN, ALL_DOMAINS, SECURITY_PATTERNS, JS_EXT_FALLBACKS22, SEVERITY_RANK, SEVERITY_ORDER, SEVERITY_LABELS, VALIDATED_BY_RANK, VALIDATION_SCORES, DOMAIN_BASELINES, FACTOR_WEIGHTS, EVIDENCE_SATURATION, CORROBORATED_AGREEMENT, STANDALONE_AGREEMENT, AGREEMENT_LINE_GAP, COMPLIANCE_DESCRIPTOR, EXPORT_RE, BUG_DETECTION_DESCRIPTOR, SECURITY_DESCRIPTOR, EVAL_PATTERN, SECRET_PATTERNS, SQL_CONCAT_PATTERN, SHELL_EXEC_PATTERN, ARCHITECTURE_DESCRIPTOR, LARGE_FILE_THRESHOLD, VIOLATION_FILE_RE, LEARNINGS_DESCRIPTOR, RELEVANCE_THRESHOLD, AGENT_DESCRIPTORS, AGENT_RUNNERS, DOWNGRADE_MAP, DEFAULT_PROVIDER_TIERS, SMALL_SUGGESTION_LINE_LIMIT, FILE_LINE_RANGE_PATTERN, FILE_LINE_PATTERN, FILE_ONLY_PATTERN, SECURITY_SENSITIVE_PATH, MIGRATION_PATH, TEST_PATH, CONFIG_PATH, STAGE_DOMAINS, EM_DASH2, STATUS_RANK, RETRY_DEFAULTS, GitHubIssuesSyncAdapter, syncMutex, PRIORITY_RANK, POSITION_WEIGHT, DEPENDENTS_WEIGHT, AFFINITY_WEIGHT, InteractionTypeSchema, QuestionSchema, ConfirmationSchema, TransitionSchema, EmitInteractionInputSchema, ProjectScanner, SHELL_TEMPLATE, STYLES, SCRIPTS, MockLLMService, llmService, ContentPipeline, BlueprintGenerator, TOKENS_PER_MILLION, fallback_default, LITELLM_PRICING_URL, CACHE_TTL_MS, STALENESS_WARNING_DAYS, MICRODOLLARS_PER_DOLLAR, TOKENS_PER_MILLION2, StructuralStrategy, DEFAULT_TOKEN_BUDGET, CHARS_PER_TOKEN, TRUNCATION_MARKER, TruncationStrategy, CompactionPipeline, STABILITY_LOOKUP, TIER_ORDER, AnthropicCacheAdapter, TIER_ORDER2, OpenAICacheAdapter, TIER_ORDER3, CACHED_CONTENT_MARKER, GeminiCacheAdapter, VERSION, POSTHOG_BATCH_URL, MAX_ATTEMPTS, TIMEOUT_MS, CompoundLockHeldError, KNOWN_CATEGORIES, ALLOWED_FIELD_KEYS, PII_TOKENS, PII_FIELD_DENYLIST, PII_LINE_RE, ALLOWED_SET, PulseAdapterAlreadyRegisteredError, REGISTRY, MOCK_ADAPTER_NAME, ALLOWED_FIELD_SET, adapter, LOOKBACK_RE, MAX_LINES, INLINE_TEMPLATE, TRUNCATION_MARKER2, execFileAsync, FIX_RE, EMPTY_REPO_RE, execFileAsync2, TRACK_CATEGORIES2, STOPWORDS, KEYWORD_TO_CATEGORY;
+var VALID_TYPES, CONVENTIONAL_PATTERN, LOOKBACK_PATTERN, PulseDbSourceSchema, PulseSourcesSchema, PulseConfigSchema, BUG_TRACK_CATEGORIES, KNOWLEDGE_TRACK_CATEGORIES, ALL_SOLUTION_CATEGORIES, ISO_DATE, BugTrackSchema, KnowledgeTrackSchema, BaseFrontmatter, SolutionDocFrontmatterSchema, TRACK_CATEGORIES, DEFAULT_AGNIX_TIMEOUT_MS, HARNESS_AGNIX_DISABLE, HARNESS_AGNIX_BIN, CLAUDE_MD_WARN_BYTES, CLAUDE_MD_ERROR_BYTES, CONTEXT_FILES, MIN_DESCRIPTION_LENGTH, SETTINGS_PATHS, KNOWN_HOOK_EVENTS, MCP_SETTINGS_FILES, REQUIRED_SECTIONS, SETTINGS_FILES, KNOWN_AGNIX_TOOLS, DEFAULT_SECTIONS, DEFAULT_RATIOS, NODE_TYPE_TO_CATEGORY, SECTION_LEVEL_MAP, DEFAULT_LEVEL, DEFAULT_BUDGET, DEFAULT_LOADER_CONFIG, LEVEL_FRACTIONS, PHASE_PRIORITIES, ManifestSchema, BundleConstraintsSchema, BundleSchema, ContributionsSchema, LockfilePackageSchema, LockfileSchema, SharableLayerSchema, SharableForbiddenImportSchema, SharableBoundaryConfigSchema, SharableSecurityRulesSchema, VALID_SCOPES, LINE_PATTERN, START_PATTERN, END_PATTERN, CODE_BLOCK_LANGUAGES, DEFAULT_DRIFT_CONFIG, JS_EXT_FALLBACKS2, FILE_TYPES, EXPORT_TYPES, CONVENTION_DESCRIPTIONS, RULE_CHECKERS, EntropyAnalyzer, readFile62, writeFile32, unlink22, mkdir22, copyFile2, DEFAULT_FIX_CONFIG, EXPORT_TYPE_KEYWORD, ALWAYS_UNSAFE_TYPES, idCounter, DEAD_CODE_FIX_ACTIONS, MustExportRuleSchema, MustExportDefaultRuleSchema, NoExportRuleSchema, MustImportRuleSchema, NoImportRuleSchema, NamingRuleSchema, MaxExportsRuleSchema, MaxLinesRuleSchema, RequireJSDocRuleSchema, RuleSchema, ConfigPatternSchema, PatternConfigSchema, DriftConfigSchema, DeadCodeConfigSchema, EntropyConfigSchema, BaselineManager, BenchmarkRunner, RegressionDetector, SKIP_DIRS, SOURCE_EXTENSIONS, FUNCTION_DECL_RE, CONST_DECL_RE, CriticalPathResolver, NoOpTelemetryAdapter, NoOpExecutor, ConsoleSink, feedbackConfig, ChecklistBuilder, AgentActionEmitter, globalEmitter, FileSink, NoOpSink, CategorySnapshotSchema, TimelineSnapshotSchema, TimelineFileSchema, TrendLineSchema, TrendResultSchema, DEFAULT_STABILITY_THRESHOLDS, ALL_CATEGORIES, TimelineManager, ConfidenceTierSchema, RegressionResultSchema, DirectionSchema, CategoryForecastSchema, SpecImpactSignalsSchema, SpecImpactEstimateSchema, ContributingFeatureSchema, AdjustedForecastSchema, PredictionWarningSchema, StabilityForecastSchema, PredictionResultSchema, PredictionOptionsSchema, VALID_STATUSES, EM_DASH, VALID_PRIORITIES, ALL_CATEGORIES2, DIRECTION_THRESHOLD, PredictionEngine, DEFAULT_COEFFICIENTS, SpecImpactEstimator, EMPTY_HISTORY, ViolationHistoryManager, NORMALIZERS, MAX_SAMPLES, DEFAULT_WINDOW_WEEKS, DEFAULT_MIN_OCCURRENCES, FailureEntrySchema, HandoffSchema, GateCheckSchema, GateResultSchema, GateConfigSchema, HarnessStateSchema, DEFAULT_STATE, StreamInfoSchema, StreamIndexSchema, DEFAULT_STREAM_INDEX, HARNESS_DIR, STATE_FILE, LEARNINGS_FILE, FAILURES_FILE, HANDOFF_FILE, GATE_CONFIG_FILE, INDEX_FILE, SESSIONS_DIR, SESSION_INDEX_FILE, SUMMARY_FILE, SESSION_STATE_FILE, ARCHIVE_DIR, CONTENT_HASHES_FILE, EVENTS_FILE, STREAMS_DIR, STREAM_NAME_REGEX, branchCache, BRANCH_CACHE_TTL_MS, STATE_FILES, MAX_CACHE_ENTRIES, learningsCacheMap, WEIGHTS, LOCK_RETRIES, LOCK_BACKOFFS, PROMOTABLE_OUTCOMES, failuresCacheMap, FAILURE_LINE_REGEX, SAFE_GATE_COMMAND, SkillEventSchema, knownHashesCache, EVENT_FORMATTERS, RuleRegistry, DEFAULT_SECURITY_CONFIG, RuleOverrideSchema, SecurityConfigSchema, secretRules, injectionRules, xssRules, cryptoRules, pathTraversalRules, networkRules, deserializationRules, agentConfigRules, mcpRules, insecureDefaultsRules, sharpEdgesRules, nodeRules, expressRules, reactRules, goRules, SecurityScanner, hiddenUnicodePatterns, reRolingPatterns, permissionEscalationPatterns, encodedPayloadPatterns, indirectInjectionPatterns, contextManipulationPatterns, socialEngineeringPatterns, suspiciousPatterns, ALL_PATTERNS, DESTRUCTIVE_BASH, TAINT_DURATION_MS, DEFAULT_SESSION_ID, SecurityCategorySnapshotSchema, SupplyChainSnapshotSchema, SecurityTimelineSnapshotSchema, FindingLifecycleSchema, SecurityTimelineFileSchema, DirectionSchema2, SecurityTrendLineSchema, TrendAttributionSchema, SecurityTrendResultSchema, TimeToFixStatsSchema, TimeToFixResultSchema, EMPTY_SUPPLY_CHAIN, SecurityTimelineManager, ALL_CHECKS, STATUS_ICONS, CINotifier, ExclusionSet, PREFIX_PATTERNS, TEST_FILE_PATTERN, MD_FILE_PATTERN, ALL_DOMAINS, SECURITY_PATTERNS, JS_EXT_FALLBACKS22, SEVERITY_RANK, SEVERITY_ORDER, SEVERITY_LABELS, VALIDATED_BY_RANK, VALIDATION_SCORES, DOMAIN_BASELINES, FACTOR_WEIGHTS, EVIDENCE_SATURATION, CORROBORATED_AGREEMENT, STANDALONE_AGREEMENT, AGREEMENT_LINE_GAP, COMPLIANCE_DESCRIPTOR, EXPORT_RE, BUG_DETECTION_DESCRIPTOR, SECURITY_DESCRIPTOR, EVAL_PATTERN, SECRET_PATTERNS, SQL_CONCAT_PATTERN, SHELL_EXEC_PATTERN, ARCHITECTURE_DESCRIPTOR, LARGE_FILE_THRESHOLD, VIOLATION_FILE_RE, LEARNINGS_DESCRIPTOR, RELEVANCE_THRESHOLD, AGENT_DESCRIPTORS, AGENT_RUNNERS, DOWNGRADE_MAP, DEFAULT_PROVIDER_TIERS, SMALL_SUGGESTION_LINE_LIMIT, FILE_LINE_RANGE_PATTERN, FILE_LINE_PATTERN, FILE_ONLY_PATTERN, SECURITY_SENSITIVE_PATH, MIGRATION_PATH, TEST_PATH, CONFIG_PATH, STAGE_DOMAINS, EM_DASH2, STATUS_RANK, RETRY_DEFAULTS, GitHubIssuesSyncAdapter, syncMutex, PRIORITY_RANK, PRIORITY_RANK2, POSITION_WEIGHT, DEPENDENTS_WEIGHT, AFFINITY_WEIGHT, ConflictError, DEFAULTS, GitHubHttp, ETagStore, START_MARKER, END_MARKER, SERIALIZER_FIELDS, GitHubIssuesTrackerAdapter, migrate_exports, HASH_RE, InteractionTypeSchema, QuestionSchema, ConfirmationSchema, TransitionSchema, EmitInteractionInputSchema, ProjectScanner, SHELL_TEMPLATE, STYLES, SCRIPTS, MockLLMService, llmService, ContentPipeline, BlueprintGenerator, TOKENS_PER_MILLION, fallback_default, LITELLM_PRICING_URL, CACHE_TTL_MS, STALENESS_WARNING_DAYS, MICRODOLLARS_PER_DOLLAR, TOKENS_PER_MILLION2, StructuralStrategy, DEFAULT_TOKEN_BUDGET, CHARS_PER_TOKEN, TRUNCATION_MARKER, TruncationStrategy, CompactionPipeline, STABILITY_LOOKUP, TIER_ORDER, AnthropicCacheAdapter, TIER_ORDER2, OpenAICacheAdapter, TIER_ORDER3, CACHED_CONTENT_MARKER, GeminiCacheAdapter, VERSION, POSTHOG_BATCH_URL, MAX_ATTEMPTS, TIMEOUT_MS, CompoundLockHeldError, KNOWN_CATEGORIES, ALLOWED_FIELD_KEYS, PII_TOKENS, PII_FIELD_DENYLIST, PII_LINE_RE, ALLOWED_SET, PulseAdapterAlreadyRegisteredError, REGISTRY, MOCK_ADAPTER_NAME, ALLOWED_FIELD_SET, adapter, LOOKBACK_RE, MAX_LINES, INLINE_TEMPLATE, TRUNCATION_MARKER2, execFileAsync, FIX_RE, EMPTY_REPO_RE, execFileAsync2, TRACK_CATEGORIES2, STOPWORDS, KEYWORD_TO_CATEGORY;
 var init_dist3 = __esm({
   "../core/dist/index.mjs"() {
-    init_chunk_CE225WRK();
+    init_chunk_NC4RPKD4();
     init_dist();
     init_dist();
     init_dist();
     init_dist2();
     init_dist();
     init_dist();
+    init_dist();
+    init_dist();
+    init_dist();
+    init_dist();
     init_dist2();
     VALID_TYPES = [
       "feat",
@@ -15356,11 +15991,11 @@ var init_dist3 = __esm({
         return detectPatternViolations(snapshotResult.value, config);
       }
     };
-    readFile62 = promisify2(fs5.readFile);
-    writeFile32 = promisify2(fs5.writeFile);
-    unlink22 = promisify2(fs5.unlink);
-    mkdir22 = promisify2(fs5.mkdir);
-    copyFile2 = promisify2(fs5.copyFile);
+    readFile62 = promisify2(fs6.readFile);
+    writeFile32 = promisify2(fs6.writeFile);
+    unlink22 = promisify2(fs6.unlink);
+    mkdir22 = promisify2(fs6.mkdir);
+    copyFile2 = promisify2(fs6.copyFile);
     DEFAULT_FIX_CONFIG = {
       dryRun: false,
       fixTypes: ["unused-imports", "dead-files"],
@@ -15482,14 +16117,14 @@ var init_dist3 = __esm({
     BaselineManager = class {
       baselinesPath;
       constructor(projectRoot) {
-        this.baselinesPath = join17(projectRoot, ".harness", "perf", "baselines.json");
+        this.baselinesPath = join18(projectRoot, ".harness", "perf", "baselines.json");
       }
       /**
        * Load the baselines file from disk.
        * Returns null if the file does not exist or contains invalid JSON.
        */
       load() {
-        if (!existsSync11(this.baselinesPath)) {
+        if (!existsSync12(this.baselinesPath)) {
           return null;
         }
         try {
@@ -15523,7 +16158,7 @@ var init_dist3 = __esm({
           benchmarks
         };
         const dir = dirname8(this.baselinesPath);
-        if (!existsSync11(dir)) {
+        if (!existsSync12(dir)) {
           mkdirSync2(dir, { recursive: true });
         }
         writeFileSync2(this.baselinesPath, JSON.stringify(file, null, 2));
@@ -15757,16 +16392,16 @@ var init_dist3 = __esm({
       walkDir(dir, entries) {
         let items;
         try {
-          items = fs6.readdirSync(dir, { withFileTypes: true });
+          items = fs7.readdirSync(dir, { withFileTypes: true });
         } catch {
           return;
         }
         for (const item of items) {
           if (item.isDirectory()) {
             if (SKIP_DIRS.has(item.name)) continue;
-            this.walkDir(path3.join(dir, item.name), entries);
-          } else if (item.isFile() && SOURCE_EXTENSIONS.has(path3.extname(item.name))) {
-            this.scanFile(path3.join(dir, item.name), entries);
+            this.walkDir(path4.join(dir, item.name), entries);
+          } else if (item.isFile() && SOURCE_EXTENSIONS.has(path4.extname(item.name))) {
+            this.scanFile(path4.join(dir, item.name), entries);
           }
         }
       }
@@ -15781,12 +16416,12 @@ var init_dist3 = __esm({
       scanFile(filePath, entries) {
         let content;
         try {
-          content = fs6.readFileSync(filePath, "utf-8");
+          content = fs7.readFileSync(filePath, "utf-8");
         } catch {
           return;
         }
         const lines = content.split("\n");
-        const relativePath = path3.relative(this.projectRoot, filePath).replace(/\\/g, "/");
+        const relativePath = path4.relative(this.projectRoot, filePath).replace(/\\/g, "/");
         for (let i = 0; i < lines.length; i++) {
           if (!lines[i].includes("@perf-critical")) continue;
           const fnName = this.resolveFunctionName(lines, i + 1);
@@ -16126,7 +16761,7 @@ var init_dist3 = __esm({
       ensureDirectory() {
         if (!this.initialized) {
           const dir = dirname9(this.filePath);
-          if (!existsSync12(dir)) {
+          if (!existsSync13(dir)) {
             mkdirSync22(dir, { recursive: true });
           }
           this.initialized = true;
@@ -16157,7 +16792,7 @@ var init_dist3 = __esm({
           this.ensureDirectory();
           const content = this.buffer.join("");
           this.buffer = [];
-          if (this.options.mode === "overwrite" && !existsSync12(this.filePath)) {
+          if (this.options.mode === "overwrite" && !existsSync13(this.filePath)) {
             writeFileSync22(this.filePath, content);
           } else {
             appendFileSync(this.filePath, content);
@@ -16239,14 +16874,14 @@ var init_dist3 = __esm({
     TimelineManager = class {
       timelinePath;
       constructor(rootDir) {
-        this.timelinePath = join19(rootDir, ".harness", "arch", "timeline.json");
+        this.timelinePath = join20(rootDir, ".harness", "arch", "timeline.json");
       }
       /**
        * Load timeline from disk.
        * Returns empty TimelineFile if file does not exist or is invalid.
        */
       load() {
-        if (!existsSync13(this.timelinePath)) {
+        if (!existsSync14(this.timelinePath)) {
           return { version: 1, snapshots: [] };
         }
         try {
@@ -16272,7 +16907,7 @@ var init_dist3 = __esm({
        */
       save(timeline) {
         const dir = dirname10(this.timelinePath);
-        if (!existsSync13(dir)) {
+        if (!existsSync14(dir)) {
           mkdirSync3(dir, { recursive: true });
         }
         const tmp = this.timelinePath + "." + randomBytes2(4).toString("hex") + ".tmp";
@@ -16829,8 +17464,8 @@ var init_dist3 = __esm({
           return null;
         }
         try {
-          const roadmapPath = path4.join(this.rootDir, "roadmap.md");
-          const raw = fs7.readFileSync(roadmapPath, "utf-8");
+          const roadmapPath = path5.join(this.rootDir, "roadmap.md");
+          const raw = fs8.readFileSync(roadmapPath, "utf-8");
           const parseResult = parseRoadmap(raw);
           if (!parseResult.ok) return null;
           const features = parseResult.value.milestones.flatMap(
@@ -16865,8 +17500,8 @@ var init_dist3 = __esm({
        * @param specPath - Relative path from rootDir to the spec file.
        */
       estimate(specPath) {
-        const absolutePath = path5.join(this.rootDir, specPath);
-        const content = fs8.readFileSync(absolutePath, "utf-8");
+        const absolutePath = path6.join(this.rootDir, specPath);
+        const content = fs9.readFileSync(absolutePath, "utf-8");
         const newFileCount = this.extractNewFileCount(content);
         const affectedLayers = this.extractAffectedLayers(content);
         const newDependencies = this.extractNewDependencies(content);
@@ -16878,7 +17513,7 @@ var init_dist3 = __esm({
           phaseCount
         );
         const h1Match = content.match(/^#\s+(.+)$/m);
-        const featureName = h1Match ? h1Match[1].trim() : path5.basename(specPath, ".md");
+        const featureName = h1Match ? h1Match[1].trim() : path6.basename(specPath, ".md");
         return {
           specPath,
           featureName,
@@ -16899,8 +17534,8 @@ var init_dist3 = __esm({
         const results = [];
         for (const feature of features) {
           if (!feature.spec) continue;
-          const absolutePath = path5.join(this.rootDir, feature.spec);
-          if (!fs8.existsSync(absolutePath)) continue;
+          const absolutePath = path6.join(this.rootDir, feature.spec);
+          if (!fs9.existsSync(absolutePath)) continue;
           const estimate = this.estimate(feature.spec);
           results.push({ ...estimate, featureName: feature.name });
         }
@@ -16928,8 +17563,8 @@ var init_dist3 = __esm({
         }
         let count = 0;
         for (const fp of filePaths) {
-          const absolute = path5.join(this.rootDir, fp);
-          if (!fs8.existsSync(absolute)) {
+          const absolute = path6.join(this.rootDir, fp);
+          if (!fs9.existsSync(absolute)) {
             count++;
           }
         }
@@ -16999,8 +17634,8 @@ var init_dist3 = __esm({
       // --- Private: Config Loading ---
       loadLayerNames() {
         try {
-          const configPath = path5.join(this.rootDir, "harness.config.json");
-          const raw = fs8.readFileSync(configPath, "utf-8");
+          const configPath = path6.join(this.rootDir, "harness.config.json");
+          const raw = fs9.readFileSync(configPath, "utf-8");
           const config = JSON.parse(raw);
           return (config.layers ?? []).map((l) => l.name);
         } catch {
@@ -17019,8 +17654,8 @@ var init_dist3 = __esm({
       historyPath;
       /** Load history from disk, returning empty history if file doesn't exist. */
       load() {
-        if (!fs9.existsSync(this.historyPath)) return { ...EMPTY_HISTORY, snapshots: [] };
-        const raw = fs9.readFileSync(this.historyPath, "utf-8");
+        if (!fs10.existsSync(this.historyPath)) return { ...EMPTY_HISTORY, snapshots: [] };
+        const raw = fs10.readFileSync(this.historyPath, "utf-8");
         return JSON.parse(raw);
       }
       /** Append a timestamped snapshot of current violations. */
@@ -17034,18 +17669,18 @@ var init_dist3 = __esm({
       }
       /** Prune snapshots older than retentionDays. */
       prune(retentionDays) {
-        if (!fs9.existsSync(this.historyPath)) return;
+        if (!fs10.existsSync(this.historyPath)) return;
         const history = this.load();
         const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
         history.snapshots = history.snapshots.filter((s) => new Date(s.timestamp).getTime() >= cutoff);
         this.write(history);
       }
       write(history) {
-        const dir = path6.dirname(this.historyPath);
-        if (!fs9.existsSync(dir)) {
-          fs9.mkdirSync(dir, { recursive: true });
+        const dir = path7.dirname(this.historyPath);
+        if (!fs10.existsSync(dir)) {
+          fs10.mkdirSync(dir, { recursive: true });
         }
-        fs9.writeFileSync(this.historyPath, JSON.stringify(history, null, 2), "utf-8");
+        fs10.writeFileSync(this.historyPath, JSON.stringify(history, null, 2), "utf-8");
       }
     };
     NORMALIZERS = {
@@ -18047,7 +18682,7 @@ var init_dist3 = __esm({
       }
       async scanFile(filePath) {
         if (!this.config.enabled) return [];
-        const content = await fs27.readFile(filePath, "utf-8");
+        const content = await fs28.readFile(filePath, "utf-8");
         return this.scanContentForFile(content, filePath, 1);
       }
       scanContentForFile(content, filePath, startLine = 1) {
@@ -18452,7 +19087,7 @@ var init_dist3 = __esm({
       timelinePath;
       constructor(rootDir) {
         this.rootDir = rootDir;
-        this.timelinePath = join39(rootDir, ".harness", "security", "timeline.json");
+        this.timelinePath = join40(rootDir, ".harness", "security", "timeline.json");
       }
       /**
        * Load timeline from disk.
@@ -18463,7 +19098,7 @@ var init_dist3 = __esm({
        * fixup is one-shot.
        */
       load() {
-        if (!existsSync332(this.timelinePath)) {
+        if (!existsSync342(this.timelinePath)) {
           return { version: 1, snapshots: [], findingLifecycles: [] };
         }
         try {
@@ -18497,7 +19132,7 @@ var init_dist3 = __esm({
        */
       save(timeline) {
         const dir = dirname13(this.timelinePath);
-        if (!existsSync332(dir)) {
+        if (!existsSync342(dir)) {
           mkdirSync15(dir, { recursive: true });
         }
         const tmp = this.timelinePath + "." + randomBytes22(4).toString("hex") + ".tmp";
@@ -19511,7 +20146,8 @@ var init_dist3 = __esm({
       }
     };
     syncMutex = Promise.resolve();
-    PRIORITY_RANK = {
+    PRIORITY_RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
+    PRIORITY_RANK2 = {
       P0: 0,
       P1: 1,
       P2: 2,
@@ -19520,6 +20156,586 @@ var init_dist3 = __esm({
     POSITION_WEIGHT = 0.5;
     DEPENDENTS_WEIGHT = 0.3;
     AFFINITY_WEIGHT = 0.2;
+    ConflictError = class extends Error {
+      code = "TRACKER_CONFLICT";
+      externalId;
+      diff;
+      serverUpdatedAt;
+      constructor(externalId, diff2, serverUpdatedAt = null, message) {
+        super(message ?? `Conflict on ${externalId}: ${Object.keys(diff2).join(", ")}`);
+        this.name = "ConflictError";
+        this.externalId = externalId;
+        this.diff = diff2;
+        this.serverUpdatedAt = serverUpdatedAt;
+      }
+    };
+    DEFAULTS = { maxRetries: 5, baseDelayMs: 1e3 };
+    GitHubHttp = class {
+      token;
+      fetchFn;
+      apiBase;
+      retryOpts;
+      constructor(opts) {
+        this.token = opts.token;
+        this.fetchFn = opts.fetchFn ?? globalThis.fetch;
+        this.apiBase = opts.apiBase ?? "https://api.github.com";
+        this.retryOpts = {
+          maxRetries: opts.maxRetries ?? DEFAULTS.maxRetries,
+          baseDelayMs: opts.baseDelayMs ?? DEFAULTS.baseDelayMs
+        };
+      }
+      headers(extra) {
+        return {
+          Authorization: `Bearer ${this.token}`,
+          Accept: "application/vnd.github+json",
+          "Content-Type": "application/json",
+          "X-GitHub-Api-Version": "2022-11-28",
+          ...extra ?? {}
+        };
+      }
+      async request(url, init) {
+        const { extraHeaders, ...rest } = init;
+        const merged = {
+          ...rest,
+          headers: this.headers(extraHeaders)
+        };
+        return this.fetchWithRetry(url, merged);
+      }
+      async fetchWithRetry(url, init) {
+        let last;
+        for (let attempt = 0; attempt <= this.retryOpts.maxRetries; attempt++) {
+          const res = await this.fetchFn(url, init);
+          if (res.status !== 403 && res.status !== 429 && res.status < 500) return res;
+          last = res;
+          if (attempt === this.retryOpts.maxRetries) break;
+          const retryAfter = res.headers.get("Retry-After");
+          let delayMs;
+          if (retryAfter) {
+            const seconds = parseInt(retryAfter, 10);
+            delayMs = isNaN(seconds) ? this.retryOpts.baseDelayMs : seconds * 1e3;
+          } else {
+            delayMs = this.retryOpts.baseDelayMs * Math.pow(2, attempt) + Math.random() * 500;
+          }
+          await new Promise((r) => setTimeout(r, delayMs));
+        }
+        return last;
+      }
+      /**
+       * Walk all pages of a paginated GET. Stops when a page returns < perPage items.
+       *
+       * Status semantics:
+       * - `status: 304` is returned ONLY when the first page returned 304 (the
+       *   server confirmed the caller's If-None-Match matched and there are no
+       *   items to read). Callers may then serve cached data.
+       * - `status: 200` is returned in all other terminal cases, including the
+       *   mid-walk case where page 1 returned 200 (with items) and a later page
+       *   returned 304. Mid-walk 304 is treated as "no further items"; already-
+       *   accumulated items are preserved and `lastEtag` is the latest ETag seen.
+       */
+      async paginate(buildUrl, perPage = 100, extraHeaders) {
+        const items = [];
+        let page = 1;
+        let lastEtag = null;
+        let status = 200;
+        for (; ; ) {
+          const init = { method: "GET" };
+          if (extraHeaders) init.extraHeaders = extraHeaders;
+          const res = await this.request(buildUrl(page), init);
+          const etag = res.headers.get("ETag");
+          if (res.status === 304) {
+            if (page === 1) return { items, lastEtag: etag, status: 304 };
+            if (etag) lastEtag = etag;
+            break;
+          }
+          if (!res.ok) {
+            throw new Error(`GitHub ${res.status}: ${await res.text()}`);
+          }
+          const data = await res.json();
+          items.push(...data);
+          lastEtag = etag;
+          status = res.status;
+          if (data.length < perPage) break;
+          page++;
+        }
+        return { items, lastEtag, status };
+      }
+    };
+    ETagStore = class {
+      max;
+      cache = /* @__PURE__ */ new Map();
+      constructor(max = 500) {
+        this.max = max;
+      }
+      get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) return null;
+        this.cache.delete(key);
+        this.cache.set(key, entry);
+        return entry;
+      }
+      set(key, etag, data) {
+        if (this.cache.has(key)) this.cache.delete(key);
+        this.cache.set(key, { etag, data });
+        if (this.cache.size > this.max) {
+          const oldestKey = this.cache.keys().next().value;
+          if (oldestKey !== void 0) this.cache.delete(oldestKey);
+        }
+      }
+      invalidate(key) {
+        this.cache.delete(key);
+      }
+      invalidateAll() {
+        this.cache.clear();
+      }
+      /** Invalidate all keys matching a prefix. Used when writes invalidate `list:*`. */
+      invalidatePrefix(prefix) {
+        for (const key of [...this.cache.keys()]) {
+          if (key.startsWith(prefix)) this.cache.delete(key);
+        }
+      }
+      get size() {
+        return this.cache.size;
+      }
+    };
+    START_MARKER = "<!-- harness-meta:start -->";
+    END_MARKER = "<!-- harness-meta:end -->";
+    SERIALIZER_FIELDS = [
+      ["spec", "spec", (v) => v],
+      ["plan", "plan", (v) => v],
+      [
+        "blocked_by",
+        "blocked_by",
+        (v) => Array.isArray(v) && v.length > 0 ? v : void 0
+      ],
+      ["priority", "priority", (v) => v],
+      ["milestone", "milestone", (v) => v]
+    ];
+    GitHubIssuesTrackerAdapter = class _GitHubIssuesTrackerAdapter {
+      http;
+      owner;
+      repo;
+      cache;
+      selectorLabel;
+      constructor(opts) {
+        this.http = new GitHubHttp(opts);
+        const [owner, repo] = opts.repo.split("/");
+        if (!owner || !repo) throw new Error(`Invalid repo "${opts.repo}", expected "owner/repo"`);
+        this.owner = owner;
+        this.repo = repo;
+        this.cache = opts.etagStore ?? new ETagStore(500);
+        this.selectorLabel = opts.selectorLabel ?? "harness-managed";
+      }
+      // --- Reads ---
+      async fetchAll() {
+        try {
+          const cacheKey = "list:all";
+          const cached = this.cache.get(cacheKey);
+          const buildUrl = (page) => {
+            const params = new URLSearchParams({
+              state: "all",
+              per_page: "100",
+              page: String(page),
+              labels: this.selectorLabel
+            });
+            return `${this.http.apiBase}/repos/${this.owner}/${this.repo}/issues?${params.toString()}`;
+          };
+          const headers = cached ? { "If-None-Match": cached.etag } : void 0;
+          const { items, lastEtag, status } = await this.http.paginate(
+            buildUrl,
+            100,
+            headers
+          );
+          if (status === 304 && cached) {
+            return Ok({ features: cached.data, etag: cached.etag });
+          }
+          const issues = items.filter((i) => !i.pull_request);
+          const nameIndex = /* @__PURE__ */ new Map();
+          for (const i of issues) {
+            nameIndex.set(i.title, buildExternalId2(this.owner, this.repo, i.number));
+          }
+          const features = issues.map((i) => this.mapIssue(i, nameIndex));
+          features.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+          if (lastEtag) this.cache.set(cacheKey, lastEtag, features);
+          return Ok({ features, etag: lastEtag });
+        } catch (err) {
+          return Err(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+      /**
+       * Fetches a feature by externalId.
+       *
+       * Confused-deputy guard: the externalId's owner/repo MUST match the
+       * adapter's configured owner/repo. If they differ we return Err rather
+       * than silently issuing a request against the externalId's repo (which
+       * the adapter is not configured to manage). The adapter's configured
+       * owner/repo always wins.
+       */
+      async fetchById(externalId) {
+        try {
+          const parsed = parseExternalId2(externalId);
+          if (!parsed) return Err(new Error(`Invalid externalId: "${externalId}"`));
+          if (parsed.owner !== this.owner || parsed.repo !== this.repo) {
+            return Err(new Error("externalId repo does not match adapter repo"));
+          }
+          const cacheKey = `feature:${externalId}`;
+          const cached = this.cache.get(cacheKey);
+          const init = { method: "GET" };
+          if (cached) init.extraHeaders = { "If-None-Match": cached.etag };
+          const res = await this.http.request(
+            `${this.http.apiBase}/repos/${parsed.owner}/${parsed.repo}/issues/${parsed.number}`,
+            init
+          );
+          if (res.status === 404) return Ok(null);
+          if (res.status === 304 && cached) {
+            return Ok({ feature: cached.data, etag: cached.etag });
+          }
+          if (!res.ok) return Err(new Error(`GitHub ${res.status}: ${await res.text()}`));
+          const data = await res.json();
+          const etag = res.headers.get("ETag");
+          if (data.pull_request) return Ok(null);
+          const feature = this.mapIssue(data, /* @__PURE__ */ new Map());
+          if (etag) this.cache.set(cacheKey, etag, feature);
+          return Ok({ feature, etag: etag ?? "" });
+        } catch (err) {
+          return Err(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+      async fetchByStatus(statuses) {
+        const all = await this.fetchAll();
+        if (!all.ok) return all;
+        return Ok(all.value.features.filter((f) => statuses.includes(f.status)));
+      }
+      // --- Writes ---
+      async create(feature) {
+        try {
+          const meta = buildCreateMeta(feature);
+          const body = serializeBodyBlock(feature.summary ?? "", meta);
+          const labels = this.buildCreateLabels(feature);
+          const payload = { title: feature.name, body, labels };
+          if (feature.assignee) payload.assignees = [feature.assignee.replace(/^@/, "")];
+          const res = await this.http.request(
+            `${this.http.apiBase}/repos/${this.owner}/${this.repo}/issues`,
+            { method: "POST", body: JSON.stringify(payload) }
+          );
+          if (!res.ok) return Err(new Error(`GitHub ${res.status}: ${await res.text()}`));
+          const data = await res.json();
+          this.cache.invalidatePrefix("list:");
+          return Ok(this.mapIssue(data, /* @__PURE__ */ new Map()));
+        } catch (err) {
+          return Err(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+      buildCreateLabels(feature) {
+        const labels = [this.selectorLabel];
+        if (feature.status && feature.status !== "backlog") labels.push(feature.status);
+        return labels;
+      }
+      /**
+       * Patches a feature.
+       *
+       * Confused-deputy guard: the externalId's owner/repo MUST match the
+       * adapter's configured owner/repo. If they differ we return Err rather
+       * than silently writing to the externalId's repo. The adapter's
+       * configured owner/repo always wins.
+       */
+      async update(externalId, patch, ifMatch) {
+        const r = await this.updateInternal(externalId, patch, ifMatch);
+        if (!r.ok) return r;
+        return Ok(r.value.feature);
+      }
+      /**
+       * Internal update that also reports whether a real PATCH was issued.
+       * Returns wrote=false on the idempotent path so callers (claim/release/complete)
+       * can skip best-effort history logging when no state change occurred.
+       *
+       * When ifMatch is supplied, updateInternal performs a refetch GET; the
+       * refetched feature is returned as `priorFeature` so callers (release/complete)
+       * can extract the pre-PATCH assignee for history attribution without a second GET.
+       */
+      async updateInternal(externalId, patch, ifMatch) {
+        try {
+          const parsed = parseExternalId2(externalId);
+          if (!parsed) return Err(new Error(`Invalid externalId: "${externalId}"`));
+          if (parsed.owner !== this.owner || parsed.repo !== this.repo) {
+            return Err(new Error("externalId repo does not match adapter repo"));
+          }
+          let priorFeature;
+          if (ifMatch) {
+            const cur = await this.fetchById(externalId);
+            if (!cur.ok) return cur;
+            if (!cur.value) return Err(new Error(`Not found: ${externalId}`));
+            priorFeature = cur.value.feature;
+            const cmp = refetchAndCompare(cur.value.feature, patch);
+            if (!cmp.ok) {
+              return Err(new ConflictError(externalId, cmp.diff, cur.value.feature.updatedAt));
+            }
+            if (cmp.idempotent) return Ok({ feature: cur.value.feature, wrote: false, priorFeature });
+          }
+          const reqBody = await this.buildIssuePatchBody(externalId, patch, priorFeature);
+          const res = await this.http.request(
+            `${this.http.apiBase}/repos/${parsed.owner}/${parsed.repo}/issues/${parsed.number}`,
+            { method: "PATCH", body: JSON.stringify(reqBody) }
+          );
+          if (!res.ok) return Err(new Error(`GitHub ${res.status}: ${await res.text()}`));
+          const data = await res.json();
+          this.cache.invalidate(`feature:${externalId}`);
+          this.cache.invalidatePrefix("list:");
+          return Ok({
+            feature: this.mapIssue(data, /* @__PURE__ */ new Map()),
+            wrote: true,
+            ...priorFeature !== void 0 ? { priorFeature } : {}
+          });
+        } catch (err) {
+          return Err(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+      /** Status labels recognized by mapStatus; 'backlog' and 'done' are state-driven. */
+      static STATUS_LABELS = /* @__PURE__ */ new Set([
+        "planned",
+        "in-progress",
+        "blocked",
+        "needs-human"
+      ]);
+      async buildIssuePatchBody(externalId, patch, priorFeature) {
+        const out = {};
+        if (patch.name !== void 0) out.title = patch.name;
+        if (patch.assignee !== void 0) {
+          out.assignees = patch.assignee ? [patch.assignee.replace(/^@/, "")] : [];
+        }
+        if (patch.status !== void 0) {
+          if (patch.status === "done") out.state = "closed";
+          else out.state = "open";
+          const labelsR = await this.fetchRawLabels(externalId);
+          if (labelsR.ok) {
+            const filtered = labelsR.value.filter(
+              (l) => !_GitHubIssuesTrackerAdapter.STATUS_LABELS.has(l)
+            );
+            if (patch.status !== "backlog" && patch.status !== "done" && _GitHubIssuesTrackerAdapter.STATUS_LABELS.has(patch.status)) {
+              filtered.push(patch.status);
+            }
+            out.labels = filtered;
+          } else {
+            console.warn(
+              `harness-tracker: skipping label sync on ${externalId} due to GET error: ${labelsR.error.message}`
+            );
+          }
+        }
+        const bodyTouches = [
+          "summary",
+          "spec",
+          "plans",
+          "blockedBy",
+          "priority",
+          "milestone"
+        ];
+        if (bodyTouches.some((k) => patch[k] !== void 0)) {
+          let current;
+          if (priorFeature) {
+            current = priorFeature;
+          } else {
+            const cur = await this.fetchById(externalId);
+            if (!cur.ok || !cur.value) throw new Error("Cannot rebuild body without current state");
+            current = cur.value.feature;
+          }
+          const meta = metaFromFeatureFields({
+            spec: patch.spec !== void 0 ? patch.spec : current.spec,
+            plans: patch.plans !== void 0 ? patch.plans : current.plans,
+            blockedBy: patch.blockedBy !== void 0 ? patch.blockedBy : current.blockedBy,
+            priority: patch.priority !== void 0 ? patch.priority : current.priority,
+            milestone: patch.milestone !== void 0 ? patch.milestone : current.milestone
+          });
+          const summaryText = patch.summary !== void 0 ? patch.summary : current.summary;
+          out.body = serializeBodyBlock(summaryText, meta);
+        }
+        return out;
+      }
+      /**
+       * Lightweight GET that returns the raw label name list.
+       *
+       * P2-RR2-IMP-1: returns Result so callers can distinguish a real Err (network
+       * failure / non-200 response) from an empty label set. The previous shape
+       * silently swallowed errors and returned [], which combined with the
+       * unconditional `out.labels = filtered` assignment in buildIssuePatchBody
+       * caused PATCH requests to wipe ALL labels (including the selectorLabel and
+       * user-added labels) on a transient GET blip.
+       */
+      async fetchRawLabels(externalId) {
+        try {
+          const parsed = parseExternalId2(externalId);
+          if (!parsed) return Err(new Error(`Invalid externalId: "${externalId}"`));
+          const res = await this.http.request(
+            `${this.http.apiBase}/repos/${parsed.owner}/${parsed.repo}/issues/${parsed.number}`,
+            { method: "GET" }
+          );
+          if (!res.ok) return Err(new Error(`GitHub ${res.status}: ${await res.text()}`));
+          const data = await res.json();
+          return Ok(data.labels.map((l) => l.name));
+        } catch (err) {
+          return Err(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+      async claim(externalId, assignee, ifMatch) {
+        const r = await this.updateInternal(externalId, { assignee, status: "in-progress" }, ifMatch);
+        if (!r.ok) return r;
+        if (r.value.wrote) await this.logEvent(externalId, "claimed", assignee);
+        return Ok(r.value.feature);
+      }
+      async release(externalId, ifMatch) {
+        const priorAssignee = await this.fetchPriorAssigneeIfNeeded(externalId, ifMatch);
+        const r = await this.updateInternal(externalId, { assignee: null, status: "backlog" }, ifMatch);
+        if (!r.ok) return r;
+        if (r.value.wrote) {
+          const actor = r.value.priorFeature?.assignee ?? priorAssignee ?? null;
+          await this.logEvent(externalId, "released", actor ?? "unknown");
+        }
+        return Ok(r.value.feature);
+      }
+      async complete(externalId, ifMatch) {
+        const priorAssignee = await this.fetchPriorAssigneeIfNeeded(externalId, ifMatch);
+        const r = await this.updateInternal(externalId, { status: "done" }, ifMatch);
+        if (!r.ok) return r;
+        if (r.value.wrote) {
+          const actor = r.value.priorFeature?.assignee ?? priorAssignee ?? null;
+          await this.logEvent(externalId, "completed", actor ?? "unknown");
+        }
+        return Ok(r.value.feature);
+      }
+      /**
+       * Best-effort GET to capture the assignee BEFORE a PATCH that may clear it.
+       * Skipped when ifMatch is supplied because updateInternal will refetch and
+       * thread the prior feature through.
+       */
+      async fetchPriorAssigneeIfNeeded(externalId, ifMatch) {
+        if (ifMatch) return null;
+        const cur = await this.fetchById(externalId);
+        if (cur.ok && cur.value) return cur.value.feature.assignee;
+        return null;
+      }
+      /**
+       * Trust model for history events.
+       *
+       * `HISTORY_PREFIX` (`<!-- harness-history -->`) marks issue comments as
+       * authentic harness events. fetchHistory reads only comments that begin
+       * with this prefix; appendHistory writes the prefix unconditionally.
+       *
+       * Trust is per-repo: only repository contributors authorized to post
+       * comments on a given issue can synthesize harness history events.
+       * GitHub's per-repo permissions are the authorization boundary; the
+       * prefix itself is not a cryptographic credential — a contributor with
+       * comment access can forge events by hand-writing the prefix.
+       *
+       * HMAC-signing of event payloads is a future hardening (post-GA) for
+       * deployments that need cross-actor tamper-evidence within the same
+       * repo. The current shape is intentional: optimized for transparency
+       * (events are human-readable, no key distribution required).
+       */
+      static HISTORY_PREFIX = "<!-- harness-history -->";
+      async appendHistory(externalId, event) {
+        try {
+          const parsed = parseExternalId2(externalId);
+          if (!parsed) return Err(new Error(`Invalid externalId: "${externalId}"`));
+          const body = `${_GitHubIssuesTrackerAdapter.HISTORY_PREFIX}
+${JSON.stringify(event)}`;
+          const res = await this.http.request(
+            `${this.http.apiBase}/repos/${parsed.owner}/${parsed.repo}/issues/${parsed.number}/comments`,
+            { method: "POST", body: JSON.stringify({ body }) }
+          );
+          if (!res.ok) return Err(new Error(`GitHub ${res.status}: ${await res.text()}`));
+          return Ok(void 0);
+        } catch (err) {
+          return Err(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+      async fetchHistory(externalId, limit) {
+        try {
+          const parsed = parseExternalId2(externalId);
+          if (!parsed) return Err(new Error(`Invalid externalId: "${externalId}"`));
+          const buildUrl = (page) => `${this.http.apiBase}/repos/${parsed.owner}/${parsed.repo}/issues/${parsed.number}/comments?per_page=100&page=${page}`;
+          const { items } = await this.http.paginate(buildUrl);
+          const events = [];
+          for (const c of items) {
+            if (!c.body.startsWith(_GitHubIssuesTrackerAdapter.HISTORY_PREFIX)) continue;
+            const json = c.body.slice(_GitHubIssuesTrackerAdapter.HISTORY_PREFIX.length).trim();
+            try {
+              events.push(JSON.parse(json));
+            } catch (e) {
+              console.warn(`harness-history: malformed JSON in ${externalId}: ${e.message}`);
+            }
+          }
+          events.sort((a, b) => a.at.localeCompare(b.at));
+          return Ok(limit ? events.slice(-limit) : events);
+        } catch (err) {
+          return Err(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+      async logEvent(externalId, type, actor) {
+        const event = {
+          type,
+          actor,
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const r = await this.appendHistory(externalId, event);
+        if (!r.ok) {
+          console.warn(`harness-history: append failed for ${externalId}: ${r.error.message}`);
+        }
+      }
+      // --- Helpers ---
+      // The nameIndex parameter is retained for backwards-compatibility with the
+      // fetchAll signature but is no longer consulted: blockedBy holds feature
+      // names verbatim from the body-meta block (see client.ts TrackedFeature.blockedBy).
+      mapIssue(issue, _nameIndex) {
+        const { summary, meta } = parseBodyBlock(issue.body ?? "");
+        const status = this.mapStatus(issue, meta);
+        return {
+          externalId: buildExternalId2(this.owner, this.repo, issue.number),
+          name: issue.title,
+          status,
+          summary,
+          spec: meta.spec ?? null,
+          plans: meta.plan ? [meta.plan] : [],
+          blockedBy: meta.blocked_by ?? [],
+          assignee: issue.assignees[0]?.login ? `@${issue.assignees[0].login}` : null,
+          priority: meta.priority ?? null,
+          milestone: issue.milestone?.title ?? meta.milestone ?? null,
+          createdAt: issue.created_at,
+          updatedAt: issue.updated_at ?? null
+        };
+      }
+      /**
+       * Status precedence (highest wins):
+       *   1. issue.state === 'closed'  → 'done'
+       *   2. 'blocked' label            → 'blocked'
+       *   3. 'needs-human' label        → 'needs-human'
+       *   4. 'in-progress' label OR any assignee  → 'in-progress'
+       *   5. 'planned' label            → 'planned'
+       *   6. otherwise                  → 'backlog'
+       *
+       * Note step 4: an assignment overrides a 'planned' label. This is
+       * intentional — a feature that someone has picked up is "in-progress"
+       * regardless of whether the planning label was cleared first. The reverse
+       * (planned label + assignee) is the common case where the orchestrator
+       * (or a human) starts work without scrubbing the planning label.
+       */
+      mapStatus(issue, _meta) {
+        if (issue.state === "closed") return "done";
+        const labels = issue.labels.map((l) => l.name);
+        if (labels.includes("blocked")) return "blocked";
+        if (labels.includes("needs-human")) return "needs-human";
+        if (labels.includes("in-progress") || issue.assignees.length > 0) return "in-progress";
+        if (labels.includes("planned")) return "planned";
+        return "backlog";
+      }
+    };
+    migrate_exports = {};
+    __export2(migrate_exports, {
+      bodyMetaMatches: () => bodyMetaMatches,
+      buildHistoryCommentBody: () => buildHistoryCommentBody,
+      buildMigrationPlan: () => buildMigrationPlan,
+      hashHistoryEvent: () => hashHistoryEvent,
+      parseHashFromCommentBody: () => parseHashFromCommentBody,
+      runMigrationPlan: () => runMigrationPlan
+    });
+    HASH_RE = /<!--\s*harness-history\s+hash:([0-9a-f]{8})\s*-->/i;
     InteractionTypeSchema = z12.enum(["question", "confirmation", "transition"]);
     QuestionSchema = z12.object({
       text: z12.string(),
@@ -19552,10 +20768,10 @@ var init_dist3 = __esm({
       }
       rootDir;
       async scan() {
-        let projectName = path30.basename(this.rootDir);
+        let projectName = path34.basename(this.rootDir);
         try {
-          const pkgPath = path30.join(this.rootDir, "package.json");
-          const pkgRaw = await fs31.readFile(pkgPath, "utf-8");
+          const pkgPath = path34.join(this.rootDir, "package.json");
+          const pkgRaw = await fs34.readFile(pkgPath, "utf-8");
           const pkg = JSON.parse(pkgRaw);
           if (pkg.name) projectName = pkg.name;
         } catch {
@@ -19668,8 +20884,8 @@ console.log('Blueprint player initialized.');
           styles: STYLES,
           scripts: SCRIPTS
         });
-        await fs32.mkdir(options.outputDir, { recursive: true });
-        await fs32.writeFile(path31.join(options.outputDir, "index.html"), html);
+        await fs35.mkdir(options.outputDir, { recursive: true });
+        await fs35.writeFile(path35.join(options.outputDir, "index.html"), html);
       }
     };
     TOKENS_PER_MILLION = 1e6;
@@ -20102,6 +21318,8 @@ export {
   validateAgentsMap,
   runFallbackRules,
   validateAgentConfigs,
+  getRoadmapMode,
+  validateRoadmapMode,
   checkDocCoverage,
   validateKnowledgeMap,
   generateAgentsMap,
@@ -20391,8 +21609,17 @@ export {
   syncToExternal,
   syncFromExternal,
   fullSync,
+  scoreRoadmapCandidatesFileLess,
   scoreRoadmapCandidates,
   assignFeature,
+  scoreRoadmapCandidatesForMode,
+  ConflictError,
+  ETagStore,
+  createTrackerClient,
+  makeTrackerConflictBody,
+  loadProjectRoadmapMode,
+  loadTrackerClientConfigFromProject,
+  migrate_exports,
   InteractionTypeSchema,
   QuestionSchema,
   ConfirmationSchema,