@harness-engineering/core 0.19.0 → 0.20.0

package/dist/index.js

@@ -33,6 +33,7 @@ var index_exports = {};
 __export(index_exports, {
   AGENT_DESCRIPTORS: () => AGENT_DESCRIPTORS,
   ARCHITECTURE_DESCRIPTOR: () => ARCHITECTURE_DESCRIPTOR,
+  AdjustedForecastSchema: () => AdjustedForecastSchema,
   AgentActionEmitter: () => AgentActionEmitter,
   ArchBaselineManager: () => ArchBaselineManager,
   ArchBaselineSchema: () => ArchBaselineSchema,
@@ -48,23 +49,29 @@ __export(index_exports, {
   CACHE_TTL_MS: () => CACHE_TTL_MS,
   COMPLIANCE_DESCRIPTOR: () => COMPLIANCE_DESCRIPTOR,
   CategoryBaselineSchema: () => CategoryBaselineSchema,
+  CategoryForecastSchema: () => CategoryForecastSchema,
   CategoryRegressionSchema: () => CategoryRegressionSchema,
+  CategorySnapshotSchema: () => CategorySnapshotSchema,
   ChecklistBuilder: () => ChecklistBuilder,
   CircularDepsCollector: () => CircularDepsCollector,
   ComplexityCollector: () => ComplexityCollector,
+  ConfidenceTierSchema: () => ConfidenceTierSchema,
   ConfirmationSchema: () => ConfirmationSchema,
   ConsoleSink: () => ConsoleSink,
   ConstraintRuleSchema: () => ConstraintRuleSchema,
   ContentPipeline: () => ContentPipeline,
+  ContributingFeatureSchema: () => ContributingFeatureSchema,
   ContributionsSchema: () => ContributionsSchema,
   CouplingCollector: () => CouplingCollector,
   CriticalPathResolver: () => CriticalPathResolver,
   DEFAULT_PROVIDER_TIERS: () => DEFAULT_PROVIDER_TIERS,
   DEFAULT_SECURITY_CONFIG: () => DEFAULT_SECURITY_CONFIG,
+  DEFAULT_STABILITY_THRESHOLDS: () => DEFAULT_STABILITY_THRESHOLDS,
   DEFAULT_STATE: () => DEFAULT_STATE,
   DEFAULT_STREAM_INDEX: () => DEFAULT_STREAM_INDEX,
   DESTRUCTIVE_BASH: () => DESTRUCTIVE_BASH,
   DepDepthCollector: () => DepDepthCollector,
+  DirectionSchema: () => DirectionSchema,
   EXTENSION_MAP: () => EXTENSION_MAP,
   EmitInteractionInputSchema: () => EmitInteractionInputSchema,
   EntropyAnalyzer: () => EntropyAnalyzer,
@@ -90,6 +97,11 @@ __export(index_exports, {
   NoOpSink: () => NoOpSink,
   NoOpTelemetryAdapter: () => NoOpTelemetryAdapter,
   PatternConfigSchema: () => PatternConfigSchema,
+  PredictionEngine: () => PredictionEngine,
+  PredictionOptionsSchema: () => PredictionOptionsSchema,
+  PredictionRegressionResultSchema: () => RegressionResultSchema,
+  PredictionResultSchema: () => PredictionResultSchema,
+  PredictionWarningSchema: () => PredictionWarningSchema,
   ProjectScanner: () => ProjectScanner,
   QuestionSchema: () => QuestionSchema,
   REQUIRED_SECTIONS: () => REQUIRED_SECTIONS,
@@ -105,10 +117,19 @@ __export(index_exports, {
   SharableLayerSchema: () => SharableLayerSchema,
   SharableSecurityRulesSchema: () => SharableSecurityRulesSchema,
   SkillEventSchema: () => SkillEventSchema,
+  SpecImpactEstimateSchema: () => SpecImpactEstimateSchema,
+  SpecImpactEstimator: () => SpecImpactEstimator,
+  SpecImpactSignalsSchema: () => SpecImpactSignalsSchema,
+  StabilityForecastSchema: () => StabilityForecastSchema,
   StreamIndexSchema: () => StreamIndexSchema,
   StreamInfoSchema: () => StreamInfoSchema,
   ThresholdConfigSchema: () => ThresholdConfigSchema,
+  TimelineFileSchema: () => TimelineFileSchema,
+  TimelineManager: () => TimelineManager,
+  TimelineSnapshotSchema: () => TimelineSnapshotSchema,
   TransitionSchema: () => TransitionSchema,
+  TrendLineSchema: () => TrendLineSchema,
+  TrendResultSchema: () => TrendResultSchema,
   TypeScriptParser: () => TypeScriptParser,
   VERSION: () => VERSION,
   ViolationSchema: () => ViolationSchema,
@@ -123,6 +144,7 @@ __export(index_exports, {
   appendSessionEntry: () => appendSessionEntry,
   applyFixes: () => applyFixes,
   applyHotspotDowngrade: () => applyHotspotDowngrade,
+  applyRecencyWeights: () => applyRecencyWeights,
   applySyncChanges: () => applySyncChanges,
   archMatchers: () => archMatchers,
   archModule: () => archModule,
@@ -140,6 +162,7 @@ __export(index_exports, {
   checkEligibility: () => checkEligibility,
   checkEvidenceCoverage: () => checkEvidenceCoverage,
   checkTaint: () => checkTaint,
+  classifyConfidence: () => classifyConfidence,
   classifyFinding: () => classifyFinding,
   clearEventHashCache: () => clearEventHashCache,
   clearFailuresCache: () => clearFailuresCache,
@@ -242,7 +265,7 @@ __export(index_exports, {
   parseDateFromEntry: () => parseDateFromEntry,
   parseDiff: () => parseDiff,
   parseFile: () => parseFile,
-  parseFrontmatter: () => parseFrontmatter,
+  parseFrontmatter: () => parseFrontmatter2,
   parseHarnessIgnore: () => parseHarnessIgnore,
   parseLiteLLMData: () => parseLiteLLMData,
   parseManifest: () => parseManifest,
@@ -251,6 +274,7 @@ __export(index_exports, {
   parseSize: () => parseSize,
   pathTraversalRules: () => pathTraversalRules,
   previewFix: () => previewFix,
+  projectValue: () => projectValue,
   promoteSessionLearnings: () => promoteSessionLearnings,
   pruneLearnings: () => pruneLearnings,
   reactRules: () => reactRules,
@@ -318,6 +342,8 @@ __export(index_exports, {
   validateKnowledgeMap: () => validateKnowledgeMap,
   validatePatternConfig: () => validatePatternConfig,
   violationId: () => violationId,
+  weeksUntilThreshold: () => weeksUntilThreshold,
+  weightedLinearRegression: () => weightedLinearRegression,
   writeConfig: () => writeConfig,
   writeLockfile: () => writeLockfile,
   writeSessionSummary: () => writeSessionSummary,
@@ -345,17 +371,17 @@ var import_node_path = require("path");
 var import_glob = require("glob");
 var accessAsync = (0, import_util.promisify)(import_fs.access);
 var readFileAsync = (0, import_util.promisify)(import_fs.readFile);
-async function fileExists(path26) {
+async function fileExists(path28) {
   try {
-    await accessAsync(path26, import_fs.constants.F_OK);
+    await accessAsync(path28, import_fs.constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function readFileContent(path26) {
+async function readFileContent(path28) {
   try {
-    const content = await readFileAsync(path26, "utf-8");
+    const content = await readFileAsync(path28, "utf-8");
     return (0, import_types.Ok)(content);
   } catch (error) {
     return (0, import_types.Err)(error);
@@ -406,15 +432,15 @@ function validateConfig(data, schema) {
   let message = "Configuration validation failed";
   const suggestions = [];
   if (firstError) {
-    const path26 = firstError.path.join(".");
-    const pathDisplay = path26 ? ` at "${path26}"` : "";
+    const path28 = firstError.path.join(".");
+    const pathDisplay = path28 ? ` at "${path28}"` : "";
     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 "${path26}" is required and must be of type "${expected}"`);
+        suggestions.push(`Field "${path28}" is required and must be of type "${expected}"`);
       } else {
         code = "INVALID_TYPE";
         message = `Invalid type${pathDisplay}: ${firstError.message}`;
@@ -630,27 +656,27 @@ function extractSections(content) {
   }
   return sections.map((section) => buildAgentMapSection(section, lines));
 }
-function isExternalLink(path26) {
-  return path26.startsWith("http://") || path26.startsWith("https://") || path26.startsWith("#") || path26.startsWith("mailto:");
+function isExternalLink(path28) {
+  return path28.startsWith("http://") || path28.startsWith("https://") || path28.startsWith("#") || path28.startsWith("mailto:");
 }
 function resolveLinkPath(linkPath, baseDir) {
   return linkPath.startsWith(".") ? (0, import_path.join)(baseDir, linkPath) : linkPath;
 }
-async function validateAgentsMap(path26 = "./AGENTS.md") {
-  const contentResult = await readFileContent(path26);
+async function validateAgentsMap(path28 = "./AGENTS.md") {
+  const contentResult = await readFileContent(path28);
   if (!contentResult.ok) {
     return (0, import_types.Err)(
       createError(
         "PARSE_ERROR",
         `Failed to read AGENTS.md: ${contentResult.error.message}`,
-        { path: path26 },
+        { path: path28 },
         ["Ensure the file exists", "Check file permissions"]
       )
     );
   }
   const content = contentResult.value;
   const sections = extractSections(content);
-  const baseDir = (0, import_path.dirname)(path26);
+  const baseDir = (0, import_path.dirname)(path28);
   const sectionTitles = sections.map((s) => s.title);
   const missingSections = REQUIRED_SECTIONS.filter(
     (required) => !sectionTitles.some((title) => title.toLowerCase().includes(required.toLowerCase()))
@@ -791,8 +817,8 @@ async function checkDocCoverage(domain, options = {}) {
 
 // src/context/knowledge-map.ts
 var import_path3 = require("path");
-function suggestFix(path26, existingFiles) {
-  const targetName = (0, import_path3.basename)(path26).toLowerCase();
+function suggestFix(path28, existingFiles) {
+  const targetName = (0, import_path3.basename)(path28).toLowerCase();
   const similar = existingFiles.find((file) => {
     const fileName = (0, import_path3.basename)(file).toLowerCase();
     return fileName.includes(targetName) || targetName.includes(fileName);
@@ -800,7 +826,7 @@ function suggestFix(path26, existingFiles) {
   if (similar) {
     return `Did you mean "${similar}"?`;
   }
-  return `Create the file "${path26}" or remove the link`;
+  return `Create the file "${path28}" or remove the link`;
 }
 async function validateKnowledgeMap(rootDir = process.cwd()) {
   const agentsPath = (0, import_path3.join)(rootDir, "AGENTS.md");
@@ -1406,8 +1432,8 @@ function createBoundaryValidator(schema, name) {
         return (0, import_types.Ok)(result.data);
       }
       const suggestions = result.error.issues.map((issue) => {
-        const path26 = issue.path.join(".");
-        return path26 ? `${path26}: ${issue.message}` : issue.message;
+        const path28 = issue.path.join(".");
+        return path28 ? `${path28}: ${issue.message}` : issue.message;
       });
       return (0, import_types.Err)(
         createError(
@@ -2039,11 +2065,11 @@ function processExportListSpecifiers(exportDecl, exports2) {
 var TypeScriptParser = class {
   name = "typescript";
   extensions = [".ts", ".tsx", ".mts", ".cts"];
-  async parseFile(path26) {
-    const contentResult = await readFileContent(path26);
+  async parseFile(path28) {
+    const contentResult = await readFileContent(path28);
     if (!contentResult.ok) {
       return (0, import_types.Err)(
-        createParseError("NOT_FOUND", `File not found: ${path26}`, { path: path26 }, [
+        createParseError("NOT_FOUND", `File not found: ${path28}`, { path: path28 }, [
           "Check that the file exists",
           "Verify the path is correct"
         ])
@@ -2053,7 +2079,7 @@ var TypeScriptParser = class {
       const ast = (0, import_typescript_estree.parse)(contentResult.value, {
         loc: true,
         range: true,
-        jsx: path26.endsWith(".tsx"),
+        jsx: path28.endsWith(".tsx"),
         errorOnUnknownASTType: false
       });
       return (0, import_types.Ok)({
@@ -2064,7 +2090,7 @@ var TypeScriptParser = class {
     } catch (e) {
       const error = e;
       return (0, import_types.Err)(
-        createParseError("SYNTAX_ERROR", `Failed to parse ${path26}: ${error.message}`, { path: path26 }, [
+        createParseError("SYNTAX_ERROR", `Failed to parse ${path28}: ${error.message}`, { path: path28 }, [
           "Check for syntax errors in the file",
           "Ensure valid TypeScript syntax"
         ])
@@ -2249,22 +2275,22 @@ function extractInlineRefs(content) {
   }
   return refs;
 }
-async function parseDocumentationFile(path26) {
-  const contentResult = await readFileContent(path26);
+async function parseDocumentationFile(path28) {
+  const contentResult = await readFileContent(path28);
   if (!contentResult.ok) {
     return (0, import_types.Err)(
       createEntropyError(
         "PARSE_ERROR",
-        `Failed to read documentation file: ${path26}`,
-        { file: path26 },
+        `Failed to read documentation file: ${path28}`,
+        { file: path28 },
         ["Check that the file exists"]
       )
     );
   }
   const content = contentResult.value;
-  const type = path26.endsWith(".md") ? "markdown" : "text";
+  const type = path28.endsWith(".md") ? "markdown" : "text";
   return (0, import_types.Ok)({
-    path: path26,
+    path: path28,
     type,
     content,
     codeBlocks: extractCodeBlocks(content),
@@ -6604,10 +6630,10 @@ function resolveThresholds2(scope, config) {
   }
   const merged = { ...projectThresholds };
   for (const [category, moduleValue] of Object.entries(moduleOverrides)) {
-    const projectValue = projectThresholds[category];
-    if (projectValue !== void 0 && typeof projectValue === "object" && !Array.isArray(projectValue) && typeof moduleValue === "object" && !Array.isArray(moduleValue)) {
+    const projectValue2 = projectThresholds[category];
+    if (projectValue2 !== void 0 && typeof projectValue2 === "object" && !Array.isArray(projectValue2) && typeof moduleValue === "object" && !Array.isArray(moduleValue)) {
       merged[category] = {
-        ...projectValue,
+        ...projectValue2,
         ...moduleValue
       };
     } else {
@@ -6803,77 +6829,1173 @@ var archMatchers = {
   toHaveMaxDepDepth
 };
 
-// src/state/types.ts
+// src/architecture/timeline-types.ts
 var import_zod4 = require("zod");
-var FailureEntrySchema = import_zod4.z.object({
-  date: import_zod4.z.string(),
-  skill: import_zod4.z.string(),
-  type: import_zod4.z.string(),
-  description: import_zod4.z.string()
+var CategorySnapshotSchema = import_zod4.z.object({
+  /** Aggregate metric value (e.g., violation count, avg complexity) */
+  value: import_zod4.z.number(),
+  /** Count of violations in this category */
+  violationCount: import_zod4.z.number()
+});
+var TimelineSnapshotSchema = import_zod4.z.object({
+  /** ISO 8601 timestamp of capture */
+  capturedAt: import_zod4.z.string().datetime(),
+  /** Git commit hash at capture time */
+  commitHash: import_zod4.z.string(),
+  /** Composite stability score (0-100, higher is healthier) */
+  stabilityScore: import_zod4.z.number().min(0).max(100),
+  /** Per-category metric aggregates */
+  metrics: import_zod4.z.record(ArchMetricCategorySchema, CategorySnapshotSchema)
+});
+var TimelineFileSchema = import_zod4.z.object({
+  version: import_zod4.z.literal(1),
+  snapshots: import_zod4.z.array(TimelineSnapshotSchema)
+});
+var TrendLineSchema = import_zod4.z.object({
+  /** Current value */
+  current: import_zod4.z.number(),
+  /** Previous value (from comparison snapshot) */
+  previous: import_zod4.z.number(),
+  /** Absolute delta (current - previous) */
+  delta: import_zod4.z.number(),
+  /** Direction indicator */
+  direction: import_zod4.z.enum(["improving", "stable", "declining"])
+});
+var TrendResultSchema = import_zod4.z.object({
+  /** Overall stability trend */
+  stability: TrendLineSchema,
+  /** Per-category trends */
+  categories: import_zod4.z.record(ArchMetricCategorySchema, TrendLineSchema),
+  /** Number of snapshots analyzed */
+  snapshotCount: import_zod4.z.number(),
+  /** Time range covered */
+  from: import_zod4.z.string(),
+  to: import_zod4.z.string()
+});
+var DEFAULT_STABILITY_THRESHOLDS = {
+  "circular-deps": 5,
+  "layer-violations": 10,
+  complexity: 100,
+  coupling: 2,
+  "forbidden-imports": 5,
+  "module-size": 10,
+  "dependency-depth": 10
+};
+
+// src/architecture/timeline-manager.ts
+var import_node_fs4 = require("fs");
+var import_node_crypto3 = require("crypto");
+var import_node_path7 = require("path");
+var ALL_CATEGORIES = ArchMetricCategorySchema.options;
+var TimelineManager = class {
+  timelinePath;
+  constructor(rootDir) {
+    this.timelinePath = (0, import_node_path7.join)(rootDir, ".harness", "arch", "timeline.json");
+  }
+  /**
+   * Load timeline from disk.
+   * Returns empty TimelineFile if file does not exist or is invalid.
+   */
+  load() {
+    if (!(0, import_node_fs4.existsSync)(this.timelinePath)) {
+      return { version: 1, snapshots: [] };
+    }
+    try {
+      const raw = (0, import_node_fs4.readFileSync)(this.timelinePath, "utf-8");
+      const data = JSON.parse(raw);
+      const parsed = TimelineFileSchema.safeParse(data);
+      if (!parsed.success) {
+        console.error(
+          `Timeline validation failed for ${this.timelinePath}:`,
+          parsed.error.format()
+        );
+        return { version: 1, snapshots: [] };
+      }
+      return parsed.data;
+    } catch (error) {
+      console.error(`Error loading timeline from ${this.timelinePath}:`, error);
+      return { version: 1, snapshots: [] };
+    }
+  }
+  /**
+   * Save timeline to disk using atomic write (temp file + rename).
+   * Creates parent directories if they do not exist.
+   */
+  save(timeline) {
+    const dir = (0, import_node_path7.dirname)(this.timelinePath);
+    if (!(0, import_node_fs4.existsSync)(dir)) {
+      (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+    }
+    const tmp = this.timelinePath + "." + (0, import_node_crypto3.randomBytes)(4).toString("hex") + ".tmp";
+    (0, import_node_fs4.writeFileSync)(tmp, JSON.stringify(timeline, null, 2));
+    (0, import_node_fs4.renameSync)(tmp, this.timelinePath);
+  }
+  /**
+   * Capture a new snapshot from current metric results.
+   * Aggregates MetricResult[] by category, computes stability score,
+   * appends to timeline (or replaces if same commitHash), and saves.
+   */
+  capture(results, commitHash) {
+    const metrics = this.aggregateByCategory(results);
+    const stabilityScore = this.computeStabilityScore(metrics);
+    const snapshot = {
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      commitHash,
+      stabilityScore,
+      metrics
+    };
+    const timeline = this.load();
+    const lastIndex = timeline.snapshots.length - 1;
+    if (lastIndex >= 0 && timeline.snapshots[lastIndex].commitHash === commitHash) {
+      timeline.snapshots[lastIndex] = snapshot;
+    } else {
+      timeline.snapshots.push(snapshot);
+    }
+    this.save(timeline);
+    return snapshot;
+  }
+  /**
+   * Compute trends between snapshots over a window.
+   * @param options.last - Number of recent snapshots to analyze (default: 10)
+   * @param options.since - ISO date string to filter snapshots from
+   */
+  trends(options) {
+    const timeline = this.load();
+    let snapshots = timeline.snapshots;
+    if (options?.since) {
+      const sinceDate = new Date(options.since);
+      snapshots = snapshots.filter((s) => new Date(s.capturedAt) >= sinceDate);
+    }
+    if (options?.last && snapshots.length > options.last) {
+      snapshots = snapshots.slice(-options.last);
+    }
+    if (snapshots.length === 0) {
+      return this.emptyTrendResult();
+    }
+    if (snapshots.length === 1) {
+      const only = snapshots[0];
+      const m = only.metrics;
+      return {
+        stability: this.buildTrendLine(only.stabilityScore, only.stabilityScore, true),
+        categories: this.buildCategoryTrends(m, m),
+        snapshotCount: 1,
+        from: only.capturedAt,
+        to: only.capturedAt
+      };
+    }
+    const first = snapshots[0];
+    const last = snapshots[snapshots.length - 1];
+    return {
+      stability: this.buildTrendLine(last.stabilityScore, first.stabilityScore, true),
+      categories: this.buildCategoryTrends(
+        last.metrics,
+        first.metrics
+      ),
+      snapshotCount: snapshots.length,
+      from: first.capturedAt,
+      to: last.capturedAt
+    };
+  }
+  /**
+   * Compute composite stability score from category metrics.
+   * Equal weight across all categories. Score is 0-100 (higher = healthier).
+   * health = max(0, 1 - (value / threshold)) per category.
+   */
+  computeStabilityScore(metrics, thresholds = DEFAULT_STABILITY_THRESHOLDS) {
+    const healthScores = [];
+    for (const category of ALL_CATEGORIES) {
+      const snapshot = metrics[category];
+      if (!snapshot) {
+        healthScores.push(1);
+        continue;
+      }
+      const threshold = thresholds[category] ?? 10;
+      const health = Math.max(0, 1 - snapshot.value / threshold);
+      healthScores.push(health);
+    }
+    const mean = healthScores.reduce((sum, h) => sum + h, 0) / healthScores.length;
+    return Math.round(mean * 100);
+  }
+  // --- Private helpers ---
+  aggregateByCategory(results) {
+    const metrics = {};
+    for (const result of results) {
+      const existing = metrics[result.category];
+      if (existing) {
+        existing.value += result.value;
+        existing.violationCount += result.violations.length;
+      } else {
+        metrics[result.category] = {
+          value: result.value,
+          violationCount: result.violations.length
+        };
+      }
+    }
+    for (const category of ALL_CATEGORIES) {
+      if (!metrics[category]) {
+        metrics[category] = { value: 0, violationCount: 0 };
+      }
+    }
+    return metrics;
+  }
+  buildTrendLine(current, previous, isStabilityScore) {
+    const delta = current - previous;
+    let direction;
+    if (Math.abs(delta) < 2) {
+      direction = "stable";
+    } else if (isStabilityScore) {
+      direction = delta > 0 ? "improving" : "declining";
+    } else {
+      direction = delta < 0 ? "improving" : "declining";
+    }
+    return { current, previous, delta, direction };
+  }
+  buildCategoryTrends(currentMetrics, previousMetrics) {
+    const trends = {};
+    for (const category of ALL_CATEGORIES) {
+      const current = currentMetrics[category]?.value ?? 0;
+      const previous = previousMetrics[category]?.value ?? 0;
+      trends[category] = this.buildTrendLine(current, previous, false);
+    }
+    return trends;
+  }
+  emptyTrendResult() {
+    const zeroLine = { current: 0, previous: 0, delta: 0, direction: "stable" };
+    const categories = {};
+    for (const category of ALL_CATEGORIES) {
+      categories[category] = { ...zeroLine };
+    }
+    return {
+      stability: { ...zeroLine },
+      categories,
+      snapshotCount: 0,
+      from: "",
+      to: ""
+    };
+  }
+};
+
+// src/architecture/prediction-types.ts
+var import_zod5 = require("zod");
+var ConfidenceTierSchema = import_zod5.z.enum(["high", "medium", "low"]);
+var RegressionResultSchema = import_zod5.z.object({
+  slope: import_zod5.z.number(),
+  intercept: import_zod5.z.number(),
+  rSquared: import_zod5.z.number().min(0).max(1),
+  dataPoints: import_zod5.z.number().int().min(0)
+});
+var DirectionSchema = import_zod5.z.enum(["improving", "stable", "declining"]);
+var CategoryForecastSchema = import_zod5.z.object({
+  category: ArchMetricCategorySchema,
+  current: import_zod5.z.number(),
+  threshold: import_zod5.z.number(),
+  projectedValue4w: import_zod5.z.number(),
+  projectedValue8w: import_zod5.z.number(),
+  projectedValue12w: import_zod5.z.number(),
+  thresholdCrossingWeeks: import_zod5.z.number().nullable(),
+  confidence: ConfidenceTierSchema,
+  regression: RegressionResultSchema,
+  direction: DirectionSchema
+});
+var SpecImpactSignalsSchema = import_zod5.z.object({
+  newFileCount: import_zod5.z.number().int().min(0),
+  affectedLayers: import_zod5.z.array(import_zod5.z.string()),
+  newDependencies: import_zod5.z.number().int().min(0),
+  phaseCount: import_zod5.z.number().int().min(0)
+});
+var SpecImpactEstimateSchema = import_zod5.z.object({
+  specPath: import_zod5.z.string(),
+  featureName: import_zod5.z.string(),
+  signals: SpecImpactSignalsSchema,
+  deltas: import_zod5.z.record(ArchMetricCategorySchema, import_zod5.z.number()).optional()
+});
+var ContributingFeatureSchema = import_zod5.z.object({
+  name: import_zod5.z.string(),
+  specPath: import_zod5.z.string(),
+  delta: import_zod5.z.number()
+});
+var AdjustedForecastSchema = import_zod5.z.object({
+  baseline: CategoryForecastSchema,
+  adjusted: CategoryForecastSchema,
+  contributingFeatures: import_zod5.z.array(ContributingFeatureSchema)
+});
+var PredictionWarningSchema = import_zod5.z.object({
+  severity: import_zod5.z.enum(["critical", "warning", "info"]),
+  category: ArchMetricCategorySchema,
+  message: import_zod5.z.string(),
+  weeksUntil: import_zod5.z.number(),
+  confidence: ConfidenceTierSchema,
+  contributingFeatures: import_zod5.z.array(import_zod5.z.string())
+});
+var StabilityForecastSchema = import_zod5.z.object({
+  current: import_zod5.z.number(),
+  projected4w: import_zod5.z.number(),
+  projected8w: import_zod5.z.number(),
+  projected12w: import_zod5.z.number(),
+  confidence: ConfidenceTierSchema,
+  direction: DirectionSchema
+});
+var PredictionResultSchema = import_zod5.z.object({
+  generatedAt: import_zod5.z.string(),
+  snapshotsUsed: import_zod5.z.number().int().min(0),
+  timelineRange: import_zod5.z.object({
+    from: import_zod5.z.string(),
+    to: import_zod5.z.string()
+  }),
+  stabilityForecast: StabilityForecastSchema,
+  categories: import_zod5.z.record(ArchMetricCategorySchema, AdjustedForecastSchema),
+  warnings: import_zod5.z.array(PredictionWarningSchema)
+});
+var PredictionOptionsSchema = import_zod5.z.object({
+  horizon: import_zod5.z.number().int().min(1).default(12),
+  includeRoadmap: import_zod5.z.boolean().default(true),
+  categories: import_zod5.z.array(ArchMetricCategorySchema).optional(),
+  thresholds: import_zod5.z.record(ArchMetricCategorySchema, import_zod5.z.number()).optional()
+});
+
+// src/architecture/regression.ts
+function computeWeightedSums(points) {
+  let sumW = 0, sumWt = 0, sumWv = 0, sumWtt = 0, sumWtv = 0;
+  for (const p of points) {
+    const w = p.weight;
+    sumW += w;
+    sumWt += w * p.t;
+    sumWv += w * p.value;
+    sumWtt += w * p.t * p.t;
+    sumWtv += w * p.t * p.value;
+  }
+  return { sumW, sumWt, sumWv, sumWtt, sumWtv };
+}
+function computeRSquared(points, slope, intercept, meanV) {
+  let ssRes = 0, ssTot = 0;
+  for (const p of points) {
+    const predicted = slope * p.t + intercept;
+    ssRes += p.weight * (p.value - predicted) ** 2;
+    ssTot += p.weight * (p.value - meanV) ** 2;
+  }
+  return ssTot < 1e-12 ? 1 : Math.max(0, 1 - ssRes / ssTot);
+}
+function weightedLinearRegression(points) {
+  if (points.length < 2) {
+    throw new Error(`Regression requires at least 2 data points, got ${points.length}`);
+  }
+  const n = points.length;
+  const { sumW, sumWt, sumWv, sumWtt, sumWtv } = computeWeightedSums(points);
+  const meanT = sumWt / sumW;
+  const meanV = sumWv / sumW;
+  const denominator = sumWtt - sumWt * sumWt / sumW;
+  if (Math.abs(denominator) < 1e-12) {
+    return { slope: 0, intercept: meanV, rSquared: 0, dataPoints: n };
+  }
+  const slope = (sumWtv - sumWt * sumWv / sumW) / denominator;
+  const intercept = meanV - slope * meanT;
+  const rSquared = computeRSquared(points, slope, intercept, meanV);
+  return { slope, intercept, rSquared, dataPoints: n };
+}
+function applyRecencyWeights(values, decay = 0.85) {
+  const n = values.length;
+  return values.map((v, i) => ({
+    t: v.t,
+    value: v.value,
+    weight: Math.pow(decay, n - 1 - i)
+  }));
+}
+function projectValue(fit, t) {
+  return fit.slope * t + fit.intercept;
+}
+function weeksUntilThreshold(fit, currentT, threshold) {
+  if (fit.slope <= 0) {
+    return null;
+  }
+  const currentProjected = projectValue(fit, currentT);
+  if (currentProjected >= threshold) {
+    return null;
+  }
+  const weeks = (threshold - currentProjected) / fit.slope;
+  return Math.ceil(weeks);
+}
+function classifyConfidence(rSquared, dataPoints) {
+  if (rSquared >= 0.7 && dataPoints >= 5) return "high";
+  if (rSquared >= 0.4 && dataPoints >= 3) return "medium";
+  return "low";
+}
+
+// src/architecture/prediction-engine.ts
+var fs5 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+
+// src/roadmap/parse.ts
+var import_types13 = require("@harness-engineering/types");
+var VALID_STATUSES = /* @__PURE__ */ new Set([
+  "backlog",
+  "planned",
+  "in-progress",
+  "done",
+  "blocked"
+]);
+var EM_DASH = "\u2014";
+var VALID_PRIORITIES = /* @__PURE__ */ new Set(["P0", "P1", "P2", "P3"]);
+function parseRoadmap(markdown) {
+  const fmMatch = markdown.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) {
+    return (0, import_types13.Err)(new Error("Missing or malformed YAML frontmatter"));
+  }
+  const fmResult = parseFrontmatter(fmMatch[1]);
+  if (!fmResult.ok) return fmResult;
+  const body = markdown.slice(fmMatch[0].length);
+  const milestonesResult = parseMilestones(body);
+  if (!milestonesResult.ok) return milestonesResult;
+  const historyResult = parseAssignmentHistory(body);
+  if (!historyResult.ok) return historyResult;
+  return (0, import_types13.Ok)({
+    frontmatter: fmResult.value,
+    milestones: milestonesResult.value,
+    assignmentHistory: historyResult.value
+  });
+}
+function parseFrontmatter(raw) {
+  const lines = raw.split("\n");
+  const map = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    const val = line.slice(idx + 1).trim();
+    map.set(key, val);
+  }
+  const project = map.get("project");
+  const versionStr = map.get("version");
+  const lastSynced = map.get("last_synced");
+  const lastManualEdit = map.get("last_manual_edit");
+  const created = map.get("created");
+  const updated = map.get("updated");
+  if (!project || !versionStr || !lastSynced || !lastManualEdit) {
+    return (0, import_types13.Err)(
+      new Error(
+        "Frontmatter missing required fields: project, version, last_synced, last_manual_edit"
+      )
+    );
+  }
+  const version = parseInt(versionStr, 10);
+  if (isNaN(version)) {
+    return (0, import_types13.Err)(new Error("Frontmatter version must be a number"));
+  }
+  const fm = { project, version, lastSynced, lastManualEdit };
+  if (created) fm.created = created;
+  if (updated) fm.updated = updated;
+  return (0, import_types13.Ok)(fm);
+}
+function parseMilestones(body) {
+  const milestones = [];
+  const h2Pattern = /^## (.+)$/gm;
+  const h2Matches = [];
+  let match;
+  let bodyEnd = body.length;
+  while ((match = h2Pattern.exec(body)) !== null) {
+    if (match[1] === "Assignment History") {
+      bodyEnd = match.index;
+      break;
+    }
+    h2Matches.push({ heading: match[1], startIndex: match.index, fullMatch: match[0] });
+  }
+  for (let i = 0; i < h2Matches.length; i++) {
+    const h2 = h2Matches[i];
+    const nextStart = i + 1 < h2Matches.length ? h2Matches[i + 1].startIndex : bodyEnd;
+    const sectionBody = body.slice(h2.startIndex + h2.fullMatch.length, nextStart);
+    const isBacklog = h2.heading === "Backlog";
+    const milestoneName = isBacklog ? "Backlog" : h2.heading.replace(/^Milestone:\s*/, "");
+    const featuresResult = parseFeatures(sectionBody);
+    if (!featuresResult.ok) return featuresResult;
+    milestones.push({
+      name: milestoneName,
+      isBacklog,
+      features: featuresResult.value
+    });
+  }
+  return (0, import_types13.Ok)(milestones);
+}
+function parseFeatures(sectionBody) {
+  const features = [];
+  const h3Pattern = /^### (?:Feature: )?(.+)$/gm;
+  const h3Matches = [];
+  let match;
+  while ((match = h3Pattern.exec(sectionBody)) !== null) {
+    h3Matches.push({ name: match[1], startIndex: match.index, fullMatch: match[0] });
+  }
+  for (let i = 0; i < h3Matches.length; i++) {
+    const h3 = h3Matches[i];
+    const nextStart = i + 1 < h3Matches.length ? h3Matches[i + 1].startIndex : sectionBody.length;
+    const featureBody = sectionBody.slice(h3.startIndex + h3.fullMatch.length, nextStart);
+    const featureResult = parseFeatureFields(h3.name, featureBody);
+    if (!featureResult.ok) return featureResult;
+    features.push(featureResult.value);
+  }
+  return (0, import_types13.Ok)(features);
+}
+function extractFieldMap(body) {
+  const fieldMap = /* @__PURE__ */ new Map();
+  const fieldPattern = /^- \*\*(.+?):\*\* (.+)$/gm;
+  let match;
+  while ((match = fieldPattern.exec(body)) !== null) {
+    fieldMap.set(match[1], match[2]);
+  }
+  return fieldMap;
+}
+function parseListField(fieldMap, ...keys) {
+  let raw = EM_DASH;
+  for (const key of keys) {
+    const val = fieldMap.get(key);
+    if (val !== void 0) {
+      raw = val;
+      break;
+    }
+  }
+  if (raw === EM_DASH || raw === "none") return [];
+  return raw.split(",").map((s) => s.trim());
+}
+function parseFeatureFields(name, body) {
+  const fieldMap = extractFieldMap(body);
+  const statusRaw = fieldMap.get("Status");
+  if (!statusRaw || !VALID_STATUSES.has(statusRaw)) {
+    return (0, import_types13.Err)(
+      new Error(
+        `Feature "${name}" has invalid status: "${statusRaw ?? "(missing)"}". Valid statuses: ${[...VALID_STATUSES].join(", ")}`
+      )
+    );
+  }
+  const specRaw = fieldMap.get("Spec") ?? EM_DASH;
+  const plans = parseListField(fieldMap, "Plans", "Plan");
+  const blockedBy = parseListField(fieldMap, "Blocked by", "Blockers");
+  const assigneeRaw = fieldMap.get("Assignee") ?? EM_DASH;
+  const priorityRaw = fieldMap.get("Priority") ?? EM_DASH;
+  const externalIdRaw = fieldMap.get("External-ID") ?? EM_DASH;
+  if (priorityRaw !== EM_DASH && !VALID_PRIORITIES.has(priorityRaw)) {
+    return (0, import_types13.Err)(
+      new Error(
+        `Feature "${name}" has invalid priority: "${priorityRaw}". Valid priorities: ${[...VALID_PRIORITIES].join(", ")}`
+      )
+    );
+  }
+  return (0, import_types13.Ok)({
+    name,
+    status: statusRaw,
+    spec: specRaw === EM_DASH ? null : specRaw,
+    plans,
+    blockedBy,
+    summary: fieldMap.get("Summary") ?? "",
+    assignee: assigneeRaw === EM_DASH ? null : assigneeRaw,
+    priority: priorityRaw === EM_DASH ? null : priorityRaw,
+    externalId: externalIdRaw === EM_DASH ? null : externalIdRaw
+  });
+}
+function parseAssignmentHistory(body) {
+  const historyMatch = body.match(/^## Assignment History\s*\n/m);
+  if (!historyMatch || historyMatch.index === void 0) return (0, import_types13.Ok)([]);
+  const historyStart = historyMatch.index + historyMatch[0].length;
+  const rawHistoryBody = body.slice(historyStart);
+  const nextH2 = rawHistoryBody.search(/^## /m);
+  const historyBody = nextH2 === -1 ? rawHistoryBody : rawHistoryBody.slice(0, nextH2);
+  const records = [];
+  const lines = historyBody.split("\n");
+  let pastHeader = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|")) continue;
+    if (!pastHeader) {
+      if (trimmed.match(/^\|[-\s|]+\|$/)) {
+        pastHeader = true;
+      }
+      continue;
+    }
+    const cells = trimmed.split("|").map((c) => c.trim()).filter((c) => c.length > 0);
+    if (cells.length < 4) continue;
+    const action = cells[2];
+    if (!["assigned", "completed", "unassigned"].includes(action)) continue;
+    records.push({
+      feature: cells[0],
+      assignee: cells[1],
+      action,
+      date: cells[3]
+    });
+  }
+  return (0, import_types13.Ok)(records);
+}
+
+// src/architecture/prediction-engine.ts
+var ALL_CATEGORIES2 = ArchMetricCategorySchema.options;
+var DIRECTION_THRESHOLD = 1e-3;
+var PredictionEngine = class {
+  constructor(rootDir, timelineManager, estimator) {
+    this.rootDir = rootDir;
+    this.timelineManager = timelineManager;
+    this.estimator = estimator;
+  }
+  rootDir;
+  timelineManager;
+  estimator;
+  /**
+   * Produce a PredictionResult with per-category forecasts and warnings.
+   * Throws if fewer than 3 snapshots are available.
+   */
+  predict(options) {
+    const opts = this.resolveOptions(options);
+    const timeline = this.timelineManager.load();
+    const snapshots = timeline.snapshots;
+    if (snapshots.length < 3) {
+      throw new Error(
+        `PredictionEngine requires at least 3 snapshots, got ${snapshots.length}. Run "harness snapshot" to capture more data points.`
+      );
+    }
+    const thresholds = this.resolveThresholds(opts);
+    const categoriesToProcess = opts.categories ?? [...ALL_CATEGORIES2];
+    const firstDate = new Date(snapshots[0].capturedAt).getTime();
+    const lastSnapshot = snapshots[snapshots.length - 1];
+    const currentT = (new Date(lastSnapshot.capturedAt).getTime() - firstDate) / (7 * 24 * 60 * 60 * 1e3);
+    const baselines = {};
+    for (const category of ALL_CATEGORIES2) {
+      const threshold = thresholds[category];
+      const shouldProcess = categoriesToProcess.includes(category);
+      if (!shouldProcess) {
+        baselines[category] = this.zeroForecast(category, threshold);
+        continue;
+      }
+      const timeSeries = this.extractTimeSeries(snapshots, category, firstDate);
+      baselines[category] = this.forecastCategory(
+        category,
+        timeSeries,
+        currentT,
+        threshold,
+        opts.horizon
+      );
+    }
+    const specImpacts = this.computeSpecImpacts(opts);
+    const categories = {};
+    for (const category of ALL_CATEGORIES2) {
+      const baseline = baselines[category];
+      const threshold = thresholds[category];
+      if (!specImpacts || specImpacts.length === 0) {
+        categories[category] = {
+          baseline,
+          adjusted: baseline,
+          contributingFeatures: []
+        };
+        continue;
+      }
+      let totalDelta = 0;
+      const contributing = [];
+      for (const impact of specImpacts) {
+        const delta = impact.deltas?.[category] ?? 0;
+        if (delta !== 0) {
+          totalDelta += delta;
+          contributing.push({
+            name: impact.featureName,
+            specPath: impact.specPath,
+            delta
+          });
+        }
+      }
+      if (totalDelta === 0) {
+        categories[category] = {
+          baseline,
+          adjusted: baseline,
+          contributingFeatures: []
+        };
+        continue;
+      }
+      const adjusted = {
+        ...baseline,
+        projectedValue4w: baseline.projectedValue4w + totalDelta,
+        projectedValue8w: baseline.projectedValue8w + totalDelta,
+        projectedValue12w: baseline.projectedValue12w + totalDelta
+      };
+      const adjustedFit = {
+        slope: baseline.regression.slope,
+        intercept: baseline.regression.intercept + totalDelta,
+        rSquared: baseline.regression.rSquared,
+        dataPoints: baseline.regression.dataPoints
+      };
+      adjusted.thresholdCrossingWeeks = weeksUntilThreshold(adjustedFit, currentT, threshold);
+      adjusted.regression = {
+        slope: adjustedFit.slope,
+        intercept: adjustedFit.intercept,
+        rSquared: adjustedFit.rSquared,
+        dataPoints: adjustedFit.dataPoints
+      };
+      categories[category] = {
+        baseline,
+        adjusted,
+        contributingFeatures: contributing
+      };
+    }
+    const warnings = this.generateWarnings(
+      categories,
+      opts.horizon
+    );
+    const stabilityForecast = this.computeStabilityForecast(
+      categories,
+      thresholds,
+      snapshots
+    );
+    return {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      snapshotsUsed: snapshots.length,
+      timelineRange: {
+        from: snapshots[0].capturedAt,
+        to: lastSnapshot.capturedAt
+      },
+      stabilityForecast,
+      categories,
+      warnings
+    };
+  }
+  // --- Private helpers ---
+  resolveOptions(options) {
+    return {
+      horizon: options?.horizon ?? 12,
+      includeRoadmap: options?.includeRoadmap ?? true,
+      categories: options?.categories,
+      thresholds: options?.thresholds
+    };
+  }
+  resolveThresholds(opts) {
+    const base = { ...DEFAULT_STABILITY_THRESHOLDS };
+    if (opts.thresholds) {
+      for (const [key, value] of Object.entries(opts.thresholds)) {
+        if (value !== void 0) {
+          base[key] = value;
+        }
+      }
+    }
+    return base;
+  }
+  /**
+   * Extract time series for a single category from snapshots.
+   * Returns array of { t (weeks from first), value } sorted oldest first.
+   */
+  extractTimeSeries(snapshots, category, firstDateMs) {
+    return snapshots.map((s) => {
+      const t = (new Date(s.capturedAt).getTime() - firstDateMs) / (7 * 24 * 60 * 60 * 1e3);
+      const metrics = s.metrics;
+      const value = metrics[category]?.value ?? 0;
+      return { t, value };
+    });
+  }
+  /**
+   * Produce a CategoryForecast for a single category using regression.
+   */
+  forecastCategory(category, timeSeries, currentT, threshold, horizon = 12) {
+    const weighted = applyRecencyWeights(timeSeries, 0.85);
+    const fit = weightedLinearRegression(weighted);
+    const current = timeSeries[timeSeries.length - 1].value;
+    const h3 = Math.round(horizon / 3);
+    const h2 = Math.round(horizon * 2 / 3);
+    const projected4w = projectValue(fit, currentT + h3);
+    const projected8w = projectValue(fit, currentT + h2);
+    const projected12w = projectValue(fit, currentT + horizon);
+    const crossing = weeksUntilThreshold(fit, currentT, threshold);
+    const confidence = classifyConfidence(fit.rSquared, fit.dataPoints);
+    const direction = this.classifyDirection(fit.slope);
+    return {
+      category,
+      current,
+      threshold,
+      projectedValue4w: projected4w,
+      projectedValue8w: projected8w,
+      projectedValue12w: projected12w,
+      thresholdCrossingWeeks: crossing,
+      confidence,
+      regression: {
+        slope: fit.slope,
+        intercept: fit.intercept,
+        rSquared: fit.rSquared,
+        dataPoints: fit.dataPoints
+      },
+      direction
+    };
+  }
+  classifyDirection(slope) {
+    if (Math.abs(slope) < DIRECTION_THRESHOLD) return "stable";
+    return slope > 0 ? "declining" : "improving";
+  }
+  zeroForecast(category, threshold) {
+    return {
+      category,
+      current: 0,
+      threshold,
+      projectedValue4w: 0,
+      projectedValue8w: 0,
+      projectedValue12w: 0,
+      thresholdCrossingWeeks: null,
+      confidence: "low",
+      regression: { slope: 0, intercept: 0, rSquared: 0, dataPoints: 0 },
+      direction: "stable"
+    };
+  }
+  /**
+   * Generate warnings based on severity rules from spec:
+   * - critical: threshold crossing <= 4w, confidence high or medium
+   * - warning: threshold crossing <= 8w, confidence high or medium
+   * - info: threshold crossing <= 12w, any confidence
+   */
+  generateWarnings(categories, horizon = 12) {
+    const warnings = [];
+    const criticalWindow = Math.round(horizon / 3);
+    const warningWindow = Math.round(horizon * 2 / 3);
+    for (const category of ALL_CATEGORIES2) {
+      const af = categories[category];
+      if (!af) continue;
+      const forecast = af.adjusted;
+      const crossing = forecast.thresholdCrossingWeeks;
+      if (crossing === null || crossing <= 0) continue;
+      let severity = null;
+      if (crossing <= criticalWindow && (forecast.confidence === "high" || forecast.confidence === "medium")) {
+        severity = "critical";
+      } else if (crossing <= warningWindow && (forecast.confidence === "high" || forecast.confidence === "medium")) {
+        severity = "warning";
+      } else if (crossing <= horizon) {
+        severity = "info";
+      }
+      if (severity) {
+        const contributingNames = af.contributingFeatures.map((f) => f.name);
+        warnings.push({
+          severity,
+          category,
+          message: `${category} projected to exceed threshold (~${crossing}w, ${forecast.confidence} confidence)`,
+          weeksUntil: crossing,
+          confidence: forecast.confidence,
+          contributingFeatures: contributingNames
+        });
+      }
+    }
+    return warnings;
+  }
+  /**
+   * Compute composite stability forecast by projecting per-category values
+   * forward and computing stability scores at each horizon.
+   */
+  computeStabilityForecast(categories, thresholds, _snapshots) {
+    const currentMetrics = this.buildMetricsFromForecasts(categories, "current");
+    const current = this.timelineManager.computeStabilityScore(currentMetrics, thresholds);
+    const metrics4w = this.buildMetricsFromForecasts(categories, "4w");
+    const projected4w = this.timelineManager.computeStabilityScore(metrics4w, thresholds);
+    const metrics8w = this.buildMetricsFromForecasts(categories, "8w");
+    const projected8w = this.timelineManager.computeStabilityScore(metrics8w, thresholds);
+    const metrics12w = this.buildMetricsFromForecasts(categories, "12w");
+    const projected12w = this.timelineManager.computeStabilityScore(metrics12w, thresholds);
+    const delta = projected12w - current;
+    let direction;
+    if (Math.abs(delta) < 2) {
+      direction = "stable";
+    } else {
+      direction = delta > 0 ? "improving" : "declining";
+    }
+    const confidences = ALL_CATEGORIES2.map((c) => categories[c]?.adjusted.confidence ?? "low");
+    const confidence = this.medianConfidence(confidences);
+    return { current, projected4w, projected8w, projected12w, confidence, direction };
+  }
+  buildMetricsFromForecasts(categories, horizon) {
+    const metrics = {};
+    for (const cat of ALL_CATEGORIES2) {
+      const forecast = categories[cat]?.adjusted;
+      let value = 0;
+      if (forecast) {
+        switch (horizon) {
+          case "current":
+            value = forecast.current;
+            break;
+          case "4w":
+            value = forecast.projectedValue4w;
+            break;
+          case "8w":
+            value = forecast.projectedValue8w;
+            break;
+          case "12w":
+            value = forecast.projectedValue12w;
+            break;
+        }
+      }
+      metrics[cat] = { value: Math.max(0, value), violationCount: 0 };
+    }
+    return metrics;
+  }
+  medianConfidence(confidences) {
+    const order = { low: 0, medium: 1, high: 2 };
+    const sorted = [...confidences].sort((a, b) => order[a] - order[b]);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted[mid] ?? "low";
+  }
+  /**
+   * Load roadmap features, estimate spec impacts via the estimator.
+   * Returns null if estimator is null or includeRoadmap is false.
+   */
+  computeSpecImpacts(opts) {
+    if (!this.estimator || !opts.includeRoadmap) {
+      return null;
+    }
+    try {
+      const roadmapPath = path2.join(this.rootDir, "roadmap.md");
+      const raw = fs5.readFileSync(roadmapPath, "utf-8");
+      const parseResult = parseRoadmap(raw);
+      if (!parseResult.ok) return null;
+      const features = [];
+      for (const milestone of parseResult.value.milestones) {
+        for (const feature of milestone.features) {
+          if (feature.status === "planned" || feature.status === "in-progress") {
+            features.push({ name: feature.name, spec: feature.spec });
+          }
+        }
+      }
+      if (features.length === 0) return null;
+      return this.estimator.estimateAll(features);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/architecture/spec-impact-estimator.ts
+var fs6 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var DEFAULT_COEFFICIENTS = {
+  newFileModuleSize: 0.3,
+  newFileComplexity: 1.5,
+  layerViolation: 0.5,
+  depCoupling: 0.2,
+  depDepth: 0.3,
+  phaseComplexity: 2
+};
+var SpecImpactEstimator = class {
+  constructor(rootDir, coefficients) {
+    this.rootDir = rootDir;
+    this.coefficients = { ...DEFAULT_COEFFICIENTS, ...coefficients };
+    this.layerNames = this.loadLayerNames();
+  }
+  rootDir;
+  coefficients;
+  layerNames;
+  /**
+   * Estimate impact of a single spec file.
+   * @param specPath - Relative path from rootDir to the spec file.
+   */
+  estimate(specPath) {
+    const absolutePath = path3.join(this.rootDir, specPath);
+    const content = fs6.readFileSync(absolutePath, "utf-8");
+    const newFileCount = this.extractNewFileCount(content);
+    const affectedLayers = this.extractAffectedLayers(content);
+    const newDependencies = this.extractNewDependencies(content);
+    const phaseCount = this.extractPhaseCount(content);
+    const deltas = this.computeDeltas(
+      newFileCount,
+      affectedLayers.length,
+      newDependencies,
+      phaseCount
+    );
+    const h1Match = content.match(/^#\s+(.+)$/m);
+    const featureName = h1Match ? h1Match[1].trim() : path3.basename(specPath, ".md");
+    return {
+      specPath,
+      featureName,
+      signals: {
+        newFileCount,
+        affectedLayers,
+        newDependencies,
+        phaseCount
+      },
+      deltas
+    };
+  }
+  /**
+   * Estimate impact for all planned features that have specs.
+   * Skips features with null specs or specs that don't exist on disk.
+   */
+  estimateAll(features) {
+    const results = [];
+    for (const feature of features) {
+      if (!feature.spec) continue;
+      const absolutePath = path3.join(this.rootDir, feature.spec);
+      if (!fs6.existsSync(absolutePath)) continue;
+      const estimate = this.estimate(feature.spec);
+      results.push({ ...estimate, featureName: feature.name });
+    }
+    return results;
+  }
+  // --- Private: Signal Extraction ---
+  /**
+   * Count file paths in Technical Design sections that don't exist on disk.
+   * Looks for paths in code blocks (```) under ## Technical Design.
+   */
+  extractNewFileCount(content) {
+    const techDesignMatch = content.match(/## Technical Design\b[\s\S]*?(?=\n## |\n# |$)/i);
+    if (!techDesignMatch) return 0;
+    const section = techDesignMatch[0];
+    const codeBlocks = section.match(/```[\s\S]*?```/g) ?? [];
+    const filePaths = [];
+    for (const block of codeBlocks) {
+      const inner = block.replace(/^```\w*\n?/, "").replace(/\n?```$/, "");
+      for (const line of inner.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.match(/^[\w@.-]+\/[\w./-]+\.\w+$/)) {
+          filePaths.push(trimmed);
+        }
+      }
+    }
+    let count = 0;
+    for (const fp of filePaths) {
+      const absolute = path3.join(this.rootDir, fp);
+      if (!fs6.existsSync(absolute)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Match layer names from harness.config.json mentioned in the spec.
+   * Returns deduplicated array of matched layer names.
+   */
+  extractAffectedLayers(content) {
+    if (this.layerNames.length === 0) return [];
+    const matched = /* @__PURE__ */ new Set();
+    for (const layer of this.layerNames) {
+      const pattern = new RegExp(`\\b${this.escapeRegex(layer)}\\b`, "i");
+      if (pattern.test(content)) {
+        matched.add(layer);
+      }
+    }
+    return [...matched].sort();
+  }
+  /**
+   * Count dependency-related keywords: "import", "depend" (covers depends/dependency),
+   * "package" in dependency context.
+   */
+  extractNewDependencies(content) {
+    const patterns = [/\bimport\b/gi, /\bdepend\w*\b/gi, /\bpackage\b/gi];
+    let count = 0;
+    for (const pattern of patterns) {
+      const matches = content.match(pattern);
+      if (matches) count += matches.length;
+    }
+    return count;
+  }
+  /**
+   * Count H3/H4 headings under "Implementation" or "Implementation Order" sections.
+   */
+  extractPhaseCount(content) {
+    const implMatch = content.match(/## Implementation\b[\s\S]*?(?=\n## |\n# |$)/i);
+    if (!implMatch) return 0;
+    const section = implMatch[0];
+    const headings = section.match(/^#{3,4}\s+.+$/gm);
+    return headings ? headings.length : 0;
+  }
+  // --- Private: Delta Computation ---
+  computeDeltas(newFileCount, crossLayerCount, newDependencies, phaseCount) {
+    const deltas = {};
+    const c = this.coefficients;
+    const addDelta = (category, value) => {
+      deltas[category] = (deltas[category] ?? 0) + value;
+    };
+    if (newFileCount > 0) {
+      addDelta("module-size", newFileCount * c.newFileModuleSize);
+      addDelta("complexity", newFileCount * c.newFileComplexity);
+    }
+    if (crossLayerCount > 0) {
+      addDelta("layer-violations", crossLayerCount * c.layerViolation);
+    }
+    if (newDependencies > 0) {
+      addDelta("coupling", newDependencies * c.depCoupling);
+      addDelta("dependency-depth", newDependencies * c.depDepth);
+    }
+    if (phaseCount > 1) {
+      addDelta("complexity", (phaseCount - 1) * c.phaseComplexity);
+    }
+    return deltas;
+  }
+  // --- Private: Config Loading ---
+  loadLayerNames() {
+    try {
+      const configPath = path3.join(this.rootDir, "harness.config.json");
+      const raw = fs6.readFileSync(configPath, "utf-8");
+      const config = JSON.parse(raw);
+      return (config.layers ?? []).map((l) => l.name);
+    } catch {
+      return [];
+    }
+  }
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+};
+
+// src/state/types.ts
+var import_zod6 = require("zod");
+var FailureEntrySchema = import_zod6.z.object({
+  date: import_zod6.z.string(),
+  skill: import_zod6.z.string(),
+  type: import_zod6.z.string(),
+  description: import_zod6.z.string()
 });
-var HandoffSchema = import_zod4.z.object({
-  timestamp: import_zod4.z.string(),
-  fromSkill: import_zod4.z.string(),
-  phase: import_zod4.z.string(),
-  summary: import_zod4.z.string(),
-  completed: import_zod4.z.array(import_zod4.z.string()).default([]),
-  pending: import_zod4.z.array(import_zod4.z.string()).default([]),
-  concerns: import_zod4.z.array(import_zod4.z.string()).default([]),
-  decisions: import_zod4.z.array(
-    import_zod4.z.object({
-      what: import_zod4.z.string(),
-      why: import_zod4.z.string()
+var HandoffSchema = import_zod6.z.object({
+  timestamp: import_zod6.z.string(),
+  fromSkill: import_zod6.z.string(),
+  phase: import_zod6.z.string(),
+  summary: import_zod6.z.string(),
+  completed: import_zod6.z.array(import_zod6.z.string()).default([]),
+  pending: import_zod6.z.array(import_zod6.z.string()).default([]),
+  concerns: import_zod6.z.array(import_zod6.z.string()).default([]),
+  decisions: import_zod6.z.array(
+    import_zod6.z.object({
+      what: import_zod6.z.string(),
+      why: import_zod6.z.string()
     })
   ).default([]),
-  blockers: import_zod4.z.array(import_zod4.z.string()).default([]),
-  contextKeywords: import_zod4.z.array(import_zod4.z.string()).default([])
+  blockers: import_zod6.z.array(import_zod6.z.string()).default([]),
+  contextKeywords: import_zod6.z.array(import_zod6.z.string()).default([])
 });
-var GateCheckSchema = import_zod4.z.object({
-  name: import_zod4.z.string(),
-  passed: import_zod4.z.boolean(),
-  command: import_zod4.z.string(),
-  output: import_zod4.z.string().optional(),
-  duration: import_zod4.z.number().optional()
+var GateCheckSchema = import_zod6.z.object({
+  name: import_zod6.z.string(),
+  passed: import_zod6.z.boolean(),
+  command: import_zod6.z.string(),
+  output: import_zod6.z.string().optional(),
+  duration: import_zod6.z.number().optional()
 });
-var GateResultSchema = import_zod4.z.object({
-  passed: import_zod4.z.boolean(),
-  checks: import_zod4.z.array(GateCheckSchema)
+var GateResultSchema = import_zod6.z.object({
+  passed: import_zod6.z.boolean(),
+  checks: import_zod6.z.array(GateCheckSchema)
 });
-var GateConfigSchema = import_zod4.z.object({
-  checks: import_zod4.z.array(
-    import_zod4.z.object({
-      name: import_zod4.z.string(),
-      command: import_zod4.z.string()
+var GateConfigSchema = import_zod6.z.object({
+  checks: import_zod6.z.array(
+    import_zod6.z.object({
+      name: import_zod6.z.string(),
+      command: import_zod6.z.string()
     })
   ).optional(),
-  trace: import_zod4.z.boolean().optional()
+  trace: import_zod6.z.boolean().optional()
 });
-var HarnessStateSchema = import_zod4.z.object({
-  schemaVersion: import_zod4.z.literal(1),
-  position: import_zod4.z.object({
-    phase: import_zod4.z.string().optional(),
-    task: import_zod4.z.string().optional()
+var HarnessStateSchema = import_zod6.z.object({
+  schemaVersion: import_zod6.z.literal(1),
+  position: import_zod6.z.object({
+    phase: import_zod6.z.string().optional(),
+    task: import_zod6.z.string().optional()
   }).default({}),
-  decisions: import_zod4.z.array(
-    import_zod4.z.object({
-      date: import_zod4.z.string(),
-      decision: import_zod4.z.string(),
-      context: import_zod4.z.string()
+  decisions: import_zod6.z.array(
+    import_zod6.z.object({
+      date: import_zod6.z.string(),
+      decision: import_zod6.z.string(),
+      context: import_zod6.z.string()
     })
   ).default([]),
-  blockers: import_zod4.z.array(
-    import_zod4.z.object({
-      id: import_zod4.z.string(),
-      description: import_zod4.z.string(),
-      status: import_zod4.z.enum(["open", "resolved"])
+  blockers: import_zod6.z.array(
+    import_zod6.z.object({
+      id: import_zod6.z.string(),
+      description: import_zod6.z.string(),
+      status: import_zod6.z.enum(["open", "resolved"])
     })
   ).default([]),
-  progress: import_zod4.z.record(import_zod4.z.enum(["pending", "in_progress", "complete"])).default({}),
-  lastSession: import_zod4.z.object({
-    date: import_zod4.z.string(),
-    summary: import_zod4.z.string(),
-    lastSkill: import_zod4.z.string().optional(),
-    pendingTasks: import_zod4.z.array(import_zod4.z.string()).optional()
+  progress: import_zod6.z.record(import_zod6.z.enum(["pending", "in_progress", "complete"])).default({}),
+  lastSession: import_zod6.z.object({
+    date: import_zod6.z.string(),
+    summary: import_zod6.z.string(),
+    lastSkill: import_zod6.z.string().optional(),
+    pendingTasks: import_zod6.z.array(import_zod6.z.string()).optional()
   }).optional()
 });
 var DEFAULT_STATE = {
@@ -6885,30 +8007,30 @@ var DEFAULT_STATE = {
 };
 
 // src/state/state-persistence.ts
-var fs8 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
 
 // src/state/state-shared.ts
-var fs7 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 
 // src/state/stream-resolver.ts
-var fs5 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
 var import_child_process = require("child_process");
 
 // src/state/stream-types.ts
-var import_zod5 = require("zod");
-var StreamInfoSchema = import_zod5.z.object({
-  name: import_zod5.z.string(),
-  branch: import_zod5.z.string().optional(),
-  createdAt: import_zod5.z.string(),
-  lastActiveAt: import_zod5.z.string()
+var import_zod7 = require("zod");
+var StreamInfoSchema = import_zod7.z.object({
+  name: import_zod7.z.string(),
+  branch: import_zod7.z.string().optional(),
+  createdAt: import_zod7.z.string(),
+  lastActiveAt: import_zod7.z.string()
 });
-var StreamIndexSchema = import_zod5.z.object({
-  schemaVersion: import_zod5.z.literal(1),
-  activeStream: import_zod5.z.string().nullable(),
-  streams: import_zod5.z.record(StreamInfoSchema)
+var StreamIndexSchema = import_zod7.z.object({
+  schemaVersion: import_zod7.z.literal(1),
+  activeStream: import_zod7.z.string().nullable(),
+  streams: import_zod7.z.record(StreamInfoSchema)
 });
 var DEFAULT_STREAM_INDEX = {
   schemaVersion: 1,
@@ -6936,10 +8058,10 @@ var EVENTS_FILE = "events.jsonl";
 var STREAMS_DIR = "streams";
 var STREAM_NAME_REGEX = /^[a-z0-9][a-z0-9._-]*$/;
 function streamsDir(projectPath) {
-  return path2.join(projectPath, HARNESS_DIR, STREAMS_DIR);
+  return path4.join(projectPath, HARNESS_DIR, STREAMS_DIR);
 }
 function indexPath(projectPath) {
-  return path2.join(streamsDir(projectPath), INDEX_FILE);
+  return path4.join(streamsDir(projectPath), INDEX_FILE);
 }
 function validateStreamName(name) {
   if (!STREAM_NAME_REGEX.test(name)) {
@@ -6953,11 +8075,11 @@ function validateStreamName(name) {
 }
 async function loadStreamIndex(projectPath) {
   const idxPath = indexPath(projectPath);
-  if (!fs5.existsSync(idxPath)) {
+  if (!fs7.existsSync(idxPath)) {
     return (0, import_types.Ok)({ ...DEFAULT_STREAM_INDEX, streams: {} });
   }
   try {
-    const raw = fs5.readFileSync(idxPath, "utf-8");
+    const raw = fs7.readFileSync(idxPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = StreamIndexSchema.safeParse(parsed);
     if (!result.success) {
@@ -6975,8 +8097,8 @@ async function loadStreamIndex(projectPath) {
 async function saveStreamIndex(projectPath, index) {
   const dir = streamsDir(projectPath);
   try {
-    fs5.mkdirSync(dir, { recursive: true });
-    fs5.writeFileSync(indexPath(projectPath), JSON.stringify(index, null, 2));
+    fs7.mkdirSync(dir, { recursive: true });
+    fs7.writeFileSync(indexPath(projectPath), JSON.stringify(index, null, 2));
     return (0, import_types.Ok)(void 0);
   } catch (error) {
     return (0, import_types.Err)(
@@ -7017,18 +8139,18 @@ async function resolveStreamPath(projectPath, options) {
         )
       );
     }
-    return (0, import_types.Ok)(path2.join(streamsDir(projectPath), options.stream));
+    return (0, import_types.Ok)(path4.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 (0, import_types.Ok)(path2.join(streamsDir(projectPath), name));
+        return (0, import_types.Ok)(path4.join(streamsDir(projectPath), name));
       }
     }
   }
   if (index.activeStream && index.streams[index.activeStream]) {
-    return (0, import_types.Ok)(path2.join(streamsDir(projectPath), index.activeStream));
+    return (0, import_types.Ok)(path4.join(streamsDir(projectPath), index.activeStream));
   }
   return (0, import_types.Err)(
     new Error(
@@ -7056,9 +8178,9 @@ async function createStream(projectPath, name, branch) {
   if (index.streams[name]) {
     return (0, import_types.Err)(new Error(`Stream '${name}' already exists`));
   }
-  const streamPath = path2.join(streamsDir(projectPath), name);
+  const streamPath = path4.join(streamsDir(projectPath), name);
   try {
-    fs5.mkdirSync(streamPath, { recursive: true });
+    fs7.mkdirSync(streamPath, { recursive: true });
   } catch (error) {
     return (0, import_types.Err)(
       new Error(
@@ -7099,12 +8221,12 @@ async function archiveStream(projectPath, name) {
   if (!index.streams[name]) {
     return (0, import_types.Err)(new Error(`Stream '${name}' not found`));
   }
-  const streamPath = path2.join(streamsDir(projectPath), name);
-  const archiveDir = path2.join(projectPath, HARNESS_DIR, "archive", "streams");
+  const streamPath = path4.join(streamsDir(projectPath), name);
+  const archiveDir = path4.join(projectPath, HARNESS_DIR, "archive", "streams");
   try {
-    fs5.mkdirSync(archiveDir, { recursive: true });
+    fs7.mkdirSync(archiveDir, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    fs5.renameSync(streamPath, path2.join(archiveDir, `${name}-${date}`));
+    fs7.renameSync(streamPath, path4.join(archiveDir, `${name}-${date}`));
   } catch (error) {
     return (0, import_types.Err)(
       new Error(
@@ -7126,19 +8248,19 @@ function getStreamForBranch(index, branch) {
 }
 var STATE_FILES = ["state.json", "handoff.json", "learnings.md", "failures.md"];
 async function migrateToStreams(projectPath) {
-  const harnessDir = path2.join(projectPath, HARNESS_DIR);
-  if (fs5.existsSync(indexPath(projectPath))) {
+  const harnessDir = path4.join(projectPath, HARNESS_DIR);
+  if (fs7.existsSync(indexPath(projectPath))) {
     return (0, import_types.Ok)(void 0);
   }
-  const filesToMove = STATE_FILES.filter((f) => fs5.existsSync(path2.join(harnessDir, f)));
+  const filesToMove = STATE_FILES.filter((f) => fs7.existsSync(path4.join(harnessDir, f)));
   if (filesToMove.length === 0) {
     return (0, import_types.Ok)(void 0);
   }
-  const defaultDir = path2.join(streamsDir(projectPath), "default");
+  const defaultDir = path4.join(streamsDir(projectPath), "default");
   try {
-    fs5.mkdirSync(defaultDir, { recursive: true });
+    fs7.mkdirSync(defaultDir, { recursive: true });
     for (const file of filesToMove) {
-      fs5.renameSync(path2.join(harnessDir, file), path2.join(defaultDir, file));
+      fs7.renameSync(path4.join(harnessDir, file), path4.join(defaultDir, file));
     }
   } catch (error) {
     return (0, import_types.Err)(
@@ -7161,8 +8283,8 @@ async function migrateToStreams(projectPath) {
 }
 
 // src/state/session-resolver.ts
-var fs6 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
+var fs8 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
 function resolveSessionDir(projectPath, sessionSlug, options) {
   if (!sessionSlug || sessionSlug.trim() === "") {
     return (0, import_types.Err)(new Error("Session slug must not be empty"));
@@ -7172,26 +8294,26 @@ function resolveSessionDir(projectPath, sessionSlug, options) {
       new Error(`Invalid session slug '${sessionSlug}': must not contain path traversal characters`)
     );
   }
-  const sessionDir = path3.join(projectPath, HARNESS_DIR, SESSIONS_DIR, sessionSlug);
+  const sessionDir = path5.join(projectPath, HARNESS_DIR, SESSIONS_DIR, sessionSlug);
   if (options?.create) {
-    fs6.mkdirSync(sessionDir, { recursive: true });
+    fs8.mkdirSync(sessionDir, { recursive: true });
   }
   return (0, import_types.Ok)(sessionDir);
 }
 function updateSessionIndex(projectPath, sessionSlug, description) {
-  const sessionsDir = path3.join(projectPath, HARNESS_DIR, SESSIONS_DIR);
-  fs6.mkdirSync(sessionsDir, { recursive: true });
-  const indexPath2 = path3.join(sessionsDir, SESSION_INDEX_FILE);
+  const sessionsDir = path5.join(projectPath, HARNESS_DIR, SESSIONS_DIR);
+  fs8.mkdirSync(sessionsDir, { recursive: true });
+  const indexPath2 = path5.join(sessionsDir, SESSION_INDEX_FILE);
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const newLine = `- [${sessionSlug}](${sessionSlug}/summary.md) \u2014 ${description} (${date})`;
-  if (!fs6.existsSync(indexPath2)) {
-    fs6.writeFileSync(indexPath2, `## Active Sessions
+  if (!fs8.existsSync(indexPath2)) {
+    fs8.writeFileSync(indexPath2, `## Active Sessions
 
 ${newLine}
 `);
     return;
   }
-  const content = fs6.readFileSync(indexPath2, "utf-8");
+  const content = fs8.readFileSync(indexPath2, "utf-8");
   const lines = content.split("\n");
   const slugPattern = `- [${sessionSlug}]`;
   const existingIdx = lines.findIndex((l) => l.startsWith(slugPattern));
@@ -7201,7 +8323,7 @@ ${newLine}
     const lastNonEmpty = lines.reduce((last, line, i) => line.trim() !== "" ? i : last, 0);
     lines.splice(lastNonEmpty + 1, 0, newLine);
   }
-  fs6.writeFileSync(indexPath2, lines.join("\n"));
+  fs8.writeFileSync(indexPath2, lines.join("\n"));
 }
 
 // src/state/state-shared.ts
@@ -7217,8 +8339,8 @@ async function getStateDir(projectPath, stream, session) {
     const sessionResult = resolveSessionDir(projectPath, session, { create: true });
     return sessionResult;
   }
-  const streamsIndexPath = path4.join(projectPath, HARNESS_DIR, "streams", INDEX_FILE);
-  const hasStreams = fs7.existsSync(streamsIndexPath);
+  const streamsIndexPath = path6.join(projectPath, HARNESS_DIR, "streams", INDEX_FILE);
+  const hasStreams = fs9.existsSync(streamsIndexPath);
   if (stream || hasStreams) {
     const result = await resolveStreamPath(projectPath, stream ? { stream } : void 0);
     if (result.ok) {
@@ -7228,7 +8350,7 @@ async function getStateDir(projectPath, stream, session) {
       return result;
     }
   }
-  return (0, import_types.Ok)(path4.join(projectPath, HARNESS_DIR));
+  return (0, import_types.Ok)(path6.join(projectPath, HARNESS_DIR));
 }
 
 // src/state/state-persistence.ts
@@ -7237,11 +8359,11 @@ async function loadState(projectPath, stream, session) {
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const statePath = path5.join(stateDir, STATE_FILE);
-    if (!fs8.existsSync(statePath)) {
+    const statePath = path7.join(stateDir, STATE_FILE);
+    if (!fs10.existsSync(statePath)) {
       return (0, import_types.Ok)({ ...DEFAULT_STATE });
     }
-    const raw = fs8.readFileSync(statePath, "utf-8");
+    const raw = fs10.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = HarnessStateSchema.safeParse(parsed);
     if (!result.success) {
@@ -7259,9 +8381,9 @@ 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 = path5.join(stateDir, STATE_FILE);
-    fs8.mkdirSync(stateDir, { recursive: true });
-    fs8.writeFileSync(statePath, JSON.stringify(state, null, 2));
+    const statePath = path7.join(stateDir, STATE_FILE);
+    fs10.mkdirSync(stateDir, { recursive: true });
+    fs10.writeFileSync(statePath, JSON.stringify(state, null, 2));
     return (0, import_types.Ok)(void 0);
   } catch (error) {
     return (0, import_types.Err)(
@@ -7271,10 +8393,10 @@ async function saveState(projectPath, state, stream, session) {
 }
 
 // src/state/learnings.ts
-var fs9 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var crypto = __toESM(require("crypto"));
-function parseFrontmatter(line) {
+function parseFrontmatter2(line) {
   const match = line.match(/^<!--\s+hash:([a-f0-9]+)(?:\s+tags:([^\s]+))?\s+-->/);
   if (!match) return null;
   const hash = match[1];
@@ -7300,10 +8422,10 @@ function computeContentHash(text) {
   return crypto.createHash("sha256").update(text).digest("hex").slice(0, 16);
 }
 function loadContentHashes(stateDir) {
-  const hashesPath = path6.join(stateDir, CONTENT_HASHES_FILE);
-  if (!fs9.existsSync(hashesPath)) return {};
+  const hashesPath = path8.join(stateDir, CONTENT_HASHES_FILE);
+  if (!fs11.existsSync(hashesPath)) return {};
   try {
-    const raw = fs9.readFileSync(hashesPath, "utf-8");
+    const raw = fs11.readFileSync(hashesPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
     return parsed;
@@ -7312,13 +8434,13 @@ function loadContentHashes(stateDir) {
   }
 }
 function saveContentHashes(stateDir, index) {
-  const hashesPath = path6.join(stateDir, CONTENT_HASHES_FILE);
-  fs9.writeFileSync(hashesPath, JSON.stringify(index, null, 2) + "\n");
+  const hashesPath = path8.join(stateDir, CONTENT_HASHES_FILE);
+  fs11.writeFileSync(hashesPath, JSON.stringify(index, null, 2) + "\n");
 }
 function rebuildContentHashes(stateDir) {
-  const learningsPath = path6.join(stateDir, LEARNINGS_FILE);
-  if (!fs9.existsSync(learningsPath)) return {};
-  const content = fs9.readFileSync(learningsPath, "utf-8");
+  const learningsPath = path8.join(stateDir, LEARNINGS_FILE);
+  if (!fs11.existsSync(learningsPath)) return {};
+  const content = fs11.readFileSync(learningsPath, "utf-8");
   const lines = content.split("\n");
   const index = {};
   for (let i = 0; i < lines.length; i++) {
@@ -7361,18 +8483,18 @@ 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 = path6.join(stateDir, LEARNINGS_FILE);
-    fs9.mkdirSync(stateDir, { recursive: true });
+    const learningsPath = path8.join(stateDir, LEARNINGS_FILE);
+    fs11.mkdirSync(stateDir, { recursive: true });
     const normalizedContent = normalizeLearningContent(learning);
     const contentHash = computeContentHash(normalizedContent);
-    const hashesPath = path6.join(stateDir, CONTENT_HASHES_FILE);
+    const hashesPath = path8.join(stateDir, CONTENT_HASHES_FILE);
     let contentHashes;
-    if (fs9.existsSync(hashesPath)) {
+    if (fs11.existsSync(hashesPath)) {
       contentHashes = loadContentHashes(stateDir);
-      if (Object.keys(contentHashes).length === 0 && fs9.existsSync(learningsPath)) {
+      if (Object.keys(contentHashes).length === 0 && fs11.existsSync(learningsPath)) {
         contentHashes = rebuildContentHashes(stateDir);
       }
-    } else if (fs9.existsSync(learningsPath)) {
+    } else if (fs11.existsSync(learningsPath)) {
       contentHashes = rebuildContentHashes(stateDir);
     } else {
       contentHashes = {};
@@ -7400,14 +8522,14 @@ ${frontmatter}
 ${bulletLine}
 `;
     let existingLineCount;
-    if (!fs9.existsSync(learningsPath)) {
-      fs9.writeFileSync(learningsPath, `# Learnings
+    if (!fs11.existsSync(learningsPath)) {
+      fs11.writeFileSync(learningsPath, `# Learnings
 ${entry}`);
       existingLineCount = 1;
     } else {
-      const existingContent = fs9.readFileSync(learningsPath, "utf-8");
+      const existingContent = fs11.readFileSync(learningsPath, "utf-8");
       existingLineCount = existingContent.split("\n").length;
-      fs9.appendFileSync(learningsPath, entry);
+      fs11.appendFileSync(learningsPath, entry);
     }
     const bulletLine_lineNum = existingLineCount + 2;
     contentHashes[contentHash] = { date: timestamp ?? "", line: bulletLine_lineNum };
@@ -7521,18 +8643,18 @@ 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 = path6.join(stateDir, LEARNINGS_FILE);
-    if (!fs9.existsSync(learningsPath)) {
+    const learningsPath = path8.join(stateDir, LEARNINGS_FILE);
+    if (!fs11.existsSync(learningsPath)) {
       return (0, import_types.Ok)([]);
     }
-    const content = fs9.readFileSync(learningsPath, "utf-8");
+    const content = fs11.readFileSync(learningsPath, "utf-8");
     const lines = content.split("\n");
     const indexEntries = [];
     let pendingFrontmatter = null;
     let currentBlock = [];
     for (const line of lines) {
       if (line.startsWith("# ")) continue;
-      const fm = parseFrontmatter(line);
+      const fm = parseFrontmatter2(line);
       if (fm) {
         pendingFrontmatter = fm;
         continue;
@@ -7583,18 +8705,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 = path6.join(stateDir, LEARNINGS_FILE);
-    if (!fs9.existsSync(learningsPath)) {
+    const learningsPath = path8.join(stateDir, LEARNINGS_FILE);
+    if (!fs11.existsSync(learningsPath)) {
       return (0, import_types.Ok)([]);
     }
-    const stats = fs9.statSync(learningsPath);
+    const stats = fs11.statSync(learningsPath);
     const cacheKey = learningsPath;
     const cached = learningsCacheMap.get(cacheKey);
     let entries;
     if (cached && cached.mtimeMs === stats.mtimeMs) {
       entries = cached.entries;
     } else {
-      const content = fs9.readFileSync(learningsPath, "utf-8");
+      const content = fs11.readFileSync(learningsPath, "utf-8");
       const lines = content.split("\n");
       entries = [];
       let currentBlock = [];
@@ -7636,16 +8758,16 @@ async function archiveLearnings(projectPath, entries, stream) {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const archiveDir = path6.join(stateDir, "learnings-archive");
-    fs9.mkdirSync(archiveDir, { recursive: true });
+    const archiveDir = path8.join(stateDir, "learnings-archive");
+    fs11.mkdirSync(archiveDir, { recursive: true });
     const now = /* @__PURE__ */ new Date();
     const yearMonth = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
-    const archivePath = path6.join(archiveDir, `${yearMonth}.md`);
+    const archivePath = path8.join(archiveDir, `${yearMonth}.md`);
     const archiveContent = entries.join("\n\n") + "\n";
-    if (fs9.existsSync(archivePath)) {
-      fs9.appendFileSync(archivePath, "\n" + archiveContent);
+    if (fs11.existsSync(archivePath)) {
+      fs11.appendFileSync(archivePath, "\n" + archiveContent);
     } else {
-      fs9.writeFileSync(archivePath, `# Learnings Archive
+      fs11.writeFileSync(archivePath, `# Learnings Archive
 
 ${archiveContent}`);
     }
@@ -7663,8 +8785,8 @@ async function pruneLearnings(projectPath, stream) {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const learningsPath = path6.join(stateDir, LEARNINGS_FILE);
-    if (!fs9.existsSync(learningsPath)) {
+    const learningsPath = path8.join(stateDir, LEARNINGS_FILE);
+    if (!fs11.existsSync(learningsPath)) {
       return (0, import_types.Ok)({ kept: 0, archived: 0, patterns: [] });
     }
     const loadResult = await loadRelevantLearnings(projectPath, void 0, stream);
@@ -7695,7 +8817,7 @@ async function pruneLearnings(projectPath, stream) {
       if (!archiveResult.ok) return archiveResult;
     }
     const newContent = "# Learnings\n\n" + toKeep.join("\n\n") + "\n";
-    fs9.writeFileSync(learningsPath, newContent);
+    fs11.writeFileSync(learningsPath, newContent);
     learningsCacheMap.delete(learningsPath);
     return (0, import_types.Ok)({
       kept: toKeep.length,
@@ -7740,19 +8862,19 @@ async function promoteSessionLearnings(projectPath, sessionSlug, stream) {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const globalPath = path6.join(stateDir, LEARNINGS_FILE);
-    const existingGlobal = fs9.existsSync(globalPath) ? fs9.readFileSync(globalPath, "utf-8") : "";
+    const globalPath = path8.join(stateDir, LEARNINGS_FILE);
+    const existingGlobal = fs11.existsSync(globalPath) ? fs11.readFileSync(globalPath, "utf-8") : "";
     const newEntries = toPromote.filter((entry) => !existingGlobal.includes(entry.trim()));
     if (newEntries.length === 0) {
       return (0, import_types.Ok)({ promoted: 0, skipped: skipped + toPromote.length });
     }
     const promotedContent = newEntries.join("\n\n") + "\n";
     if (!existingGlobal) {
-      fs9.writeFileSync(globalPath, `# Learnings
+      fs11.writeFileSync(globalPath, `# Learnings
 
 ${promotedContent}`);
     } else {
-      fs9.appendFileSync(globalPath, "\n\n" + promotedContent);
+      fs11.appendFileSync(globalPath, "\n\n" + promotedContent);
     }
     learningsCacheMap.delete(globalPath);
     return (0, import_types.Ok)({
@@ -7774,8 +8896,8 @@ async function countLearningEntries(projectPath, stream) {
 }
 
 // src/state/failures.ts
-var fs10 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
 var failuresCacheMap = /* @__PURE__ */ new Map();
 function clearFailuresCache() {
   failuresCacheMap.clear();
@@ -7786,17 +8908,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 = path7.join(stateDir, FAILURES_FILE);
-    fs10.mkdirSync(stateDir, { recursive: true });
+    const failuresPath = path9.join(stateDir, FAILURES_FILE);
+    fs12.mkdirSync(stateDir, { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const entry = `
 - **${timestamp} [skill:${skillName}] [type:${type}]:** ${description}
 `;
-    if (!fs10.existsSync(failuresPath)) {
-      fs10.writeFileSync(failuresPath, `# Failures
+    if (!fs12.existsSync(failuresPath)) {
+      fs12.writeFileSync(failuresPath, `# Failures
 ${entry}`);
     } else {
-      fs10.appendFileSync(failuresPath, entry);
+      fs12.appendFileSync(failuresPath, entry);
     }
     failuresCacheMap.delete(failuresPath);
     return (0, import_types.Ok)(void 0);
@@ -7813,17 +8935,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 = path7.join(stateDir, FAILURES_FILE);
-    if (!fs10.existsSync(failuresPath)) {
+    const failuresPath = path9.join(stateDir, FAILURES_FILE);
+    if (!fs12.existsSync(failuresPath)) {
       return (0, import_types.Ok)([]);
     }
-    const stats = fs10.statSync(failuresPath);
+    const stats = fs12.statSync(failuresPath);
     const cacheKey = failuresPath;
     const cached = failuresCacheMap.get(cacheKey);
     if (cached && cached.mtimeMs === stats.mtimeMs) {
       return (0, import_types.Ok)(cached.entries);
     }
-    const content = fs10.readFileSync(failuresPath, "utf-8");
+    const content = fs12.readFileSync(failuresPath, "utf-8");
     const entries = [];
     for (const line of content.split("\n")) {
       const match = line.match(FAILURE_LINE_REGEX);
@@ -7852,20 +8974,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 = path7.join(stateDir, FAILURES_FILE);
-    if (!fs10.existsSync(failuresPath)) {
+    const failuresPath = path9.join(stateDir, FAILURES_FILE);
+    if (!fs12.existsSync(failuresPath)) {
       return (0, import_types.Ok)(void 0);
     }
-    const archiveDir = path7.join(stateDir, "archive");
-    fs10.mkdirSync(archiveDir, { recursive: true });
+    const archiveDir = path9.join(stateDir, "archive");
+    fs12.mkdirSync(archiveDir, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     let archiveName = `failures-${date}.md`;
     let counter = 2;
-    while (fs10.existsSync(path7.join(archiveDir, archiveName))) {
+    while (fs12.existsSync(path9.join(archiveDir, archiveName))) {
       archiveName = `failures-${date}-${counter}.md`;
       counter++;
     }
-    fs10.renameSync(failuresPath, path7.join(archiveDir, archiveName));
+    fs12.renameSync(failuresPath, path9.join(archiveDir, archiveName));
     failuresCacheMap.delete(failuresPath);
     return (0, import_types.Ok)(void 0);
   } catch (error) {
@@ -7878,16 +9000,16 @@ async function archiveFailures(projectPath, stream, session) {
 }
 
 // src/state/handoff.ts
-var fs11 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 async function saveHandoff(projectPath, handoff, stream, session) {
   try {
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const handoffPath = path8.join(stateDir, HANDOFF_FILE);
-    fs11.mkdirSync(stateDir, { recursive: true });
-    fs11.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2));
+    const handoffPath = path10.join(stateDir, HANDOFF_FILE);
+    fs13.mkdirSync(stateDir, { recursive: true });
+    fs13.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2));
     return (0, import_types.Ok)(void 0);
   } catch (error) {
     return (0, import_types.Err)(
@@ -7900,11 +9022,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 = path8.join(stateDir, HANDOFF_FILE);
-    if (!fs11.existsSync(handoffPath)) {
+    const handoffPath = path10.join(stateDir, HANDOFF_FILE);
+    if (!fs13.existsSync(handoffPath)) {
       return (0, import_types.Ok)(null);
     }
-    const raw = fs11.readFileSync(handoffPath, "utf-8");
+    const raw = fs13.readFileSync(handoffPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = HandoffSchema.safeParse(parsed);
     if (!result.success) {
@@ -7919,33 +9041,33 @@ async function loadHandoff(projectPath, stream, session) {
 }
 
 // src/state/mechanical-gate.ts
-var fs12 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 var import_child_process2 = require("child_process");
 var SAFE_GATE_COMMAND = /^(?:npm|pnpm|yarn)\s+(?:test|run\s+[\w.-]+|run-script\s+[\w.-]+)$|^go\s+(?:test|build|vet|fmt)\s+[\w./ -]+$|^(?:python|python3)\s+-m\s+[\w.-]+$|^make\s+[\w.-]+$|^cargo\s+(?:test|build|check|clippy)(?:\s+[\w./ -]+)?$|^(?:gradle|mvn)\s+[\w:.-]+$/;
 function loadChecksFromConfig(gateConfigPath) {
-  if (!fs12.existsSync(gateConfigPath)) return [];
-  const raw = JSON.parse(fs12.readFileSync(gateConfigPath, "utf-8"));
+  if (!fs14.existsSync(gateConfigPath)) return [];
+  const raw = JSON.parse(fs14.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 = path9.join(projectPath, "package.json");
-  if (fs12.existsSync(packageJsonPath)) {
-    const pkg = JSON.parse(fs12.readFileSync(packageJsonPath, "utf-8"));
+  const packageJsonPath = path11.join(projectPath, "package.json");
+  if (fs14.existsSync(packageJsonPath)) {
+    const pkg = JSON.parse(fs14.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 (fs12.existsSync(path9.join(projectPath, "go.mod"))) {
+  if (fs14.existsSync(path11.join(projectPath, "go.mod"))) {
     checks.push({ name: "test", command: "go test ./..." });
     checks.push({ name: "build", command: "go build ./..." });
   }
-  if (fs12.existsSync(path9.join(projectPath, "pyproject.toml")) || fs12.existsSync(path9.join(projectPath, "setup.py"))) {
+  if (fs14.existsSync(path11.join(projectPath, "pyproject.toml")) || fs14.existsSync(path11.join(projectPath, "setup.py"))) {
     checks.push({ name: "test", command: "python -m pytest" });
   }
   return checks;
@@ -7985,8 +9107,8 @@ function executeCheck(check, projectPath) {
   }
 }
 async function runMechanicalGate(projectPath) {
-  const harnessDir = path9.join(projectPath, HARNESS_DIR);
-  const gateConfigPath = path9.join(harnessDir, GATE_CONFIG_FILE);
+  const harnessDir = path11.join(projectPath, HARNESS_DIR);
+  const gateConfigPath = path11.join(harnessDir, GATE_CONFIG_FILE);
   try {
     let checks = loadChecksFromConfig(gateConfigPath);
     if (checks.length === 0) {
@@ -8006,9 +9128,9 @@ async function runMechanicalGate(projectPath) {
   }
 }
 
-// src/state/session-summary.ts
-var fs13 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+// src/state/session-summary.ts
+var fs15 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 function formatSummary(data) {
   const lines = [
     "## Session Summary",
@@ -8046,9 +9168,9 @@ function writeSessionSummary(projectPath, sessionSlug, data) {
     const dirResult = resolveSessionDir(projectPath, sessionSlug, { create: true });
     if (!dirResult.ok) return dirResult;
     const sessionDir = dirResult.value;
-    const summaryPath = path10.join(sessionDir, SUMMARY_FILE);
+    const summaryPath = path12.join(sessionDir, SUMMARY_FILE);
     const content = formatSummary(data);
-    fs13.writeFileSync(summaryPath, content);
+    fs15.writeFileSync(summaryPath, content);
     const description = deriveIndexDescription(data);
     updateSessionIndex(projectPath, sessionSlug, description);
     return (0, import_types.Ok)(void 0);
@@ -8065,11 +9187,11 @@ function loadSessionSummary(projectPath, sessionSlug) {
     const dirResult = resolveSessionDir(projectPath, sessionSlug);
     if (!dirResult.ok) return dirResult;
     const sessionDir = dirResult.value;
-    const summaryPath = path10.join(sessionDir, SUMMARY_FILE);
-    if (!fs13.existsSync(summaryPath)) {
+    const summaryPath = path12.join(sessionDir, SUMMARY_FILE);
+    if (!fs15.existsSync(summaryPath)) {
       return (0, import_types.Ok)(null);
     }
-    const content = fs13.readFileSync(summaryPath, "utf-8");
+    const content = fs15.readFileSync(summaryPath, "utf-8");
     return (0, import_types.Ok)(content);
   } catch (error) {
     return (0, import_types.Err)(
@@ -8081,11 +9203,11 @@ function loadSessionSummary(projectPath, sessionSlug) {
 }
 function listActiveSessions(projectPath) {
   try {
-    const indexPath2 = path10.join(projectPath, HARNESS_DIR, SESSIONS_DIR, SESSION_INDEX_FILE);
-    if (!fs13.existsSync(indexPath2)) {
+    const indexPath2 = path12.join(projectPath, HARNESS_DIR, SESSIONS_DIR, SESSION_INDEX_FILE);
+    if (!fs15.existsSync(indexPath2)) {
       return (0, import_types.Ok)(null);
     }
-    const content = fs13.readFileSync(indexPath2, "utf-8");
+    const content = fs15.readFileSync(indexPath2, "utf-8");
     return (0, import_types.Ok)(content);
   } catch (error) {
     return (0, import_types.Err)(
@@ -8097,12 +9219,12 @@ function listActiveSessions(projectPath) {
 }
 
 // src/state/session-sections.ts
-var fs14 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
-var import_types14 = require("@harness-engineering/types");
+var fs16 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
+var import_types19 = require("@harness-engineering/types");
 function emptySections() {
   const sections = {};
-  for (const name of import_types14.SESSION_SECTION_NAMES) {
+  for (const name of import_types19.SESSION_SECTION_NAMES) {
     sections[name] = [];
   }
   return sections;
@@ -8111,15 +9233,15 @@ async function loadSessionState(projectPath, sessionSlug) {
   const dirResult = resolveSessionDir(projectPath, sessionSlug);
   if (!dirResult.ok) return dirResult;
   const sessionDir = dirResult.value;
-  const filePath = path11.join(sessionDir, SESSION_STATE_FILE);
-  if (!fs14.existsSync(filePath)) {
+  const filePath = path13.join(sessionDir, SESSION_STATE_FILE);
+  if (!fs16.existsSync(filePath)) {
     return (0, import_types.Ok)(emptySections());
   }
   try {
-    const raw = fs14.readFileSync(filePath, "utf-8");
+    const raw = fs16.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     const sections = emptySections();
-    for (const name of import_types14.SESSION_SECTION_NAMES) {
+    for (const name of import_types19.SESSION_SECTION_NAMES) {
       if (Array.isArray(parsed[name])) {
         sections[name] = parsed[name];
       }
@@ -8137,9 +9259,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 = path11.join(sessionDir, SESSION_STATE_FILE);
+  const filePath = path13.join(sessionDir, SESSION_STATE_FILE);
   try {
-    fs14.writeFileSync(filePath, JSON.stringify(sections, null, 2));
+    fs16.writeFileSync(filePath, JSON.stringify(sections, null, 2));
     return (0, import_types.Ok)(void 0);
   } catch (error) {
     return (0, import_types.Err)(
@@ -8193,32 +9315,32 @@ function generateEntryId() {
 }
 
 // src/state/session-archive.ts
-var fs15 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
 async function archiveSession(projectPath, sessionSlug) {
   const dirResult = resolveSessionDir(projectPath, sessionSlug);
   if (!dirResult.ok) return dirResult;
   const sessionDir = dirResult.value;
-  if (!fs15.existsSync(sessionDir)) {
+  if (!fs17.existsSync(sessionDir)) {
     return (0, import_types.Err)(new Error(`Session '${sessionSlug}' not found at ${sessionDir}`));
   }
-  const archiveBase = path12.join(projectPath, HARNESS_DIR, ARCHIVE_DIR, "sessions");
+  const archiveBase = path14.join(projectPath, HARNESS_DIR, ARCHIVE_DIR, "sessions");
   try {
-    fs15.mkdirSync(archiveBase, { recursive: true });
+    fs17.mkdirSync(archiveBase, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     let archiveName = `${sessionSlug}-${date}`;
     let counter = 1;
-    while (fs15.existsSync(path12.join(archiveBase, archiveName))) {
+    while (fs17.existsSync(path14.join(archiveBase, archiveName))) {
       archiveName = `${sessionSlug}-${date}-${counter}`;
       counter++;
     }
-    const dest = path12.join(archiveBase, archiveName);
+    const dest = path14.join(archiveBase, archiveName);
     try {
-      fs15.renameSync(sessionDir, dest);
+      fs17.renameSync(sessionDir, dest);
     } catch (renameErr) {
       if (renameErr instanceof Error && "code" in renameErr && renameErr.code === "EXDEV") {
-        fs15.cpSync(sessionDir, dest, { recursive: true });
-        fs15.rmSync(sessionDir, { recursive: true });
+        fs17.cpSync(sessionDir, dest, { recursive: true });
+        fs17.rmSync(sessionDir, { recursive: true });
       } else {
         throw renameErr;
       }
@@ -8234,18 +9356,18 @@ async function archiveSession(projectPath, sessionSlug) {
 }
 
 // src/state/events.ts
-var fs16 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
-var import_zod6 = require("zod");
-var SkillEventSchema = import_zod6.z.object({
-  timestamp: import_zod6.z.string(),
-  skill: import_zod6.z.string(),
-  session: import_zod6.z.string().optional(),
-  type: import_zod6.z.enum(["phase_transition", "decision", "gate_result", "handoff", "error", "checkpoint"]),
-  summary: import_zod6.z.string(),
-  data: import_zod6.z.record(import_zod6.z.unknown()).optional(),
-  refs: import_zod6.z.array(import_zod6.z.string()).optional(),
-  contentHash: import_zod6.z.string().optional()
+var fs18 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
+var import_zod8 = require("zod");
+var SkillEventSchema = import_zod8.z.object({
+  timestamp: import_zod8.z.string(),
+  skill: import_zod8.z.string(),
+  session: import_zod8.z.string().optional(),
+  type: import_zod8.z.enum(["phase_transition", "decision", "gate_result", "handoff", "error", "checkpoint"]),
+  summary: import_zod8.z.string(),
+  data: import_zod8.z.record(import_zod8.z.unknown()).optional(),
+  refs: import_zod8.z.array(import_zod8.z.string()).optional(),
+  contentHash: import_zod8.z.string().optional()
 });
 function computeEventHash(event, session) {
   const identity = `${event.skill}|${event.type}|${event.summary}|${session ?? ""}`;
@@ -8256,8 +9378,8 @@ function loadKnownHashes(eventsPath) {
   const cached = knownHashesCache.get(eventsPath);
   if (cached) return cached;
   const hashes = /* @__PURE__ */ new Set();
-  if (fs16.existsSync(eventsPath)) {
-    const content = fs16.readFileSync(eventsPath, "utf-8");
+  if (fs18.existsSync(eventsPath)) {
+    const content = fs18.readFileSync(eventsPath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim() !== "");
     for (const line of lines) {
       try {
@@ -8280,8 +9402,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 = path13.join(stateDir, EVENTS_FILE);
-    fs16.mkdirSync(stateDir, { recursive: true });
+    const eventsPath = path15.join(stateDir, EVENTS_FILE);
+    fs18.mkdirSync(stateDir, { recursive: true });
     const contentHash = computeEventHash(event, options?.session);
     const knownHashes = loadKnownHashes(eventsPath);
     if (knownHashes.has(contentHash)) {
@@ -8295,7 +9417,7 @@ async function emitEvent(projectPath, event, options) {
     if (options?.session) {
       fullEvent.session = options.session;
     }
-    fs16.appendFileSync(eventsPath, JSON.stringify(fullEvent) + "\n");
+    fs18.appendFileSync(eventsPath, JSON.stringify(fullEvent) + "\n");
     knownHashes.add(contentHash);
     return (0, import_types.Ok)({ written: true });
   } catch (error) {
@@ -8309,11 +9431,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 = path13.join(stateDir, EVENTS_FILE);
-    if (!fs16.existsSync(eventsPath)) {
+    const eventsPath = path15.join(stateDir, EVENTS_FILE);
+    if (!fs18.existsSync(eventsPath)) {
       return (0, import_types.Ok)([]);
     }
-    const content = fs16.readFileSync(eventsPath, "utf-8");
+    const content = fs18.readFileSync(eventsPath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim() !== "");
     const events = [];
     for (const line of lines) {
@@ -8527,7 +9649,7 @@ async function runMultiTurnPipeline(initialContext, turnExecutor, options) {
 }
 
 // src/security/scanner.ts
-var fs18 = __toESM(require("fs/promises"));
+var fs20 = __toESM(require("fs/promises"));
 var import_minimatch5 = require("minimatch");
 
 // src/security/rules/registry.ts
@@ -8559,7 +9681,7 @@ var RuleRegistry = class {
 };
 
 // src/security/config.ts
-var import_zod7 = require("zod");
+var import_zod9 = require("zod");
 
 // src/security/types.ts
 var DEFAULT_SECURITY_CONFIG = {
@@ -8570,19 +9692,19 @@ var DEFAULT_SECURITY_CONFIG = {
 };
 
 // src/security/config.ts
-var RuleOverrideSchema = import_zod7.z.enum(["off", "error", "warning", "info"]);
-var SecurityConfigSchema = import_zod7.z.object({
-  enabled: import_zod7.z.boolean().default(true),
-  strict: import_zod7.z.boolean().default(false),
-  rules: import_zod7.z.record(import_zod7.z.string(), RuleOverrideSchema).optional().default({}),
-  exclude: import_zod7.z.array(import_zod7.z.string()).optional().default(["**/node_modules/**", "**/dist/**", "**/*.test.ts", "**/fixtures/**"]),
-  external: import_zod7.z.object({
-    semgrep: import_zod7.z.object({
-      enabled: import_zod7.z.union([import_zod7.z.literal("auto"), import_zod7.z.boolean()]).default("auto"),
-      rulesets: import_zod7.z.array(import_zod7.z.string()).optional()
+var RuleOverrideSchema = import_zod9.z.enum(["off", "error", "warning", "info"]);
+var SecurityConfigSchema = import_zod9.z.object({
+  enabled: import_zod9.z.boolean().default(true),
+  strict: import_zod9.z.boolean().default(false),
+  rules: import_zod9.z.record(import_zod9.z.string(), RuleOverrideSchema).optional().default({}),
+  exclude: import_zod9.z.array(import_zod9.z.string()).optional().default(["**/node_modules/**", "**/dist/**", "**/*.test.ts", "**/fixtures/**"]),
+  external: import_zod9.z.object({
+    semgrep: import_zod9.z.object({
+      enabled: import_zod9.z.union([import_zod9.z.literal("auto"), import_zod9.z.boolean()]).default("auto"),
+      rulesets: import_zod9.z.array(import_zod9.z.string()).optional()
     }).optional(),
-    gitleaks: import_zod7.z.object({
-      enabled: import_zod7.z.union([import_zod7.z.literal("auto"), import_zod7.z.boolean()]).default("auto")
+    gitleaks: import_zod9.z.object({
+      enabled: import_zod9.z.union([import_zod9.z.literal("auto"), import_zod9.z.boolean()]).default("auto")
     }).optional()
   }).optional()
 });
@@ -8615,15 +9737,15 @@ function resolveRuleSeverity(ruleId, defaultSeverity, overrides, strict) {
 }
 
 // src/security/stack-detector.ts
-var fs17 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 function detectStack(projectRoot) {
   const stacks = [];
-  const pkgJsonPath = path14.join(projectRoot, "package.json");
-  if (fs17.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path16.join(projectRoot, "package.json");
+  if (fs19.existsSync(pkgJsonPath)) {
     stacks.push("node");
     try {
-      const pkgJson = JSON.parse(fs17.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs19.readFileSync(pkgJsonPath, "utf-8"));
       const allDeps = {
         ...pkgJson.dependencies,
         ...pkgJson.devDependencies
@@ -8638,13 +9760,13 @@ function detectStack(projectRoot) {
     } catch {
     }
   }
-  const goModPath = path14.join(projectRoot, "go.mod");
-  if (fs17.existsSync(goModPath)) {
+  const goModPath = path16.join(projectRoot, "go.mod");
+  if (fs19.existsSync(goModPath)) {
     stacks.push("go");
   }
-  const requirementsPath = path14.join(projectRoot, "requirements.txt");
-  const pyprojectPath = path14.join(projectRoot, "pyproject.toml");
-  if (fs17.existsSync(requirementsPath) || fs17.existsSync(pyprojectPath)) {
+  const requirementsPath = path16.join(projectRoot, "requirements.txt");
+  const pyprojectPath = path16.join(projectRoot, "pyproject.toml");
+  if (fs19.existsSync(requirementsPath) || fs19.existsSync(pyprojectPath)) {
     stacks.push("python");
   }
   return stacks;
@@ -9475,7 +10597,7 @@ var SecurityScanner = class {
   }
   async scanFile(filePath) {
     if (!this.config.enabled) return [];
-    const content = await fs18.readFile(filePath, "utf-8");
+    const content = await fs20.readFile(filePath, "utf-8");
     return this.scanContentForFile(content, filePath, 1);
   }
   scanContentForFile(content, filePath, startLine = 1) {
@@ -9802,19 +10924,19 @@ var DESTRUCTIVE_BASH = [
 ];
 
 // src/security/taint.ts
-var import_node_fs4 = require("fs");
-var import_node_path7 = require("path");
+var import_node_fs5 = require("fs");
+var import_node_path8 = require("path");
 var TAINT_DURATION_MS = 30 * 60 * 1e3;
 var DEFAULT_SESSION_ID = "default";
 function getTaintFilePath(projectRoot, sessionId) {
   const id = sessionId || DEFAULT_SESSION_ID;
-  return (0, import_node_path7.join)(projectRoot, ".harness", `session-taint-${id}.json`);
+  return (0, import_node_path8.join)(projectRoot, ".harness", `session-taint-${id}.json`);
 }
 function readTaint(projectRoot, sessionId) {
   const filePath = getTaintFilePath(projectRoot, sessionId);
   let content;
   try {
-    content = (0, import_node_fs4.readFileSync)(filePath, "utf8");
+    content = (0, import_node_fs5.readFileSync)(filePath, "utf8");
   } catch {
     return null;
   }
@@ -9823,14 +10945,14 @@ function readTaint(projectRoot, sessionId) {
     state = JSON.parse(content);
   } catch {
     try {
-      (0, import_node_fs4.unlinkSync)(filePath);
+      (0, import_node_fs5.unlinkSync)(filePath);
     } catch {
     }
     return null;
   }
   if (!state.sessionId || !state.taintedAt || !state.expiresAt || !state.findings) {
     try {
-      (0, import_node_fs4.unlinkSync)(filePath);
+      (0, import_node_fs5.unlinkSync)(filePath);
     } catch {
     }
     return null;
@@ -9847,7 +10969,7 @@ function checkTaint(projectRoot, sessionId) {
   if (now >= expiresAt) {
     const filePath = getTaintFilePath(projectRoot, sessionId);
     try {
-      (0, import_node_fs4.unlinkSync)(filePath);
+      (0, import_node_fs5.unlinkSync)(filePath);
     } catch {
     }
     return { tainted: false, expired: true, state };
@@ -9858,8 +10980,8 @@ function writeTaint(projectRoot, sessionId, reason, findings, source) {
   const id = sessionId || DEFAULT_SESSION_ID;
   const filePath = getTaintFilePath(projectRoot, id);
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const dir = (0, import_node_path7.dirname)(filePath);
-  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path8.dirname)(filePath);
+  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
   const existing = readTaint(projectRoot, id);
   const maxSeverity = findings.some((f) => f.severity === "high") ? "high" : "medium";
   const taintFindings = findings.map((f) => ({
@@ -9877,27 +10999,27 @@ function writeTaint(projectRoot, sessionId, reason, findings, source) {
     severity: existing?.severity === "high" || maxSeverity === "high" ? "high" : "medium",
     findings: [...existing?.findings || [], ...taintFindings]
   };
-  (0, import_node_fs4.writeFileSync)(filePath, JSON.stringify(state, null, 2) + "\n");
+  (0, import_node_fs5.writeFileSync)(filePath, JSON.stringify(state, null, 2) + "\n");
   return state;
 }
 function clearTaint(projectRoot, sessionId) {
   if (sessionId) {
     const filePath = getTaintFilePath(projectRoot, sessionId);
     try {
-      (0, import_node_fs4.unlinkSync)(filePath);
+      (0, import_node_fs5.unlinkSync)(filePath);
       return 1;
     } catch {
       return 0;
     }
   }
-  const harnessDir = (0, import_node_path7.join)(projectRoot, ".harness");
+  const harnessDir = (0, import_node_path8.join)(projectRoot, ".harness");
   let count = 0;
   try {
-    const files = (0, import_node_fs4.readdirSync)(harnessDir);
+    const files = (0, import_node_fs5.readdirSync)(harnessDir);
     for (const file of files) {
       if (file.startsWith("session-taint-") && file.endsWith(".json")) {
         try {
-          (0, import_node_fs4.unlinkSync)((0, import_node_path7.join)(harnessDir, file));
+          (0, import_node_fs5.unlinkSync)((0, import_node_path8.join)(harnessDir, file));
           count++;
         } catch {
         }
@@ -9908,10 +11030,10 @@ function clearTaint(projectRoot, sessionId) {
   return count;
 }
 function listTaintedSessions(projectRoot) {
-  const harnessDir = (0, import_node_path7.join)(projectRoot, ".harness");
+  const harnessDir = (0, import_node_path8.join)(projectRoot, ".harness");
   const sessions = [];
   try {
-    const files = (0, import_node_fs4.readdirSync)(harnessDir);
+    const files = (0, import_node_fs5.readdirSync)(harnessDir);
     for (const file of files) {
       if (file.startsWith("session-taint-") && file.endsWith(".json")) {
         const sessionId = file.replace("session-taint-", "").replace(".json", "");
@@ -9978,7 +11100,8 @@ function mapSecurityFindings(secFindings, existing) {
 }
 
 // src/ci/check-orchestrator.ts
-var path15 = __toESM(require("path"));
+var path17 = __toESM(require("path"));
+var import_graph = require("@harness-engineering/graph");
 var ALL_CHECKS = [
   "validate",
   "deps",
@@ -9987,11 +11110,12 @@ var ALL_CHECKS = [
   "security",
   "perf",
   "phase-gate",
-  "arch"
+  "arch",
+  "traceability"
 ];
 async function runValidateCheck(projectRoot, config) {
   const issues = [];
-  const agentsPath = path15.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
+  const agentsPath = path17.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
   const result = await validateAgentsMap(agentsPath);
   if (!result.ok) {
     issues.push({ severity: "error", message: result.error.message });
@@ -10048,7 +11172,7 @@ async function runDepsCheck(projectRoot, config) {
 }
 async function runDocsCheck(projectRoot, config) {
   const issues = [];
-  const docsDir = path15.join(projectRoot, config.docsDir ?? "docs");
+  const docsDir = path17.join(projectRoot, config.docsDir ?? "docs");
   const entropyConfig = config.entropy || {};
   const result = await checkDocCoverage("project", {
     docsDir,
@@ -10229,6 +11353,39 @@ async function runArchCheck(projectRoot, config) {
   }
   return issues;
 }
+async function runTraceabilityCheck(projectRoot, config) {
+  const issues = [];
+  const traceConfig = config.traceability || {};
+  if (traceConfig.enabled === false) return issues;
+  const graphDir = path17.join(projectRoot, ".harness", "graph");
+  const store = new import_graph.GraphStore();
+  const loaded = await store.load(graphDir);
+  if (!loaded) {
+    return issues;
+  }
+  const results = (0, import_graph.queryTraceability)(store);
+  if (results.length === 0) return issues;
+  const minCoverage = traceConfig.minCoverage ?? 0;
+  const severity = traceConfig.severity ?? "warning";
+  for (const result of results) {
+    const pct = result.summary.coveragePercent;
+    if (pct < minCoverage) {
+      issues.push({
+        severity,
+        message: `Traceability coverage for "${result.featureName}" is ${pct}% (minimum: ${minCoverage}%)`
+      });
+    }
+    for (const req of result.requirements) {
+      if (req.status === "none") {
+        issues.push({
+          severity: "warning",
+          message: `Requirement "${req.requirementName}" has no traced code or tests`
+        });
+      }
+    }
+  }
+  return issues;
+}
 async function runSingleCheck(name, projectRoot, config) {
   const start = Date.now();
   const issues = [];
@@ -10258,6 +11415,9 @@ async function runSingleCheck(name, projectRoot, config) {
       case "arch":
         issues.push(...await runArchCheck(projectRoot, config));
         break;
+      case "traceability":
+        issues.push(...await runTraceabilityCheck(projectRoot, config));
+        break;
     }
   } catch (error) {
     issues.push({
@@ -10326,7 +11486,7 @@ async function runCIChecks(input) {
 }
 
 // src/review/mechanical-checks.ts
-var path16 = __toESM(require("path"));
+var path18 = __toESM(require("path"));
 async function runMechanicalChecks(options) {
   const { projectRoot, config, skip = [], changedFiles } = options;
   const findings = [];
@@ -10338,7 +11498,7 @@ async function runMechanicalChecks(options) {
   };
   if (!skip.includes("validate")) {
     try {
-      const agentsPath = path16.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
+      const agentsPath = path18.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
       const result = await validateAgentsMap(agentsPath);
       if (!result.ok) {
         statuses.validate = "fail";
@@ -10375,7 +11535,7 @@ async function runMechanicalChecks(options) {
       statuses.validate = "fail";
       findings.push({
         tool: "validate",
-        file: path16.join(projectRoot, "AGENTS.md"),
+        file: path18.join(projectRoot, "AGENTS.md"),
         message: err instanceof Error ? err.message : String(err),
         severity: "error"
       });
@@ -10439,7 +11599,7 @@ async function runMechanicalChecks(options) {
       (async () => {
         const localFindings = [];
         try {
-          const docsDir = path16.join(projectRoot, config.docsDir ?? "docs");
+          const docsDir = path18.join(projectRoot, config.docsDir ?? "docs");
           const result = await checkDocCoverage("project", { docsDir });
           if (!result.ok) {
             statuses["check-docs"] = "warn";
@@ -10466,7 +11626,7 @@ async function runMechanicalChecks(options) {
           statuses["check-docs"] = "warn";
           localFindings.push({
             tool: "check-docs",
-            file: path16.join(projectRoot, "docs"),
+            file: path18.join(projectRoot, "docs"),
             message: err instanceof Error ? err.message : String(err),
             severity: "warning"
           });
@@ -10614,7 +11774,7 @@ function detectChangeType(commitMessage, diff2) {
 }
 
 // src/review/context-scoper.ts
-var path17 = __toESM(require("path"));
+var path19 = __toESM(require("path"));
 var ALL_DOMAINS = ["compliance", "bug", "security", "architecture"];
 var SECURITY_PATTERNS = /auth|crypto|password|secret|token|session|cookie|hash|encrypt|decrypt|sql|shell|exec|eval/i;
 function computeContextBudget(diffLines) {
@@ -10622,18 +11782,18 @@ function computeContextBudget(diffLines) {
   return diffLines;
 }
 function isWithinProject(absPath, projectRoot) {
-  const resolvedRoot = path17.resolve(projectRoot) + path17.sep;
-  const resolvedPath = path17.resolve(absPath);
-  return resolvedPath.startsWith(resolvedRoot) || resolvedPath === path17.resolve(projectRoot);
+  const resolvedRoot = path19.resolve(projectRoot) + path19.sep;
+  const resolvedPath = path19.resolve(absPath);
+  return resolvedPath.startsWith(resolvedRoot) || resolvedPath === path19.resolve(projectRoot);
 }
 async function readContextFile(projectRoot, filePath, reason) {
-  const absPath = path17.isAbsolute(filePath) ? filePath : path17.join(projectRoot, filePath);
+  const absPath = path19.isAbsolute(filePath) ? filePath : path19.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 relPath = path17.isAbsolute(filePath) ? relativePosix(projectRoot, filePath) : filePath;
+  const relPath = path19.isAbsolute(filePath) ? relativePosix(projectRoot, filePath) : filePath;
   return { path: relPath, content, reason, lines };
 }
 function extractImportSources2(content) {
@@ -10648,18 +11808,18 @@ function extractImportSources2(content) {
 }
 async function resolveImportPath2(projectRoot, fromFile, importSource) {
   if (!importSource.startsWith(".")) return null;
-  const fromDir = path17.dirname(path17.join(projectRoot, fromFile));
-  const basePath = path17.resolve(fromDir, importSource);
+  const fromDir = path19.dirname(path19.join(projectRoot, fromFile));
+  const basePath = path19.resolve(fromDir, importSource);
   if (!isWithinProject(basePath, projectRoot)) return null;
   const relBase = relativePosix(projectRoot, basePath);
   const candidates = [
     relBase + ".ts",
     relBase + ".tsx",
     relBase + ".mts",
-    path17.join(relBase, "index.ts")
+    path19.join(relBase, "index.ts")
   ];
   for (const candidate of candidates) {
-    const absCandidate = path17.join(projectRoot, candidate);
+    const absCandidate = path19.join(projectRoot, candidate);
     if (await fileExists(absCandidate)) {
       return candidate;
     }
@@ -10667,7 +11827,7 @@ async function resolveImportPath2(projectRoot, fromFile, importSource) {
   return null;
 }
 async function findTestFiles(projectRoot, sourceFile) {
-  const baseName = path17.basename(sourceFile, path17.extname(sourceFile));
+  const baseName = path19.basename(sourceFile, path19.extname(sourceFile));
   const pattern = `**/${baseName}.{test,spec}.{ts,tsx,mts}`;
   const results = await findFiles(pattern, projectRoot);
   return results.map((f) => relativePosix(projectRoot, f));
@@ -11476,7 +12636,7 @@ async function fanOutReview(options) {
 }
 
 // src/review/validate-findings.ts
-var path18 = __toESM(require("path"));
+var path20 = __toESM(require("path"));
 var DOWNGRADE_MAP = {
   critical: "important",
   important: "suggestion",
@@ -11497,7 +12657,7 @@ function normalizePath(filePath, projectRoot) {
   let normalized = filePath;
   normalized = normalized.replace(/\\/g, "/");
   const normalizedRoot = projectRoot.replace(/\\/g, "/");
-  if (path18.isAbsolute(normalized)) {
+  if (path20.isAbsolute(normalized)) {
     const root = normalizedRoot.endsWith("/") ? normalizedRoot : normalizedRoot + "/";
     if (normalized.startsWith(root)) {
       normalized = normalized.slice(root.length);
@@ -11522,12 +12682,12 @@ function followImportChain(fromFile, fileContents, maxDepth = 2) {
     while ((match = importRegex.exec(content)) !== null) {
       const importPath = match[1];
       if (!importPath.startsWith(".")) continue;
-      const dir = path18.dirname(current.file);
-      let resolved = path18.join(dir, importPath).replace(/\\/g, "/");
+      const dir = path20.dirname(current.file);
+      let resolved = path20.join(dir, importPath).replace(/\\/g, "/");
       if (!resolved.match(/\.(ts|tsx|js|jsx)$/)) {
         resolved += ".ts";
       }
-      resolved = path18.normalize(resolved).replace(/\\/g, "/");
+      resolved = path20.normalize(resolved).replace(/\\/g, "/");
       if (!visited.has(resolved) && current.depth + 1 <= maxDepth) {
         queue.push({ file: resolved, depth: current.depth + 1 });
       }
@@ -11544,7 +12704,7 @@ async function validateFindings(options) {
     if (exclusionSet.isExcluded(normalizedFile, finding.lineRange) || exclusionSet.isExcluded(finding.file, finding.lineRange)) {
       continue;
     }
-    const absoluteFile = path18.isAbsolute(finding.file) ? finding.file : path18.join(projectRoot, finding.file).replace(/\\/g, "/");
+    const absoluteFile = path20.isAbsolute(finding.file) ? finding.file : path20.join(projectRoot, finding.file).replace(/\\/g, "/");
     if (exclusionSet.isExcluded(absoluteFile, finding.lineRange)) {
       continue;
     }
@@ -12157,203 +13317,6 @@ async function runReviewPipeline(options) {
   };
 }
 
-// src/roadmap/parse.ts
-var import_types19 = require("@harness-engineering/types");
-var VALID_STATUSES = /* @__PURE__ */ new Set([
-  "backlog",
-  "planned",
-  "in-progress",
-  "done",
-  "blocked"
-]);
-var EM_DASH = "\u2014";
-var VALID_PRIORITIES = /* @__PURE__ */ new Set(["P0", "P1", "P2", "P3"]);
-function parseRoadmap(markdown) {
-  const fmMatch = markdown.match(/^---\n([\s\S]*?)\n---/);
-  if (!fmMatch) {
-    return (0, import_types19.Err)(new Error("Missing or malformed YAML frontmatter"));
-  }
-  const fmResult = parseFrontmatter2(fmMatch[1]);
-  if (!fmResult.ok) return fmResult;
-  const body = markdown.slice(fmMatch[0].length);
-  const milestonesResult = parseMilestones(body);
-  if (!milestonesResult.ok) return milestonesResult;
-  const historyResult = parseAssignmentHistory(body);
-  if (!historyResult.ok) return historyResult;
-  return (0, import_types19.Ok)({
-    frontmatter: fmResult.value,
-    milestones: milestonesResult.value,
-    assignmentHistory: historyResult.value
-  });
-}
-function parseFrontmatter2(raw) {
-  const lines = raw.split("\n");
-  const map = /* @__PURE__ */ new Map();
-  for (const line of lines) {
-    const idx = line.indexOf(":");
-    if (idx === -1) continue;
-    const key = line.slice(0, idx).trim();
-    const val = line.slice(idx + 1).trim();
-    map.set(key, val);
-  }
-  const project = map.get("project");
-  const versionStr = map.get("version");
-  const lastSynced = map.get("last_synced");
-  const lastManualEdit = map.get("last_manual_edit");
-  const created = map.get("created");
-  const updated = map.get("updated");
-  if (!project || !versionStr || !lastSynced || !lastManualEdit) {
-    return (0, import_types19.Err)(
-      new Error(
-        "Frontmatter missing required fields: project, version, last_synced, last_manual_edit"
-      )
-    );
-  }
-  const version = parseInt(versionStr, 10);
-  if (isNaN(version)) {
-    return (0, import_types19.Err)(new Error("Frontmatter version must be a number"));
-  }
-  const fm = { project, version, lastSynced, lastManualEdit };
-  if (created) fm.created = created;
-  if (updated) fm.updated = updated;
-  return (0, import_types19.Ok)(fm);
-}
-function parseMilestones(body) {
-  const milestones = [];
-  const h2Pattern = /^## (.+)$/gm;
-  const h2Matches = [];
-  let match;
-  let bodyEnd = body.length;
-  while ((match = h2Pattern.exec(body)) !== null) {
-    if (match[1] === "Assignment History") {
-      bodyEnd = match.index;
-      break;
-    }
-    h2Matches.push({ heading: match[1], startIndex: match.index, fullMatch: match[0] });
-  }
-  for (let i = 0; i < h2Matches.length; i++) {
-    const h2 = h2Matches[i];
-    const nextStart = i + 1 < h2Matches.length ? h2Matches[i + 1].startIndex : bodyEnd;
-    const sectionBody = body.slice(h2.startIndex + h2.fullMatch.length, nextStart);
-    const isBacklog = h2.heading === "Backlog";
-    const milestoneName = isBacklog ? "Backlog" : h2.heading.replace(/^Milestone:\s*/, "");
-    const featuresResult = parseFeatures(sectionBody);
-    if (!featuresResult.ok) return featuresResult;
-    milestones.push({
-      name: milestoneName,
-      isBacklog,
-      features: featuresResult.value
-    });
-  }
-  return (0, import_types19.Ok)(milestones);
-}
-function parseFeatures(sectionBody) {
-  const features = [];
-  const h3Pattern = /^### (?:Feature: )?(.+)$/gm;
-  const h3Matches = [];
-  let match;
-  while ((match = h3Pattern.exec(sectionBody)) !== null) {
-    h3Matches.push({ name: match[1], startIndex: match.index, fullMatch: match[0] });
-  }
-  for (let i = 0; i < h3Matches.length; i++) {
-    const h3 = h3Matches[i];
-    const nextStart = i + 1 < h3Matches.length ? h3Matches[i + 1].startIndex : sectionBody.length;
-    const featureBody = sectionBody.slice(h3.startIndex + h3.fullMatch.length, nextStart);
-    const featureResult = parseFeatureFields(h3.name, featureBody);
-    if (!featureResult.ok) return featureResult;
-    features.push(featureResult.value);
-  }
-  return (0, import_types19.Ok)(features);
-}
-function extractFieldMap(body) {
-  const fieldMap = /* @__PURE__ */ new Map();
-  const fieldPattern = /^- \*\*(.+?):\*\* (.+)$/gm;
-  let match;
-  while ((match = fieldPattern.exec(body)) !== null) {
-    fieldMap.set(match[1], match[2]);
-  }
-  return fieldMap;
-}
-function parseListField(fieldMap, ...keys) {
-  let raw = EM_DASH;
-  for (const key of keys) {
-    const val = fieldMap.get(key);
-    if (val !== void 0) {
-      raw = val;
-      break;
-    }
-  }
-  if (raw === EM_DASH || raw === "none") return [];
-  return raw.split(",").map((s) => s.trim());
-}
-function parseFeatureFields(name, body) {
-  const fieldMap = extractFieldMap(body);
-  const statusRaw = fieldMap.get("Status");
-  if (!statusRaw || !VALID_STATUSES.has(statusRaw)) {
-    return (0, import_types19.Err)(
-      new Error(
-        `Feature "${name}" has invalid status: "${statusRaw ?? "(missing)"}". Valid statuses: ${[...VALID_STATUSES].join(", ")}`
-      )
-    );
-  }
-  const specRaw = fieldMap.get("Spec") ?? EM_DASH;
-  const plans = parseListField(fieldMap, "Plans", "Plan");
-  const blockedBy = parseListField(fieldMap, "Blocked by", "Blockers");
-  const assigneeRaw = fieldMap.get("Assignee") ?? EM_DASH;
-  const priorityRaw = fieldMap.get("Priority") ?? EM_DASH;
-  const externalIdRaw = fieldMap.get("External-ID") ?? EM_DASH;
-  if (priorityRaw !== EM_DASH && !VALID_PRIORITIES.has(priorityRaw)) {
-    return (0, import_types19.Err)(
-      new Error(
-        `Feature "${name}" has invalid priority: "${priorityRaw}". Valid priorities: ${[...VALID_PRIORITIES].join(", ")}`
-      )
-    );
-  }
-  return (0, import_types19.Ok)({
-    name,
-    status: statusRaw,
-    spec: specRaw === EM_DASH ? null : specRaw,
-    plans,
-    blockedBy,
-    summary: fieldMap.get("Summary") ?? "",
-    assignee: assigneeRaw === EM_DASH ? null : assigneeRaw,
-    priority: priorityRaw === EM_DASH ? null : priorityRaw,
-    externalId: externalIdRaw === EM_DASH ? null : externalIdRaw
-  });
-}
-function parseAssignmentHistory(body) {
-  const historyMatch = body.match(/^## Assignment History\s*\n/m);
-  if (!historyMatch || historyMatch.index === void 0) return (0, import_types19.Ok)([]);
-  const historyStart = historyMatch.index + historyMatch[0].length;
-  const rawHistoryBody = body.slice(historyStart);
-  const nextH2 = rawHistoryBody.search(/^## /m);
-  const historyBody = nextH2 === -1 ? rawHistoryBody : rawHistoryBody.slice(0, nextH2);
-  const records = [];
-  const lines = historyBody.split("\n");
-  let pastHeader = false;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith("|")) continue;
-    if (!pastHeader) {
-      if (trimmed.match(/^\|[-\s|]+\|$/)) {
-        pastHeader = true;
-      }
-      continue;
-    }
-    const cells = trimmed.split("|").map((c) => c.trim()).filter((c) => c.length > 0);
-    if (cells.length < 4) continue;
-    const action = cells[2];
-    if (!["assigned", "completed", "unassigned"].includes(action)) continue;
-    records.push({
-      feature: cells[0],
-      assignee: cells[1],
-      action,
-      date: cells[3]
-    });
-  }
-  return (0, import_types19.Ok)(records);
-}
-
 // src/roadmap/serialize.ts
 var EM_DASH2 = "\u2014";
 function serializeRoadmap(roadmap) {
@@ -12424,9 +13387,9 @@ function serializeAssignmentHistory(records) {
 }
 
 // src/roadmap/sync.ts
-var fs19 = __toESM(require("fs"));
-var path19 = __toESM(require("path"));
-var import_types20 = require("@harness-engineering/types");
+var fs21 = __toESM(require("fs"));
+var path21 = __toESM(require("path"));
+var import_types24 = require("@harness-engineering/types");
 
 // src/roadmap/status-rank.ts
 var STATUS_RANK = {
@@ -12455,10 +13418,10 @@ function inferStatus(feature, projectPath, allFeatures) {
   const featuresWithPlans = allFeatures.filter((f) => f.plans.length > 0);
   const useRootState = featuresWithPlans.length <= 1;
   if (useRootState) {
-    const rootStatePath = path19.join(projectPath, ".harness", "state.json");
-    if (fs19.existsSync(rootStatePath)) {
+    const rootStatePath = path21.join(projectPath, ".harness", "state.json");
+    if (fs21.existsSync(rootStatePath)) {
       try {
-        const raw = fs19.readFileSync(rootStatePath, "utf-8");
+        const raw = fs21.readFileSync(rootStatePath, "utf-8");
         const state = JSON.parse(raw);
         if (state.progress) {
           for (const status of Object.values(state.progress)) {
@@ -12469,16 +13432,16 @@ function inferStatus(feature, projectPath, allFeatures) {
       }
     }
   }
-  const sessionsDir = path19.join(projectPath, ".harness", "sessions");
-  if (fs19.existsSync(sessionsDir)) {
+  const sessionsDir = path21.join(projectPath, ".harness", "sessions");
+  if (fs21.existsSync(sessionsDir)) {
     try {
-      const sessionDirs = fs19.readdirSync(sessionsDir, { withFileTypes: true });
+      const sessionDirs = fs21.readdirSync(sessionsDir, { withFileTypes: true });
       for (const entry of sessionDirs) {
         if (!entry.isDirectory()) continue;
-        const autopilotPath = path19.join(sessionsDir, entry.name, "autopilot-state.json");
-        if (!fs19.existsSync(autopilotPath)) continue;
+        const autopilotPath = path21.join(sessionsDir, entry.name, "autopilot-state.json");
+        if (!fs21.existsSync(autopilotPath)) continue;
         try {
-          const raw = fs19.readFileSync(autopilotPath, "utf-8");
+          const raw = fs21.readFileSync(autopilotPath, "utf-8");
           const autopilot = JSON.parse(raw);
           if (!autopilot.phases) continue;
           const linkedPhases = autopilot.phases.filter(
@@ -12523,7 +13486,7 @@ function syncRoadmap(options) {
       to: inferred
     });
   }
-  return (0, import_types20.Ok)(changes);
+  return (0, import_types24.Ok)(changes);
 }
 function applySyncChanges(roadmap, changes) {
   for (const change of changes) {
@@ -12557,7 +13520,7 @@ function resolveReverseStatus(externalStatus, labels, config) {
 }
 
 // src/roadmap/adapters/github-issues.ts
-var import_types21 = require("@harness-engineering/types");
+var import_types25 = require("@harness-engineering/types");
 function parseExternalId(externalId) {
   const match = externalId.match(/^github:([^/]+)\/([^#]+)#(\d+)$/);
   if (!match) return null;
@@ -12575,6 +13538,13 @@ function labelsForStatus(status, config) {
   return [...base];
 }
 var RETRY_DEFAULTS = { maxRetries: 5, baseDelayMs: 1e3 };
+function parseRepoParts(repo) {
+  const parts = (repo ?? "").split("/");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new Error(`Invalid repo format: "${repo}". Expected "owner/repo".`);
+  }
+  return { owner: parts[0], repo: parts[1] };
+}
 function sleep(ms) {
   return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
@@ -12618,12 +13588,9 @@ var GitHubIssuesSyncAdapter = class {
       maxRetries: options.maxRetries ?? RETRY_DEFAULTS.maxRetries,
       baseDelayMs: options.baseDelayMs ?? RETRY_DEFAULTS.baseDelayMs
     };
-    const repoParts = (options.config.repo ?? "").split("/");
-    if (repoParts.length !== 2 || !repoParts[0] || !repoParts[1]) {
-      throw new Error(`Invalid repo format: "${options.config.repo}". Expected "owner/repo".`);
-    }
-    this.owner = repoParts[0];
-    this.repo = repoParts[1];
+    const { owner, repo } = parseRepoParts(options.config.repo);
+    this.owner = owner;
+    this.repo = repo;
   }
   /**
    * Fetch all GitHub milestones and build the name -> ID cache.
@@ -12663,7 +13630,7 @@ var GitHubIssuesSyncAdapter = class {
     return data.number;
   }
   async getAuthenticatedUser() {
-    if (this.authenticatedUserCache) return (0, import_types21.Ok)(this.authenticatedUserCache);
+    if (this.authenticatedUserCache) return (0, import_types25.Ok)(this.authenticatedUserCache);
     try {
       const response = await fetchWithRetry(
         this.fetchFn,
@@ -12673,13 +13640,13 @@ var GitHubIssuesSyncAdapter = class {
       );
       if (!response.ok) {
         const text = await response.text();
-        return (0, import_types21.Err)(new Error(`GitHub API error ${response.status}: ${text}`));
+        return (0, import_types25.Err)(new Error(`GitHub API error ${response.status}: ${text}`));
       }
       const data = await response.json();
       this.authenticatedUserCache = `@${data.login}`;
-      return (0, import_types21.Ok)(this.authenticatedUserCache);
+      return (0, import_types25.Ok)(this.authenticatedUserCache);
     } catch (error) {
-      return (0, import_types21.Err)(error instanceof Error ? error : new Error(String(error)));
+      return (0, import_types25.Err)(error instanceof Error ? error : new Error(String(error)));
     }
   }
   headers() {
@@ -12723,20 +13690,20 @@ var GitHubIssuesSyncAdapter = class {
       );
       if (!response.ok) {
         const text = await response.text();
-        return (0, import_types21.Err)(new Error(`GitHub API error ${response.status}: ${text}`));
+        return (0, import_types25.Err)(new Error(`GitHub API error ${response.status}: ${text}`));
       }
       const data = await response.json();
       const externalId = buildExternalId(this.owner, this.repo, data.number);
       await this.closeIfDone(data.number, feature.status);
-      return (0, import_types21.Ok)({ externalId, url: data.html_url });
+      return (0, import_types25.Ok)({ externalId, url: data.html_url });
     } catch (error) {
-      return (0, import_types21.Err)(error instanceof Error ? error : new Error(String(error)));
+      return (0, import_types25.Err)(error instanceof Error ? error : new Error(String(error)));
     }
   }
   async updateTicket(externalId, changes, milestone) {
     try {
       const parsed = parseExternalId(externalId);
-      if (!parsed) return (0, import_types21.Err)(new Error(`Invalid externalId format: "${externalId}"`));
+      if (!parsed) return (0, import_types25.Err)(new Error(`Invalid externalId format: "${externalId}"`));
       const patch = {};
       if (changes.name !== void 0) patch.title = changes.name;
       if (changes.summary !== void 0) {
@@ -12772,18 +13739,18 @@ var GitHubIssuesSyncAdapter = class {
       );
       if (!response.ok) {
         const text = await response.text();
-        return (0, import_types21.Err)(new Error(`GitHub API error ${response.status}: ${text}`));
+        return (0, import_types25.Err)(new Error(`GitHub API error ${response.status}: ${text}`));
       }
       const data = await response.json();
-      return (0, import_types21.Ok)({ externalId, url: data.html_url });
+      return (0, import_types25.Ok)({ externalId, url: data.html_url });
     } catch (error) {
-      return (0, import_types21.Err)(error instanceof Error ? error : new Error(String(error)));
+      return (0, import_types25.Err)(error instanceof Error ? error : new Error(String(error)));
     }
   }
   async fetchTicketState(externalId) {
     try {
       const parsed = parseExternalId(externalId);
-      if (!parsed) return (0, import_types21.Err)(new Error(`Invalid externalId format: "${externalId}"`));
+      if (!parsed) return (0, import_types25.Err)(new Error(`Invalid externalId format: "${externalId}"`));
       const response = await fetchWithRetry(
         this.fetchFn,
         `${this.apiBase}/repos/${parsed.owner}/${parsed.repo}/issues/${parsed.number}`,
@@ -12795,17 +13762,17 @@ var GitHubIssuesSyncAdapter = class {
       );
       if (!response.ok) {
         const text = await response.text();
-        return (0, import_types21.Err)(new Error(`GitHub API error ${response.status}: ${text}`));
+        return (0, import_types25.Err)(new Error(`GitHub API error ${response.status}: ${text}`));
       }
       const data = await response.json();
-      return (0, import_types21.Ok)({
+      return (0, import_types25.Ok)({
         externalId,
         status: data.state,
         labels: data.labels.map((l) => l.name),
         assignee: data.assignee ? `@${data.assignee.login}` : null
       });
     } catch (error) {
-      return (0, import_types21.Err)(error instanceof Error ? error : new Error(String(error)));
+      return (0, import_types25.Err)(error instanceof Error ? error : new Error(String(error)));
     }
   }
   async fetchAllTickets() {
@@ -12827,7 +13794,7 @@ var GitHubIssuesSyncAdapter = class {
         );
         if (!response.ok) {
           const text = await response.text();
-          return (0, import_types21.Err)(new Error(`GitHub API error ${response.status}: ${text}`));
+          return (0, import_types25.Err)(new Error(`GitHub API error ${response.status}: ${text}`));
         }
         const data = await response.json();
         const issues = data.filter((d) => !d.pull_request);
@@ -12842,15 +13809,15 @@ var GitHubIssuesSyncAdapter = class {
         if (data.length < perPage) break;
         page++;
       }
-      return (0, import_types21.Ok)(tickets);
+      return (0, import_types25.Ok)(tickets);
     } catch (error) {
-      return (0, import_types21.Err)(error instanceof Error ? error : new Error(String(error)));
+      return (0, import_types25.Err)(error instanceof Error ? error : new Error(String(error)));
     }
   }
   async assignTicket(externalId, assignee) {
     try {
       const parsed = parseExternalId(externalId);
-      if (!parsed) return (0, import_types21.Err)(new Error(`Invalid externalId format: "${externalId}"`));
+      if (!parsed) return (0, import_types25.Err)(new Error(`Invalid externalId format: "${externalId}"`));
       const login = assignee.startsWith("@") ? assignee.slice(1) : assignee;
       const response = await fetchWithRetry(
         this.fetchFn,
@@ -12864,17 +13831,17 @@ var GitHubIssuesSyncAdapter = class {
       );
       if (!response.ok) {
         const text = await response.text();
-        return (0, import_types21.Err)(new Error(`GitHub API error ${response.status}: ${text}`));
+        return (0, import_types25.Err)(new Error(`GitHub API error ${response.status}: ${text}`));
       }
-      return (0, import_types21.Ok)(void 0);
+      return (0, import_types25.Ok)(void 0);
     } catch (error) {
-      return (0, import_types21.Err)(error instanceof Error ? error : new Error(String(error)));
+      return (0, import_types25.Err)(error instanceof Error ? error : new Error(String(error)));
     }
   }
 };
 
 // src/roadmap/sync-engine.ts
-var fs20 = __toESM(require("fs"));
+var fs22 = __toESM(require("fs"));
 function emptySyncResult() {
   return { created: [], updated: [], assignmentChanges: [], errors: [] };
 }
@@ -12962,7 +13929,7 @@ async function fullSync(roadmapPath, adapter, config, options) {
   });
   await previousSync;
   try {
-    const raw = fs20.readFileSync(roadmapPath, "utf-8");
+    const raw = fs22.readFileSync(roadmapPath, "utf-8");
     const parseResult = parseRoadmap(raw);
     if (!parseResult.ok) {
       return {
@@ -12973,7 +13940,7 @@ async function fullSync(roadmapPath, adapter, config, options) {
     const roadmap = parseResult.value;
     const pushResult = await syncToExternal(roadmap, adapter, config);
     const pullResult = await syncFromExternal(roadmap, adapter, config, options);
-    fs20.writeFileSync(roadmapPath, serializeRoadmap(roadmap), "utf-8");
+    fs22.writeFileSync(roadmapPath, serializeRoadmap(roadmap), "utf-8");
     return {
       created: pushResult.created,
       updated: pushResult.updated,
@@ -13103,47 +14070,47 @@ function assignFeature(roadmap, feature, assignee, date) {
 }
 
 // src/interaction/types.ts
-var import_zod8 = require("zod");
-var InteractionTypeSchema = import_zod8.z.enum(["question", "confirmation", "transition"]);
-var QuestionSchema = import_zod8.z.object({
-  text: import_zod8.z.string(),
-  options: import_zod8.z.array(import_zod8.z.string()).optional(),
-  default: import_zod8.z.string().optional()
+var import_zod10 = require("zod");
+var InteractionTypeSchema = import_zod10.z.enum(["question", "confirmation", "transition"]);
+var QuestionSchema = import_zod10.z.object({
+  text: import_zod10.z.string(),
+  options: import_zod10.z.array(import_zod10.z.string()).optional(),
+  default: import_zod10.z.string().optional()
 });
-var ConfirmationSchema = import_zod8.z.object({
-  text: import_zod8.z.string(),
-  context: import_zod8.z.string()
+var ConfirmationSchema = import_zod10.z.object({
+  text: import_zod10.z.string(),
+  context: import_zod10.z.string()
 });
-var TransitionSchema = import_zod8.z.object({
-  completedPhase: import_zod8.z.string(),
-  suggestedNext: import_zod8.z.string(),
-  reason: import_zod8.z.string(),
-  artifacts: import_zod8.z.array(import_zod8.z.string()),
-  requiresConfirmation: import_zod8.z.boolean(),
-  summary: import_zod8.z.string()
+var TransitionSchema = import_zod10.z.object({
+  completedPhase: import_zod10.z.string(),
+  suggestedNext: import_zod10.z.string(),
+  reason: import_zod10.z.string(),
+  artifacts: import_zod10.z.array(import_zod10.z.string()),
+  requiresConfirmation: import_zod10.z.boolean(),
+  summary: import_zod10.z.string()
 });
-var EmitInteractionInputSchema = import_zod8.z.object({
-  path: import_zod8.z.string(),
+var EmitInteractionInputSchema = import_zod10.z.object({
+  path: import_zod10.z.string(),
   type: InteractionTypeSchema,
-  stream: import_zod8.z.string().optional(),
+  stream: import_zod10.z.string().optional(),
   question: QuestionSchema.optional(),
   confirmation: ConfirmationSchema.optional(),
   transition: TransitionSchema.optional()
 });
 
 // src/blueprint/scanner.ts
-var fs21 = __toESM(require("fs/promises"));
-var path20 = __toESM(require("path"));
+var fs23 = __toESM(require("fs/promises"));
+var path22 = __toESM(require("path"));
 var ProjectScanner = class {
   constructor(rootDir) {
     this.rootDir = rootDir;
   }
   rootDir;
   async scan() {
-    let projectName = path20.basename(this.rootDir);
+    let projectName = path22.basename(this.rootDir);
     try {
-      const pkgPath = path20.join(this.rootDir, "package.json");
-      const pkgRaw = await fs21.readFile(pkgPath, "utf-8");
+      const pkgPath = path22.join(this.rootDir, "package.json");
+      const pkgRaw = await fs23.readFile(pkgPath, "utf-8");
       const pkg = JSON.parse(pkgRaw);
       if (pkg.name) projectName = pkg.name;
     } catch {
@@ -13184,8 +14151,8 @@ var ProjectScanner = class {
 };
 
 // src/blueprint/generator.ts
-var fs22 = __toESM(require("fs/promises"));
-var path21 = __toESM(require("path"));
+var fs24 = __toESM(require("fs/promises"));
+var path23 = __toESM(require("path"));
 var ejs = __toESM(require("ejs"));
 
 // src/blueprint/templates.ts
@@ -13269,19 +14236,19 @@ var BlueprintGenerator = class {
       styles: STYLES,
       scripts: SCRIPTS
     });
-    await fs22.mkdir(options.outputDir, { recursive: true });
-    await fs22.writeFile(path21.join(options.outputDir, "index.html"), html);
+    await fs24.mkdir(options.outputDir, { recursive: true });
+    await fs24.writeFile(path23.join(options.outputDir, "index.html"), html);
   }
 };
 
 // src/update-checker.ts
-var fs23 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
+var fs25 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
 var os = __toESM(require("os"));
 var import_child_process3 = require("child_process");
 function getStatePath() {
   const home = process.env["HOME"] || os.homedir();
-  return path22.join(home, ".harness", "update-check.json");
+  return path24.join(home, ".harness", "update-check.json");
 }
 function isUpdateCheckEnabled(configInterval) {
   if (process.env["HARNESS_NO_UPDATE_CHECK"] === "1") return false;
@@ -13294,7 +14261,7 @@ function shouldRunCheck(state, intervalMs) {
 }
 function readCheckState() {
   try {
-    const raw = fs23.readFileSync(getStatePath(), "utf-8");
+    const raw = fs25.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;
@@ -13311,7 +14278,7 @@ function readCheckState() {
 }
 function spawnBackgroundCheck(currentVersion) {
   const statePath = getStatePath();
-  const stateDir = path22.dirname(statePath);
+  const stateDir = path24.dirname(statePath);
   const script = `
 const { execSync } = require('child_process');
 const fs = require('fs');
@@ -13401,9 +14368,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 path26 = await import("path");
-  const pkgDir = path26.dirname(pkgPath);
-  return path26.join(pkgDir, "out", `${grammarName}.wasm`);
+  const path28 = await import("path");
+  const pkgDir = path28.dirname(pkgPath);
+  return path28.join(pkgDir, "out", `${grammarName}.wasm`);
 }
 async function loadLanguage(lang) {
   const grammarName = GRAMMAR_MAP[lang];
@@ -13807,8 +14774,8 @@ function getModelPrice(model, dataset) {
 }
 
 // src/pricing/cache.ts
-var fs24 = __toESM(require("fs/promises"));
-var path23 = __toESM(require("path"));
+var fs26 = __toESM(require("fs/promises"));
+var path25 = __toESM(require("path"));
 
 // src/pricing/fallback.json
 var fallback_default = {
@@ -13861,14 +14828,14 @@ var LITELLM_PRICING_URL = "https://raw.githubusercontent.com/BerriAI/litellm/mai
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var STALENESS_WARNING_DAYS = 7;
 function getCachePath(projectRoot) {
-  return path23.join(projectRoot, ".harness", "cache", "pricing.json");
+  return path25.join(projectRoot, ".harness", "cache", "pricing.json");
 }
 function getStalenessMarkerPath(projectRoot) {
-  return path23.join(projectRoot, ".harness", "cache", "staleness-marker.json");
+  return path25.join(projectRoot, ".harness", "cache", "staleness-marker.json");
 }
 async function readDiskCache(projectRoot) {
   try {
-    const raw = await fs24.readFile(getCachePath(projectRoot), "utf-8");
+    const raw = await fs26.readFile(getCachePath(projectRoot), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -13876,8 +14843,8 @@ async function readDiskCache(projectRoot) {
 }
 async function writeDiskCache(projectRoot, data) {
   const cachePath = getCachePath(projectRoot);
-  await fs24.mkdir(path23.dirname(cachePath), { recursive: true });
-  await fs24.writeFile(cachePath, JSON.stringify(data, null, 2));
+  await fs26.mkdir(path25.dirname(cachePath), { recursive: true });
+  await fs26.writeFile(cachePath, JSON.stringify(data, null, 2));
 }
 async function fetchFromNetwork() {
   try {
@@ -13904,7 +14871,7 @@ function loadFallbackDataset() {
 async function checkAndWarnStaleness(projectRoot) {
   const markerPath = getStalenessMarkerPath(projectRoot);
   try {
-    const raw = await fs24.readFile(markerPath, "utf-8");
+    const raw = await fs26.readFile(markerPath, "utf-8");
     const marker = JSON.parse(raw);
     const firstUse = new Date(marker.firstFallbackUse).getTime();
     const now = Date.now();
@@ -13916,8 +14883,8 @@ async function checkAndWarnStaleness(projectRoot) {
     }
   } catch {
     try {
-      await fs24.mkdir(path23.dirname(markerPath), { recursive: true });
-      await fs24.writeFile(
+      await fs26.mkdir(path25.dirname(markerPath), { recursive: true });
+      await fs26.writeFile(
         markerPath,
         JSON.stringify({ firstFallbackUse: (/* @__PURE__ */ new Date()).toISOString() })
       );
@@ -13927,7 +14894,7 @@ async function checkAndWarnStaleness(projectRoot) {
 }
 async function clearStalenessMarker(projectRoot) {
   try {
-    await fs24.unlink(getStalenessMarkerPath(projectRoot));
+    await fs26.unlink(getStalenessMarkerPath(projectRoot));
   } catch {
   }
 }
@@ -14097,8 +15064,8 @@ function aggregateByDay(records) {
 }
 
 // src/usage/jsonl-reader.ts
-var fs25 = __toESM(require("fs"));
-var path24 = __toESM(require("path"));
+var fs27 = __toESM(require("fs"));
+var path26 = __toESM(require("path"));
 function parseLine(line, lineNumber) {
   let entry;
   try {
@@ -14137,10 +15104,10 @@ function parseLine(line, lineNumber) {
   return record;
 }
 function readCostRecords(projectRoot) {
-  const costsFile = path24.join(projectRoot, ".harness", "metrics", "costs.jsonl");
+  const costsFile = path26.join(projectRoot, ".harness", "metrics", "costs.jsonl");
   let raw;
   try {
-    raw = fs25.readFileSync(costsFile, "utf-8");
+    raw = fs27.readFileSync(costsFile, "utf-8");
   } catch {
     return [];
   }
@@ -14158,8 +15125,8 @@ function readCostRecords(projectRoot) {
 }
 
 // src/usage/cc-parser.ts
-var fs26 = __toESM(require("fs"));
-var path25 = __toESM(require("path"));
+var fs28 = __toESM(require("fs"));
+var path27 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
 function extractUsage(entry) {
   if (entry.type !== "assistant") return null;
@@ -14192,7 +15159,7 @@ function parseCCLine(line, filePath, lineNumber) {
     entry = JSON.parse(line);
   } catch {
     console.warn(
-      `[harness usage] Skipping malformed CC JSONL line ${lineNumber} in ${path25.basename(filePath)}`
+      `[harness usage] Skipping malformed CC JSONL line ${lineNumber} in ${path27.basename(filePath)}`
     );
     return null;
   }
@@ -14206,7 +15173,7 @@ function parseCCLine(line, filePath, lineNumber) {
 function readCCFile(filePath) {
   let raw;
   try {
-    raw = fs26.readFileSync(filePath, "utf-8");
+    raw = fs28.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -14228,10 +15195,10 @@ function readCCFile(filePath) {
 }
 function parseCCRecords() {
   const homeDir = process.env.HOME ?? os2.homedir();
-  const projectsDir = path25.join(homeDir, ".claude", "projects");
+  const projectsDir = path27.join(homeDir, ".claude", "projects");
   let projectDirs;
   try {
-    projectDirs = fs26.readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path25.join(projectsDir, d.name));
+    projectDirs = fs28.readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path27.join(projectsDir, d.name));
   } catch {
     return [];
   }
@@ -14239,7 +15206,7 @@ function parseCCRecords() {
   for (const dir of projectDirs) {
     let files;
     try {
-      files = fs26.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path25.join(dir, f));
+      files = fs28.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path27.join(dir, f));
     } catch {
       continue;
     }
@@ -14256,6 +15223,7 @@ var VERSION = "0.15.0";
 0 && (module.exports = {
   AGENT_DESCRIPTORS,
   ARCHITECTURE_DESCRIPTOR,
+  AdjustedForecastSchema,
   AgentActionEmitter,
   ArchBaselineManager,
   ArchBaselineSchema,
@@ -14271,23 +15239,29 @@ var VERSION = "0.15.0";
   CACHE_TTL_MS,
   COMPLIANCE_DESCRIPTOR,
   CategoryBaselineSchema,
+  CategoryForecastSchema,
   CategoryRegressionSchema,
+  CategorySnapshotSchema,
   ChecklistBuilder,
   CircularDepsCollector,
   ComplexityCollector,
+  ConfidenceTierSchema,
   ConfirmationSchema,
   ConsoleSink,
   ConstraintRuleSchema,
   ContentPipeline,
+  ContributingFeatureSchema,
   ContributionsSchema,
   CouplingCollector,
   CriticalPathResolver,
   DEFAULT_PROVIDER_TIERS,
   DEFAULT_SECURITY_CONFIG,
+  DEFAULT_STABILITY_THRESHOLDS,
   DEFAULT_STATE,
   DEFAULT_STREAM_INDEX,
   DESTRUCTIVE_BASH,
   DepDepthCollector,
+  DirectionSchema,
   EXTENSION_MAP,
   EmitInteractionInputSchema,
   EntropyAnalyzer,
@@ -14313,6 +15287,11 @@ var VERSION = "0.15.0";
   NoOpSink,
   NoOpTelemetryAdapter,
   PatternConfigSchema,
+  PredictionEngine,
+  PredictionOptionsSchema,
+  PredictionRegressionResultSchema,
+  PredictionResultSchema,
+  PredictionWarningSchema,
   ProjectScanner,
   QuestionSchema,
   REQUIRED_SECTIONS,
@@ -14328,10 +15307,19 @@ var VERSION = "0.15.0";
   SharableLayerSchema,
   SharableSecurityRulesSchema,
   SkillEventSchema,
+  SpecImpactEstimateSchema,
+  SpecImpactEstimator,
+  SpecImpactSignalsSchema,
+  StabilityForecastSchema,
   StreamIndexSchema,
   StreamInfoSchema,
   ThresholdConfigSchema,
+  TimelineFileSchema,
+  TimelineManager,
+  TimelineSnapshotSchema,
   TransitionSchema,
+  TrendLineSchema,
+  TrendResultSchema,
   TypeScriptParser,
   VERSION,
   ViolationSchema,
@@ -14346,6 +15334,7 @@ var VERSION = "0.15.0";
   appendSessionEntry,
   applyFixes,
   applyHotspotDowngrade,
+  applyRecencyWeights,
   applySyncChanges,
   archMatchers,
   archModule,
@@ -14363,6 +15352,7 @@ var VERSION = "0.15.0";
   checkEligibility,
   checkEvidenceCoverage,
   checkTaint,
+  classifyConfidence,
   classifyFinding,
   clearEventHashCache,
   clearFailuresCache,
@@ -14474,6 +15464,7 @@ var VERSION = "0.15.0";
   parseSize,
   pathTraversalRules,
   previewFix,
+  projectValue,
   promoteSessionLearnings,
   pruneLearnings,
   reactRules,
@@ -14541,6 +15532,8 @@ var VERSION = "0.15.0";
   validateKnowledgeMap,
   validatePatternConfig,
   violationId,
+  weeksUntilThreshold,
+  weightedLinearRegression,
   writeConfig,
   writeLockfile,
   writeSessionSummary,