@harness-engineering/core 0.20.0 → 0.21.1

package/dist/index.js

@@ -168,6 +168,7 @@ __export(index_exports, {
   clearFailuresCache: () => clearFailuresCache,
   clearLearningsCache: () => clearLearningsCache,
   clearTaint: () => clearTaint,
+  computeContentHash: () => computeContentHash,
   computeOverallSeverity: () => computeOverallSeverity,
   computeScanExitCode: () => computeScanExitCode,
   configureFeedback: () => configureFeedback,
@@ -261,6 +262,7 @@ __export(index_exports, {
   migrateToStreams: () => migrateToStreams,
   networkRules: () => networkRules,
   nodeRules: () => nodeRules,
+  normalizeLearningContent: () => normalizeLearningContent,
   parseCCRecords: () => parseCCRecords,
   parseDateFromEntry: () => parseDateFromEntry,
   parseDiff: () => parseDiff,
@@ -371,17 +373,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(path28) {
+async function fileExists(path31) {
   try {
-    await accessAsync(path28, import_fs.constants.F_OK);
+    await accessAsync(path31, import_fs.constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function readFileContent(path28) {
+async function readFileContent(path31) {
   try {
-    const content = await readFileAsync(path28, "utf-8");
+    const content = await readFileAsync(path31, "utf-8");
     return (0, import_types.Ok)(content);
   } catch (error) {
     return (0, import_types.Err)(error);
@@ -432,15 +434,15 @@ function validateConfig(data, schema) {
   let message = "Configuration validation failed";
   const suggestions = [];
   if (firstError) {
-    const path28 = firstError.path.join(".");
-    const pathDisplay = path28 ? ` at "${path28}"` : "";
+    const path31 = firstError.path.join(".");
+    const pathDisplay = path31 ? ` at "${path31}"` : "";
     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 "${path28}" is required and must be of type "${expected}"`);
+        suggestions.push(`Field "${path31}" is required and must be of type "${expected}"`);
       } else {
         code = "INVALID_TYPE";
         message = `Invalid type${pathDisplay}: ${firstError.message}`;
@@ -656,27 +658,27 @@ function extractSections(content) {
   }
   return sections.map((section) => buildAgentMapSection(section, lines));
 }
-function isExternalLink(path28) {
-  return path28.startsWith("http://") || path28.startsWith("https://") || path28.startsWith("#") || path28.startsWith("mailto:");
+function isExternalLink(path31) {
+  return path31.startsWith("http://") || path31.startsWith("https://") || path31.startsWith("#") || path31.startsWith("mailto:");
 }
 function resolveLinkPath(linkPath, baseDir) {
   return linkPath.startsWith(".") ? (0, import_path.join)(baseDir, linkPath) : linkPath;
 }
-async function validateAgentsMap(path28 = "./AGENTS.md") {
-  const contentResult = await readFileContent(path28);
+async function validateAgentsMap(path31 = "./AGENTS.md") {
+  const contentResult = await readFileContent(path31);
   if (!contentResult.ok) {
     return (0, import_types.Err)(
       createError(
         "PARSE_ERROR",
         `Failed to read AGENTS.md: ${contentResult.error.message}`,
-        { path: path28 },
+        { path: path31 },
         ["Ensure the file exists", "Check file permissions"]
       )
     );
   }
   const content = contentResult.value;
   const sections = extractSections(content);
-  const baseDir = (0, import_path.dirname)(path28);
+  const baseDir = (0, import_path.dirname)(path31);
   const sectionTitles = sections.map((s) => s.title);
   const missingSections = REQUIRED_SECTIONS.filter(
     (required) => !sectionTitles.some((title) => title.toLowerCase().includes(required.toLowerCase()))
@@ -817,8 +819,8 @@ async function checkDocCoverage(domain, options = {}) {
 
 // src/context/knowledge-map.ts
 var import_path3 = require("path");
-function suggestFix(path28, existingFiles) {
-  const targetName = (0, import_path3.basename)(path28).toLowerCase();
+function suggestFix(path31, existingFiles) {
+  const targetName = (0, import_path3.basename)(path31).toLowerCase();
   const similar = existingFiles.find((file) => {
     const fileName = (0, import_path3.basename)(file).toLowerCase();
     return fileName.includes(targetName) || targetName.includes(fileName);
@@ -826,7 +828,7 @@ function suggestFix(path28, existingFiles) {
   if (similar) {
     return `Did you mean "${similar}"?`;
   }
-  return `Create the file "${path28}" or remove the link`;
+  return `Create the file "${path31}" or remove the link`;
 }
 async function validateKnowledgeMap(rootDir = process.cwd()) {
   const agentsPath = (0, import_path3.join)(rootDir, "AGENTS.md");
@@ -1432,8 +1434,8 @@ function createBoundaryValidator(schema, name) {
         return (0, import_types.Ok)(result.data);
       }
       const suggestions = result.error.issues.map((issue) => {
-        const path28 = issue.path.join(".");
-        return path28 ? `${path28}: ${issue.message}` : issue.message;
+        const path31 = issue.path.join(".");
+        return path31 ? `${path31}: ${issue.message}` : issue.message;
       });
       return (0, import_types.Err)(
         createError(
@@ -2065,11 +2067,11 @@ function processExportListSpecifiers(exportDecl, exports2) {
 var TypeScriptParser = class {
   name = "typescript";
   extensions = [".ts", ".tsx", ".mts", ".cts"];
-  async parseFile(path28) {
-    const contentResult = await readFileContent(path28);
+  async parseFile(path31) {
+    const contentResult = await readFileContent(path31);
     if (!contentResult.ok) {
       return (0, import_types.Err)(
-        createParseError("NOT_FOUND", `File not found: ${path28}`, { path: path28 }, [
+        createParseError("NOT_FOUND", `File not found: ${path31}`, { path: path31 }, [
           "Check that the file exists",
           "Verify the path is correct"
         ])
@@ -2079,7 +2081,7 @@ var TypeScriptParser = class {
       const ast = (0, import_typescript_estree.parse)(contentResult.value, {
         loc: true,
         range: true,
-        jsx: path28.endsWith(".tsx"),
+        jsx: path31.endsWith(".tsx"),
         errorOnUnknownASTType: false
       });
       return (0, import_types.Ok)({
@@ -2090,7 +2092,7 @@ var TypeScriptParser = class {
     } catch (e) {
       const error = e;
       return (0, import_types.Err)(
-        createParseError("SYNTAX_ERROR", `Failed to parse ${path28}: ${error.message}`, { path: path28 }, [
+        createParseError("SYNTAX_ERROR", `Failed to parse ${path31}: ${error.message}`, { path: path31 }, [
           "Check for syntax errors in the file",
           "Ensure valid TypeScript syntax"
         ])
@@ -2275,22 +2277,22 @@ function extractInlineRefs(content) {
   }
   return refs;
 }
-async function parseDocumentationFile(path28) {
-  const contentResult = await readFileContent(path28);
+async function parseDocumentationFile(path31) {
+  const contentResult = await readFileContent(path31);
   if (!contentResult.ok) {
     return (0, import_types.Err)(
       createEntropyError(
         "PARSE_ERROR",
-        `Failed to read documentation file: ${path28}`,
-        { file: path28 },
+        `Failed to read documentation file: ${path31}`,
+        { file: path31 },
         ["Check that the file exists"]
       )
     );
   }
   const content = contentResult.value;
-  const type = path28.endsWith(".md") ? "markdown" : "text";
+  const type = path31.endsWith(".md") ? "markdown" : "text";
   return (0, import_types.Ok)({
-    path: path28,
+    path: path31,
     type,
     content,
     codeBlocks: extractCodeBlocks(content),
@@ -7353,8 +7355,7 @@ function parseListField(fieldMap, ...keys) {
   if (raw === EM_DASH || raw === "none") return [];
   return raw.split(",").map((s) => s.trim());
 }
-function parseFeatureFields(name, body) {
-  const fieldMap = extractFieldMap(body);
+function validateStatus(name, fieldMap) {
   const statusRaw = fieldMap.get("Status");
   if (!statusRaw || !VALID_STATUSES.has(statusRaw)) {
     return (0, import_types13.Err)(
@@ -7363,12 +7364,10 @@ function parseFeatureFields(name, body) {
       )
     );
   }
-  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;
+  return (0, import_types13.Ok)(statusRaw);
+}
+function validatePriority(name, fieldMap) {
   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(
@@ -7376,16 +7375,28 @@ function parseFeatureFields(name, body) {
       )
     );
   }
+  return (0, import_types13.Ok)(priorityRaw === EM_DASH ? null : priorityRaw);
+}
+function optionalField(fieldMap, key) {
+  const raw = fieldMap.get(key) ?? EM_DASH;
+  return raw === EM_DASH ? null : raw;
+}
+function parseFeatureFields(name, body) {
+  const fieldMap = extractFieldMap(body);
+  const statusResult = validateStatus(name, fieldMap);
+  if (!statusResult.ok) return statusResult;
+  const priorityResult = validatePriority(name, fieldMap);
+  if (!priorityResult.ok) return priorityResult;
   return (0, import_types13.Ok)({
     name,
-    status: statusRaw,
-    spec: specRaw === EM_DASH ? null : specRaw,
-    plans,
-    blockedBy,
+    status: statusResult.value,
+    spec: optionalField(fieldMap, "Spec"),
+    plans: parseListField(fieldMap, "Plans", "Plan"),
+    blockedBy: parseListField(fieldMap, "Blocked by", "Blockers"),
     summary: fieldMap.get("Summary") ?? "",
-    assignee: assigneeRaw === EM_DASH ? null : assigneeRaw,
-    priority: priorityRaw === EM_DASH ? null : priorityRaw,
-    externalId: externalIdRaw === EM_DASH ? null : externalIdRaw
+    assignee: optionalField(fieldMap, "Assignee"),
+    priority: priorityResult.value,
+    externalId: optionalField(fieldMap, "External-ID")
   });
 }
 function parseAssignmentHistory(body) {
@@ -7451,82 +7462,16 @@ var PredictionEngine = class {
     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 baselines = this.computeBaselines(
+      categoriesToProcess,
+      thresholds,
+      snapshots,
+      firstDate,
+      currentT,
+      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 categories = this.computeAdjustedForecasts(baselines, thresholds, specImpacts, currentT);
     const warnings = this.generateWarnings(
       categories,
       opts.horizon
@@ -7568,6 +7513,76 @@ var PredictionEngine = class {
     }
     return base;
   }
+  computeBaselines(categoriesToProcess, thresholds, snapshots, firstDate, currentT, horizon) {
+    const baselines = {};
+    for (const category of ALL_CATEGORIES2) {
+      const threshold = thresholds[category];
+      if (!categoriesToProcess.includes(category)) {
+        baselines[category] = this.zeroForecast(category, threshold);
+        continue;
+      }
+      const timeSeries = this.extractTimeSeries(snapshots, category, firstDate);
+      baselines[category] = this.forecastCategory(
+        category,
+        timeSeries,
+        currentT,
+        threshold,
+        horizon
+      );
+    }
+    return baselines;
+  }
+  computeAdjustedForecasts(baselines, thresholds, specImpacts, currentT) {
+    const categories = {};
+    for (const category of ALL_CATEGORIES2) {
+      const baseline = baselines[category];
+      categories[category] = this.adjustForecastForCategory(
+        category,
+        baseline,
+        thresholds[category],
+        specImpacts,
+        currentT
+      );
+    }
+    return categories;
+  }
+  adjustForecastForCategory(category, baseline, threshold, specImpacts, currentT) {
+    if (!specImpacts || specImpacts.length === 0) {
+      return { baseline, adjusted: baseline, contributingFeatures: [] };
+    }
+    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) {
+      return { baseline, adjusted: baseline, contributingFeatures: [] };
+    }
+    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
+    };
+    return { baseline, adjusted, contributingFeatures: contributing };
+  }
   /**
    * Extract time series for a single category from snapshots.
    * Returns array of { t (weeks from first), value } sorted oldest first.
@@ -8392,7 +8407,7 @@ async function saveState(projectPath, state, stream, session) {
   }
 }
 
-// src/state/learnings.ts
+// src/state/learnings-content.ts
 var fs11 = __toESM(require("fs"));
 var path8 = __toESM(require("path"));
 var crypto = __toESM(require("crypto"));
@@ -8403,6 +8418,25 @@ function parseFrontmatter2(line) {
   const tags = match[2] ? match[2].split(",").filter(Boolean) : [];
   return { hash, tags };
 }
+function parseDateFromEntry(entry) {
+  const match = entry.match(/(\d{4}-\d{2}-\d{2})/);
+  return match ? match[1] ?? null : null;
+}
+function extractIndexEntry(entry) {
+  const lines = entry.split("\n");
+  const summary = lines[0] ?? entry;
+  const tags = [];
+  const skillMatch = entry.match(/\[skill:([^\]]+)\]/);
+  if (skillMatch?.[1]) tags.push(skillMatch[1]);
+  const outcomeMatch = entry.match(/\[outcome:([^\]]+)\]/);
+  if (outcomeMatch?.[1]) tags.push(outcomeMatch[1]);
+  return {
+    hash: computeEntryHash(entry),
+    tags,
+    summary,
+    fullText: entry
+  };
+}
 function computeEntryHash(text) {
   return crypto.createHash("sha256").update(text).digest("hex").slice(0, 8);
 }
@@ -8437,8 +8471,8 @@ function saveContentHashes(stateDir, index) {
   const hashesPath = path8.join(stateDir, CONTENT_HASHES_FILE);
   fs11.writeFileSync(hashesPath, JSON.stringify(index, null, 2) + "\n");
 }
-function rebuildContentHashes(stateDir) {
-  const learningsPath = path8.join(stateDir, LEARNINGS_FILE);
+function rebuildContentHashes(stateDir, learningsFile) {
+  const learningsPath = path8.join(stateDir, learningsFile);
   if (!fs11.existsSync(learningsPath)) return {};
   const content = fs11.readFileSync(learningsPath, "utf-8");
   const lines = content.split("\n");
@@ -8459,43 +8493,125 @@ function rebuildContentHashes(stateDir) {
   saveContentHashes(stateDir, index);
   return index;
 }
-function extractIndexEntry(entry) {
-  const lines = entry.split("\n");
-  const summary = lines[0] ?? entry;
-  const tags = [];
-  const skillMatch = entry.match(/\[skill:([^\]]+)\]/);
-  if (skillMatch?.[1]) tags.push(skillMatch[1]);
-  const outcomeMatch = entry.match(/\[outcome:([^\]]+)\]/);
-  if (outcomeMatch?.[1]) tags.push(outcomeMatch[1]);
-  return {
-    hash: computeEntryHash(entry),
-    tags,
-    summary,
-    fullText: entry
-  };
+function analyzeLearningPatterns(entries) {
+  const tagGroups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const tagMatches = entry.matchAll(/\[(skill:[^\]]+)\]|\[(outcome:[^\]]+)\]/g);
+    for (const match of tagMatches) {
+      const tag = match[1] ?? match[2];
+      if (tag) {
+        const group = tagGroups.get(tag) ?? [];
+        group.push(entry);
+        tagGroups.set(tag, group);
+      }
+    }
+  }
+  const patterns = [];
+  for (const [tag, groupEntries] of tagGroups) {
+    if (groupEntries.length >= 3) {
+      patterns.push({ tag, count: groupEntries.length, entries: groupEntries });
+    }
+  }
+  return patterns.sort((a, b) => b.count - a.count);
 }
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function scoreRelevance(entry, intent) {
+  if (!intent || intent.trim() === "") return 0;
+  const intentWords = intent.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+  if (intentWords.length === 0) return 0;
+  const entryLower = entry.toLowerCase();
+  const matches = intentWords.filter((word) => entryLower.includes(word));
+  return matches.length / intentWords.length;
+}
+
+// src/state/learnings-loader.ts
+var fs12 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
 var learningsCacheMap = /* @__PURE__ */ new Map();
 function clearLearningsCache() {
   learningsCacheMap.clear();
 }
+function invalidateLearningsCacheEntry(key) {
+  learningsCacheMap.delete(key);
+}
+async function loadRelevantLearnings(projectPath, skillName, stream, session) {
+  try {
+    const dirResult = await getStateDir(projectPath, stream, session);
+    if (!dirResult.ok) return dirResult;
+    const stateDir = dirResult.value;
+    const learningsPath = path9.join(stateDir, LEARNINGS_FILE);
+    if (!fs12.existsSync(learningsPath)) {
+      return (0, import_types.Ok)([]);
+    }
+    const stats = fs12.statSync(learningsPath);
+    const cacheKey = learningsPath;
+    const cached = learningsCacheMap.get(cacheKey);
+    let entries;
+    if (cached && cached.mtimeMs === stats.mtimeMs) {
+      entries = cached.entries;
+    } else {
+      const content = fs12.readFileSync(learningsPath, "utf-8");
+      const lines = content.split("\n");
+      entries = [];
+      let currentBlock = [];
+      for (const line of lines) {
+        if (line.startsWith("# ")) continue;
+        if (/^<!--\s+hash:[a-f0-9]+/.test(line)) continue;
+        const isDatedBullet = /^- \*\*\d{4}-\d{2}-\d{2}/.test(line);
+        const isHeading = /^## \d{4}-\d{2}-\d{2}/.test(line);
+        if (isDatedBullet || isHeading) {
+          if (currentBlock.length > 0) {
+            entries.push(currentBlock.join("\n"));
+          }
+          currentBlock = [line];
+        } else if (line.trim() !== "" && currentBlock.length > 0) {
+          currentBlock.push(line);
+        }
+      }
+      if (currentBlock.length > 0) {
+        entries.push(currentBlock.join("\n"));
+      }
+      learningsCacheMap.set(cacheKey, { mtimeMs: stats.mtimeMs, entries });
+      evictIfNeeded(learningsCacheMap);
+    }
+    if (!skillName) {
+      return (0, import_types.Ok)(entries);
+    }
+    const filtered = entries.filter((entry) => entry.includes(`[skill:${skillName}]`));
+    return (0, import_types.Ok)(filtered);
+  } catch (error) {
+    return (0, import_types.Err)(
+      new Error(
+        `Failed to load learnings: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+
+// src/state/learnings.ts
+var fs13 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
+var crypto2 = __toESM(require("crypto"));
 async function appendLearning(projectPath, learning, skillName, outcome, stream, session) {
   try {
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const learningsPath = path8.join(stateDir, LEARNINGS_FILE);
-    fs11.mkdirSync(stateDir, { recursive: true });
+    const learningsPath = path10.join(stateDir, LEARNINGS_FILE);
+    fs13.mkdirSync(stateDir, { recursive: true });
     const normalizedContent = normalizeLearningContent(learning);
     const contentHash = computeContentHash(normalizedContent);
-    const hashesPath = path8.join(stateDir, CONTENT_HASHES_FILE);
+    const hashesPath = path10.join(stateDir, CONTENT_HASHES_FILE);
     let contentHashes;
-    if (fs11.existsSync(hashesPath)) {
+    if (fs13.existsSync(hashesPath)) {
       contentHashes = loadContentHashes(stateDir);
-      if (Object.keys(contentHashes).length === 0 && fs11.existsSync(learningsPath)) {
-        contentHashes = rebuildContentHashes(stateDir);
+      if (Object.keys(contentHashes).length === 0 && fs13.existsSync(learningsPath)) {
+        contentHashes = rebuildContentHashes(stateDir, LEARNINGS_FILE);
       }
-    } else if (fs11.existsSync(learningsPath)) {
-      contentHashes = rebuildContentHashes(stateDir);
+    } else if (fs13.existsSync(learningsPath)) {
+      contentHashes = rebuildContentHashes(stateDir, LEARNINGS_FILE);
     } else {
       contentHashes = {};
     }
@@ -8514,7 +8630,7 @@ async function appendLearning(projectPath, learning, skillName, outcome, stream,
     } else {
       bulletLine = `- **${timestamp}:** ${learning}`;
     }
-    const hash = crypto.createHash("sha256").update(bulletLine).digest("hex").slice(0, 8);
+    const hash = crypto2.createHash("sha256").update(bulletLine).digest("hex").slice(0, 8);
     const tagsStr = fmTags.length > 0 ? ` tags:${fmTags.join(",")}` : "";
     const frontmatter = `<!-- hash:${hash}${tagsStr} -->`;
     const entry = `
@@ -8522,19 +8638,19 @@ ${frontmatter}
 ${bulletLine}
 `;
     let existingLineCount;
-    if (!fs11.existsSync(learningsPath)) {
-      fs11.writeFileSync(learningsPath, `# Learnings
+    if (!fs13.existsSync(learningsPath)) {
+      fs13.writeFileSync(learningsPath, `# Learnings
 ${entry}`);
       existingLineCount = 1;
     } else {
-      const existingContent = fs11.readFileSync(learningsPath, "utf-8");
+      const existingContent = fs13.readFileSync(learningsPath, "utf-8");
       existingLineCount = existingContent.split("\n").length;
-      fs11.appendFileSync(learningsPath, entry);
+      fs13.appendFileSync(learningsPath, entry);
     }
     const bulletLine_lineNum = existingLineCount + 2;
     contentHashes[contentHash] = { date: timestamp ?? "", line: bulletLine_lineNum };
     saveContentHashes(stateDir, contentHashes);
-    learningsCacheMap.delete(learningsPath);
+    invalidateLearningsCacheEntry(learningsPath);
     return (0, import_types.Ok)(void 0);
   } catch (error) {
     return (0, import_types.Err)(
@@ -8544,42 +8660,6 @@ ${entry}`);
     );
   }
 }
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function scoreRelevance(entry, intent) {
-  if (!intent || intent.trim() === "") return 0;
-  const intentWords = intent.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
-  if (intentWords.length === 0) return 0;
-  const entryLower = entry.toLowerCase();
-  const matches = intentWords.filter((word) => entryLower.includes(word));
-  return matches.length / intentWords.length;
-}
-function parseDateFromEntry(entry) {
-  const match = entry.match(/(\d{4}-\d{2}-\d{2})/);
-  return match ? match[1] ?? null : null;
-}
-function analyzeLearningPatterns(entries) {
-  const tagGroups = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const tagMatches = entry.matchAll(/\[(skill:[^\]]+)\]|\[(outcome:[^\]]+)\]/g);
-    for (const match of tagMatches) {
-      const tag = match[1] ?? match[2];
-      if (tag) {
-        const group = tagGroups.get(tag) ?? [];
-        group.push(entry);
-        tagGroups.set(tag, group);
-      }
-    }
-  }
-  const patterns = [];
-  for (const [tag, groupEntries] of tagGroups) {
-    if (groupEntries.length >= 3) {
-      patterns.push({ tag, count: groupEntries.length, entries: groupEntries });
-    }
-  }
-  return patterns.sort((a, b) => b.count - a.count);
-}
 async function loadBudgetedLearnings(projectPath, options) {
   const { intent, tokenBudget = 1e3, skill, session, stream, depth = "summary" } = options;
   if (depth === "index") {
@@ -8643,11 +8723,11 @@ async function loadIndexEntries(projectPath, skillName, stream, session) {
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const learningsPath = path8.join(stateDir, LEARNINGS_FILE);
-    if (!fs11.existsSync(learningsPath)) {
+    const learningsPath = path10.join(stateDir, LEARNINGS_FILE);
+    if (!fs13.existsSync(learningsPath)) {
       return (0, import_types.Ok)([]);
     }
-    const content = fs11.readFileSync(learningsPath, "utf-8");
+    const content = fs13.readFileSync(learningsPath, "utf-8");
     const lines = content.split("\n");
     const indexEntries = [];
     let pendingFrontmatter = null;
@@ -8700,74 +8780,25 @@ async function loadIndexEntries(projectPath, skillName, stream, session) {
     );
   }
 }
-async function loadRelevantLearnings(projectPath, skillName, stream, session) {
-  try {
-    const dirResult = await getStateDir(projectPath, stream, session);
-    if (!dirResult.ok) return dirResult;
-    const stateDir = dirResult.value;
-    const learningsPath = path8.join(stateDir, LEARNINGS_FILE);
-    if (!fs11.existsSync(learningsPath)) {
-      return (0, import_types.Ok)([]);
-    }
-    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 = fs11.readFileSync(learningsPath, "utf-8");
-      const lines = content.split("\n");
-      entries = [];
-      let currentBlock = [];
-      for (const line of lines) {
-        if (line.startsWith("# ")) continue;
-        if (/^<!--\s+hash:[a-f0-9]+/.test(line)) continue;
-        const isDatedBullet = /^- \*\*\d{4}-\d{2}-\d{2}/.test(line);
-        const isHeading = /^## \d{4}-\d{2}-\d{2}/.test(line);
-        if (isDatedBullet || isHeading) {
-          if (currentBlock.length > 0) {
-            entries.push(currentBlock.join("\n"));
-          }
-          currentBlock = [line];
-        } else if (line.trim() !== "" && currentBlock.length > 0) {
-          currentBlock.push(line);
-        }
-      }
-      if (currentBlock.length > 0) {
-        entries.push(currentBlock.join("\n"));
-      }
-      learningsCacheMap.set(cacheKey, { mtimeMs: stats.mtimeMs, entries });
-      evictIfNeeded(learningsCacheMap);
-    }
-    if (!skillName) {
-      return (0, import_types.Ok)(entries);
-    }
-    const filtered = entries.filter((entry) => entry.includes(`[skill:${skillName}]`));
-    return (0, import_types.Ok)(filtered);
-  } catch (error) {
-    return (0, import_types.Err)(
-      new Error(
-        `Failed to load learnings: ${error instanceof Error ? error.message : String(error)}`
-      )
-    );
-  }
-}
+
+// src/state/learnings-lifecycle.ts
+var fs14 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 async function archiveLearnings(projectPath, entries, stream) {
   try {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const archiveDir = path8.join(stateDir, "learnings-archive");
-    fs11.mkdirSync(archiveDir, { recursive: true });
+    const archiveDir = path11.join(stateDir, "learnings-archive");
+    fs14.mkdirSync(archiveDir, { recursive: true });
     const now = /* @__PURE__ */ new Date();
     const yearMonth = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
-    const archivePath = path8.join(archiveDir, `${yearMonth}.md`);
+    const archivePath = path11.join(archiveDir, `${yearMonth}.md`);
     const archiveContent = entries.join("\n\n") + "\n";
-    if (fs11.existsSync(archivePath)) {
-      fs11.appendFileSync(archivePath, "\n" + archiveContent);
+    if (fs14.existsSync(archivePath)) {
+      fs14.appendFileSync(archivePath, "\n" + archiveContent);
     } else {
-      fs11.writeFileSync(archivePath, `# Learnings Archive
+      fs14.writeFileSync(archivePath, `# Learnings Archive
 
 ${archiveContent}`);
     }
@@ -8785,8 +8816,8 @@ async function pruneLearnings(projectPath, stream) {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const learningsPath = path8.join(stateDir, LEARNINGS_FILE);
-    if (!fs11.existsSync(learningsPath)) {
+    const learningsPath = path11.join(stateDir, LEARNINGS_FILE);
+    if (!fs14.existsSync(learningsPath)) {
       return (0, import_types.Ok)({ kept: 0, archived: 0, patterns: [] });
     }
     const loadResult = await loadRelevantLearnings(projectPath, void 0, stream);
@@ -8817,8 +8848,8 @@ async function pruneLearnings(projectPath, stream) {
       if (!archiveResult.ok) return archiveResult;
     }
     const newContent = "# Learnings\n\n" + toKeep.join("\n\n") + "\n";
-    fs11.writeFileSync(learningsPath, newContent);
-    learningsCacheMap.delete(learningsPath);
+    fs14.writeFileSync(learningsPath, newContent);
+    invalidateLearningsCacheEntry(learningsPath);
     return (0, import_types.Ok)({
       kept: toKeep.length,
       archived: toArchive.length,
@@ -8862,21 +8893,21 @@ async function promoteSessionLearnings(projectPath, sessionSlug, stream) {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const globalPath = path8.join(stateDir, LEARNINGS_FILE);
-    const existingGlobal = fs11.existsSync(globalPath) ? fs11.readFileSync(globalPath, "utf-8") : "";
+    const globalPath = path11.join(stateDir, LEARNINGS_FILE);
+    const existingGlobal = fs14.existsSync(globalPath) ? fs14.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) {
-      fs11.writeFileSync(globalPath, `# Learnings
+      fs14.writeFileSync(globalPath, `# Learnings
 
 ${promotedContent}`);
     } else {
-      fs11.appendFileSync(globalPath, "\n\n" + promotedContent);
+      fs14.appendFileSync(globalPath, "\n\n" + promotedContent);
     }
-    learningsCacheMap.delete(globalPath);
+    invalidateLearningsCacheEntry(globalPath);
     return (0, import_types.Ok)({
       promoted: newEntries.length,
       skipped: skipped + (toPromote.length - newEntries.length)
@@ -8896,8 +8927,8 @@ async function countLearningEntries(projectPath, stream) {
 }
 
 // src/state/failures.ts
-var fs12 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 var failuresCacheMap = /* @__PURE__ */ new Map();
 function clearFailuresCache() {
   failuresCacheMap.clear();
@@ -8908,17 +8939,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 = path9.join(stateDir, FAILURES_FILE);
-    fs12.mkdirSync(stateDir, { recursive: true });
+    const failuresPath = path12.join(stateDir, FAILURES_FILE);
+    fs15.mkdirSync(stateDir, { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const entry = `
 - **${timestamp} [skill:${skillName}] [type:${type}]:** ${description}
 `;
-    if (!fs12.existsSync(failuresPath)) {
-      fs12.writeFileSync(failuresPath, `# Failures
+    if (!fs15.existsSync(failuresPath)) {
+      fs15.writeFileSync(failuresPath, `# Failures
 ${entry}`);
     } else {
-      fs12.appendFileSync(failuresPath, entry);
+      fs15.appendFileSync(failuresPath, entry);
     }
     failuresCacheMap.delete(failuresPath);
     return (0, import_types.Ok)(void 0);
@@ -8935,17 +8966,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 = path9.join(stateDir, FAILURES_FILE);
-    if (!fs12.existsSync(failuresPath)) {
+    const failuresPath = path12.join(stateDir, FAILURES_FILE);
+    if (!fs15.existsSync(failuresPath)) {
       return (0, import_types.Ok)([]);
     }
-    const stats = fs12.statSync(failuresPath);
+    const stats = fs15.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 = fs12.readFileSync(failuresPath, "utf-8");
+    const content = fs15.readFileSync(failuresPath, "utf-8");
     const entries = [];
     for (const line of content.split("\n")) {
       const match = line.match(FAILURE_LINE_REGEX);
@@ -8974,20 +9005,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 = path9.join(stateDir, FAILURES_FILE);
-    if (!fs12.existsSync(failuresPath)) {
+    const failuresPath = path12.join(stateDir, FAILURES_FILE);
+    if (!fs15.existsSync(failuresPath)) {
       return (0, import_types.Ok)(void 0);
     }
-    const archiveDir = path9.join(stateDir, "archive");
-    fs12.mkdirSync(archiveDir, { recursive: true });
+    const archiveDir = path12.join(stateDir, "archive");
+    fs15.mkdirSync(archiveDir, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     let archiveName = `failures-${date}.md`;
     let counter = 2;
-    while (fs12.existsSync(path9.join(archiveDir, archiveName))) {
+    while (fs15.existsSync(path12.join(archiveDir, archiveName))) {
       archiveName = `failures-${date}-${counter}.md`;
       counter++;
     }
-    fs12.renameSync(failuresPath, path9.join(archiveDir, archiveName));
+    fs15.renameSync(failuresPath, path12.join(archiveDir, archiveName));
     failuresCacheMap.delete(failuresPath);
     return (0, import_types.Ok)(void 0);
   } catch (error) {
@@ -9000,16 +9031,16 @@ async function archiveFailures(projectPath, stream, session) {
 }
 
 // src/state/handoff.ts
-var fs13 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var path13 = __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 = path10.join(stateDir, HANDOFF_FILE);
-    fs13.mkdirSync(stateDir, { recursive: true });
-    fs13.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2));
+    const handoffPath = path13.join(stateDir, HANDOFF_FILE);
+    fs16.mkdirSync(stateDir, { recursive: true });
+    fs16.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2));
     return (0, import_types.Ok)(void 0);
   } catch (error) {
     return (0, import_types.Err)(
@@ -9022,11 +9053,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 = path10.join(stateDir, HANDOFF_FILE);
-    if (!fs13.existsSync(handoffPath)) {
+    const handoffPath = path13.join(stateDir, HANDOFF_FILE);
+    if (!fs16.existsSync(handoffPath)) {
       return (0, import_types.Ok)(null);
     }
-    const raw = fs13.readFileSync(handoffPath, "utf-8");
+    const raw = fs16.readFileSync(handoffPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = HandoffSchema.safeParse(parsed);
     if (!result.success) {
@@ -9041,33 +9072,33 @@ async function loadHandoff(projectPath, stream, session) {
 }
 
 // src/state/mechanical-gate.ts
-var fs14 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
+var path14 = __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 (!fs14.existsSync(gateConfigPath)) return [];
-  const raw = JSON.parse(fs14.readFileSync(gateConfigPath, "utf-8"));
+  if (!fs17.existsSync(gateConfigPath)) return [];
+  const raw = JSON.parse(fs17.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 = path11.join(projectPath, "package.json");
-  if (fs14.existsSync(packageJsonPath)) {
-    const pkg = JSON.parse(fs14.readFileSync(packageJsonPath, "utf-8"));
+  const packageJsonPath = path14.join(projectPath, "package.json");
+  if (fs17.existsSync(packageJsonPath)) {
+    const pkg = JSON.parse(fs17.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 (fs14.existsSync(path11.join(projectPath, "go.mod"))) {
+  if (fs17.existsSync(path14.join(projectPath, "go.mod"))) {
     checks.push({ name: "test", command: "go test ./..." });
     checks.push({ name: "build", command: "go build ./..." });
   }
-  if (fs14.existsSync(path11.join(projectPath, "pyproject.toml")) || fs14.existsSync(path11.join(projectPath, "setup.py"))) {
+  if (fs17.existsSync(path14.join(projectPath, "pyproject.toml")) || fs17.existsSync(path14.join(projectPath, "setup.py"))) {
     checks.push({ name: "test", command: "python -m pytest" });
   }
   return checks;
@@ -9107,8 +9138,8 @@ function executeCheck(check, projectPath) {
   }
 }
 async function runMechanicalGate(projectPath) {
-  const harnessDir = path11.join(projectPath, HARNESS_DIR);
-  const gateConfigPath = path11.join(harnessDir, GATE_CONFIG_FILE);
+  const harnessDir = path14.join(projectPath, HARNESS_DIR);
+  const gateConfigPath = path14.join(harnessDir, GATE_CONFIG_FILE);
   try {
     let checks = loadChecksFromConfig(gateConfigPath);
     if (checks.length === 0) {
@@ -9129,8 +9160,8 @@ async function runMechanicalGate(projectPath) {
 }
 
 // src/state/session-summary.ts
-var fs15 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 function formatSummary(data) {
   const lines = [
     "## Session Summary",
@@ -9168,9 +9199,9 @@ function writeSessionSummary(projectPath, sessionSlug, data) {
     const dirResult = resolveSessionDir(projectPath, sessionSlug, { create: true });
     if (!dirResult.ok) return dirResult;
     const sessionDir = dirResult.value;
-    const summaryPath = path12.join(sessionDir, SUMMARY_FILE);
+    const summaryPath = path15.join(sessionDir, SUMMARY_FILE);
     const content = formatSummary(data);
-    fs15.writeFileSync(summaryPath, content);
+    fs18.writeFileSync(summaryPath, content);
     const description = deriveIndexDescription(data);
     updateSessionIndex(projectPath, sessionSlug, description);
     return (0, import_types.Ok)(void 0);
@@ -9187,11 +9218,11 @@ function loadSessionSummary(projectPath, sessionSlug) {
     const dirResult = resolveSessionDir(projectPath, sessionSlug);
     if (!dirResult.ok) return dirResult;
     const sessionDir = dirResult.value;
-    const summaryPath = path12.join(sessionDir, SUMMARY_FILE);
-    if (!fs15.existsSync(summaryPath)) {
+    const summaryPath = path15.join(sessionDir, SUMMARY_FILE);
+    if (!fs18.existsSync(summaryPath)) {
       return (0, import_types.Ok)(null);
     }
-    const content = fs15.readFileSync(summaryPath, "utf-8");
+    const content = fs18.readFileSync(summaryPath, "utf-8");
     return (0, import_types.Ok)(content);
   } catch (error) {
     return (0, import_types.Err)(
@@ -9203,11 +9234,11 @@ function loadSessionSummary(projectPath, sessionSlug) {
 }
 function listActiveSessions(projectPath) {
   try {
-    const indexPath2 = path12.join(projectPath, HARNESS_DIR, SESSIONS_DIR, SESSION_INDEX_FILE);
-    if (!fs15.existsSync(indexPath2)) {
+    const indexPath2 = path15.join(projectPath, HARNESS_DIR, SESSIONS_DIR, SESSION_INDEX_FILE);
+    if (!fs18.existsSync(indexPath2)) {
       return (0, import_types.Ok)(null);
     }
-    const content = fs15.readFileSync(indexPath2, "utf-8");
+    const content = fs18.readFileSync(indexPath2, "utf-8");
     return (0, import_types.Ok)(content);
   } catch (error) {
     return (0, import_types.Err)(
@@ -9219,8 +9250,8 @@ function listActiveSessions(projectPath) {
 }
 
 // src/state/session-sections.ts
-var fs16 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 var import_types19 = require("@harness-engineering/types");
 function emptySections() {
   const sections = {};
@@ -9233,12 +9264,12 @@ async function loadSessionState(projectPath, sessionSlug) {
   const dirResult = resolveSessionDir(projectPath, sessionSlug);
   if (!dirResult.ok) return dirResult;
   const sessionDir = dirResult.value;
-  const filePath = path13.join(sessionDir, SESSION_STATE_FILE);
-  if (!fs16.existsSync(filePath)) {
+  const filePath = path16.join(sessionDir, SESSION_STATE_FILE);
+  if (!fs19.existsSync(filePath)) {
     return (0, import_types.Ok)(emptySections());
   }
   try {
-    const raw = fs16.readFileSync(filePath, "utf-8");
+    const raw = fs19.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     const sections = emptySections();
     for (const name of import_types19.SESSION_SECTION_NAMES) {
@@ -9259,9 +9290,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 = path13.join(sessionDir, SESSION_STATE_FILE);
+  const filePath = path16.join(sessionDir, SESSION_STATE_FILE);
   try {
-    fs16.writeFileSync(filePath, JSON.stringify(sections, null, 2));
+    fs19.writeFileSync(filePath, JSON.stringify(sections, null, 2));
     return (0, import_types.Ok)(void 0);
   } catch (error) {
     return (0, import_types.Err)(
@@ -9315,32 +9346,32 @@ function generateEntryId() {
 }
 
 // src/state/session-archive.ts
-var fs17 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs20 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 async function archiveSession(projectPath, sessionSlug) {
   const dirResult = resolveSessionDir(projectPath, sessionSlug);
   if (!dirResult.ok) return dirResult;
   const sessionDir = dirResult.value;
-  if (!fs17.existsSync(sessionDir)) {
+  if (!fs20.existsSync(sessionDir)) {
     return (0, import_types.Err)(new Error(`Session '${sessionSlug}' not found at ${sessionDir}`));
   }
-  const archiveBase = path14.join(projectPath, HARNESS_DIR, ARCHIVE_DIR, "sessions");
+  const archiveBase = path17.join(projectPath, HARNESS_DIR, ARCHIVE_DIR, "sessions");
   try {
-    fs17.mkdirSync(archiveBase, { recursive: true });
+    fs20.mkdirSync(archiveBase, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     let archiveName = `${sessionSlug}-${date}`;
     let counter = 1;
-    while (fs17.existsSync(path14.join(archiveBase, archiveName))) {
+    while (fs20.existsSync(path17.join(archiveBase, archiveName))) {
       archiveName = `${sessionSlug}-${date}-${counter}`;
       counter++;
     }
-    const dest = path14.join(archiveBase, archiveName);
+    const dest = path17.join(archiveBase, archiveName);
     try {
-      fs17.renameSync(sessionDir, dest);
+      fs20.renameSync(sessionDir, dest);
     } catch (renameErr) {
       if (renameErr instanceof Error && "code" in renameErr && renameErr.code === "EXDEV") {
-        fs17.cpSync(sessionDir, dest, { recursive: true });
-        fs17.rmSync(sessionDir, { recursive: true });
+        fs20.cpSync(sessionDir, dest, { recursive: true });
+        fs20.rmSync(sessionDir, { recursive: true });
       } else {
         throw renameErr;
       }
@@ -9356,8 +9387,8 @@ async function archiveSession(projectPath, sessionSlug) {
 }
 
 // src/state/events.ts
-var fs18 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs21 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
 var import_zod8 = require("zod");
 var SkillEventSchema = import_zod8.z.object({
   timestamp: import_zod8.z.string(),
@@ -9378,8 +9409,8 @@ function loadKnownHashes(eventsPath) {
   const cached = knownHashesCache.get(eventsPath);
   if (cached) return cached;
   const hashes = /* @__PURE__ */ new Set();
-  if (fs18.existsSync(eventsPath)) {
-    const content = fs18.readFileSync(eventsPath, "utf-8");
+  if (fs21.existsSync(eventsPath)) {
+    const content = fs21.readFileSync(eventsPath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim() !== "");
     for (const line of lines) {
       try {
@@ -9402,8 +9433,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 = path15.join(stateDir, EVENTS_FILE);
-    fs18.mkdirSync(stateDir, { recursive: true });
+    const eventsPath = path18.join(stateDir, EVENTS_FILE);
+    fs21.mkdirSync(stateDir, { recursive: true });
     const contentHash = computeEventHash(event, options?.session);
     const knownHashes = loadKnownHashes(eventsPath);
     if (knownHashes.has(contentHash)) {
@@ -9417,7 +9448,7 @@ async function emitEvent(projectPath, event, options) {
     if (options?.session) {
       fullEvent.session = options.session;
     }
-    fs18.appendFileSync(eventsPath, JSON.stringify(fullEvent) + "\n");
+    fs21.appendFileSync(eventsPath, JSON.stringify(fullEvent) + "\n");
     knownHashes.add(contentHash);
     return (0, import_types.Ok)({ written: true });
   } catch (error) {
@@ -9431,11 +9462,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 = path15.join(stateDir, EVENTS_FILE);
-    if (!fs18.existsSync(eventsPath)) {
+    const eventsPath = path18.join(stateDir, EVENTS_FILE);
+    if (!fs21.existsSync(eventsPath)) {
       return (0, import_types.Ok)([]);
     }
-    const content = fs18.readFileSync(eventsPath, "utf-8");
+    const content = fs21.readFileSync(eventsPath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim() !== "");
     const events = [];
     for (const line of lines) {
@@ -9649,7 +9680,7 @@ async function runMultiTurnPipeline(initialContext, turnExecutor, options) {
 }
 
 // src/security/scanner.ts
-var fs20 = __toESM(require("fs/promises"));
+var fs23 = __toESM(require("fs/promises"));
 var import_minimatch5 = require("minimatch");
 
 // src/security/rules/registry.ts
@@ -9737,15 +9768,15 @@ function resolveRuleSeverity(ruleId, defaultSeverity, overrides, strict) {
 }
 
 // src/security/stack-detector.ts
-var fs19 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs22 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
 function detectStack(projectRoot) {
   const stacks = [];
-  const pkgJsonPath = path16.join(projectRoot, "package.json");
-  if (fs19.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path19.join(projectRoot, "package.json");
+  if (fs22.existsSync(pkgJsonPath)) {
     stacks.push("node");
     try {
-      const pkgJson = JSON.parse(fs19.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs22.readFileSync(pkgJsonPath, "utf-8"));
       const allDeps = {
         ...pkgJson.dependencies,
         ...pkgJson.devDependencies
@@ -9760,13 +9791,13 @@ function detectStack(projectRoot) {
     } catch {
     }
   }
-  const goModPath = path16.join(projectRoot, "go.mod");
-  if (fs19.existsSync(goModPath)) {
+  const goModPath = path19.join(projectRoot, "go.mod");
+  if (fs22.existsSync(goModPath)) {
     stacks.push("go");
   }
-  const requirementsPath = path16.join(projectRoot, "requirements.txt");
-  const pyprojectPath = path16.join(projectRoot, "pyproject.toml");
-  if (fs19.existsSync(requirementsPath) || fs19.existsSync(pyprojectPath)) {
+  const requirementsPath = path19.join(projectRoot, "requirements.txt");
+  const pyprojectPath = path19.join(projectRoot, "pyproject.toml");
+  if (fs22.existsSync(requirementsPath) || fs22.existsSync(pyprojectPath)) {
     stacks.push("python");
   }
   return stacks;
@@ -10597,7 +10628,7 @@ var SecurityScanner = class {
   }
   async scanFile(filePath) {
     if (!this.config.enabled) return [];
-    const content = await fs20.readFile(filePath, "utf-8");
+    const content = await fs23.readFile(filePath, "utf-8");
     return this.scanContentForFile(content, filePath, 1);
   }
   scanContentForFile(content, filePath, startLine = 1) {
@@ -11100,7 +11131,7 @@ function mapSecurityFindings(secFindings, existing) {
 }
 
 // src/ci/check-orchestrator.ts
-var path17 = __toESM(require("path"));
+var path20 = __toESM(require("path"));
 var import_graph = require("@harness-engineering/graph");
 var ALL_CHECKS = [
   "validate",
@@ -11115,7 +11146,7 @@ var ALL_CHECKS = [
 ];
 async function runValidateCheck(projectRoot, config) {
   const issues = [];
-  const agentsPath = path17.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
+  const agentsPath = path20.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
   const result = await validateAgentsMap(agentsPath);
   if (!result.ok) {
     issues.push({ severity: "error", message: result.error.message });
@@ -11172,7 +11203,7 @@ async function runDepsCheck(projectRoot, config) {
 }
 async function runDocsCheck(projectRoot, config) {
   const issues = [];
-  const docsDir = path17.join(projectRoot, config.docsDir ?? "docs");
+  const docsDir = path20.join(projectRoot, config.docsDir ?? "docs");
   const entropyConfig = config.entropy || {};
   const result = await checkDocCoverage("project", {
     docsDir,
@@ -11357,7 +11388,7 @@ 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 graphDir = path20.join(projectRoot, ".harness", "graph");
   const store = new import_graph.GraphStore();
   const loaded = await store.load(graphDir);
   if (!loaded) {
@@ -11486,7 +11517,7 @@ async function runCIChecks(input) {
 }
 
 // src/review/mechanical-checks.ts
-var path18 = __toESM(require("path"));
+var path21 = __toESM(require("path"));
 async function runMechanicalChecks(options) {
   const { projectRoot, config, skip = [], changedFiles } = options;
   const findings = [];
@@ -11498,7 +11529,7 @@ async function runMechanicalChecks(options) {
   };
   if (!skip.includes("validate")) {
     try {
-      const agentsPath = path18.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
+      const agentsPath = path21.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
       const result = await validateAgentsMap(agentsPath);
       if (!result.ok) {
         statuses.validate = "fail";
@@ -11535,7 +11566,7 @@ async function runMechanicalChecks(options) {
       statuses.validate = "fail";
       findings.push({
         tool: "validate",
-        file: path18.join(projectRoot, "AGENTS.md"),
+        file: path21.join(projectRoot, "AGENTS.md"),
         message: err instanceof Error ? err.message : String(err),
         severity: "error"
       });
@@ -11599,7 +11630,7 @@ async function runMechanicalChecks(options) {
       (async () => {
         const localFindings = [];
         try {
-          const docsDir = path18.join(projectRoot, config.docsDir ?? "docs");
+          const docsDir = path21.join(projectRoot, config.docsDir ?? "docs");
           const result = await checkDocCoverage("project", { docsDir });
           if (!result.ok) {
             statuses["check-docs"] = "warn";
@@ -11626,7 +11657,7 @@ async function runMechanicalChecks(options) {
           statuses["check-docs"] = "warn";
           localFindings.push({
             tool: "check-docs",
-            file: path18.join(projectRoot, "docs"),
+            file: path21.join(projectRoot, "docs"),
             message: err instanceof Error ? err.message : String(err),
             severity: "warning"
           });
@@ -11774,7 +11805,7 @@ function detectChangeType(commitMessage, diff2) {
 }
 
 // src/review/context-scoper.ts
-var path19 = __toESM(require("path"));
+var path22 = __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) {
@@ -11782,18 +11813,18 @@ function computeContextBudget(diffLines) {
   return diffLines;
 }
 function isWithinProject(absPath, projectRoot) {
-  const resolvedRoot = path19.resolve(projectRoot) + path19.sep;
-  const resolvedPath = path19.resolve(absPath);
-  return resolvedPath.startsWith(resolvedRoot) || resolvedPath === path19.resolve(projectRoot);
+  const resolvedRoot = path22.resolve(projectRoot) + path22.sep;
+  const resolvedPath = path22.resolve(absPath);
+  return resolvedPath.startsWith(resolvedRoot) || resolvedPath === path22.resolve(projectRoot);
 }
 async function readContextFile(projectRoot, filePath, reason) {
-  const absPath = path19.isAbsolute(filePath) ? filePath : path19.join(projectRoot, filePath);
+  const absPath = path22.isAbsolute(filePath) ? filePath : path22.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 = path19.isAbsolute(filePath) ? relativePosix(projectRoot, filePath) : filePath;
+  const relPath = path22.isAbsolute(filePath) ? relativePosix(projectRoot, filePath) : filePath;
   return { path: relPath, content, reason, lines };
 }
 function extractImportSources2(content) {
@@ -11808,18 +11839,18 @@ function extractImportSources2(content) {
 }
 async function resolveImportPath2(projectRoot, fromFile, importSource) {
   if (!importSource.startsWith(".")) return null;
-  const fromDir = path19.dirname(path19.join(projectRoot, fromFile));
-  const basePath = path19.resolve(fromDir, importSource);
+  const fromDir = path22.dirname(path22.join(projectRoot, fromFile));
+  const basePath = path22.resolve(fromDir, importSource);
   if (!isWithinProject(basePath, projectRoot)) return null;
   const relBase = relativePosix(projectRoot, basePath);
   const candidates = [
     relBase + ".ts",
     relBase + ".tsx",
     relBase + ".mts",
-    path19.join(relBase, "index.ts")
+    path22.join(relBase, "index.ts")
   ];
   for (const candidate of candidates) {
-    const absCandidate = path19.join(projectRoot, candidate);
+    const absCandidate = path22.join(projectRoot, candidate);
     if (await fileExists(absCandidate)) {
       return candidate;
     }
@@ -11827,7 +11858,7 @@ async function resolveImportPath2(projectRoot, fromFile, importSource) {
   return null;
 }
 async function findTestFiles(projectRoot, sourceFile) {
-  const baseName = path19.basename(sourceFile, path19.extname(sourceFile));
+  const baseName = path22.basename(sourceFile, path22.extname(sourceFile));
   const pattern = `**/${baseName}.{test,spec}.{ts,tsx,mts}`;
   const results = await findFiles(pattern, projectRoot);
   return results.map((f) => relativePosix(projectRoot, f));
@@ -12636,7 +12667,7 @@ async function fanOutReview(options) {
 }
 
 // src/review/validate-findings.ts
-var path20 = __toESM(require("path"));
+var path23 = __toESM(require("path"));
 var DOWNGRADE_MAP = {
   critical: "important",
   important: "suggestion",
@@ -12657,7 +12688,7 @@ function normalizePath(filePath, projectRoot) {
   let normalized = filePath;
   normalized = normalized.replace(/\\/g, "/");
   const normalizedRoot = projectRoot.replace(/\\/g, "/");
-  if (path20.isAbsolute(normalized)) {
+  if (path23.isAbsolute(normalized)) {
     const root = normalizedRoot.endsWith("/") ? normalizedRoot : normalizedRoot + "/";
     if (normalized.startsWith(root)) {
       normalized = normalized.slice(root.length);
@@ -12682,12 +12713,12 @@ function followImportChain(fromFile, fileContents, maxDepth = 2) {
     while ((match = importRegex.exec(content)) !== null) {
       const importPath = match[1];
       if (!importPath.startsWith(".")) continue;
-      const dir = path20.dirname(current.file);
-      let resolved = path20.join(dir, importPath).replace(/\\/g, "/");
+      const dir = path23.dirname(current.file);
+      let resolved = path23.join(dir, importPath).replace(/\\/g, "/");
       if (!resolved.match(/\.(ts|tsx|js|jsx)$/)) {
         resolved += ".ts";
       }
-      resolved = path20.normalize(resolved).replace(/\\/g, "/");
+      resolved = path23.normalize(resolved).replace(/\\/g, "/");
       if (!visited.has(resolved) && current.depth + 1 <= maxDepth) {
         queue.push({ file: resolved, depth: current.depth + 1 });
       }
@@ -12704,7 +12735,7 @@ async function validateFindings(options) {
     if (exclusionSet.isExcluded(normalizedFile, finding.lineRange) || exclusionSet.isExcluded(finding.file, finding.lineRange)) {
       continue;
     }
-    const absoluteFile = path20.isAbsolute(finding.file) ? finding.file : path20.join(projectRoot, finding.file).replace(/\\/g, "/");
+    const absoluteFile = path23.isAbsolute(finding.file) ? finding.file : path23.join(projectRoot, finding.file).replace(/\\/g, "/");
     if (exclusionSet.isExcluded(absoluteFile, finding.lineRange)) {
       continue;
     }
@@ -13387,8 +13418,8 @@ function serializeAssignmentHistory(records) {
 }
 
 // src/roadmap/sync.ts
-var fs21 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
+var fs24 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
 var import_types24 = require("@harness-engineering/types");
 
 // src/roadmap/status-rank.ts
@@ -13418,10 +13449,10 @@ function inferStatus(feature, projectPath, allFeatures) {
   const featuresWithPlans = allFeatures.filter((f) => f.plans.length > 0);
   const useRootState = featuresWithPlans.length <= 1;
   if (useRootState) {
-    const rootStatePath = path21.join(projectPath, ".harness", "state.json");
-    if (fs21.existsSync(rootStatePath)) {
+    const rootStatePath = path24.join(projectPath, ".harness", "state.json");
+    if (fs24.existsSync(rootStatePath)) {
       try {
-        const raw = fs21.readFileSync(rootStatePath, "utf-8");
+        const raw = fs24.readFileSync(rootStatePath, "utf-8");
         const state = JSON.parse(raw);
         if (state.progress) {
           for (const status of Object.values(state.progress)) {
@@ -13432,16 +13463,16 @@ function inferStatus(feature, projectPath, allFeatures) {
       }
     }
   }
-  const sessionsDir = path21.join(projectPath, ".harness", "sessions");
-  if (fs21.existsSync(sessionsDir)) {
+  const sessionsDir = path24.join(projectPath, ".harness", "sessions");
+  if (fs24.existsSync(sessionsDir)) {
     try {
-      const sessionDirs = fs21.readdirSync(sessionsDir, { withFileTypes: true });
+      const sessionDirs = fs24.readdirSync(sessionsDir, { withFileTypes: true });
       for (const entry of sessionDirs) {
         if (!entry.isDirectory()) continue;
-        const autopilotPath = path21.join(sessionsDir, entry.name, "autopilot-state.json");
-        if (!fs21.existsSync(autopilotPath)) continue;
+        const autopilotPath = path24.join(sessionsDir, entry.name, "autopilot-state.json");
+        if (!fs24.existsSync(autopilotPath)) continue;
         try {
-          const raw = fs21.readFileSync(autopilotPath, "utf-8");
+          const raw = fs24.readFileSync(autopilotPath, "utf-8");
           const autopilot = JSON.parse(raw);
           if (!autopilot.phases) continue;
           const linkedPhases = autopilot.phases.filter(
@@ -13767,6 +13798,7 @@ var GitHubIssuesSyncAdapter = class {
       const data = await response.json();
       return (0, import_types25.Ok)({
         externalId,
+        title: data.title,
         status: data.state,
         labels: data.labels.map((l) => l.name),
         assignee: data.assignee ? `@${data.assignee.login}` : null
@@ -13801,6 +13833,7 @@ var GitHubIssuesSyncAdapter = class {
         for (const issue of issues) {
           tickets.push({
             externalId: buildExternalId(this.owner, this.repo, issue.number),
+            title: issue.title,
             status: issue.state,
             labels: issue.labels.map((l) => l.name),
             assignee: issue.assignee ? `@${issue.assignee.login}` : null
@@ -13841,47 +13874,65 @@ var GitHubIssuesSyncAdapter = class {
 };
 
 // src/roadmap/sync-engine.ts
-var fs22 = __toESM(require("fs"));
+var fs25 = __toESM(require("fs"));
 function emptySyncResult() {
   return { created: [], updated: [], assignmentChanges: [], errors: [] };
 }
-async function syncToExternal(roadmap, adapter, _config) {
-  const result = emptySyncResult();
-  let defaultAssignee = null;
-  const userResult = await adapter.getAuthenticatedUser();
-  if (userResult.ok) {
-    defaultAssignee = userResult.value;
+function buildDedupIndex(tickets, config) {
+  const index = /* @__PURE__ */ new Map();
+  if (!tickets) return index;
+  const configLabels = new Set((config.labels ?? []).map((l) => l.toLowerCase()));
+  for (const ticket of tickets) {
+    const hasConfigLabels = configLabels.size === 0 || ticket.labels.some((l) => configLabels.has(l.toLowerCase()));
+    if (!hasConfigLabels) continue;
+    const key = ticket.title.toLowerCase();
+    const prev = index.get(key);
+    if (!prev || prev.status === "closed" && ticket.status === "open") {
+      index.set(key, ticket);
+    }
   }
+  return index;
+}
+async function resolveExternalId(feature, milestone, adapter, dedupIndex, result) {
+  if (feature.externalId) return true;
+  const existing = dedupIndex.get(feature.name.toLowerCase());
+  if (existing) {
+    feature.externalId = existing.externalId;
+    return true;
+  }
+  const createResult = await adapter.createTicket(feature, milestone);
+  if (createResult.ok) {
+    feature.externalId = createResult.value.externalId;
+    result.created.push(createResult.value);
+  } else {
+    result.errors.push({ featureOrId: feature.name, error: createResult.error });
+  }
+  return false;
+}
+async function syncToExternal(roadmap, adapter, config, prefetchedTickets) {
+  const result = emptySyncResult();
+  const dedupIndex = buildDedupIndex(prefetchedTickets, config);
   for (const milestone of roadmap.milestones) {
     for (const feature of milestone.features) {
-      if (!feature.assignee && defaultAssignee) {
-        feature.assignee = defaultAssignee;
-      }
-      if (!feature.externalId) {
-        const createResult = await adapter.createTicket(feature, milestone.name);
-        if (createResult.ok) {
-          feature.externalId = createResult.value.externalId;
-          result.created.push(createResult.value);
-        } else {
-          result.errors.push({ featureOrId: feature.name, error: createResult.error });
-        }
+      const shouldUpdate = await resolveExternalId(
+        feature,
+        milestone.name,
+        adapter,
+        dedupIndex,
+        result
+      );
+      if (!shouldUpdate) continue;
+      const updateResult = await adapter.updateTicket(feature.externalId, feature, milestone.name);
+      if (updateResult.ok) {
+        result.updated.push(feature.externalId);
       } else {
-        const updateResult = await adapter.updateTicket(
-          feature.externalId,
-          feature,
-          milestone.name
-        );
-        if (updateResult.ok) {
-          result.updated.push(feature.externalId);
-        } else {
-          result.errors.push({ featureOrId: feature.externalId, error: updateResult.error });
-        }
+        result.errors.push({ featureOrId: feature.externalId, error: updateResult.error });
       }
     }
   }
   return result;
 }
-async function syncFromExternal(roadmap, adapter, config, options) {
+async function syncFromExternal(roadmap, adapter, config, options, prefetchedTickets) {
   const result = emptySyncResult();
   const forceSync = options?.forceSync ?? false;
   const featureByExternalId = /* @__PURE__ */ new Map();
@@ -13893,12 +13944,18 @@ async function syncFromExternal(roadmap, adapter, config, options) {
     }
   }
   if (featureByExternalId.size === 0) return result;
-  const fetchResult = await adapter.fetchAllTickets();
-  if (!fetchResult.ok) {
-    result.errors.push({ featureOrId: "*", error: fetchResult.error });
-    return result;
+  let tickets;
+  if (prefetchedTickets) {
+    tickets = prefetchedTickets;
+  } else {
+    const fetchResult = await adapter.fetchAllTickets();
+    if (!fetchResult.ok) {
+      result.errors.push({ featureOrId: "*", error: fetchResult.error });
+      return result;
+    }
+    tickets = fetchResult.value;
   }
-  for (const ticketState of fetchResult.value) {
+  for (const ticketState of tickets) {
     const feature = featureByExternalId.get(ticketState.externalId);
     if (!feature) continue;
     if (ticketState.assignee !== feature.assignee) {
@@ -13915,6 +13972,9 @@ async function syncFromExternal(roadmap, adapter, config, options) {
       if (!forceSync && isRegression(feature.status, newStatus)) {
         continue;
       }
+      if (!forceSync && feature.status === "blocked" && newStatus === "planned") {
+        continue;
+      }
       feature.status = newStatus;
     }
   }
@@ -13929,7 +13989,7 @@ async function fullSync(roadmapPath, adapter, config, options) {
   });
   await previousSync;
   try {
-    const raw = fs22.readFileSync(roadmapPath, "utf-8");
+    const raw = fs25.readFileSync(roadmapPath, "utf-8");
     const parseResult = parseRoadmap(raw);
     if (!parseResult.ok) {
       return {
@@ -13938,9 +13998,11 @@ 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);
-    fs22.writeFileSync(roadmapPath, serializeRoadmap(roadmap), "utf-8");
+    const fetchResult = await adapter.fetchAllTickets();
+    const tickets = fetchResult.ok ? fetchResult.value : void 0;
+    const pushResult = await syncToExternal(roadmap, adapter, config, tickets);
+    const pullResult = await syncFromExternal(roadmap, adapter, config, options, tickets);
+    fs25.writeFileSync(roadmapPath, serializeRoadmap(roadmap), "utf-8");
     return {
       created: pushResult.created,
       updated: pushResult.updated,
@@ -14099,18 +14161,18 @@ var EmitInteractionInputSchema = import_zod10.z.object({
 });
 
 // src/blueprint/scanner.ts
-var fs23 = __toESM(require("fs/promises"));
-var path22 = __toESM(require("path"));
+var fs26 = __toESM(require("fs/promises"));
+var path25 = __toESM(require("path"));
 var ProjectScanner = class {
   constructor(rootDir) {
     this.rootDir = rootDir;
   }
   rootDir;
   async scan() {
-    let projectName = path22.basename(this.rootDir);
+    let projectName = path25.basename(this.rootDir);
     try {
-      const pkgPath = path22.join(this.rootDir, "package.json");
-      const pkgRaw = await fs23.readFile(pkgPath, "utf-8");
+      const pkgPath = path25.join(this.rootDir, "package.json");
+      const pkgRaw = await fs26.readFile(pkgPath, "utf-8");
       const pkg = JSON.parse(pkgRaw);
       if (pkg.name) projectName = pkg.name;
     } catch {
@@ -14151,8 +14213,8 @@ var ProjectScanner = class {
 };
 
 // src/blueprint/generator.ts
-var fs24 = __toESM(require("fs/promises"));
-var path23 = __toESM(require("path"));
+var fs27 = __toESM(require("fs/promises"));
+var path26 = __toESM(require("path"));
 var ejs = __toESM(require("ejs"));
 
 // src/blueprint/templates.ts
@@ -14236,19 +14298,19 @@ var BlueprintGenerator = class {
       styles: STYLES,
       scripts: SCRIPTS
     });
-    await fs24.mkdir(options.outputDir, { recursive: true });
-    await fs24.writeFile(path23.join(options.outputDir, "index.html"), html);
+    await fs27.mkdir(options.outputDir, { recursive: true });
+    await fs27.writeFile(path26.join(options.outputDir, "index.html"), html);
   }
 };
 
 // src/update-checker.ts
-var fs25 = __toESM(require("fs"));
-var path24 = __toESM(require("path"));
+var fs28 = __toESM(require("fs"));
+var path27 = __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 path24.join(home, ".harness", "update-check.json");
+  return path27.join(home, ".harness", "update-check.json");
 }
 function isUpdateCheckEnabled(configInterval) {
   if (process.env["HARNESS_NO_UPDATE_CHECK"] === "1") return false;
@@ -14261,7 +14323,7 @@ function shouldRunCheck(state, intervalMs) {
 }
 function readCheckState() {
   try {
-    const raw = fs25.readFileSync(getStatePath(), "utf-8");
+    const raw = fs28.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;
@@ -14278,7 +14340,7 @@ function readCheckState() {
 }
 function spawnBackgroundCheck(currentVersion) {
   const statePath = getStatePath();
-  const stateDir = path24.dirname(statePath);
+  const stateDir = path27.dirname(statePath);
   const script = `
 const { execSync } = require('child_process');
 const fs = require('fs');
@@ -14368,9 +14430,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 path28 = await import("path");
-  const pkgDir = path28.dirname(pkgPath);
-  return path28.join(pkgDir, "out", `${grammarName}.wasm`);
+  const path31 = await import("path");
+  const pkgDir = path31.dirname(pkgPath);
+  return path31.join(pkgDir, "out", `${grammarName}.wasm`);
 }
 async function loadLanguage(lang) {
   const grammarName = GRAMMAR_MAP[lang];
@@ -14774,8 +14836,8 @@ function getModelPrice(model, dataset) {
 }
 
 // src/pricing/cache.ts
-var fs26 = __toESM(require("fs/promises"));
-var path25 = __toESM(require("path"));
+var fs29 = __toESM(require("fs/promises"));
+var path28 = __toESM(require("path"));
 
 // src/pricing/fallback.json
 var fallback_default = {
@@ -14828,14 +14890,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 path25.join(projectRoot, ".harness", "cache", "pricing.json");
+  return path28.join(projectRoot, ".harness", "cache", "pricing.json");
 }
 function getStalenessMarkerPath(projectRoot) {
-  return path25.join(projectRoot, ".harness", "cache", "staleness-marker.json");
+  return path28.join(projectRoot, ".harness", "cache", "staleness-marker.json");
 }
 async function readDiskCache(projectRoot) {
   try {
-    const raw = await fs26.readFile(getCachePath(projectRoot), "utf-8");
+    const raw = await fs29.readFile(getCachePath(projectRoot), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -14843,8 +14905,8 @@ async function readDiskCache(projectRoot) {
 }
 async function writeDiskCache(projectRoot, data) {
   const cachePath = getCachePath(projectRoot);
-  await fs26.mkdir(path25.dirname(cachePath), { recursive: true });
-  await fs26.writeFile(cachePath, JSON.stringify(data, null, 2));
+  await fs29.mkdir(path28.dirname(cachePath), { recursive: true });
+  await fs29.writeFile(cachePath, JSON.stringify(data, null, 2));
 }
 async function fetchFromNetwork() {
   try {
@@ -14871,7 +14933,7 @@ function loadFallbackDataset() {
 async function checkAndWarnStaleness(projectRoot) {
   const markerPath = getStalenessMarkerPath(projectRoot);
   try {
-    const raw = await fs26.readFile(markerPath, "utf-8");
+    const raw = await fs29.readFile(markerPath, "utf-8");
     const marker = JSON.parse(raw);
     const firstUse = new Date(marker.firstFallbackUse).getTime();
     const now = Date.now();
@@ -14883,8 +14945,8 @@ async function checkAndWarnStaleness(projectRoot) {
     }
   } catch {
     try {
-      await fs26.mkdir(path25.dirname(markerPath), { recursive: true });
-      await fs26.writeFile(
+      await fs29.mkdir(path28.dirname(markerPath), { recursive: true });
+      await fs29.writeFile(
         markerPath,
         JSON.stringify({ firstFallbackUse: (/* @__PURE__ */ new Date()).toISOString() })
       );
@@ -14894,7 +14956,7 @@ async function checkAndWarnStaleness(projectRoot) {
 }
 async function clearStalenessMarker(projectRoot) {
   try {
-    await fs26.unlink(getStalenessMarkerPath(projectRoot));
+    await fs29.unlink(getStalenessMarkerPath(projectRoot));
   } catch {
   }
 }
@@ -14940,8 +15002,7 @@ function calculateCost(record, dataset) {
 }
 
 // src/usage/aggregator.ts
-function aggregateBySession(records) {
-  if (records.length === 0) return [];
+function bucketRecordsBySession(records) {
   const sessionMap = /* @__PURE__ */ new Map();
   for (const record of records) {
     const tagged = record;
@@ -14957,58 +15018,104 @@ function aggregateBySession(records) {
     }
     bucket.allRecords.push(tagged);
   }
+  return sessionMap;
+}
+function accumulateCost(running, recordCost) {
+  if (recordCost != null && running != null) {
+    return running + recordCost;
+  }
+  if (recordCost == null) {
+    return null;
+  }
+  return running;
+}
+function sumRecordTokens(tokenSource) {
+  const tokens = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  let cacheCreation;
+  let cacheRead;
+  let costMicroUSD = 0;
+  let model;
+  for (const r of tokenSource) {
+    tokens.inputTokens += r.tokens.inputTokens;
+    tokens.outputTokens += r.tokens.outputTokens;
+    tokens.totalTokens += r.tokens.totalTokens;
+    if (r.cacheCreationTokens != null) {
+      cacheCreation = (cacheCreation ?? 0) + r.cacheCreationTokens;
+    }
+    if (r.cacheReadTokens != null) {
+      cacheRead = (cacheRead ?? 0) + r.cacheReadTokens;
+    }
+    costMicroUSD = accumulateCost(costMicroUSD, r.costMicroUSD);
+    if (!model && r.model) {
+      model = r.model;
+    }
+  }
+  return { tokens, cacheCreation, cacheRead, costMicroUSD, model };
+}
+function findModel(records) {
+  for (const r of records) {
+    if (r.model) return r.model;
+  }
+  return void 0;
+}
+function determineSource(hasHarness, hasCC) {
+  if (hasHarness && hasCC) return "merged";
+  if (hasCC) return "claude-code";
+  return "harness";
+}
+function applyOptionalFields(session, totals, model) {
+  if (model) session.model = model;
+  if (totals.cacheCreation != null) session.cacheCreationTokens = totals.cacheCreation;
+  if (totals.cacheRead != null) session.cacheReadTokens = totals.cacheRead;
+}
+function buildSessionUsage(sessionId, bucket) {
+  const hasHarness = bucket.harnessRecords.length > 0;
+  const hasCC = bucket.ccRecords.length > 0;
+  const tokenSource = hasHarness ? bucket.harnessRecords : bucket.ccRecords;
+  const totals = sumRecordTokens(tokenSource);
+  const model = totals.model ?? (hasCC ? findModel(bucket.ccRecords) : void 0);
+  const timestamps = bucket.allRecords.map((r) => r.timestamp).sort();
+  const session = {
+    sessionId,
+    firstTimestamp: timestamps[0] ?? "",
+    lastTimestamp: timestamps[timestamps.length - 1] ?? "",
+    tokens: totals.tokens,
+    costMicroUSD: totals.costMicroUSD,
+    source: determineSource(hasHarness, hasCC)
+  };
+  applyOptionalFields(session, totals, model);
+  return session;
+}
+function accumulateIntoDayBucket(day, record) {
+  day.sessions.add(record.sessionId);
+  day.tokens.inputTokens += record.tokens.inputTokens;
+  day.tokens.outputTokens += record.tokens.outputTokens;
+  day.tokens.totalTokens += record.tokens.totalTokens;
+  if (record.cacheCreationTokens != null) {
+    day.cacheCreation = (day.cacheCreation ?? 0) + record.cacheCreationTokens;
+  }
+  if (record.cacheReadTokens != null) {
+    day.cacheRead = (day.cacheRead ?? 0) + record.cacheReadTokens;
+  }
+  day.costMicroUSD = accumulateCost(day.costMicroUSD, record.costMicroUSD);
+  if (record.model) {
+    day.models.add(record.model);
+  }
+}
+function createDayBucket() {
+  return {
+    sessions: /* @__PURE__ */ new Set(),
+    tokens: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+    costMicroUSD: 0,
+    models: /* @__PURE__ */ new Set()
+  };
+}
+function aggregateBySession(records) {
+  if (records.length === 0) return [];
+  const sessionMap = bucketRecordsBySession(records);
   const results = [];
   for (const [sessionId, bucket] of sessionMap) {
-    const hasHarness = bucket.harnessRecords.length > 0;
-    const hasCC = bucket.ccRecords.length > 0;
-    const isMerged = hasHarness && hasCC;
-    const tokenSource = hasHarness ? bucket.harnessRecords : bucket.ccRecords;
-    const tokens = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-    let cacheCreation;
-    let cacheRead;
-    let costMicroUSD = 0;
-    let model;
-    for (const r of tokenSource) {
-      tokens.inputTokens += r.tokens.inputTokens;
-      tokens.outputTokens += r.tokens.outputTokens;
-      tokens.totalTokens += r.tokens.totalTokens;
-      if (r.cacheCreationTokens != null) {
-        cacheCreation = (cacheCreation ?? 0) + r.cacheCreationTokens;
-      }
-      if (r.cacheReadTokens != null) {
-        cacheRead = (cacheRead ?? 0) + r.cacheReadTokens;
-      }
-      if (r.costMicroUSD != null && costMicroUSD != null) {
-        costMicroUSD += r.costMicroUSD;
-      } else if (r.costMicroUSD == null) {
-        costMicroUSD = null;
-      }
-      if (!model && r.model) {
-        model = r.model;
-      }
-    }
-    if (!model && hasCC) {
-      for (const r of bucket.ccRecords) {
-        if (r.model) {
-          model = r.model;
-          break;
-        }
-      }
-    }
-    const timestamps = bucket.allRecords.map((r) => r.timestamp).sort();
-    const source = isMerged ? "merged" : hasCC ? "claude-code" : "harness";
-    const session = {
-      sessionId,
-      firstTimestamp: timestamps[0] ?? "",
-      lastTimestamp: timestamps[timestamps.length - 1] ?? "",
-      tokens,
-      costMicroUSD,
-      source
-    };
-    if (model) session.model = model;
-    if (cacheCreation != null) session.cacheCreationTokens = cacheCreation;
-    if (cacheRead != null) session.cacheReadTokens = cacheRead;
-    results.push(session);
+    results.push(buildSessionUsage(sessionId, bucket));
   }
   results.sort((a, b) => b.firstTimestamp.localeCompare(a.firstTimestamp));
   return results;
@@ -15019,32 +15126,9 @@ function aggregateByDay(records) {
   for (const record of records) {
     const date = record.timestamp.slice(0, 10);
     if (!dayMap.has(date)) {
-      dayMap.set(date, {
-        sessions: /* @__PURE__ */ new Set(),
-        tokens: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-        costMicroUSD: 0,
-        models: /* @__PURE__ */ new Set()
-      });
-    }
-    const day = dayMap.get(date);
-    day.sessions.add(record.sessionId);
-    day.tokens.inputTokens += record.tokens.inputTokens;
-    day.tokens.outputTokens += record.tokens.outputTokens;
-    day.tokens.totalTokens += record.tokens.totalTokens;
-    if (record.cacheCreationTokens != null) {
-      day.cacheCreation = (day.cacheCreation ?? 0) + record.cacheCreationTokens;
-    }
-    if (record.cacheReadTokens != null) {
-      day.cacheRead = (day.cacheRead ?? 0) + record.cacheReadTokens;
-    }
-    if (record.costMicroUSD != null && day.costMicroUSD != null) {
-      day.costMicroUSD += record.costMicroUSD;
-    } else if (record.costMicroUSD == null) {
-      day.costMicroUSD = null;
-    }
-    if (record.model) {
-      day.models.add(record.model);
+      dayMap.set(date, createDayBucket());
     }
+    accumulateIntoDayBucket(dayMap.get(date), record);
   }
   const results = [];
   for (const [date, day] of dayMap) {
@@ -15064,8 +15148,8 @@ function aggregateByDay(records) {
 }
 
 // src/usage/jsonl-reader.ts
-var fs27 = __toESM(require("fs"));
-var path26 = __toESM(require("path"));
+var fs30 = __toESM(require("fs"));
+var path29 = __toESM(require("path"));
 function parseLine(line, lineNumber) {
   let entry;
   try {
@@ -15104,10 +15188,10 @@ function parseLine(line, lineNumber) {
   return record;
 }
 function readCostRecords(projectRoot) {
-  const costsFile = path26.join(projectRoot, ".harness", "metrics", "costs.jsonl");
+  const costsFile = path29.join(projectRoot, ".harness", "metrics", "costs.jsonl");
   let raw;
   try {
-    raw = fs27.readFileSync(costsFile, "utf-8");
+    raw = fs30.readFileSync(costsFile, "utf-8");
   } catch {
     return [];
   }
@@ -15125,8 +15209,8 @@ function readCostRecords(projectRoot) {
 }
 
 // src/usage/cc-parser.ts
-var fs28 = __toESM(require("fs"));
-var path27 = __toESM(require("path"));
+var fs31 = __toESM(require("fs"));
+var path30 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
 function extractUsage(entry) {
   if (entry.type !== "assistant") return null;
@@ -15159,7 +15243,7 @@ function parseCCLine(line, filePath, lineNumber) {
     entry = JSON.parse(line);
   } catch {
     console.warn(
-      `[harness usage] Skipping malformed CC JSONL line ${lineNumber} in ${path27.basename(filePath)}`
+      `[harness usage] Skipping malformed CC JSONL line ${lineNumber} in ${path30.basename(filePath)}`
     );
     return null;
   }
@@ -15173,7 +15257,7 @@ function parseCCLine(line, filePath, lineNumber) {
 function readCCFile(filePath) {
   let raw;
   try {
-    raw = fs28.readFileSync(filePath, "utf-8");
+    raw = fs31.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -15195,10 +15279,10 @@ function readCCFile(filePath) {
 }
 function parseCCRecords() {
   const homeDir = process.env.HOME ?? os2.homedir();
-  const projectsDir = path27.join(homeDir, ".claude", "projects");
+  const projectsDir = path30.join(homeDir, ".claude", "projects");
   let projectDirs;
   try {
-    projectDirs = fs28.readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path27.join(projectsDir, d.name));
+    projectDirs = fs31.readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path30.join(projectsDir, d.name));
   } catch {
     return [];
   }
@@ -15206,7 +15290,7 @@ function parseCCRecords() {
   for (const dir of projectDirs) {
     let files;
     try {
-      files = fs28.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path27.join(dir, f));
+      files = fs31.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path30.join(dir, f));
     } catch {
       continue;
     }
@@ -15358,6 +15442,7 @@ var VERSION = "0.15.0";
   clearFailuresCache,
   clearLearningsCache,
   clearTaint,
+  computeContentHash,
   computeOverallSeverity,
   computeScanExitCode,
   configureFeedback,
@@ -15451,6 +15536,7 @@ var VERSION = "0.15.0";
   migrateToStreams,
   networkRules,
   nodeRules,
+  normalizeLearningContent,
   parseCCRecords,
   parseDateFromEntry,
   parseDiff,