@harness-engineering/cli 1.28.1 → 2.1.0

package/dist/{chunk-RFYF7TJS.js → chunk-MAFI6UWT.js}

@@ -13,7 +13,7 @@ import {
   NODE_STABILITY,
   init_dist as init_dist2,
   queryTraceability
-} from "./chunk-S2WB4LE7.js";
+} from "./chunk-BMM3GXV6.js";
 import {
   __esm,
   __export
@@ -69,17 +69,17 @@ function resolveFileToLayer(file, layers) {
   }
   return void 0;
 }
-async function fileExists(path37) {
+async function fileExists(path42) {
   try {
-    await accessAsync(path37, constants.F_OK);
+    await accessAsync(path42, constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function readFileContent(path37) {
+async function readFileContent(path42) {
   try {
-    const content = await readFileAsync(path37, "utf-8");
+    const content = await readFileAsync(path42, "utf-8");
     return Ok(content);
   } catch (error) {
     return Err(error);
@@ -473,9 +473,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 path37 = await import("path");
-  const pkgDir = path37.dirname(pkgPath);
-  return path37.join(pkgDir, "out", `${grammarName}.wasm`);
+  const path42 = await import("path");
+  const pkgDir = path42.dirname(pkgPath);
+  return path42.join(pkgDir, "out", `${grammarName}.wasm`);
 }
 async function loadLanguage(lang) {
   const grammarName = GRAMMAR_MAP[lang];
@@ -1908,11 +1908,11 @@ var init_chunk_H73442AZ = __esm({
     TypeScriptParser = class {
       name = "typescript";
       extensions = [".ts", ".tsx", ".mts", ".cts"];
-      async parseFile(path37) {
-        const contentResult = await readFileContent(path37);
+      async parseFile(path42) {
+        const contentResult = await readFileContent(path42);
         if (!contentResult.ok) {
           return Err(
-            createParseError("NOT_FOUND", `File not found: ${path37}`, { path: path37 }, [
+            createParseError("NOT_FOUND", `File not found: ${path42}`, { path: path42 }, [
               "Check that the file exists",
               "Verify the path is correct"
             ])
@@ -1922,7 +1922,7 @@ var init_chunk_H73442AZ = __esm({
           const ast = parse(contentResult.value, {
             loc: true,
             range: true,
-            jsx: path37.endsWith(".tsx"),
+            jsx: path42.endsWith(".tsx"),
             errorOnUnknownASTType: false
           });
           return Ok({
@@ -1933,7 +1933,7 @@ var init_chunk_H73442AZ = __esm({
         } catch (e) {
           const error = e;
           return Err(
-            createParseError("SYNTAX_ERROR", `Failed to parse ${path37}: ${error.message}`, { path: path37 }, [
+            createParseError("SYNTAX_ERROR", `Failed to parse ${path42}: ${error.message}`, { path: path42 }, [
               "Check for syntax errors in the file",
               "Ensure valid TypeScript syntax"
             ])
@@ -2248,11 +2248,11 @@ var init_chunk_H73442AZ = __esm({
         this.extensions = extensions;
         this.strategy = strategy;
       }
-      async parseFile(path37) {
-        const contentResult = await readFileContent(path37);
+      async parseFile(path42) {
+        const contentResult = await readFileContent(path42);
         if (!contentResult.ok) {
           return Err(
-            createParseError("NOT_FOUND", `File not found: ${path37}`, { path: path37 }, [
+            createParseError("NOT_FOUND", `File not found: ${path42}`, { path: path42 }, [
               "Check that the file exists"
             ])
           );
@@ -2268,7 +2268,7 @@ var init_chunk_H73442AZ = __esm({
         } catch (e) {
           const error = e;
           return Err(
-            createParseError("SYNTAX_ERROR", `Failed to parse ${path37}: ${error.message}`, { path: path37 }, [
+            createParseError("SYNTAX_ERROR", `Failed to parse ${path42}: ${error.message}`, { path: path42 }, [
               "Check for syntax errors in the file"
             ])
           );
@@ -2784,6 +2784,8 @@ var dist_exports = {};
 __export(dist_exports, {
   AGENT_DESCRIPTORS: () => AGENT_DESCRIPTORS,
   AGREEMENT_LINE_GAP: () => AGREEMENT_LINE_GAP,
+  ALLOWED_FIELD_KEYS: () => ALLOWED_FIELD_KEYS,
+  ALL_SOLUTION_CATEGORIES: () => ALL_SOLUTION_CATEGORIES,
   ARCHITECTURE_DESCRIPTOR: () => ARCHITECTURE_DESCRIPTOR,
   AdjustedForecastSchema: () => AdjustedForecastSchema,
   AgentActionEmitter: () => AgentActionEmitter,
@@ -2794,6 +2796,7 @@ __export(dist_exports, {
   ArchDiffResultSchema: () => ArchDiffResultSchema,
   ArchMetricCategorySchema: () => ArchMetricCategorySchema,
   BUG_DETECTION_DESCRIPTOR: () => BUG_DETECTION_DESCRIPTOR,
+  BUG_TRACK_CATEGORIES: () => BUG_TRACK_CATEGORIES,
   BaselineManager: () => BaselineManager,
   BenchmarkRunner: () => BenchmarkRunner,
   BlueprintGenerator: () => BlueprintGenerator,
@@ -2811,6 +2814,7 @@ __export(dist_exports, {
   CircularDepsCollector: () => CircularDepsCollector,
   CompactionPipeline: () => CompactionPipeline,
   ComplexityCollector: () => ComplexityCollector,
+  CompoundLockHeldError: () => CompoundLockHeldError,
   ConfidenceTierSchema: () => ConfidenceTierSchema,
   ConfirmationSchema: () => ConfirmationSchema,
   ConsoleSink: () => ConsoleSink,
@@ -2854,10 +2858,12 @@ __export(dist_exports, {
   HandoffSchema: () => HandoffSchema,
   HarnessStateSchema: () => HarnessStateSchema,
   InteractionTypeSchema: () => InteractionTypeSchema,
+  KNOWLEDGE_TRACK_CATEGORIES: () => KNOWLEDGE_TRACK_CATEGORIES,
   LITELLM_PRICING_URL: () => LITELLM_PRICING_URL,
   LayerViolationCollector: () => LayerViolationCollector,
   LockfilePackageSchema: () => LockfilePackageSchema,
   LockfileSchema: () => LockfileSchema,
+  MOCK_ADAPTER_NAME: () => MOCK_ADAPTER_NAME,
   ManifestSchema: () => ManifestSchema,
   MetricResultSchema: () => MetricResultSchema,
   ModuleSizeCollector: () => ModuleSizeCollector,
@@ -2866,6 +2872,9 @@ __export(dist_exports, {
   NoOpTelemetryAdapter: () => NoOpTelemetryAdapter,
   Ok: () => Ok,
   OpenAICacheAdapter: () => OpenAICacheAdapter,
+  PII_FIELD_DENYLIST: () => PII_FIELD_DENYLIST,
+  PII_LINE_RE: () => PII_LINE_RE,
+  PII_TOKENS: () => PII_TOKENS,
   PatternConfigSchema: () => PatternConfigSchema,
   PredictionEngine: () => PredictionEngine,
   PredictionOptionsSchema: () => PredictionOptionsSchema,
@@ -2873,6 +2882,10 @@ __export(dist_exports, {
   PredictionResultSchema: () => PredictionResultSchema,
   PredictionWarningSchema: () => PredictionWarningSchema,
   ProjectScanner: () => ProjectScanner,
+  PulseAdapterAlreadyRegisteredError: () => PulseAdapterAlreadyRegisteredError,
+  PulseConfigSchema: () => PulseConfigSchema,
+  PulseDbSourceSchema: () => PulseDbSourceSchema,
+  PulseSourcesSchema: () => PulseSourcesSchema,
   QuestionSchema: () => QuestionSchema,
   REQUIRED_SECTIONS: () => REQUIRED_SECTIONS,
   RegressionDetector: () => RegressionDetector,
@@ -2897,6 +2910,7 @@ __export(dist_exports, {
   SharableLayerSchema: () => SharableLayerSchema,
   SharableSecurityRulesSchema: () => SharableSecurityRulesSchema,
   SkillEventSchema: () => SkillEventSchema,
+  SolutionDocFrontmatterSchema: () => SolutionDocFrontmatterSchema,
   SpecImpactEstimateSchema: () => SpecImpactEstimateSchema,
   SpecImpactEstimator: () => SpecImpactEstimator,
   SpecImpactSignalsSchema: () => SpecImpactSignalsSchema,
@@ -2924,6 +2938,7 @@ __export(dist_exports, {
   ViolationHistorySchema: () => ViolationHistorySchema,
   ViolationSchema: () => ViolationSchema,
   ViolationSnapshotSchema: () => ViolationSnapshotSchema,
+  acquireCompoundLock: () => acquireCompoundLock,
   addProvenance: () => addProvenance,
   agentConfigRules: () => agentConfigRules,
   aggregateAdoptionByDay: () => aggregateByDay2,
@@ -2946,6 +2961,9 @@ __export(dist_exports, {
   archiveLearnings: () => archiveLearnings,
   archiveSession: () => archiveSession,
   archiveStream: () => archiveStream,
+  assembleCandidateReport: () => assembleCandidateReport,
+  assembleReport: () => assembleReport,
+  assertSanitized: () => assertSanitized,
   assignFeature: () => assignFeature,
   buildDependencyGraph: () => buildDependencyGraph,
   buildExclusionSet: () => buildExclusionSet,
@@ -2962,15 +2980,18 @@ __export(dist_exports, {
   clearEventHashCache: () => clearEventHashCache,
   clearFailuresCache: () => clearFailuresCache,
   clearLearningsCache: () => clearLearningsCache,
+  clearPulseAdapters: () => clearPulseAdapters,
   clearTaint: () => clearTaint,
   clusterViolations: () => clusterViolations,
   collectEvents: () => collectEvents,
   computeContentHash: () => computeContentHash,
+  computeHotspots: () => computeHotspots,
   computeLexicalSimilarity: () => computeLexicalSimilarity,
   computeLoadPlan: () => computeLoadPlan,
   computeOverallSeverity: () => computeOverallSeverity,
   computeScanExitCode: () => computeScanExitCode,
   computeTrustScores: () => computeTrustScores,
+  computeWindow: () => computeWindow,
   configureFeedback: () => configureFeedback,
   constraintRuleId: () => constraintRuleId,
   contextBudget: () => contextBudget,
@@ -2986,6 +3007,7 @@ __export(dist_exports, {
   createRegionMap: () => createRegionMap,
   createSelfReview: () => createSelfReview,
   createStream: () => createStream,
+  crossReferenceUndocumentedFixes: () => crossReferenceUndocumentedFixes,
   cryptoRules: () => cryptoRules,
   deduplicateCleanupFindings: () => deduplicateCleanupFindings,
   deduplicateFindings: () => deduplicateFindings,
@@ -3016,6 +3038,7 @@ __export(dist_exports, {
   extractBundle: () => extractBundle,
   extractDirectoryScope: () => extractDirectoryScope,
   extractFileReferences: () => extractFileReferences,
+  extractHeadlines: () => extractHeadlines,
   extractIndexEntry: () => extractIndexEntry,
   extractLevel: () => extractLevel,
   extractMarkdownLinks: () => extractMarkdownLinks,
@@ -3027,6 +3050,7 @@ __export(dist_exports, {
   formatFindingBlock: () => formatFindingBlock,
   formatGitHubComment: () => formatGitHubComment,
   formatGitHubSummary: () => formatGitHubSummary,
+  formatIsoWeek: () => formatIsoWeek,
   formatOutline: () => formatOutline,
   formatTerminalOutput: () => formatTerminalOutput,
   fullSync: () => fullSync,
@@ -3042,10 +3066,12 @@ __export(dist_exports, {
   getOutline: () => getOutline,
   getParser: () => getParser,
   getPhaseCategories: () => getPhaseCategories,
+  getPulseAdapter: () => getPulseAdapter,
   getStreamForBranch: () => getStreamForBranch,
   getTaintFilePath: () => getTaintFilePath,
   getTrustLevel: () => getTrustLevel,
   getUpdateNotification: () => getUpdateNotification,
+  gitScan: () => gitScan,
   goRules: () => goRules,
   injectionRules: () => injectionRules,
   insecureDefaultsRules: () => insecureDefaultsRules,
@@ -3053,9 +3079,12 @@ __export(dist_exports, {
   isErr: () => isErr,
   isOk: () => isOk,
   isRegression: () => isRegression,
+  isSanitizedResult: () => isSanitizedResult,
   isSmallSuggestion: () => isSmallSuggestion,
   isUpdateCheckEnabled: () => isUpdateCheckEnabled,
+  isoWeek: () => isoWeek,
   listActiveSessions: () => listActiveSessions,
+  listPulseAdapters: () => listPulseAdapters,
   listStreams: () => listStreams,
   listTaintedSessions: () => listTaintedSessions,
   loadBudgetedLearnings: () => loadBudgetedLearnings,
@@ -3089,6 +3118,7 @@ __export(dist_exports, {
   parseFrontmatter: () => parseFrontmatter2,
   parseHarnessIgnore: () => parseHarnessIgnore,
   parseLiteLLMData: () => parseLiteLLMData,
+  parseLookback: () => parseLookback,
   parseManifest: () => parseManifest,
   parseProtectedRegions: () => parseProtectedRegions,
   parseRoadmap: () => parseRoadmap,
@@ -3109,6 +3139,8 @@ __export(dist_exports, {
   readSessionSection: () => readSessionSection,
   readSessionSections: () => readSessionSections,
   readTaint: () => readTaint,
+  registerMockAdapter: () => registerMockAdapter,
+  registerPulseAdapter: () => registerPulseAdapter,
   removeContributions: () => removeContributions,
   removeProvenance: () => removeProvenance,
   requestMultiplePeerReviews: () => requestMultiplePeerReviews,
@@ -3134,6 +3166,7 @@ __export(dist_exports, {
   runMechanicalGate: () => runMechanicalGate,
   runMultiTurnPipeline: () => runMultiTurnPipeline,
   runPipeline: () => runPipeline,
+  runPulse: () => runPulse,
   runReviewPipeline: () => runReviewPipeline,
   runSecurityAgent: () => runSecurityAgent,
   saveHandoff: () => saveHandoff,
@@ -3145,6 +3178,7 @@ __export(dist_exports, {
   searchSymbols: () => searchSymbols,
   secretRules: () => secretRules,
   securityFindingId: () => securityFindingId,
+  seedFromStrategy: () => seedFromStrategy,
   send: () => send,
   serializeEnvelope: () => serializeEnvelope,
   serializeRoadmap: () => serializeRoadmap,
@@ -3154,6 +3188,7 @@ __export(dist_exports, {
   spawnBackgroundCheck: () => spawnBackgroundCheck,
   splitBundlesByStage: () => splitBundlesByStage,
   stageDomains: () => stageDomains,
+  suggestCategory: () => suggestCategory,
   syncConstraintNodes: () => syncConstraintNodes,
   syncFromExternal: () => syncFromExternal,
   syncRoadmap: () => syncRoadmap,
@@ -3176,164 +3211,188 @@ __export(dist_exports, {
   validateFindings: () => validateFindings,
   validateKnowledgeMap: () => validateKnowledgeMap,
   validatePatternConfig: () => validatePatternConfig,
+  validatePulseConfig: () => validatePulseConfig,
+  validateSolutionsDir: () => validateSolutionsDir,
   violationId: () => violationId,
   weeksUntilThreshold: () => weeksUntilThreshold,
   weightedLinearRegression: () => weightedLinearRegression,
   writeConfig: () => writeConfig,
   writeLockfile: () => writeLockfile,
+  writePulseConfig: () => writePulseConfig,
   writeSessionSummary: () => writeSessionSummary,
   writeTaint: () => writeTaint,
   xssRules: () => xssRules
 });
+import * as fs from "fs/promises";
+import * as path from "path";
+import { z as z2 } from "zod";
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import matter from "gray-matter";
+import { z as z22 } from "zod";
 import { spawn } from "child_process";
 import { existsSync as existsSync2 } from "fs";
-import { join as join4, isAbsolute } from "path";
+import { join as join32, isAbsolute } from "path";
 import { existsSync as existsSync22 } from "fs";
-import { join as join22 } from "path";
+import { join as join42 } from "path";
 import { readFileSync as readFileSync2, statSync } from "fs";
 import { glob as glob2 } from "glob";
 import { existsSync as existsSync3 } from "fs";
-import { isAbsolute as isAbsolute2, resolve as resolve3, join as join32 } from "path";
+import { isAbsolute as isAbsolute2, resolve as resolve3, join as join52 } from "path";
 import { glob as glob22 } from "glob";
 import { existsSync as existsSync4 } from "fs";
-import { basename, dirname as dirname4, join as join42 } from "path";
+import { basename, dirname as dirname4, join as join6 } from "path";
 import { existsSync as existsSync5 } from "fs";
-import { join as join5 } from "path";
-import { existsSync as existsSync6 } from "fs";
 import { join as join7 } from "path";
-import { join as join6, dirname as dirname22 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { join as join9 } from "path";
+import { join as join8, dirname as dirname22 } from "path";
 import { glob as glob3 } from "glob";
 import { existsSync as existsSync7 } from "fs";
 import { dirname as dirname32, resolve as resolve22, isAbsolute as isAbsolute3 } from "path";
 import { existsSync as existsSync8 } from "fs";
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 import { glob as glob4 } from "glob";
 import { existsSync as existsSync9 } from "fs";
-import { join as join9 } from "path";
+import { join as join11 } from "path";
 import { existsSync as existsSync10 } from "fs";
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 import { minimatch as minimatch2 } from "minimatch";
 import { basename as basename2 } from "path";
-import { join as join11, basename as basename3 } from "path";
+import { join as join13, basename as basename3 } from "path";
 import { basename as basename4, dirname as dirname42 } from "path";
-import { z as z2 } from "zod";
-import * as fs from "fs/promises";
-import * as fs2 from "fs/promises";
-import { join as join12, resolve as resolve32 } from "path";
+import { z as z3 } from "zod";
+import * as fs3 from "fs/promises";
+import * as fs4 from "fs/promises";
+import { join as join14, resolve as resolve32 } from "path";
 import { minimatch as minimatch22 } from "minimatch";
 import { dirname as dirname5, resolve as resolve4 } from "path";
 import { dirname as dirname6, resolve as resolve5 } from "path";
 import { minimatch as minimatch3 } from "minimatch";
 import { readdirSync, statSync as statSync2 } from "fs";
-import { join as join13 } from "path";
-import * as fs3 from "fs";
+import { join as join15 } from "path";
+import * as fs5 from "fs";
 import { promisify as promisify2 } from "util";
-import { dirname as dirname7, basename as basename5, join as join14 } from "path";
-import { z as z22 } from "zod";
+import { dirname as dirname7, basename as basename5, join as join16 } from "path";
+import { z as z4 } from "zod";
 import { readFileSync as readFileSync22, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync11 } from "fs";
-import { join as join15, dirname as dirname8 } from "path";
+import { join as join17, dirname as dirname8 } from "path";
 import { execFileSync } from "child_process";
-import * as fs4 from "fs";
-import * as path from "path";
+import * as fs6 from "fs";
+import * as path3 from "path";
 import { appendFileSync, writeFileSync as writeFileSync22, existsSync as existsSync12, mkdirSync as mkdirSync22 } from "fs";
 import { dirname as dirname9 } from "path";
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync as renameSync2, mkdirSync as mkdirSync3, existsSync as existsSync13 } from "fs";
 import { randomBytes as randomBytes2 } from "crypto";
-import { join as join17, dirname as dirname10 } from "path";
-import { z as z4 } from "zod";
-import * as fs5 from "fs";
-import * as path2 from "path";
-import * as fs6 from "fs";
-import * as path3 from "path";
+import { join as join19, dirname as dirname10 } from "path";
+import { z as z6 } from "zod";
 import * as fs7 from "fs";
 import * as path4 from "path";
-import { z as z5 } from "zod";
-import * as fs11 from "fs";
-import * as path8 from "path";
-import * as fs10 from "fs";
-import * as path7 from "path";
 import * as fs8 from "fs";
 import * as path5 from "path";
-import { execSync } from "child_process";
-import { z as z6 } from "zod";
 import * as fs9 from "fs";
 import * as path6 from "path";
-import * as fs12 from "fs";
-import * as path9 from "path";
-import * as crypto2 from "crypto";
+import { z as z7 } from "zod";
 import * as fs13 from "fs";
 import * as path10 from "path";
+import * as fs12 from "fs";
+import * as path9 from "path";
+import * as fs10 from "fs";
+import * as path7 from "path";
+import { execSync } from "child_process";
+import { z as z8 } from "zod";
+import * as fs11 from "fs";
+import * as path8 from "path";
 import * as fs14 from "fs";
 import * as path11 from "path";
-import * as crypto3 from "crypto";
+import * as crypto2 from "crypto";
 import * as fs15 from "fs";
 import * as path12 from "path";
 import * as fs16 from "fs";
 import * as path13 from "path";
+import * as crypto3 from "crypto";
 import * as fs17 from "fs";
 import * as path14 from "path";
 import * as fs18 from "fs";
 import * as path15 from "path";
 import * as fs19 from "fs";
 import * as path16 from "path";
-import { execSync as execSync2 } from "child_process";
 import * as fs20 from "fs";
 import * as path17 from "path";
 import * as fs21 from "fs";
 import * as path18 from "path";
+import { execSync as execSync2 } from "child_process";
 import * as fs22 from "fs";
 import * as path19 from "path";
 import * as fs23 from "fs";
 import * as path20 from "path";
-import { z as z7 } from "zod";
-import * as fs25 from "fs/promises";
-import { minimatch as minimatch4 } from "minimatch";
-import { z as z8 } from "zod";
 import * as fs24 from "fs";
 import * as path21 from "path";
+import * as fs25 from "fs";
+import * as path22 from "path";
+import { z as z9 } from "zod";
+import * as fs27 from "fs/promises";
+import { minimatch as minimatch4 } from "minimatch";
+import { z as z10 } from "zod";
+import * as fs26 from "fs";
+import * as path23 from "path";
 import { readFileSync as readFileSync222, writeFileSync as writeFileSync15, unlinkSync as unlinkSync2, mkdirSync as mkdirSync14, readdirSync as readdirSync3 } from "fs";
-import { join as join362, dirname as dirname12 } from "path";
+import { join as join382, dirname as dirname12 } from "path";
 import { createHash as createHash32 } from "crypto";
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 import { readFileSync as readFileSync23, writeFileSync as writeFileSync16, renameSync as renameSync82, mkdirSync as mkdirSync15, existsSync as existsSync332 } from "fs";
 import { execSync as execSync3 } from "child_process";
 import { randomBytes as randomBytes22 } from "crypto";
-import { join as join372, dirname as dirname13 } from "path";
-import * as path22 from "path";
-import * as path23 from "path";
+import { join as join39, dirname as dirname13 } from "path";
 import * as path24 from "path";
 import * as path25 from "path";
-import * as fs26 from "fs";
 import * as path26 from "path";
-import * as fs27 from "fs";
 import * as path27 from "path";
 import * as fs28 from "fs";
-import { z as z10 } from "zod";
-import * as fs29 from "fs/promises";
 import * as path28 from "path";
-import * as fs30 from "fs/promises";
+import * as fs29 from "fs";
 import * as path29 from "path";
-import * as ejs from "ejs";
-import * as fs31 from "fs";
+import * as fs30 from "fs";
+import { z as z12 } from "zod";
+import * as fs31 from "fs/promises";
 import * as path30 from "path";
-import * as os from "os";
-import { spawn as spawn2 } from "child_process";
 import * as fs32 from "fs/promises";
 import * as path31 from "path";
+import * as ejs from "ejs";
 import * as fs33 from "fs";
 import * as path32 from "path";
-import * as fs34 from "fs";
+import * as os from "os";
+import { spawn as spawn2 } from "child_process";
+import * as fs34 from "fs/promises";
 import * as path33 from "path";
-import * as os2 from "os";
 import * as fs35 from "fs";
 import * as path34 from "path";
+import * as fs36 from "fs";
+import * as path35 from "path";
+import * as os2 from "os";
 import * as fs37 from "fs";
 import * as path36 from "path";
+import * as fs39 from "fs";
+import * as path38 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
-import * as fs36 from "fs";
-import * as path35 from "path";
+import * as fs38 from "fs";
+import * as path37 from "path";
 import * as crypto4 from "crypto";
+import * as fs40 from "fs";
+import * as path39 from "path";
+import * as fs41 from "fs";
+import * as fs42 from "fs";
+import * as path40 from "path";
+import { readFileSync as readFileSync36 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname18, join as join572 } from "path";
+import { execFile } from "child_process";
+import { promisify as promisify22 } from "util";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify3 } from "util";
+import * as fs43 from "fs/promises";
+import * as path41 from "path";
 async function validateFileStructure(projectPath, conventions) {
   const missing = [];
   const unexpected = [];
@@ -3369,15 +3428,15 @@ function validateConfig(data, schema) {
   let message = "Configuration validation failed";
   const suggestions = [];
   if (firstError) {
-    const path37 = firstError.path.join(".");
-    const pathDisplay = path37 ? ` at "${path37}"` : "";
+    const path42 = firstError.path.join(".");
+    const pathDisplay = path42 ? ` at "${path42}"` : "";
     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 "${path37}" is required and must be of type "${expected}"`);
+        suggestions.push(`Field "${path42}" is required and must be of type "${expected}"`);
       } else {
         code = "INVALID_TYPE";
         message = `Invalid type${pathDisplay}: ${firstError.message}`;
@@ -3487,6 +3546,82 @@ function validateConventionalCommit(message) {
     issues: []
   });
 }
+async function validatePulseConfig(cwd) {
+  const configPath = path.join(cwd, "harness.config.json");
+  let raw;
+  try {
+    raw = await fs.readFile(configPath, "utf-8");
+  } catch {
+    return Ok({ present: false, valid: true });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    return Err(
+      createError(
+        "VALIDATION_FAILED",
+        `harness.config.json is not valid JSON: ${e.message}`,
+        {},
+        []
+      )
+    );
+  }
+  if (!("pulse" in parsed)) return Ok({ present: false, valid: true });
+  const result = validateConfig(parsed.pulse, PulseConfigSchema);
+  if (!result.ok) return Err(result.error);
+  return Ok({ present: true, valid: true });
+}
+async function* walk2(dir) {
+  let entries;
+  try {
+    entries = await fs2.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    const p = path2.join(dir, e.name);
+    if (e.isDirectory()) yield* walk2(p);
+    else if (e.isFile() && e.name.endsWith(".md")) yield p;
+  }
+}
+async function validateSolutionsDir(cwd) {
+  const root = path2.join(cwd, "docs", "solutions");
+  try {
+    await fs2.stat(root);
+  } catch {
+    return Ok({ filesChecked: 0, issues: [] });
+  }
+  const issues = [];
+  let count = 0;
+  for (const [track, categories] of TRACK_CATEGORIES) {
+    for (const category of categories) {
+      const categoryDir = path2.join(root, track, category);
+      for await (const file of walk2(categoryDir)) {
+        count++;
+        const raw = await fs2.readFile(file, "utf-8");
+        const parsed = matter(raw);
+        const result = validateConfig(parsed.data, SolutionDocFrontmatterSchema);
+        if (!result.ok)
+          issues.push({
+            file: path2.relative(cwd, file).replaceAll("\\", "/"),
+            message: result.error.message
+          });
+      }
+    }
+  }
+  if (issues.length > 0) {
+    return Err(
+      createError(
+        "VALIDATION_FAILED",
+        `${issues.length} solution doc(s) failed frontmatter validation`,
+        { issues },
+        []
+      )
+    );
+  }
+  return Ok({ filesChecked: count, issues: [] });
+}
 function resolveAgnixBinary(explicit) {
   if (explicit) return existsSync2(explicit) ? explicit : null;
   const fromEnv = process.env[HARNESS_AGNIX_BIN];
@@ -3507,7 +3642,7 @@ function lookupOnPath() {
 function firstExistingIn(dir, candidates) {
   if (!dir) return null;
   for (const name of candidates) {
-    const candidate = isAbsolute(dir) ? join4(dir, name) : join4(process.cwd(), dir, name);
+    const candidate = isAbsolute(dir) ? join32(dir, name) : join32(process.cwd(), dir, name);
     if (existsSync2(candidate)) return candidate;
   }
   return null;
@@ -3584,7 +3719,7 @@ function extractDiagnostics(parsed) {
 }
 function normalizeDiagnostic(diag, cwd) {
   const finding = {
-    file: normalizeFilePath(readFile10(diag), cwd),
+    file: normalizeFilePath(readFile32(diag), cwd),
     ruleId: readRuleId(diag),
     severity: normalizeSeverity(readSeverity(diag)),
     message: diag.message ?? "agnix diagnostic"
@@ -3592,7 +3727,7 @@ function normalizeDiagnostic(diag, cwd) {
   attachOptionalFields(finding, diag);
   return finding;
 }
-function readFile10(diag) {
+function readFile32(diag) {
   return diag.file ?? diag.path ?? "";
 }
 function readRuleId(diag) {
@@ -3635,16 +3770,16 @@ function makeFinding(input) {
   if (input.suggestion) finding.suggestion = input.suggestion;
   return finding;
 }
-function readTextSafe(path37) {
+function readTextSafe(path42) {
   try {
-    return readFileSync2(path37, "utf-8");
+    return readFileSync2(path42, "utf-8");
   } catch {
     return null;
   }
 }
-function safeFileSize(path37) {
+function safeFileSize(path42) {
   try {
-    return statSync(path37).size;
+    return statSync(path42).size;
   } catch {
     return null;
   }
@@ -3681,7 +3816,7 @@ function stripQuotes(value) {
 function runClaudeMdRules(cwd) {
   const findings = [];
   for (const name of CONTEXT_FILES) {
-    const abs = join22(cwd, name);
+    const abs = join42(cwd, name);
     if (!existsSync22(abs)) continue;
     findings.push(...inspectContextFile(abs, name));
   }
@@ -3828,7 +3963,7 @@ function appendDescriptionFindings(out, rel, description) {
 function runHookRules(cwd) {
   const findings = [];
   for (const rel of SETTINGS_PATHS) {
-    const abs = join32(cwd, rel);
+    const abs = join52(cwd, rel);
     if (!existsSync3(abs)) continue;
     const content = readTextSafe(abs);
     if (content === null) continue;
@@ -3944,7 +4079,7 @@ async function runSkillRules(cwd) {
   for (const abs of skillFiles) {
     const rel = relPath(cwd, abs);
     const dirName = basename(dirname4(abs));
-    const siblingYaml = join42(dirname4(abs), "skill.yaml");
+    const siblingYaml = join6(dirname4(abs), "skill.yaml");
     if (existsSync4(siblingYaml)) {
       const yamlFields = parseFrontmatterFields(readTextSafe(siblingYaml) ?? "");
       findings.push(...checkSkillMetadata(relPath(cwd, siblingYaml), dirName, yamlFields));
@@ -4050,7 +4185,7 @@ function runMcpRules(cwd) {
   return findings;
 }
 function loadMcpServers(cwd, rel) {
-  const abs = join5(cwd, rel);
+  const abs = join7(cwd, rel);
   if (!existsSync5(abs)) return null;
   const content = readTextSafe(abs);
   if (content === null) return null;
@@ -4189,27 +4324,27 @@ function extractSections(content) {
   }
   return sections.map((section) => buildAgentMapSection(section, lines));
 }
-function isExternalLink(path37) {
-  return path37.startsWith("http://") || path37.startsWith("https://") || path37.startsWith("#") || path37.startsWith("mailto:");
+function isExternalLink(path42) {
+  return path42.startsWith("http://") || path42.startsWith("https://") || path42.startsWith("#") || path42.startsWith("mailto:");
 }
 function resolveLinkPath(linkPath, baseDir) {
-  return linkPath.startsWith(".") ? join6(baseDir, linkPath) : linkPath;
+  return linkPath.startsWith(".") ? join8(baseDir, linkPath) : linkPath;
 }
-async function validateAgentsMap(path37 = "./AGENTS.md") {
-  const contentResult = await readFileContent(path37);
+async function validateAgentsMap(path42 = "./AGENTS.md") {
+  const contentResult = await readFileContent(path42);
   if (!contentResult.ok) {
     return Err(
       createError(
         "PARSE_ERROR",
         `Failed to read AGENTS.md: ${contentResult.error.message}`,
-        { path: path37 },
+        { path: path42 },
         ["Ensure the file exists", "Check file permissions"]
       )
     );
   }
   const content = contentResult.value;
   const sections = extractSections(content);
-  const baseDir = dirname22(path37);
+  const baseDir = dirname22(path42);
   const sectionTitles = sections.map((s) => s.title);
   const missingSections = REQUIRED_SECTIONS.filter(
     (required) => !sectionTitles.some((title) => title.toLowerCase().includes(required.toLowerCase()))
@@ -4248,7 +4383,7 @@ async function validateAgentsMap(path37 = "./AGENTS.md") {
   });
 }
 async function runAgentsMdRules(cwd) {
-  const abs = join7(cwd, "AGENTS.md");
+  const abs = join9(cwd, "AGENTS.md");
   if (!existsSync6(abs)) return [];
   const result = await validateAgentsMap(abs);
   if (result.ok) return [];
@@ -4305,7 +4440,7 @@ function extractLinkTargets(content) {
 function runSettingsJsonRules(cwd) {
   const findings = [];
   for (const rel of SETTINGS_FILES) {
-    const abs = join8(cwd, rel);
+    const abs = join10(cwd, rel);
     if (!existsSync8(abs)) continue;
     const content = readTextSafe(abs);
     if (content === null) continue;
@@ -4381,15 +4516,15 @@ function stripQuotes2(value) {
   return value;
 }
 function skillExists(cwd, slug) {
-  if (existsSync9(join9(cwd, "agents", "skills", slug, "SKILL.md"))) return true;
+  if (existsSync9(join11(cwd, "agents", "skills", slug, "SKILL.md"))) return true;
   for (const platform of ["claude-code", "gemini-cli", "codex", "cursor", "shared"]) {
-    if (existsSync9(join9(cwd, "agents", "skills", platform, slug, "SKILL.md"))) return true;
+    if (existsSync9(join11(cwd, "agents", "skills", platform, slug, "SKILL.md"))) return true;
   }
   return false;
 }
 function runAgnixTomlRules(cwd) {
   const rel = ".agnix.toml";
-  const abs = join10(cwd, rel);
+  const abs = join12(cwd, rel);
   if (!existsSync10(abs)) return [];
   const content = readTextSafe(abs);
   if (content === null) return [];
@@ -4649,8 +4784,8 @@ async function checkDocCoverage(domain, options = {}) {
     );
   }
 }
-function suggestFix(path37, existingFiles) {
-  const targetName = basename3(path37).toLowerCase();
+function suggestFix(path42, existingFiles) {
+  const targetName = basename3(path42).toLowerCase();
   const similar = existingFiles.find((file) => {
     const fileName = basename3(file).toLowerCase();
     return fileName.includes(targetName) || targetName.includes(fileName);
@@ -4658,10 +4793,10 @@ function suggestFix(path37, existingFiles) {
   if (similar) {
     return `Did you mean "${similar}"?`;
   }
-  return `Create the file "${path37}" or remove the link`;
+  return `Create the file "${path42}" or remove the link`;
 }
 async function validateKnowledgeMap(rootDir = process.cwd()) {
-  const agentsPath = join11(rootDir, "AGENTS.md");
+  const agentsPath = join13(rootDir, "AGENTS.md");
   const agentsResult = await validateAgentsMap(agentsPath);
   if (!agentsResult.ok) {
     return Err(agentsResult.error);
@@ -5016,8 +5151,8 @@ function createBoundaryValidator(schema, name) {
         return Ok(result.data);
       }
       const suggestions = result.error.issues.map((issue) => {
-        const path37 = issue.path.join(".");
-        return path37 ? `${path37}: ${issue.message}` : issue.message;
+        const path42 = issue.path.join(".");
+        return path42 ? `${path42}: ${issue.message}` : issue.message;
       });
       return Err(
         createError(
@@ -5063,7 +5198,7 @@ function validateBoundaries(boundaries, data) {
 async function writeConfig(filePath, content) {
   try {
     const json = JSON.stringify(content, null, 2) + "\n";
-    await fs.writeFile(filePath, json, "utf-8");
+    await fs3.writeFile(filePath, json, "utf-8");
     return Ok(void 0);
   } catch (error) {
     return Err(error instanceof Error ? error : new Error(String(error)));
@@ -5337,7 +5472,7 @@ function deepMergeConstraints(localConfig, bundleConstraints, _existingContribut
 async function readLockfile(lockfilePath) {
   let raw;
   try {
-    raw = await fs2.readFile(lockfilePath, "utf-8");
+    raw = await fs4.readFile(lockfilePath, "utf-8");
   } catch (err) {
     if (isNodeError(err) && err.code === "ENOENT") {
       return { ok: true, value: null };
@@ -5640,7 +5775,7 @@ async function resolveEntryPoints(rootDir, explicitEntries) {
   if (explicitEntries && explicitEntries.length > 0) {
     return Ok(explicitEntries.map((e) => resolve32(rootDir, e)));
   }
-  const pkgPath = join12(rootDir, "package.json");
+  const pkgPath = join14(rootDir, "package.json");
   if (await fileExists(pkgPath)) {
     const pkgContent = await readFileContent(pkgPath);
     if (pkgContent.ok) {
@@ -5654,7 +5789,7 @@ async function resolveEntryPoints(rootDir, explicitEntries) {
   }
   const conventions = ["src/index.ts", "src/main.ts", "index.ts", "main.ts"];
   for (const conv of conventions) {
-    const convPath = join12(rootDir, conv);
+    const convPath = join14(rootDir, conv);
     if (await fileExists(convPath)) {
       return Ok([convPath]);
     }
@@ -5721,22 +5856,22 @@ function extractInlineRefs(content) {
   }
   return refs;
 }
-async function parseDocumentationFile(path37) {
-  const contentResult = await readFileContent(path37);
+async function parseDocumentationFile(path42) {
+  const contentResult = await readFileContent(path42);
   if (!contentResult.ok) {
     return Err(
       createEntropyError(
         "PARSE_ERROR",
-        `Failed to read documentation file: ${path37}`,
-        { file: path37 },
+        `Failed to read documentation file: ${path42}`,
+        { file: path42 },
         ["Check that the file exists"]
       )
     );
   }
   const content = contentResult.value;
-  const type = path37.endsWith(".md") ? "markdown" : "text";
+  const type = path42.endsWith(".md") ? "markdown" : "text";
   return Ok({
-    path: path37,
+    path: path42,
     type,
     content,
     codeBlocks: extractCodeBlocks(content),
@@ -6635,13 +6770,13 @@ function dirSize(dirPath) {
   }
   for (const entry of entries) {
     if (entry === "node_modules" || entry === ".git") continue;
-    const fullPath = join13(dirPath, entry);
+    const fullPath = join15(dirPath, entry);
     try {
-      const stat = statSync2(fullPath);
-      if (stat.isDirectory()) {
+      const stat2 = statSync2(fullPath);
+      if (stat2.isDirectory()) {
         total += dirSize(fullPath);
-      } else if (stat.isFile()) {
-        total += stat.size;
+      } else if (stat2.isFile()) {
+        total += stat2.size;
       }
     } catch {
       continue;
@@ -6655,7 +6790,7 @@ async function detectSizeBudgetViolations(rootDir, config) {
   let packagesChecked = 0;
   for (const [pkgPath, budget] of Object.entries(budgets)) {
     packagesChecked++;
-    const distPath = join13(rootDir, pkgPath, "dist");
+    const distPath = join15(rootDir, pkgPath, "dist");
     const currentSize = dirSize(distPath);
     if (budget.warn) {
       const budgetBytes = parseSize(budget.warn);
@@ -6899,7 +7034,7 @@ function previewFix(fix) {
   }
 }
 async function createBackup(filePath, backupDir) {
-  const backupPath = join14(backupDir, `${Date.now()}-${basename5(filePath)}`);
+  const backupPath = join16(backupDir, `${Date.now()}-${basename5(filePath)}`);
   try {
     await mkdir22(dirname7(backupPath), { recursive: true });
     await copyFile2(filePath, backupPath);
@@ -6925,7 +7060,7 @@ async function applyDeleteFile(fix, config) {
 }
 async function applyDeleteLines(fix) {
   if (fix.line !== void 0) {
-    const content = await readFile42(fix.file, "utf-8");
+    const content = await readFile62(fix.file, "utf-8");
     const lines = content.split("\n");
     lines.splice(fix.line - 1, 1);
     await writeFile32(fix.file, lines.join("\n"));
@@ -6933,13 +7068,13 @@ async function applyDeleteLines(fix) {
 }
 async function applyReplace(fix) {
   if (fix.oldContent && fix.newContent !== void 0) {
-    const content = await readFile42(fix.file, "utf-8");
+    const content = await readFile62(fix.file, "utf-8");
     await writeFile32(fix.file, content.replace(fix.oldContent, fix.newContent));
   }
 }
 async function applyInsert(fix) {
   if (fix.line !== void 0 && fix.newContent) {
-    const content = await readFile42(fix.file, "utf-8");
+    const content = await readFile62(fix.file, "utf-8");
     const lines = content.split("\n");
     lines.splice(fix.line - 1, 0, fix.newContent);
     await writeFile32(fix.file, lines.join("\n"));
@@ -7274,12 +7409,12 @@ function parseDiffHeader(part) {
   return headerMatch[2];
 }
 function parseDiffPart(part) {
-  const path37 = parseDiffHeader(part);
-  if (!path37) return null;
+  const path42 = parseDiffHeader(part);
+  if (!path42) return null;
   const additionRegex = /^\+(?!\+\+)/gm;
   const deletionRegex = /^-(?!--)/gm;
   return {
-    path: path37,
+    path: path42,
     status: detectFileStatus(part),
     additions: (part.match(additionRegex) || []).length,
     deletions: (part.match(deletionRegex) || []).length
@@ -8064,10 +8199,10 @@ function detectEmergentConstraints(history, options) {
   return { suggestions, totalViolationsAnalyzed, windowWeeks, minOccurrences };
 }
 function streamsDir(projectPath) {
-  return path5.join(projectPath, HARNESS_DIR, STREAMS_DIR);
+  return path7.join(projectPath, HARNESS_DIR, STREAMS_DIR);
 }
 function indexPath(projectPath) {
-  return path5.join(streamsDir(projectPath), INDEX_FILE);
+  return path7.join(streamsDir(projectPath), INDEX_FILE);
 }
 function validateStreamName(name) {
   if (!STREAM_NAME_REGEX.test(name)) {
@@ -8081,11 +8216,11 @@ function validateStreamName(name) {
 }
 async function loadStreamIndex(projectPath) {
   const idxPath = indexPath(projectPath);
-  if (!fs8.existsSync(idxPath)) {
+  if (!fs10.existsSync(idxPath)) {
     return Ok({ ...DEFAULT_STREAM_INDEX, streams: {} });
   }
   try {
-    const raw = fs8.readFileSync(idxPath, "utf-8");
+    const raw = fs10.readFileSync(idxPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = StreamIndexSchema.safeParse(parsed);
     if (!result.success) {
@@ -8103,8 +8238,8 @@ async function loadStreamIndex(projectPath) {
 async function saveStreamIndex(projectPath, index) {
   const dir = streamsDir(projectPath);
   try {
-    fs8.mkdirSync(dir, { recursive: true });
-    fs8.writeFileSync(indexPath(projectPath), JSON.stringify(index, null, 2));
+    fs10.mkdirSync(dir, { recursive: true });
+    fs10.writeFileSync(indexPath(projectPath), JSON.stringify(index, null, 2));
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -8143,18 +8278,18 @@ async function resolveStreamPath(projectPath, options) {
         )
       );
     }
-    return Ok(path5.join(streamsDir(projectPath), options.stream));
+    return Ok(path7.join(streamsDir(projectPath), options.stream));
   }
   const branch = getCurrentBranch(projectPath);
   if (branch && branch !== "main" && branch !== "master") {
     for (const [name, info] of Object.entries(index.streams)) {
       if (info.branch === branch) {
-        return Ok(path5.join(streamsDir(projectPath), name));
+        return Ok(path7.join(streamsDir(projectPath), name));
       }
     }
   }
   if (index.activeStream && index.streams[index.activeStream]) {
-    return Ok(path5.join(streamsDir(projectPath), index.activeStream));
+    return Ok(path7.join(streamsDir(projectPath), index.activeStream));
   }
   return Err(
     new Error(
@@ -8182,9 +8317,9 @@ async function createStream(projectPath, name, branch) {
   if (index.streams[name]) {
     return Err(new Error(`Stream '${name}' already exists`));
   }
-  const streamPath = path5.join(streamsDir(projectPath), name);
+  const streamPath = path7.join(streamsDir(projectPath), name);
   try {
-    fs8.mkdirSync(streamPath, { recursive: true });
+    fs10.mkdirSync(streamPath, { recursive: true });
   } catch (error) {
     return Err(
       new Error(
@@ -8225,12 +8360,12 @@ async function archiveStream(projectPath, name) {
   if (!index.streams[name]) {
     return Err(new Error(`Stream '${name}' not found`));
   }
-  const streamPath = path5.join(streamsDir(projectPath), name);
-  const archiveDir = path5.join(projectPath, HARNESS_DIR, "archive", "streams");
+  const streamPath = path7.join(streamsDir(projectPath), name);
+  const archiveDir = path7.join(projectPath, HARNESS_DIR, "archive", "streams");
   try {
-    fs8.mkdirSync(archiveDir, { recursive: true });
+    fs10.mkdirSync(archiveDir, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    fs8.renameSync(streamPath, path5.join(archiveDir, `${name}-${date}`));
+    fs10.renameSync(streamPath, path7.join(archiveDir, `${name}-${date}`));
   } catch (error) {
     return Err(
       new Error(
@@ -8251,19 +8386,19 @@ function getStreamForBranch(index, branch) {
   return null;
 }
 async function migrateToStreams(projectPath) {
-  const harnessDir = path5.join(projectPath, HARNESS_DIR);
-  if (fs8.existsSync(indexPath(projectPath))) {
+  const harnessDir = path7.join(projectPath, HARNESS_DIR);
+  if (fs10.existsSync(indexPath(projectPath))) {
     return Ok(void 0);
   }
-  const filesToMove = STATE_FILES.filter((f) => fs8.existsSync(path5.join(harnessDir, f)));
+  const filesToMove = STATE_FILES.filter((f) => fs10.existsSync(path7.join(harnessDir, f)));
   if (filesToMove.length === 0) {
     return Ok(void 0);
   }
-  const defaultDir = path5.join(streamsDir(projectPath), "default");
+  const defaultDir = path7.join(streamsDir(projectPath), "default");
   try {
-    fs8.mkdirSync(defaultDir, { recursive: true });
+    fs10.mkdirSync(defaultDir, { recursive: true });
     for (const file of filesToMove) {
-      fs8.renameSync(path5.join(harnessDir, file), path5.join(defaultDir, file));
+      fs10.renameSync(path7.join(harnessDir, file), path7.join(defaultDir, file));
     }
   } catch (error) {
     return Err(
@@ -8293,26 +8428,26 @@ function resolveSessionDir(projectPath, sessionSlug, options) {
       new Error(`Invalid session slug '${sessionSlug}': must not contain path traversal characters`)
     );
   }
-  const sessionDir = path6.join(projectPath, HARNESS_DIR, SESSIONS_DIR, sessionSlug);
+  const sessionDir = path8.join(projectPath, HARNESS_DIR, SESSIONS_DIR, sessionSlug);
   if (options?.create) {
-    fs9.mkdirSync(sessionDir, { recursive: true });
+    fs11.mkdirSync(sessionDir, { recursive: true });
   }
   return Ok(sessionDir);
 }
 function updateSessionIndex(projectPath, sessionSlug, description) {
-  const sessionsDir = path6.join(projectPath, HARNESS_DIR, SESSIONS_DIR);
-  fs9.mkdirSync(sessionsDir, { recursive: true });
-  const indexPath2 = path6.join(sessionsDir, SESSION_INDEX_FILE);
+  const sessionsDir = path8.join(projectPath, HARNESS_DIR, SESSIONS_DIR);
+  fs11.mkdirSync(sessionsDir, { recursive: true });
+  const indexPath2 = path8.join(sessionsDir, SESSION_INDEX_FILE);
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const newLine = `- [${sessionSlug}](${sessionSlug}/summary.md) \u2014 ${description} (${date})`;
-  if (!fs9.existsSync(indexPath2)) {
-    fs9.writeFileSync(indexPath2, `## Active Sessions
+  if (!fs11.existsSync(indexPath2)) {
+    fs11.writeFileSync(indexPath2, `## Active Sessions
 
 ${newLine}
 `);
     return;
   }
-  const content = fs9.readFileSync(indexPath2, "utf-8");
+  const content = fs11.readFileSync(indexPath2, "utf-8");
   const lines = content.split("\n");
   const slugPattern = `- [${sessionSlug}]`;
   const existingIdx = lines.findIndex((l) => l.startsWith(slugPattern));
@@ -8322,7 +8457,7 @@ ${newLine}
     const lastNonEmpty = lines.reduce((last, line, i) => line.trim() !== "" ? i : last, 0);
     lines.splice(lastNonEmpty + 1, 0, newLine);
   }
-  fs9.writeFileSync(indexPath2, lines.join("\n"));
+  fs11.writeFileSync(indexPath2, lines.join("\n"));
 }
 function evictIfNeeded(map) {
   if (map.size > MAX_CACHE_ENTRIES) {
@@ -8335,8 +8470,8 @@ async function getStateDir(projectPath, stream, session) {
     const sessionResult = resolveSessionDir(projectPath, session, { create: true });
     return sessionResult;
   }
-  const streamsIndexPath = path7.join(projectPath, HARNESS_DIR, "streams", INDEX_FILE);
-  const hasStreams = fs10.existsSync(streamsIndexPath);
+  const streamsIndexPath = path9.join(projectPath, HARNESS_DIR, "streams", INDEX_FILE);
+  const hasStreams = fs12.existsSync(streamsIndexPath);
   if (stream || hasStreams) {
     const result = await resolveStreamPath(projectPath, stream ? { stream } : void 0);
     if (result.ok) {
@@ -8346,18 +8481,18 @@ async function getStateDir(projectPath, stream, session) {
       return result;
     }
   }
-  return Ok(path7.join(projectPath, HARNESS_DIR));
+  return Ok(path9.join(projectPath, HARNESS_DIR));
 }
 async function loadState(projectPath, stream, session) {
   try {
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const statePath = path8.join(stateDir, STATE_FILE);
-    if (!fs11.existsSync(statePath)) {
+    const statePath = path10.join(stateDir, STATE_FILE);
+    if (!fs13.existsSync(statePath)) {
       return Ok({ ...DEFAULT_STATE });
     }
-    const raw = fs11.readFileSync(statePath, "utf-8");
+    const raw = fs13.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = HarnessStateSchema.safeParse(parsed);
     if (!result.success) {
@@ -8375,11 +8510,11 @@ async function saveState(projectPath, state, stream, session) {
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const statePath = path8.join(stateDir, STATE_FILE);
-    fs11.mkdirSync(stateDir, { recursive: true });
+    const statePath = path10.join(stateDir, STATE_FILE);
+    fs13.mkdirSync(stateDir, { recursive: true });
     const tmpPath = statePath + ".tmp";
-    fs11.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
-    fs11.renameSync(tmpPath, statePath);
+    fs13.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
+    fs13.renameSync(tmpPath, statePath);
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -8465,10 +8600,10 @@ function computeContentHash(text) {
   return crypto2.createHash("sha256").update(text).digest("hex").slice(0, 16);
 }
 function loadContentHashes(stateDir) {
-  const hashesPath = path9.join(stateDir, CONTENT_HASHES_FILE);
-  if (!fs12.existsSync(hashesPath)) return {};
+  const hashesPath = path11.join(stateDir, CONTENT_HASHES_FILE);
+  if (!fs14.existsSync(hashesPath)) return {};
   try {
-    const raw = fs12.readFileSync(hashesPath, "utf-8");
+    const raw = fs14.readFileSync(hashesPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
     return parsed;
@@ -8477,15 +8612,15 @@ function loadContentHashes(stateDir) {
   }
 }
 function saveContentHashes(stateDir, index) {
-  const hashesPath = path9.join(stateDir, CONTENT_HASHES_FILE);
+  const hashesPath = path11.join(stateDir, CONTENT_HASHES_FILE);
   const tmpPath = hashesPath + ".tmp";
-  fs12.writeFileSync(tmpPath, JSON.stringify(index, null, 2) + "\n");
-  fs12.renameSync(tmpPath, hashesPath);
+  fs14.writeFileSync(tmpPath, JSON.stringify(index, null, 2) + "\n");
+  fs14.renameSync(tmpPath, hashesPath);
 }
 function rebuildContentHashes(stateDir, learningsFile) {
-  const learningsPath = path9.join(stateDir, learningsFile);
-  if (!fs12.existsSync(learningsPath)) return {};
-  const content = fs12.readFileSync(learningsPath, "utf-8");
+  const learningsPath = path11.join(stateDir, learningsFile);
+  if (!fs14.existsSync(learningsPath)) return {};
+  const content = fs14.readFileSync(learningsPath, "utf-8");
   const lines = content.split("\n");
   const index = {};
   for (let i = 0; i < lines.length; i++) {
@@ -8544,18 +8679,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 = path10.join(stateDir, LEARNINGS_FILE);
-    if (!fs13.existsSync(learningsPath)) {
+    const learningsPath = path12.join(stateDir, LEARNINGS_FILE);
+    if (!fs15.existsSync(learningsPath)) {
       return Ok([]);
     }
-    const stats = fs13.statSync(learningsPath);
+    const stats = fs15.statSync(learningsPath);
     const cacheKey = learningsPath;
     const cached = learningsCacheMap.get(cacheKey);
     let entries;
     if (cached && cached.mtimeMs === stats.mtimeMs) {
       entries = cached.entries;
     } else {
-      const content = fs13.readFileSync(learningsPath, "utf-8");
+      const content = fs15.readFileSync(learningsPath, "utf-8");
       const lines = content.split("\n");
       entries = [];
       let currentBlock = [];
@@ -8696,11 +8831,11 @@ function sleep(ms) {
 async function acquireFileLock(lockPath) {
   for (let attempt = 0; attempt < LOCK_RETRIES; attempt++) {
     try {
-      const fd = fs14.openSync(
+      const fd = fs16.openSync(
         lockPath,
-        fs14.constants.O_CREAT | fs14.constants.O_EXCL | fs14.constants.O_WRONLY
+        fs16.constants.O_CREAT | fs16.constants.O_EXCL | fs16.constants.O_WRONLY
       );
-      fs14.closeSync(fd);
+      fs16.closeSync(fd);
       return;
     } catch (err) {
       const isExist = err instanceof Error && "code" in err && err.code === "EEXIST";
@@ -8714,20 +8849,20 @@ async function acquireFileLock(lockPath) {
 }
 function releaseFileLock(lockPath) {
   try {
-    fs14.unlinkSync(lockPath);
+    fs16.unlinkSync(lockPath);
   } catch {
   }
 }
 function loadOrRebuildHashes(stateDir, learningsPath) {
-  const hashesPath = path11.join(stateDir, CONTENT_HASHES_FILE);
-  if (fs14.existsSync(hashesPath)) {
+  const hashesPath = path13.join(stateDir, CONTENT_HASHES_FILE);
+  if (fs16.existsSync(hashesPath)) {
     const hashes = loadContentHashes(stateDir);
-    if (Object.keys(hashes).length === 0 && fs14.existsSync(learningsPath)) {
+    if (Object.keys(hashes).length === 0 && fs16.existsSync(learningsPath)) {
       return rebuildContentHashes(stateDir, LEARNINGS_FILE);
     }
     return hashes;
   }
-  if (fs14.existsSync(learningsPath)) {
+  if (fs16.existsSync(learningsPath)) {
     return rebuildContentHashes(stateDir, LEARNINGS_FILE);
   }
   return {};
@@ -8751,8 +8886,8 @@ async function appendLearning(projectPath, learning, skillName, outcome, stream,
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const learningsPath = path11.join(stateDir, LEARNINGS_FILE);
-    fs14.mkdirSync(stateDir, { recursive: true });
+    const learningsPath = path13.join(stateDir, LEARNINGS_FILE);
+    fs16.mkdirSync(stateDir, { recursive: true });
     const lockPath = learningsPath + ".lock";
     await acquireFileLock(lockPath);
     try {
@@ -8782,17 +8917,17 @@ ${bulletLine}
 `;
       let overlapResult;
       let existingLineCount;
-      if (!fs14.existsSync(learningsPath)) {
-        fs14.writeFileSync(learningsPath, `# Learnings
+      if (!fs16.existsSync(learningsPath)) {
+        fs16.writeFileSync(learningsPath, `# Learnings
 ${entry}`);
         existingLineCount = 1;
       } else {
-        const existingContent = fs14.readFileSync(learningsPath, "utf-8");
+        const existingContent = fs16.readFileSync(learningsPath, "utf-8");
         const existingEntries = existingContent.split("\n").filter((line) => /^- \*\*\d{4}-\d{2}-\d{2}/.test(line));
         const overlap = checkOverlap(bulletLine, existingEntries);
         if (overlap.score >= 0.7) overlapResult = overlap;
         existingLineCount = existingContent.split("\n").length;
-        fs14.appendFileSync(learningsPath, entry);
+        fs16.appendFileSync(learningsPath, entry);
       }
       const bulletLineNum = existingLineCount + 2;
       contentHashes[contentHash] = { date: timestamp ?? "", line: bulletLineNum };
@@ -8897,11 +9032,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 = path11.join(stateDir, LEARNINGS_FILE);
-    if (!fs14.existsSync(learningsPath)) {
+    const learningsPath = path13.join(stateDir, LEARNINGS_FILE);
+    if (!fs16.existsSync(learningsPath)) {
       return Ok([]);
     }
-    const content = fs14.readFileSync(learningsPath, "utf-8");
+    const content = fs16.readFileSync(learningsPath, "utf-8");
     const lines = content.split("\n");
     const indexEntries = [];
     let pendingFrontmatter = null;
@@ -8943,16 +9078,16 @@ async function archiveLearnings(projectPath, entries, stream) {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const archiveDir = path12.join(stateDir, "learnings-archive");
-    fs15.mkdirSync(archiveDir, { recursive: true });
+    const archiveDir = path14.join(stateDir, "learnings-archive");
+    fs17.mkdirSync(archiveDir, { recursive: true });
     const now = /* @__PURE__ */ new Date();
     const yearMonth = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
-    const archivePath = path12.join(archiveDir, `${yearMonth}.md`);
+    const archivePath = path14.join(archiveDir, `${yearMonth}.md`);
     const archiveContent = entries.join("\n\n") + "\n";
-    if (fs15.existsSync(archivePath)) {
-      fs15.appendFileSync(archivePath, "\n" + archiveContent);
+    if (fs17.existsSync(archivePath)) {
+      fs17.appendFileSync(archivePath, "\n" + archiveContent);
     } else {
-      fs15.writeFileSync(archivePath, `# Learnings Archive
+      fs17.writeFileSync(archivePath, `# Learnings Archive
 
 ${archiveContent}`);
     }
@@ -8970,8 +9105,8 @@ async function pruneLearnings(projectPath, stream) {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const learningsPath = path12.join(stateDir, LEARNINGS_FILE);
-    if (!fs15.existsSync(learningsPath)) {
+    const learningsPath = path14.join(stateDir, LEARNINGS_FILE);
+    if (!fs17.existsSync(learningsPath)) {
       return Ok({ kept: 0, archived: 0, patterns: [] });
     }
     const loadResult = await loadRelevantLearnings(projectPath, void 0, stream);
@@ -9002,7 +9137,7 @@ async function pruneLearnings(projectPath, stream) {
       if (!archiveResult.ok) return archiveResult;
     }
     const newContent = "# Learnings\n\n" + toKeep.join("\n\n") + "\n";
-    fs15.writeFileSync(learningsPath, newContent);
+    fs17.writeFileSync(learningsPath, newContent);
     invalidateLearningsCacheEntry(learningsPath);
     return Ok({
       kept: toKeep.length,
@@ -9046,19 +9181,19 @@ async function promoteSessionLearnings(projectPath, sessionSlug, stream) {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const globalPath = path12.join(stateDir, LEARNINGS_FILE);
-    const existingGlobal = fs15.existsSync(globalPath) ? fs15.readFileSync(globalPath, "utf-8") : "";
+    const globalPath = path14.join(stateDir, LEARNINGS_FILE);
+    const existingGlobal = fs17.existsSync(globalPath) ? fs17.readFileSync(globalPath, "utf-8") : "";
     const newEntries = toPromote.filter((entry) => !existingGlobal.includes(entry.trim()));
     if (newEntries.length === 0) {
       return Ok({ promoted: 0, skipped: skipped + toPromote.length });
     }
     const promotedContent = newEntries.join("\n\n") + "\n";
     if (!existingGlobal) {
-      fs15.writeFileSync(globalPath, `# Learnings
+      fs17.writeFileSync(globalPath, `# Learnings
 
 ${promotedContent}`);
     } else {
-      fs15.appendFileSync(globalPath, "\n\n" + promotedContent);
+      fs17.appendFileSync(globalPath, "\n\n" + promotedContent);
     }
     invalidateLearningsCacheEntry(globalPath);
     return Ok({
@@ -9094,13 +9229,13 @@ async function detectStaleLearnings(projectPath, stream, session) {
         freshCount++;
         continue;
       }
-      const resolvedRoot = path13.resolve(projectPath);
+      const resolvedRoot = path15.resolve(projectPath);
       const missing = refs.filter((ref) => {
-        const absPath = path13.resolve(projectPath, ref);
-        if (!absPath.startsWith(resolvedRoot + path13.sep) && absPath !== resolvedRoot) {
+        const absPath = path15.resolve(projectPath, ref);
+        if (!absPath.startsWith(resolvedRoot + path15.sep) && absPath !== resolvedRoot) {
           return false;
         }
-        return !fs16.existsSync(absPath);
+        return !fs18.existsSync(absPath);
       });
       if (missing.length > 0) {
         const idx = extractIndexEntry(entry);
@@ -9135,17 +9270,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 = path14.join(stateDir, FAILURES_FILE);
-    fs17.mkdirSync(stateDir, { recursive: true });
+    const failuresPath = path16.join(stateDir, FAILURES_FILE);
+    fs19.mkdirSync(stateDir, { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const entry = `
 - **${timestamp} [skill:${skillName}] [type:${type}]:** ${description}
 `;
-    if (!fs17.existsSync(failuresPath)) {
-      fs17.writeFileSync(failuresPath, `# Failures
+    if (!fs19.existsSync(failuresPath)) {
+      fs19.writeFileSync(failuresPath, `# Failures
 ${entry}`);
     } else {
-      fs17.appendFileSync(failuresPath, entry);
+      fs19.appendFileSync(failuresPath, entry);
     }
     failuresCacheMap.delete(failuresPath);
     return Ok(void 0);
@@ -9162,17 +9297,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 = path14.join(stateDir, FAILURES_FILE);
-    if (!fs17.existsSync(failuresPath)) {
+    const failuresPath = path16.join(stateDir, FAILURES_FILE);
+    if (!fs19.existsSync(failuresPath)) {
       return Ok([]);
     }
-    const stats = fs17.statSync(failuresPath);
+    const stats = fs19.statSync(failuresPath);
     const cacheKey = failuresPath;
     const cached = failuresCacheMap.get(cacheKey);
     if (cached && cached.mtimeMs === stats.mtimeMs) {
       return Ok(cached.entries);
     }
-    const content = fs17.readFileSync(failuresPath, "utf-8");
+    const content = fs19.readFileSync(failuresPath, "utf-8");
     const entries = [];
     for (const line of content.split("\n")) {
       const match = line.match(FAILURE_LINE_REGEX);
@@ -9201,20 +9336,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 = path14.join(stateDir, FAILURES_FILE);
-    if (!fs17.existsSync(failuresPath)) {
+    const failuresPath = path16.join(stateDir, FAILURES_FILE);
+    if (!fs19.existsSync(failuresPath)) {
       return Ok(void 0);
     }
-    const archiveDir = path14.join(stateDir, "archive");
-    fs17.mkdirSync(archiveDir, { recursive: true });
+    const archiveDir = path16.join(stateDir, "archive");
+    fs19.mkdirSync(archiveDir, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     let archiveName = `failures-${date}.md`;
     let counter = 2;
-    while (fs17.existsSync(path14.join(archiveDir, archiveName))) {
+    while (fs19.existsSync(path16.join(archiveDir, archiveName))) {
       archiveName = `failures-${date}-${counter}.md`;
       counter++;
     }
-    fs17.renameSync(failuresPath, path14.join(archiveDir, archiveName));
+    fs19.renameSync(failuresPath, path16.join(archiveDir, archiveName));
     failuresCacheMap.delete(failuresPath);
     return Ok(void 0);
   } catch (error) {
@@ -9230,11 +9365,11 @@ async function saveHandoff(projectPath, handoff, stream, session) {
     const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const handoffPath = path15.join(stateDir, HANDOFF_FILE);
-    fs18.mkdirSync(stateDir, { recursive: true });
+    const handoffPath = path17.join(stateDir, HANDOFF_FILE);
+    fs20.mkdirSync(stateDir, { recursive: true });
     const tmpPath = handoffPath + ".tmp";
-    fs18.writeFileSync(tmpPath, JSON.stringify(handoff, null, 2));
-    fs18.renameSync(tmpPath, handoffPath);
+    fs20.writeFileSync(tmpPath, JSON.stringify(handoff, null, 2));
+    fs20.renameSync(tmpPath, handoffPath);
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -9247,11 +9382,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 = path15.join(stateDir, HANDOFF_FILE);
-    if (!fs18.existsSync(handoffPath)) {
+    const handoffPath = path17.join(stateDir, HANDOFF_FILE);
+    if (!fs20.existsSync(handoffPath)) {
       return Ok(null);
     }
-    const raw = fs18.readFileSync(handoffPath, "utf-8");
+    const raw = fs20.readFileSync(handoffPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = HandoffSchema.safeParse(parsed);
     if (!result.success) {
@@ -9265,28 +9400,28 @@ async function loadHandoff(projectPath, stream, session) {
   }
 }
 function loadChecksFromConfig(gateConfigPath) {
-  if (!fs19.existsSync(gateConfigPath)) return [];
-  const raw = JSON.parse(fs19.readFileSync(gateConfigPath, "utf-8"));
+  if (!fs21.existsSync(gateConfigPath)) return [];
+  const raw = JSON.parse(fs21.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 = path16.join(projectPath, "package.json");
-  if (fs19.existsSync(packageJsonPath)) {
-    const pkg = JSON.parse(fs19.readFileSync(packageJsonPath, "utf-8"));
+  const packageJsonPath = path18.join(projectPath, "package.json");
+  if (fs21.existsSync(packageJsonPath)) {
+    const pkg = JSON.parse(fs21.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 (fs19.existsSync(path16.join(projectPath, "go.mod"))) {
+  if (fs21.existsSync(path18.join(projectPath, "go.mod"))) {
     checks.push({ name: "test", command: "go test ./..." });
     checks.push({ name: "build", command: "go build ./..." });
   }
-  if (fs19.existsSync(path16.join(projectPath, "pyproject.toml")) || fs19.existsSync(path16.join(projectPath, "setup.py"))) {
+  if (fs21.existsSync(path18.join(projectPath, "pyproject.toml")) || fs21.existsSync(path18.join(projectPath, "setup.py"))) {
     checks.push({ name: "test", command: "python -m pytest" });
   }
   return checks;
@@ -9326,8 +9461,8 @@ function executeCheck(check, projectPath) {
   }
 }
 async function runMechanicalGate(projectPath) {
-  const harnessDir = path16.join(projectPath, HARNESS_DIR);
-  const gateConfigPath = path16.join(harnessDir, GATE_CONFIG_FILE);
+  const harnessDir = path18.join(projectPath, HARNESS_DIR);
+  const gateConfigPath = path18.join(harnessDir, GATE_CONFIG_FILE);
   try {
     let checks = loadChecksFromConfig(gateConfigPath);
     if (checks.length === 0) {
@@ -9383,9 +9518,9 @@ function writeSessionSummary(projectPath, sessionSlug, data) {
     const dirResult = resolveSessionDir(projectPath, sessionSlug, { create: true });
     if (!dirResult.ok) return dirResult;
     const sessionDir = dirResult.value;
-    const summaryPath = path17.join(sessionDir, SUMMARY_FILE);
+    const summaryPath = path19.join(sessionDir, SUMMARY_FILE);
     const content = formatSummary(data);
-    fs20.writeFileSync(summaryPath, content);
+    fs22.writeFileSync(summaryPath, content);
     const description = deriveIndexDescription(data);
     updateSessionIndex(projectPath, sessionSlug, description);
     return Ok(void 0);
@@ -9402,11 +9537,11 @@ function loadSessionSummary(projectPath, sessionSlug) {
     const dirResult = resolveSessionDir(projectPath, sessionSlug);
     if (!dirResult.ok) return dirResult;
     const sessionDir = dirResult.value;
-    const summaryPath = path17.join(sessionDir, SUMMARY_FILE);
-    if (!fs20.existsSync(summaryPath)) {
+    const summaryPath = path19.join(sessionDir, SUMMARY_FILE);
+    if (!fs22.existsSync(summaryPath)) {
       return Ok(null);
     }
-    const content = fs20.readFileSync(summaryPath, "utf-8");
+    const content = fs22.readFileSync(summaryPath, "utf-8");
     return Ok(content);
   } catch (error) {
     return Err(
@@ -9418,11 +9553,11 @@ function loadSessionSummary(projectPath, sessionSlug) {
 }
 function listActiveSessions(projectPath) {
   try {
-    const indexPath2 = path17.join(projectPath, HARNESS_DIR, SESSIONS_DIR, SESSION_INDEX_FILE);
-    if (!fs20.existsSync(indexPath2)) {
+    const indexPath2 = path19.join(projectPath, HARNESS_DIR, SESSIONS_DIR, SESSION_INDEX_FILE);
+    if (!fs22.existsSync(indexPath2)) {
       return Ok(null);
     }
-    const content = fs20.readFileSync(indexPath2, "utf-8");
+    const content = fs22.readFileSync(indexPath2, "utf-8");
     return Ok(content);
   } catch (error) {
     return Err(
@@ -9443,12 +9578,12 @@ async function loadSessionState(projectPath, sessionSlug) {
   const dirResult = resolveSessionDir(projectPath, sessionSlug);
   if (!dirResult.ok) return dirResult;
   const sessionDir = dirResult.value;
-  const filePath = path18.join(sessionDir, SESSION_STATE_FILE);
-  if (!fs21.existsSync(filePath)) {
+  const filePath = path20.join(sessionDir, SESSION_STATE_FILE);
+  if (!fs23.existsSync(filePath)) {
     return Ok(emptySections());
   }
   try {
-    const raw = fs21.readFileSync(filePath, "utf-8");
+    const raw = fs23.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     const sections = emptySections();
     for (const name of SESSION_SECTION_NAMES) {
@@ -9469,9 +9604,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 = path18.join(sessionDir, SESSION_STATE_FILE);
+  const filePath = path20.join(sessionDir, SESSION_STATE_FILE);
   try {
-    fs21.writeFileSync(filePath, JSON.stringify(sections, null, 2));
+    fs23.writeFileSync(filePath, JSON.stringify(sections, null, 2));
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -9527,26 +9662,26 @@ async function archiveSession(projectPath, sessionSlug) {
   const dirResult = resolveSessionDir(projectPath, sessionSlug);
   if (!dirResult.ok) return dirResult;
   const sessionDir = dirResult.value;
-  if (!fs22.existsSync(sessionDir)) {
+  if (!fs24.existsSync(sessionDir)) {
     return Err(new Error(`Session '${sessionSlug}' not found at ${sessionDir}`));
   }
-  const archiveBase = path19.join(projectPath, HARNESS_DIR, ARCHIVE_DIR, "sessions");
+  const archiveBase = path21.join(projectPath, HARNESS_DIR, ARCHIVE_DIR, "sessions");
   try {
-    fs22.mkdirSync(archiveBase, { recursive: true });
+    fs24.mkdirSync(archiveBase, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     let archiveName = `${sessionSlug}-${date}`;
     let counter = 1;
-    while (fs22.existsSync(path19.join(archiveBase, archiveName))) {
+    while (fs24.existsSync(path21.join(archiveBase, archiveName))) {
       archiveName = `${sessionSlug}-${date}-${counter}`;
       counter++;
     }
-    const dest = path19.join(archiveBase, archiveName);
+    const dest = path21.join(archiveBase, archiveName);
     try {
-      fs22.renameSync(sessionDir, dest);
+      fs24.renameSync(sessionDir, dest);
     } catch (renameErr) {
       if (renameErr instanceof Error && "code" in renameErr && renameErr.code === "EXDEV") {
-        fs22.cpSync(sessionDir, dest, { recursive: true });
-        fs22.rmSync(sessionDir, { recursive: true });
+        fs24.cpSync(sessionDir, dest, { recursive: true });
+        fs24.rmSync(sessionDir, { recursive: true });
       } else {
         throw renameErr;
       }
@@ -9568,8 +9703,8 @@ function loadKnownHashes(eventsPath) {
   const cached = knownHashesCache.get(eventsPath);
   if (cached) return cached;
   const hashes = /* @__PURE__ */ new Set();
-  if (fs23.existsSync(eventsPath)) {
-    const content = fs23.readFileSync(eventsPath, "utf-8");
+  if (fs25.existsSync(eventsPath)) {
+    const content = fs25.readFileSync(eventsPath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim() !== "");
     for (const line of lines) {
       try {
@@ -9592,8 +9727,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 = path20.join(stateDir, EVENTS_FILE);
-    fs23.mkdirSync(stateDir, { recursive: true });
+    const eventsPath = path22.join(stateDir, EVENTS_FILE);
+    fs25.mkdirSync(stateDir, { recursive: true });
     const contentHash = computeEventHash(event, options?.session);
     const knownHashes = loadKnownHashes(eventsPath);
     if (knownHashes.has(contentHash)) {
@@ -9607,7 +9742,7 @@ async function emitEvent(projectPath, event, options) {
     if (options?.session) {
       fullEvent.session = options.session;
     }
-    fs23.appendFileSync(eventsPath, JSON.stringify(fullEvent) + "\n");
+    fs25.appendFileSync(eventsPath, JSON.stringify(fullEvent) + "\n");
     knownHashes.add(contentHash);
     return Ok({ written: true });
   } catch (error) {
@@ -9621,11 +9756,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 = path20.join(stateDir, EVENTS_FILE);
-    if (!fs23.existsSync(eventsPath)) {
+    const eventsPath = path22.join(stateDir, EVENTS_FILE);
+    if (!fs25.existsSync(eventsPath)) {
       return Ok([]);
     }
-    const content = fs23.readFileSync(eventsPath, "utf-8");
+    const content = fs25.readFileSync(eventsPath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim() !== "");
     const events = [];
     for (const line of lines) {
@@ -9874,11 +10009,11 @@ function nodeSubStacks(allDeps) {
   return found;
 }
 function detectNodeStacks(projectRoot) {
-  const pkgJsonPath = path21.join(projectRoot, "package.json");
-  if (!fs24.existsSync(pkgJsonPath)) return [];
+  const pkgJsonPath = path23.join(projectRoot, "package.json");
+  if (!fs26.existsSync(pkgJsonPath)) return [];
   const stacks = ["node"];
   try {
-    const pkgJson = JSON.parse(fs24.readFileSync(pkgJsonPath, "utf-8"));
+    const pkgJson = JSON.parse(fs26.readFileSync(pkgJsonPath, "utf-8"));
     const allDeps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
     stacks.push(...nodeSubStacks(allDeps));
   } catch {
@@ -9887,10 +10022,10 @@ function detectNodeStacks(projectRoot) {
 }
 function detectStack(projectRoot) {
   const stacks = [...detectNodeStacks(projectRoot)];
-  if (fs24.existsSync(path21.join(projectRoot, "go.mod"))) {
+  if (fs26.existsSync(path23.join(projectRoot, "go.mod"))) {
     stacks.push("go");
   }
-  const hasPython = fs24.existsSync(path21.join(projectRoot, "requirements.txt")) || fs24.existsSync(path21.join(projectRoot, "pyproject.toml"));
+  const hasPython = fs26.existsSync(path23.join(projectRoot, "requirements.txt")) || fs26.existsSync(path23.join(projectRoot, "pyproject.toml"));
   if (hasPython) {
     stacks.push("python");
   }
@@ -9933,7 +10068,7 @@ function getInjectionPatterns() {
 }
 function getTaintFilePath(projectRoot, sessionId) {
   const id = sessionId || DEFAULT_SESSION_ID;
-  return join362(projectRoot, ".harness", `session-taint-${id}.json`);
+  return join382(projectRoot, ".harness", `session-taint-${id}.json`);
 }
 function readTaint(projectRoot, sessionId) {
   const filePath = getTaintFilePath(projectRoot, sessionId);
@@ -10015,14 +10150,14 @@ function clearTaint(projectRoot, sessionId) {
       return 0;
     }
   }
-  const harnessDir = join362(projectRoot, ".harness");
+  const harnessDir = join382(projectRoot, ".harness");
   let count = 0;
   try {
     const files = readdirSync3(harnessDir);
     for (const file of files) {
       if (file.startsWith("session-taint-") && file.endsWith(".json")) {
         try {
-          unlinkSync2(join362(harnessDir, file));
+          unlinkSync2(join382(harnessDir, file));
           count++;
         } catch {
         }
@@ -10033,7 +10168,7 @@ function clearTaint(projectRoot, sessionId) {
   return count;
 }
 function listTaintedSessions(projectRoot) {
-  const harnessDir = join362(projectRoot, ".harness");
+  const harnessDir = join382(projectRoot, ".harness");
   const sessions = [];
   try {
     const files = readdirSync3(harnessDir);
@@ -10105,7 +10240,7 @@ function securityFindingId(finding) {
 }
 async function runValidateCheck(projectRoot, config) {
   const issues = [];
-  const agentsPath = path22.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
+  const agentsPath = path24.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
   const result = await validateAgentsMap(agentsPath);
   if (!result.ok) {
     issues.push({ severity: "error", message: result.error.message });
@@ -10162,7 +10297,7 @@ async function runDepsCheck(projectRoot, config) {
 }
 async function runDocsCheck(projectRoot, config) {
   const issues = [];
-  const docsDir = path22.join(projectRoot, config.docsDir ?? "docs");
+  const docsDir = path24.join(projectRoot, config.docsDir ?? "docs");
   const entropyConfig = config.entropy || {};
   const result = await checkDocCoverage("project", {
     docsDir,
@@ -10347,7 +10482,7 @@ async function runTraceabilityCheck(projectRoot, config) {
   const issues = [];
   const traceConfig = config.traceability || {};
   if (traceConfig.enabled === false) return issues;
-  const graphDir = path22.join(projectRoot, ".harness", "graph");
+  const graphDir = path24.join(projectRoot, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);
   if (!loaded) {
@@ -10525,7 +10660,7 @@ async function runMechanicalChecks(options) {
   };
   if (!skip.includes("validate")) {
     try {
-      const agentsPath = path23.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
+      const agentsPath = path25.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
       const result = await validateAgentsMap(agentsPath);
       if (!result.ok) {
         statuses.validate = "fail";
@@ -10562,7 +10697,7 @@ async function runMechanicalChecks(options) {
       statuses.validate = "fail";
       findings.push({
         tool: "validate",
-        file: path23.join(projectRoot, "AGENTS.md"),
+        file: path25.join(projectRoot, "AGENTS.md"),
         message: err instanceof Error ? err.message : String(err),
         severity: "error"
       });
@@ -10626,7 +10761,7 @@ async function runMechanicalChecks(options) {
       (async () => {
         const localFindings = [];
         try {
-          const docsDir = path23.join(projectRoot, config.docsDir ?? "docs");
+          const docsDir = path25.join(projectRoot, config.docsDir ?? "docs");
           const result = await checkDocCoverage("project", { docsDir });
           if (!result.ok) {
             statuses["check-docs"] = "warn";
@@ -10653,7 +10788,7 @@ async function runMechanicalChecks(options) {
           statuses["check-docs"] = "warn";
           localFindings.push({
             tool: "check-docs",
-            file: path23.join(projectRoot, "docs"),
+            file: path25.join(projectRoot, "docs"),
             message: err instanceof Error ? err.message : String(err),
             severity: "warning"
           });
@@ -10750,18 +10885,18 @@ function computeContextBudget(diffLines) {
   return diffLines;
 }
 function isWithinProject(absPath, projectRoot) {
-  const resolvedRoot = path24.resolve(projectRoot) + path24.sep;
-  const resolvedPath = path24.resolve(absPath);
-  return resolvedPath.startsWith(resolvedRoot) || resolvedPath === path24.resolve(projectRoot);
+  const resolvedRoot = path26.resolve(projectRoot) + path26.sep;
+  const resolvedPath = path26.resolve(absPath);
+  return resolvedPath.startsWith(resolvedRoot) || resolvedPath === path26.resolve(projectRoot);
 }
 async function readContextFile(projectRoot, filePath, reason) {
-  const absPath = path24.isAbsolute(filePath) ? filePath : path24.join(projectRoot, filePath);
+  const absPath = path26.isAbsolute(filePath) ? filePath : path26.join(projectRoot, filePath);
   if (!isWithinProject(absPath, projectRoot)) return null;
   const result = await readFileContent(absPath);
   if (!result.ok) return null;
   const content = result.value;
   const lines = content.split("\n").length;
-  const relPath2 = path24.isAbsolute(filePath) ? relativePosix(projectRoot, filePath) : filePath;
+  const relPath2 = path26.isAbsolute(filePath) ? relativePosix(projectRoot, filePath) : filePath;
   return { path: relPath2, content, reason, lines };
 }
 function extractImportSources2(content) {
@@ -10776,18 +10911,18 @@ function extractImportSources2(content) {
 }
 async function resolveImportPath2(projectRoot, fromFile, importSource) {
   if (!importSource.startsWith(".")) return null;
-  const fromDir = path24.dirname(path24.join(projectRoot, fromFile));
-  const basePath = path24.resolve(fromDir, importSource);
+  const fromDir = path26.dirname(path26.join(projectRoot, fromFile));
+  const basePath = path26.resolve(fromDir, importSource);
   if (!isWithinProject(basePath, projectRoot)) return null;
   const relBase = relativePosix(projectRoot, basePath);
   const candidates = [
     relBase + ".ts",
     relBase + ".tsx",
     relBase + ".mts",
-    path24.join(relBase, "index.ts")
+    path26.join(relBase, "index.ts")
   ];
   for (const candidate of candidates) {
-    const absCandidate = path24.join(projectRoot, candidate);
+    const absCandidate = path26.join(projectRoot, candidate);
     if (await fileExists(absCandidate)) {
       return candidate;
     }
@@ -10795,7 +10930,7 @@ async function resolveImportPath2(projectRoot, fromFile, importSource) {
   return null;
 }
 async function findTestFiles(projectRoot, sourceFile) {
-  const baseName = path24.basename(sourceFile, path24.extname(sourceFile));
+  const baseName = path26.basename(sourceFile, path26.extname(sourceFile));
   const pattern = `**/${baseName}.{test,spec}.{ts,tsx,mts}`;
   const results = await findFiles(pattern, projectRoot);
   return results.map((f) => relativePosix(projectRoot, f));
@@ -11563,7 +11698,7 @@ function normalizePath(filePath, projectRoot) {
   let normalized = filePath;
   normalized = normalized.replace(/\\/g, "/");
   const normalizedRoot = projectRoot.replace(/\\/g, "/");
-  if (path25.isAbsolute(normalized)) {
+  if (path27.isAbsolute(normalized)) {
     const root = normalizedRoot.endsWith("/") ? normalizedRoot : normalizedRoot + "/";
     if (normalized.startsWith(root)) {
       normalized = normalized.slice(root.length);
@@ -11575,12 +11710,12 @@ function normalizePath(filePath, projectRoot) {
   return normalized;
 }
 function resolveImportPath22(currentFile, importPath) {
-  const dir = path25.dirname(currentFile);
-  let resolved = path25.join(dir, importPath).replace(/\\/g, "/");
+  const dir = path27.dirname(currentFile);
+  let resolved = path27.join(dir, importPath).replace(/\\/g, "/");
   if (!resolved.match(/\.(ts|tsx|js|jsx)$/)) {
     resolved += ".ts";
   }
-  return path25.normalize(resolved).replace(/\\/g, "/");
+  return path27.normalize(resolved).replace(/\\/g, "/");
 }
 function enqueueImports(content, current, visited, queue, maxDepth) {
   const importRegex = /import\s+.*?from\s+['"]([^'"]+)['"]/g;
@@ -11612,7 +11747,7 @@ function isMechanicallyExcluded(finding, exclusionSet, projectRoot) {
   const normalizedFile = normalizePath(finding.file, projectRoot);
   if (exclusionSet.isExcluded(normalizedFile, finding.lineRange)) return true;
   if (exclusionSet.isExcluded(finding.file, finding.lineRange)) return true;
-  const absoluteFile = path25.isAbsolute(finding.file) ? finding.file : path25.join(projectRoot, finding.file).replace(/\\/g, "/");
+  const absoluteFile = path27.isAbsolute(finding.file) ? finding.file : path27.join(projectRoot, finding.file).replace(/\\/g, "/");
   return exclusionSet.isExcluded(absoluteFile, finding.lineRange);
 }
 async function validateWithGraph(crossFileRefs, graph) {
@@ -12620,7 +12755,7 @@ function isRegression(from, to) {
 }
 function collectAutopilotStatuses(autopilotPath, featurePlans, allTaskStatuses) {
   try {
-    const raw = fs26.readFileSync(autopilotPath, "utf-8");
+    const raw = fs28.readFileSync(autopilotPath, "utf-8");
     const autopilot = JSON.parse(raw);
     if (!autopilot.phases) return;
     const linkedPhases = autopilot.phases.filter(
@@ -12652,10 +12787,10 @@ function inferStatus(feature, projectPath, allFeatures) {
   const featuresWithPlans = allFeatures.filter((f) => f.plans.length > 0);
   const useRootState = featuresWithPlans.length <= 1;
   if (useRootState) {
-    const rootStatePath = path26.join(projectPath, ".harness", "state.json");
-    if (fs26.existsSync(rootStatePath)) {
+    const rootStatePath = path28.join(projectPath, ".harness", "state.json");
+    if (fs28.existsSync(rootStatePath)) {
       try {
-        const raw = fs26.readFileSync(rootStatePath, "utf-8");
+        const raw = fs28.readFileSync(rootStatePath, "utf-8");
         const state = JSON.parse(raw);
         if (state.progress) {
           for (const status of Object.values(state.progress)) {
@@ -12666,14 +12801,14 @@ function inferStatus(feature, projectPath, allFeatures) {
       }
     }
   }
-  const sessionsDir = path26.join(projectPath, ".harness", "sessions");
-  if (fs26.existsSync(sessionsDir)) {
+  const sessionsDir = path28.join(projectPath, ".harness", "sessions");
+  if (fs28.existsSync(sessionsDir)) {
     try {
-      const sessionDirs = fs26.readdirSync(sessionsDir, { withFileTypes: true });
+      const sessionDirs = fs28.readdirSync(sessionsDir, { withFileTypes: true });
       for (const entry of sessionDirs) {
         if (!entry.isDirectory()) continue;
-        const autopilotPath = path26.join(sessionsDir, entry.name, "autopilot-state.json");
-        if (!fs26.existsSync(autopilotPath)) continue;
+        const autopilotPath = path28.join(sessionsDir, entry.name, "autopilot-state.json");
+        if (!fs28.existsSync(autopilotPath)) continue;
         collectAutopilotStatuses(autopilotPath, feature.plans, allTaskStatuses);
       }
     } catch {
@@ -12788,9 +12923,9 @@ function isValidTrackerShape(tracker) {
 }
 function loadTrackerSyncConfig(projectRoot) {
   try {
-    const configPath = path27.join(projectRoot, "harness.config.json");
-    if (!fs27.existsSync(configPath)) return null;
-    const raw = fs27.readFileSync(configPath, "utf-8");
+    const configPath = path29.join(projectRoot, "harness.config.json");
+    if (!fs29.existsSync(configPath)) return null;
+    const raw = fs29.readFileSync(configPath, "utf-8");
     const config = JSON.parse(raw);
     const tracker = config.roadmap?.tracker;
     if (!isValidTrackerShape(tracker)) return null;
@@ -12817,14 +12952,14 @@ function buildDedupIndex(tickets, config) {
   }
   return index;
 }
-async function resolveExternalId(feature, milestone, adapter, dedupIndex, result) {
+async function resolveExternalId(feature, milestone, adapter2, 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);
+  const createResult = await adapter2.createTicket(feature, milestone);
   if (createResult.ok) {
     feature.externalId = createResult.value.externalId;
     result.created.push(createResult.value);
@@ -12833,7 +12968,7 @@ async function resolveExternalId(feature, milestone, adapter, dedupIndex, result
   }
   return false;
 }
-async function syncToExternal(roadmap, adapter, config, prefetchedTickets) {
+async function syncToExternal(roadmap, adapter2, config, prefetchedTickets) {
   const result = emptySyncResult();
   const dedupIndex = buildDedupIndex(prefetchedTickets, config);
   for (const milestone of roadmap.milestones) {
@@ -12841,12 +12976,12 @@ async function syncToExternal(roadmap, adapter, config, prefetchedTickets) {
       const shouldUpdate = await resolveExternalId(
         feature,
         milestone.name,
-        adapter,
+        adapter2,
         dedupIndex,
         result
       );
       if (!shouldUpdate) continue;
-      const updateResult = await adapter.updateTicket(feature.externalId, feature, milestone.name);
+      const updateResult = await adapter2.updateTicket(feature.externalId, feature, milestone.name);
       if (updateResult.ok) {
         result.updated.push(feature.externalId);
       } else {
@@ -12872,7 +13007,7 @@ function applyTicketToFeature(ticketState, feature, config, forceSync, result) {
   if (!forceSync && feature.status === "blocked" && newStatus === "planned") return;
   feature.status = newStatus;
 }
-async function syncFromExternal(roadmap, adapter, config, options, prefetchedTickets) {
+async function syncFromExternal(roadmap, adapter2, config, options, prefetchedTickets) {
   const result = emptySyncResult();
   const forceSync = options?.forceSync ?? false;
   const featureByExternalId = /* @__PURE__ */ new Map();
@@ -12888,7 +13023,7 @@ async function syncFromExternal(roadmap, adapter, config, options, prefetchedTic
   if (prefetchedTickets) {
     tickets = prefetchedTickets;
   } else {
-    const fetchResult = await adapter.fetchAllTickets();
+    const fetchResult = await adapter2.fetchAllTickets();
     if (!fetchResult.ok) {
       result.errors.push({ featureOrId: "*", error: fetchResult.error });
       return result;
@@ -12902,7 +13037,7 @@ async function syncFromExternal(roadmap, adapter, config, options, prefetchedTic
   }
   return result;
 }
-async function fullSync(roadmapPath, adapter, config, options) {
+async function fullSync(roadmapPath, adapter2, config, options) {
   const previousSync = syncMutex;
   let releaseMutex;
   syncMutex = new Promise((resolve8) => {
@@ -12910,7 +13045,7 @@ async function fullSync(roadmapPath, adapter, config, options) {
   });
   await previousSync;
   try {
-    const raw = fs28.readFileSync(roadmapPath, "utf-8");
+    const raw = fs30.readFileSync(roadmapPath, "utf-8");
     const parseResult = parseRoadmap(raw);
     if (!parseResult.ok) {
       return {
@@ -12919,11 +13054,11 @@ async function fullSync(roadmapPath, adapter, config, options) {
       };
     }
     const roadmap = parseResult.value;
-    const fetchResult = await adapter.fetchAllTickets();
+    const fetchResult = await adapter2.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);
-    fs28.writeFileSync(roadmapPath, serializeRoadmap(roadmap), "utf-8");
+    const pushResult = await syncToExternal(roadmap, adapter2, config, tickets);
+    const pullResult = await syncFromExternal(roadmap, adapter2, config, options);
+    fs30.writeFileSync(roadmapPath, serializeRoadmap(roadmap), "utf-8");
     return {
       created: pushResult.created,
       updated: pushResult.updated,
@@ -13045,7 +13180,7 @@ function assignFeature(roadmap, feature, assignee, date) {
 }
 function getStatePath() {
   const home = process.env["HOME"] || os.homedir();
-  return path30.join(home, ".harness", "update-check.json");
+  return path32.join(home, ".harness", "update-check.json");
 }
 function isUpdateCheckEnabled(configInterval) {
   if (process.env["HARNESS_NO_UPDATE_CHECK"] === "1") return false;
@@ -13058,7 +13193,7 @@ function shouldRunCheck(state, intervalMs) {
 }
 function readCheckState() {
   try {
-    const raw = fs31.readFileSync(getStatePath(), "utf-8");
+    const raw = fs33.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;
@@ -13075,7 +13210,7 @@ function readCheckState() {
 }
 function spawnBackgroundCheck(currentVersion) {
   const statePath = getStatePath();
-  const stateDir = path30.dirname(statePath);
+  const stateDir = path32.dirname(statePath);
   const script = `
 const { execSync } = require('child_process');
 const fs = require('fs');
@@ -13318,14 +13453,14 @@ function getModelPrice(model, dataset) {
   return pricing;
 }
 function getCachePath(projectRoot) {
-  return path31.join(projectRoot, ".harness", "cache", "pricing.json");
+  return path33.join(projectRoot, ".harness", "cache", "pricing.json");
 }
 function getStalenessMarkerPath(projectRoot) {
-  return path31.join(projectRoot, ".harness", "cache", "staleness-marker.json");
+  return path33.join(projectRoot, ".harness", "cache", "staleness-marker.json");
 }
 async function readDiskCache(projectRoot) {
   try {
-    const raw = await fs32.readFile(getCachePath(projectRoot), "utf-8");
+    const raw = await fs34.readFile(getCachePath(projectRoot), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -13333,8 +13468,8 @@ async function readDiskCache(projectRoot) {
 }
 async function writeDiskCache(projectRoot, data) {
   const cachePath = getCachePath(projectRoot);
-  await fs32.mkdir(path31.dirname(cachePath), { recursive: true });
-  await fs32.writeFile(cachePath, JSON.stringify(data, null, 2));
+  await fs34.mkdir(path33.dirname(cachePath), { recursive: true });
+  await fs34.writeFile(cachePath, JSON.stringify(data, null, 2));
 }
 async function fetchFromNetwork() {
   try {
@@ -13361,7 +13496,7 @@ function loadFallbackDataset() {
 async function checkAndWarnStaleness(projectRoot) {
   const markerPath = getStalenessMarkerPath(projectRoot);
   try {
-    const raw = await fs32.readFile(markerPath, "utf-8");
+    const raw = await fs34.readFile(markerPath, "utf-8");
     const marker = JSON.parse(raw);
     const firstUse = new Date(marker.firstFallbackUse).getTime();
     const now = Date.now();
@@ -13373,8 +13508,8 @@ async function checkAndWarnStaleness(projectRoot) {
     }
   } catch {
     try {
-      await fs32.mkdir(path31.dirname(markerPath), { recursive: true });
-      await fs32.writeFile(
+      await fs34.mkdir(path33.dirname(markerPath), { recursive: true });
+      await fs34.writeFile(
         markerPath,
         JSON.stringify({ firstFallbackUse: (/* @__PURE__ */ new Date()).toISOString() })
       );
@@ -13384,7 +13519,7 @@ async function checkAndWarnStaleness(projectRoot) {
 }
 async function clearStalenessMarker(projectRoot) {
   try {
-    await fs32.unlink(getStalenessMarkerPath(projectRoot));
+    await fs34.unlink(getStalenessMarkerPath(projectRoot));
   } catch {
   }
 }
@@ -13621,10 +13756,10 @@ function parseLine(line, lineNumber) {
   return record;
 }
 function readCostRecords(projectRoot) {
-  const costsFile = path32.join(projectRoot, ".harness", "metrics", "costs.jsonl");
+  const costsFile = path34.join(projectRoot, ".harness", "metrics", "costs.jsonl");
   let raw;
   try {
-    raw = fs33.readFileSync(costsFile, "utf-8");
+    raw = fs35.readFileSync(costsFile, "utf-8");
   } catch {
     return [];
   }
@@ -13674,7 +13809,7 @@ function parseCCLine(line, filePath, lineNumber) {
     entry = JSON.parse(line);
   } catch {
     console.warn(
-      `[harness usage] Skipping malformed CC JSONL line ${lineNumber} in ${path33.basename(filePath)}`
+      `[harness usage] Skipping malformed CC JSONL line ${lineNumber} in ${path35.basename(filePath)}`
     );
     return null;
   }
@@ -13688,7 +13823,7 @@ function parseCCLine(line, filePath, lineNumber) {
 function readCCFile(filePath) {
   let raw;
   try {
-    raw = fs34.readFileSync(filePath, "utf-8");
+    raw = fs36.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -13710,10 +13845,10 @@ function readCCFile(filePath) {
 }
 function parseCCRecords() {
   const homeDir = process.env.HOME ?? os2.homedir();
-  const projectsDir = path33.join(homeDir, ".claude", "projects");
+  const projectsDir = path35.join(homeDir, ".claude", "projects");
   let projectDirs;
   try {
-    projectDirs = fs34.readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path33.join(projectsDir, d.name));
+    projectDirs = fs36.readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path35.join(projectsDir, d.name));
   } catch {
     return [];
   }
@@ -13721,7 +13856,7 @@ function parseCCRecords() {
   for (const dir of projectDirs) {
     let files;
     try {
-      files = fs34.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path33.join(dir, f));
+      files = fs36.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path35.join(dir, f));
     } catch {
       continue;
     }
@@ -13749,10 +13884,10 @@ function parseLine2(line, lineNumber) {
   }
 }
 function readAdoptionRecords(projectRoot) {
-  const adoptionFile = path34.join(projectRoot, ".harness", "metrics", "adoption.jsonl");
+  const adoptionFile = path36.join(projectRoot, ".harness", "metrics", "adoption.jsonl");
   let raw;
   try {
-    raw = fs35.readFileSync(adoptionFile, "utf-8");
+    raw = fs37.readFileSync(adoptionFile, "utf-8");
   } catch {
     return [];
   }
@@ -13900,25 +14035,25 @@ function resolveStability(contentType) {
   return STABILITY_LOOKUP[contentType] ?? "ephemeral";
 }
 function getOrCreateInstallId(projectRoot) {
-  const harnessDir = path35.join(projectRoot, ".harness");
-  const installIdFile = path35.join(harnessDir, ".install-id");
+  const harnessDir = path37.join(projectRoot, ".harness");
+  const installIdFile = path37.join(harnessDir, ".install-id");
   const UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
   try {
-    const existing = fs36.readFileSync(installIdFile, "utf-8").trim();
+    const existing = fs38.readFileSync(installIdFile, "utf-8").trim();
     if (UUID_V4_RE.test(existing)) {
       return existing;
     }
   } catch {
   }
   const id = crypto4.randomUUID();
-  fs36.mkdirSync(harnessDir, { recursive: true });
-  fs36.writeFileSync(installIdFile, id, { encoding: "utf-8", mode: 384 });
+  fs38.mkdirSync(harnessDir, { recursive: true });
+  fs38.writeFileSync(installIdFile, id, { encoding: "utf-8", mode: 384 });
   return id;
 }
 function parseIdentityFromTelemetryFile(filePath) {
   const identity = {};
   try {
-    const raw = fs37.readFileSync(filePath, "utf-8");
+    const raw = fs39.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     const src = parsed?.identity;
     if (!src || typeof src !== "object") return identity;
@@ -13931,7 +14066,7 @@ function parseIdentityFromTelemetryFile(filePath) {
 }
 function readProjectNameFallback(configPath) {
   try {
-    const raw = fs37.readFileSync(configPath, "utf-8");
+    const raw = fs39.readFileSync(configPath, "utf-8");
     const config = JSON.parse(raw);
     return typeof config?.name === "string" ? config.name : void 0;
   } catch {
@@ -13952,10 +14087,10 @@ function readGitAliasFallback(cwd) {
   }
 }
 function readIdentity(projectRoot) {
-  const filePath = path36.join(projectRoot, ".harness", "telemetry.json");
+  const filePath = path38.join(projectRoot, ".harness", "telemetry.json");
   const identity = parseIdentityFromTelemetryFile(filePath);
   if (!identity.project) {
-    const fallbackProject = readProjectNameFallback(path36.join(projectRoot, "harness.config.json"));
+    const fallbackProject = readProjectNameFallback(path38.join(projectRoot, "harness.config.json"));
     if (fallbackProject) identity.project = fallbackProject;
   }
   if (!identity.alias) {
@@ -14025,7 +14160,557 @@ async function send(events, apiKey) {
     }
   }
 }
-var VALID_TYPES, CONVENTIONAL_PATTERN, DEFAULT_AGNIX_TIMEOUT_MS, HARNESS_AGNIX_DISABLE, HARNESS_AGNIX_BIN, CLAUDE_MD_WARN_BYTES, CLAUDE_MD_ERROR_BYTES, CONTEXT_FILES, MIN_DESCRIPTION_LENGTH, SETTINGS_PATHS, KNOWN_HOOK_EVENTS, MCP_SETTINGS_FILES, REQUIRED_SECTIONS, SETTINGS_FILES, KNOWN_AGNIX_TOOLS, DEFAULT_SECTIONS, DEFAULT_RATIOS, NODE_TYPE_TO_CATEGORY, SECTION_LEVEL_MAP, DEFAULT_LEVEL, DEFAULT_BUDGET, DEFAULT_LOADER_CONFIG, LEVEL_FRACTIONS, PHASE_PRIORITIES, ManifestSchema, BundleConstraintsSchema, BundleSchema, ContributionsSchema, LockfilePackageSchema, LockfileSchema, SharableLayerSchema, SharableForbiddenImportSchema, SharableBoundaryConfigSchema, SharableSecurityRulesSchema, VALID_SCOPES, LINE_PATTERN, START_PATTERN, END_PATTERN, CODE_BLOCK_LANGUAGES, DEFAULT_DRIFT_CONFIG, FILE_TYPES, EXPORT_TYPES, CONVENTION_DESCRIPTIONS, RULE_CHECKERS, EntropyAnalyzer, readFile42, writeFile32, unlink22, mkdir22, copyFile2, DEFAULT_FIX_CONFIG, EXPORT_TYPE_KEYWORD, ALWAYS_UNSAFE_TYPES, idCounter, DEAD_CODE_FIX_ACTIONS, MustExportRuleSchema, MustExportDefaultRuleSchema, NoExportRuleSchema, MustImportRuleSchema, NoImportRuleSchema, NamingRuleSchema, MaxExportsRuleSchema, MaxLinesRuleSchema, RequireJSDocRuleSchema, RuleSchema, ConfigPatternSchema, PatternConfigSchema, DriftConfigSchema, DeadCodeConfigSchema, EntropyConfigSchema, BaselineManager, BenchmarkRunner, RegressionDetector, SKIP_DIRS, SOURCE_EXTENSIONS, FUNCTION_DECL_RE, CONST_DECL_RE, CriticalPathResolver, NoOpTelemetryAdapter, NoOpExecutor, ConsoleSink, feedbackConfig, ChecklistBuilder, AgentActionEmitter, globalEmitter, FileSink, NoOpSink, CategorySnapshotSchema, TimelineSnapshotSchema, TimelineFileSchema, TrendLineSchema, TrendResultSchema, DEFAULT_STABILITY_THRESHOLDS, ALL_CATEGORIES, TimelineManager, ConfidenceTierSchema, RegressionResultSchema, DirectionSchema, CategoryForecastSchema, SpecImpactSignalsSchema, SpecImpactEstimateSchema, ContributingFeatureSchema, AdjustedForecastSchema, PredictionWarningSchema, StabilityForecastSchema, PredictionResultSchema, PredictionOptionsSchema, VALID_STATUSES, EM_DASH, VALID_PRIORITIES, ALL_CATEGORIES2, DIRECTION_THRESHOLD, PredictionEngine, DEFAULT_COEFFICIENTS, SpecImpactEstimator, EMPTY_HISTORY, ViolationHistoryManager, NORMALIZERS, MAX_SAMPLES, DEFAULT_WINDOW_WEEKS, DEFAULT_MIN_OCCURRENCES, FailureEntrySchema, HandoffSchema, GateCheckSchema, GateResultSchema, GateConfigSchema, HarnessStateSchema, DEFAULT_STATE, StreamInfoSchema, StreamIndexSchema, DEFAULT_STREAM_INDEX, HARNESS_DIR, STATE_FILE, LEARNINGS_FILE, FAILURES_FILE, HANDOFF_FILE, GATE_CONFIG_FILE, INDEX_FILE, SESSIONS_DIR, SESSION_INDEX_FILE, SUMMARY_FILE, SESSION_STATE_FILE, ARCHIVE_DIR, CONTENT_HASHES_FILE, EVENTS_FILE, STREAMS_DIR, STREAM_NAME_REGEX, branchCache, BRANCH_CACHE_TTL_MS, STATE_FILES, MAX_CACHE_ENTRIES, learningsCacheMap, WEIGHTS, LOCK_RETRIES, LOCK_BACKOFFS, PROMOTABLE_OUTCOMES, failuresCacheMap, FAILURE_LINE_REGEX, SAFE_GATE_COMMAND, SkillEventSchema, knownHashesCache, EVENT_FORMATTERS, RuleRegistry, DEFAULT_SECURITY_CONFIG, RuleOverrideSchema, SecurityConfigSchema, secretRules, injectionRules, xssRules, cryptoRules, pathTraversalRules, networkRules, deserializationRules, agentConfigRules, mcpRules, insecureDefaultsRules, sharpEdgesRules, nodeRules, expressRules, reactRules, goRules, SecurityScanner, hiddenUnicodePatterns, reRolingPatterns, permissionEscalationPatterns, encodedPayloadPatterns, indirectInjectionPatterns, contextManipulationPatterns, socialEngineeringPatterns, suspiciousPatterns, ALL_PATTERNS, DESTRUCTIVE_BASH, TAINT_DURATION_MS, DEFAULT_SESSION_ID, SecurityCategorySnapshotSchema, SupplyChainSnapshotSchema, SecurityTimelineSnapshotSchema, FindingLifecycleSchema, SecurityTimelineFileSchema, DirectionSchema2, SecurityTrendLineSchema, TrendAttributionSchema, SecurityTrendResultSchema, TimeToFixStatsSchema, TimeToFixResultSchema, EMPTY_SUPPLY_CHAIN, SecurityTimelineManager, ALL_CHECKS, STATUS_ICONS, CINotifier, ExclusionSet, PREFIX_PATTERNS, TEST_FILE_PATTERN, MD_FILE_PATTERN, ALL_DOMAINS, SECURITY_PATTERNS, SEVERITY_RANK, SEVERITY_ORDER, SEVERITY_LABELS, VALIDATED_BY_RANK, VALIDATION_SCORES, DOMAIN_BASELINES, FACTOR_WEIGHTS, EVIDENCE_SATURATION, CORROBORATED_AGREEMENT, STANDALONE_AGREEMENT, AGREEMENT_LINE_GAP, COMPLIANCE_DESCRIPTOR, EXPORT_RE, BUG_DETECTION_DESCRIPTOR, SECURITY_DESCRIPTOR, EVAL_PATTERN, SECRET_PATTERNS, SQL_CONCAT_PATTERN, SHELL_EXEC_PATTERN, ARCHITECTURE_DESCRIPTOR, LARGE_FILE_THRESHOLD, VIOLATION_FILE_RE, LEARNINGS_DESCRIPTOR, RELEVANCE_THRESHOLD, AGENT_DESCRIPTORS, AGENT_RUNNERS, DOWNGRADE_MAP, DEFAULT_PROVIDER_TIERS, SMALL_SUGGESTION_LINE_LIMIT, FILE_LINE_RANGE_PATTERN, FILE_LINE_PATTERN, FILE_ONLY_PATTERN, SECURITY_SENSITIVE_PATH, MIGRATION_PATH, TEST_PATH, CONFIG_PATH, STAGE_DOMAINS, EM_DASH2, STATUS_RANK, RETRY_DEFAULTS, GitHubIssuesSyncAdapter, syncMutex, PRIORITY_RANK, POSITION_WEIGHT, DEPENDENTS_WEIGHT, AFFINITY_WEIGHT, InteractionTypeSchema, QuestionSchema, ConfirmationSchema, TransitionSchema, EmitInteractionInputSchema, ProjectScanner, SHELL_TEMPLATE, STYLES, SCRIPTS, MockLLMService, llmService, ContentPipeline, BlueprintGenerator, TOKENS_PER_MILLION, fallback_default, LITELLM_PRICING_URL, CACHE_TTL_MS, STALENESS_WARNING_DAYS, MICRODOLLARS_PER_DOLLAR, TOKENS_PER_MILLION2, StructuralStrategy, DEFAULT_TOKEN_BUDGET, CHARS_PER_TOKEN, TRUNCATION_MARKER, TruncationStrategy, CompactionPipeline, STABILITY_LOOKUP, TIER_ORDER, AnthropicCacheAdapter, TIER_ORDER2, OpenAICacheAdapter, TIER_ORDER3, CACHED_CONTENT_MARKER, GeminiCacheAdapter, VERSION, POSTHOG_BATCH_URL, MAX_ATTEMPTS, TIMEOUT_MS;
+function acquireCompoundLock(category, opts = {}) {
+  if (!KNOWN_CATEGORIES.has(category)) {
+    throw new Error(
+      `Unknown category "${category}". Must be one of: ${[...KNOWN_CATEGORIES].join(", ")}`
+    );
+  }
+  const cwd = opts.cwd ?? process.cwd();
+  const lockDir = path39.join(cwd, ".harness", "locks");
+  fs40.mkdirSync(lockDir, { recursive: true });
+  const lockPath = path39.join(lockDir, `compound-${category}.lock`);
+  let fd;
+  try {
+    fd = fs40.openSync(lockPath, "wx");
+  } catch (e) {
+    const err = e;
+    if (err.code === "EEXIST") {
+      const holderPid = readHolderPid(lockPath);
+      throw new CompoundLockHeldError(category, holderPid, lockPath);
+    }
+    throw err;
+  }
+  fs40.writeSync(fd, String(process.pid));
+  fs40.closeSync(fd);
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    try {
+      fs40.unlinkSync(lockPath);
+    } catch {
+    }
+    process.removeListener("exit", onExit);
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+    process.removeListener("uncaughtException", onUncaught);
+  };
+  const onExit = () => release();
+  const onSignal = (sig) => {
+    release();
+    process.kill(process.pid, sig);
+  };
+  const onUncaught = (err) => {
+    release();
+    console.error(err && err.stack ? err.stack : err);
+    process.exit(1);
+  };
+  process.once("exit", onExit);
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  process.once("uncaughtException", onUncaught);
+  return { category, lockPath, release };
+}
+function readHolderPid(lockPath) {
+  try {
+    const raw = fs40.readFileSync(lockPath, "utf-8").trim();
+    const n = Number.parseInt(raw, 10);
+    return Number.isFinite(n) ? n : -1;
+  } catch {
+    return -1;
+  }
+}
+function isSanitizedResult(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (!v.fields || typeof v.fields !== "object") return false;
+  for (const k of Object.keys(v.fields)) {
+    if (!ALLOWED_SET.has(k)) return false;
+    if (PII_FIELD_DENYLIST.test(k)) return false;
+  }
+  if (!v.distributions || typeof v.distributions !== "object") return false;
+  return true;
+}
+function assertSanitized(value) {
+  if (!isSanitizedResult(value)) {
+    throw new Error("PII boundary violated: result is not a SanitizedResult");
+  }
+}
+function writePulseConfig(config, opts) {
+  PulseConfigSchema.parse(config);
+  if (!fs41.existsSync(opts.configPath)) {
+    throw new Error(`harness.config.json not found at ${opts.configPath}`);
+  }
+  const raw = fs41.readFileSync(opts.configPath, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`Invalid JSON in ${opts.configPath}: ${e.message}`, { cause: e });
+  }
+  const bakPath = `${opts.configPath}.bak`;
+  if (!opts.skipBackup && !fs41.existsSync(bakPath)) {
+    fs41.writeFileSync(bakPath, raw, "utf-8");
+  }
+  parsed.pulse = config;
+  const serialized = JSON.stringify(parsed, null, 2) + "\n";
+  const tmpPath = `${opts.configPath}.tmp-${process.pid}`;
+  fs41.writeFileSync(tmpPath, serialized, "utf-8");
+  try {
+    fs41.renameSync(tmpPath, opts.configPath);
+  } catch (e) {
+    try {
+      fs41.unlinkSync(tmpPath);
+    } catch {
+    }
+    throw e;
+  }
+}
+function seedFromStrategy(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const strategyPath = path40.join(cwd, "STRATEGY.md");
+  const warnings = [];
+  if (!fs42.existsSync(strategyPath)) {
+    return { name: null, keyMetrics: [], warnings: ["STRATEGY.md not found"] };
+  }
+  const raw = fs42.readFileSync(strategyPath, "utf-8");
+  let name = null;
+  const fmMatch = /^---\s*\n([\s\S]*?)\n---\s*\n/.exec(raw);
+  const fm = fmMatch?.[1];
+  if (fm !== void 0) {
+    const nameMatch = /^name:\s*['"]?([^'"\n]+)['"]?\s*$/m.exec(fm);
+    const nameCapture = nameMatch?.[1];
+    if (nameCapture !== void 0) {
+      name = nameCapture.trim();
+    }
+  }
+  if (name === null) {
+    const h1 = /^#\s+(.+)$/m.exec(raw);
+    const h1Capture = h1?.[1];
+    if (h1Capture !== void 0) {
+      name = h1Capture.trim();
+      warnings.push("STRATEGY.md frontmatter missing name; used H1 fallback");
+    }
+  }
+  const keyMetrics = [];
+  const headerMatch = /^##\s+Key metrics\s*$/m.exec(raw);
+  if (headerMatch && headerMatch.index !== void 0) {
+    const startIdx = headerMatch.index + headerMatch[0].length;
+    const after = raw.slice(startIdx);
+    const stopMatch = /^(#{1,3})\s+/m.exec(after);
+    const block = stopMatch ? after.slice(0, stopMatch.index) : after;
+    for (const line of block.split("\n")) {
+      const m = /^[-*]\s+(.+)$/.exec(line.trim());
+      const capture = m?.[1];
+      if (capture !== void 0) keyMetrics.push(capture.trim());
+    }
+  } else {
+    warnings.push("STRATEGY.md is missing a `## Key metrics` section");
+  }
+  return { name, keyMetrics, warnings };
+}
+function registerPulseAdapter(name, adapter2) {
+  if (!adapter2 || typeof adapter2 !== "object") {
+    throw new TypeError(`Pulse adapter "${name}" must be an object with query and sanitize.`);
+  }
+  if (typeof adapter2.query !== "function") {
+    throw new TypeError(`Pulse adapter "${name}" is missing required field: query`);
+  }
+  if (typeof adapter2.sanitize !== "function") {
+    throw new TypeError(`Pulse adapter "${name}" is missing required field: sanitize`);
+  }
+  if (REGISTRY.has(name)) {
+    throw new PulseAdapterAlreadyRegisteredError(name);
+  }
+  REGISTRY.set(name, adapter2);
+}
+function getPulseAdapter(name) {
+  return REGISTRY.get(name);
+}
+function listPulseAdapters() {
+  return [...REGISTRY.keys()].sort();
+}
+function clearPulseAdapters() {
+  REGISTRY.clear();
+}
+function registerMockAdapter() {
+  if (listPulseAdapters().includes(MOCK_ADAPTER_NAME)) return;
+  registerPulseAdapter(MOCK_ADAPTER_NAME, adapter);
+}
+function parseLookback(input) {
+  const match = LOOKBACK_RE.exec(input);
+  if (!match) {
+    throw new Error(`Invalid lookback "${input}": expected format like "24h" or "7d"`);
+  }
+  const n = Number(match[1]);
+  const unit = match[2];
+  return unit === "h" ? n * 60 * 60 * 1e3 : n * 24 * 60 * 60 * 1e3;
+}
+function computeWindow(now, lookback, bufferMinutes = 15) {
+  const lookbackMs = parseLookback(lookback);
+  const bufferMs = bufferMinutes * 60 * 1e3;
+  const end = new Date(now.getTime() - bufferMs);
+  const start = new Date(end.getTime() - lookbackMs);
+  return { start, end };
+}
+async function querySource(name, window) {
+  const adapter2 = getPulseAdapter(name);
+  if (!adapter2) {
+    return {
+      ok: false,
+      skipKind: "no-adapter",
+      reason: `no adapter registered for "${name}"`
+    };
+  }
+  let sanitized;
+  try {
+    const raw = await adapter2.query(window);
+    sanitized = adapter2.sanitize(raw);
+  } catch (err) {
+    return {
+      ok: false,
+      skipKind: "query-failure",
+      reason: err instanceof Error ? err.message : String(err)
+    };
+  }
+  try {
+    assertSanitized(sanitized);
+  } catch (err) {
+    return {
+      ok: false,
+      skipKind: "pii-violation",
+      reason: err instanceof Error ? err.message : String(err)
+    };
+  }
+  return { ok: true, result: sanitized };
+}
+async function runPulse(config, window) {
+  const startedAt = Date.now();
+  const sources = [];
+  const sourcesQueried = [];
+  const sourcesSkipped = [];
+  const parallelSlots = [
+    ["analytics", config.sources.analytics],
+    ["tracing", config.sources.tracing],
+    ["payments", config.sources.payments]
+  ];
+  const parallelEntries = parallelSlots.filter(
+    (slot) => slot[1] != null
+  );
+  const parallelResults = await Promise.all(
+    parallelEntries.map(([kind, n]) => querySource(n, window).then((r) => [kind, n, r]))
+  );
+  for (const [kind, name, r] of parallelResults) {
+    if (r.ok) {
+      sources.push({ kind, name, result: r.result });
+      sourcesQueried.push(name);
+    } else {
+      sourcesSkipped.push({ name, kind, skipKind: r.skipKind, reason: r.reason });
+    }
+  }
+  if (config.sources.db.enabled && config.sources.db.source) {
+    const name = config.sources.db.source;
+    const r = await querySource(name, window);
+    if (r.ok) {
+      sources.push({ kind: "db", name, result: r.result });
+      sourcesQueried.push(name);
+    } else {
+      sourcesSkipped.push({ name, kind: "db", skipKind: r.skipKind, reason: r.reason });
+    }
+  }
+  return { sources, sourcesQueried, sourcesSkipped, durationMs: Date.now() - startedAt };
+}
+function loadTemplate() {
+  try {
+    const url = import.meta?.url;
+    if (!url) return INLINE_TEMPLATE;
+    const here = dirname18(fileURLToPath(url));
+    return readFileSync36(join572(here, "template.md"), "utf-8");
+  } catch {
+    return INLINE_TEMPLATE;
+  }
+}
+function totalCount(s) {
+  const c = s.fields.count;
+  return typeof c === "number" ? c : 0;
+}
+function buildHeadlines(r) {
+  const total = r.sources.reduce((sum, s) => sum + totalCount(s.result), 0);
+  return [
+    `- ${r.sourcesQueried.length} source(s) queried in ${r.durationMs}ms`,
+    `- ${total} total events recorded`,
+    `- ${r.sourcesSkipped.length} source(s) skipped`
+  ].join("\n");
+}
+function buildUsage(r) {
+  if (r.sources.length === 0) return "_(none)_";
+  return r.sources.map((s) => {
+    const name = s.result.fields.event_name ?? "unknown";
+    const count = totalCount(s.result);
+    return `- ${name}: count=${count}`;
+  }).join("\n");
+}
+function buildSystemPerformance(r) {
+  const tracing = r.sources.find((s) => s.kind === "tracing") ?? null;
+  if (!tracing) return "_(no tracing source configured)_";
+  const dist = tracing.result.distributions;
+  const lines = Object.entries(dist).map(([k, v]) => `- ${k}: ${JSON.stringify(v)}`);
+  return lines.length > 0 ? lines.join("\n") : "_(no distributions)_";
+}
+function buildFollowups(r) {
+  if (r.sourcesSkipped.length === 0) return "_(none)_";
+  return r.sourcesSkipped.map((s) => `- ${s.name} skipped: ${s.reason}`).join("\n");
+}
+function finalPiiSweep(text) {
+  return text.split("\n").filter((l) => {
+    if (l.startsWith("# ") || l.startsWith("## ")) return true;
+    return !PII_LINE_RE.test(l);
+  }).join("\n");
+}
+function truncateSection(lines, startIdx, endIdx) {
+  const head = lines.slice(0, startIdx + 1);
+  const section = lines.slice(startIdx + 1, endIdx);
+  const tail = lines.slice(endIdx);
+  let truncated = false;
+  while (head.length + section.length + tail.length + (truncated ? 0 : 1) > MAX_LINES && section.length > 0) {
+    section.pop();
+    truncated = true;
+  }
+  if (truncated) section.push(TRUNCATION_MARKER2);
+  return [...head, ...section, ...tail];
+}
+function truncateToFit(text) {
+  let lines = text.split("\n");
+  if (lines.length <= MAX_LINES) return text;
+  const sections = [
+    { header: "## Followups" },
+    { header: "## System performance" },
+    { header: "## Usage" }
+  ];
+  for (const { header } of sections) {
+    if (lines.length <= MAX_LINES) break;
+    const startIdx = lines.findIndex((l) => l === header || l.startsWith(`${header} `));
+    if (startIdx < 0) continue;
+    let endIdx = lines.length;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+      const line = lines[i];
+      if (line !== void 0 && line.startsWith("## ")) {
+        endIdx = i;
+        break;
+      }
+    }
+    lines = truncateSection(lines, startIdx, endIdx);
+  }
+  if (lines.length > MAX_LINES) lines = lines.slice(0, MAX_LINES);
+  return lines.join("\n");
+}
+function assembleReport(result, productName, windowLabel) {
+  const template = loadTemplate();
+  const filled = template.replace("{{productName}}", productName).replace("{{windowLabel}}", windowLabel).replace("{{headlines}}", buildHeadlines(result)).replace("{{usage}}", buildUsage(result)).replace("{{systemPerformance}}", buildSystemPerformance(result)).replace("{{followups}}", buildFollowups(result));
+  const swept = finalPiiSweep(filled);
+  return truncateToFit(swept);
+}
+function extractHeadlines(report) {
+  const lines = report.split("\n");
+  const headlinesIdx = lines.findIndex((l) => l === "## Headlines" || l.startsWith("## Headlines"));
+  if (headlinesIdx < 0) return lines.slice(0, 5).join("\n");
+  let endIdx = lines.length;
+  for (let i = headlinesIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line !== void 0 && line.startsWith("## ")) {
+      endIdx = i;
+      break;
+    }
+  }
+  while (endIdx > headlinesIdx + 1 && lines[endIdx - 1] === "") endIdx--;
+  return lines.slice(0, endIdx).join("\n");
+}
+function isoWeek(date) {
+  const d = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+  const dayNum = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+  const year = d.getUTCFullYear();
+  const yearStart = new Date(Date.UTC(year, 0, 1));
+  const week = Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+  return { year, week };
+}
+function formatIsoWeek(w) {
+  return `${w.year}-W${String(w.week).padStart(2, "0")}`;
+}
+function normalizeSince(since) {
+  const m = /^(\d+)(h|d|w|mo)$/i.exec(since.trim());
+  if (!m) {
+    throw new Error(
+      `Invalid lookback "${since}": expected format like "24h", "7d", "4w", or "3mo"`
+    );
+  }
+  const n = m[1];
+  const unit = m[2]?.toLowerCase();
+  switch (unit) {
+    case "h":
+      return `${n} hours ago`;
+    case "d":
+      return `${n} days ago`;
+    case "w":
+      return `${n} weeks ago`;
+    case "mo":
+      return `${n} months ago`;
+    default:
+      throw new Error(`Invalid lookback "${since}"`);
+  }
+}
+async function readCommits(opts) {
+  let stdout;
+  try {
+    const r = await execFileAsync(
+      "git",
+      ["log", `--since=${normalizeSince(opts.since)}`, "--name-only", "--format=%x1e%H%x1f%s"],
+      { cwd: opts.cwd, maxBuffer: 16 * 1024 * 1024 }
+    );
+    stdout = r.stdout;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (EMPTY_REPO_RE.test(msg)) {
+      process.stderr.write(`gitScan: empty repo or non-repo at ${opts.cwd}; returning []
+`);
+      return [];
+    }
+    throw err;
+  }
+  const records = stdout.split("").filter((r) => r.trim().length > 0);
+  return records.map((rec) => {
+    const [header, ...fileLines] = rec.split("\n");
+    const [sha, subject] = (header ?? "").split("");
+    const files = fileLines.map((l) => l.trim()).filter((l) => l.length > 0);
+    return { sha: sha ?? "", subject: subject ?? "", files };
+  });
+}
+async function gitScan(opts) {
+  const all = await readCommits(opts);
+  const fixes = all.filter((c) => FIX_RE.test(c.subject));
+  return fixes.map((c) => {
+    const overlap = all.filter(
+      (other) => other.sha !== c.sha && other.files.some((f) => c.files.includes(f))
+    ).length;
+    return {
+      sha: c.sha,
+      subject: c.subject,
+      filesChanged: c.files.length,
+      branchIterations: overlap
+    };
+  });
+}
+async function computeHotspots(opts) {
+  let stdout;
+  try {
+    const r = await execFileAsync2(
+      "git",
+      ["log", `--since=${normalizeSince(opts.since)}`, "--name-only", "--format="],
+      { cwd: opts.cwd, maxBuffer: 16 * 1024 * 1024 }
+    );
+    stdout = r.stdout;
+  } catch {
+    return [];
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of stdout.split("\n")) {
+    const path42 = line.trim();
+    if (path42.length === 0) continue;
+    counts.set(path42, (counts.get(path42) ?? 0) + 1);
+  }
+  return [...counts.entries()].filter(([, c]) => c > opts.threshold).map(([path42, churn]) => ({ path: path42, churn })).sort((a, b) => b.churn - a.churn);
+}
+function tokenize(text) {
+  return new Set(
+    text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length > 2 && !STOPWORDS.has(t))
+  );
+}
+async function* walk22(dir) {
+  let entries;
+  try {
+    entries = await fs43.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    const p = path41.join(dir, e.name);
+    if (e.isDirectory()) yield* walk22(p);
+    else if (e.isFile() && e.name.endsWith(".md")) yield p;
+  }
+}
+async function readDocumentedTokens(solutionsDir) {
+  const docs = [];
+  for (const [track, categories] of TRACK_CATEGORIES2) {
+    for (const category of categories) {
+      const dir = path41.join(solutionsDir, track, category);
+      for await (const file of walk22(dir)) {
+        const raw = await fs43.readFile(file, "utf-8");
+        const m = /^#\s+(.+)$/m.exec(raw);
+        const title = m?.[1] ?? path41.basename(file, ".md");
+        docs.push(tokenize(title));
+      }
+    }
+  }
+  return docs;
+}
+function jaccard(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let inter = 0;
+  for (const t of a) if (b.has(t)) inter++;
+  const union = a.size + b.size - inter;
+  return union === 0 ? 0 : inter / union;
+}
+async function crossReferenceUndocumentedFixes(commits, solutionsDir) {
+  const documented = await readDocumentedTokens(solutionsDir);
+  const OVERLAP_THRESHOLD = 0.4;
+  return commits.filter((c) => {
+    const tokens = tokenize(c.subject);
+    return !documented.some((d) => jaccard(tokens, d) >= OVERLAP_THRESHOLD);
+  });
+}
+function suggestCategory(subject) {
+  for (const [re, cat] of KEYWORD_TO_CATEGORY) if (re.test(subject)) return cat;
+  return "bug-track/logic-errors";
+}
+function descriptor(subject) {
+  return subject.replace(/^fix(\([^)]+\))?:\s*/i, "").trim();
+}
+function assembleCandidateReport(input) {
+  const week = formatIsoWeek(input.isoWeek);
+  const lines = [];
+  lines.push(`# Compound candidates \u2014 week ${week}`, "");
+  lines.push(`## Undocumented fixes (from \`git log\` past ${input.lookback})`, "");
+  if (input.undocumentedFixes.length === 0) {
+    lines.push("_(none this week)_", "");
+  } else {
+    for (const c of input.undocumentedFixes) {
+      const d = descriptor(c.subject);
+      const cat = suggestCategory(c.subject);
+      lines.push(
+        `- **${c.subject}** (commit ${c.sha.slice(0, 7)}, ${c.filesChanged} file(s), ${c.branchIterations} related commits)`
+      );
+      lines.push(`  - Suggested category: ${cat}`);
+      lines.push(`  - Run: \`/harness:compound "${d}"\``);
+    }
+    lines.push("");
+  }
+  lines.push("## Pattern candidates (from churn + hotspot analysis)", "");
+  if (input.hotspotCandidates.length === 0) {
+    lines.push("_(none this week)_", "");
+  } else {
+    for (const h of input.hotspotCandidates) {
+      lines.push(
+        `- File \`${h.path}\` has ${h.churn} commits in ${input.lookback}; no docs/solutions/ entry`
+      );
+      lines.push("  - Suggested category: knowledge-track/architecture-patterns");
+      lines.push(`  - Run: \`/harness:compound "${h.path} pattern"\``);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var VALID_TYPES, CONVENTIONAL_PATTERN, LOOKBACK_PATTERN, PulseDbSourceSchema, PulseSourcesSchema, PulseConfigSchema, BUG_TRACK_CATEGORIES, KNOWLEDGE_TRACK_CATEGORIES, ALL_SOLUTION_CATEGORIES, ISO_DATE, BugTrackSchema, KnowledgeTrackSchema, BaseFrontmatter, SolutionDocFrontmatterSchema, TRACK_CATEGORIES, DEFAULT_AGNIX_TIMEOUT_MS, HARNESS_AGNIX_DISABLE, HARNESS_AGNIX_BIN, CLAUDE_MD_WARN_BYTES, CLAUDE_MD_ERROR_BYTES, CONTEXT_FILES, MIN_DESCRIPTION_LENGTH, SETTINGS_PATHS, KNOWN_HOOK_EVENTS, MCP_SETTINGS_FILES, REQUIRED_SECTIONS, SETTINGS_FILES, KNOWN_AGNIX_TOOLS, DEFAULT_SECTIONS, DEFAULT_RATIOS, NODE_TYPE_TO_CATEGORY, SECTION_LEVEL_MAP, DEFAULT_LEVEL, DEFAULT_BUDGET, DEFAULT_LOADER_CONFIG, LEVEL_FRACTIONS, PHASE_PRIORITIES, ManifestSchema, BundleConstraintsSchema, BundleSchema, ContributionsSchema, LockfilePackageSchema, LockfileSchema, SharableLayerSchema, SharableForbiddenImportSchema, SharableBoundaryConfigSchema, SharableSecurityRulesSchema, VALID_SCOPES, LINE_PATTERN, START_PATTERN, END_PATTERN, CODE_BLOCK_LANGUAGES, DEFAULT_DRIFT_CONFIG, FILE_TYPES, EXPORT_TYPES, CONVENTION_DESCRIPTIONS, RULE_CHECKERS, EntropyAnalyzer, readFile62, writeFile32, unlink22, mkdir22, copyFile2, DEFAULT_FIX_CONFIG, EXPORT_TYPE_KEYWORD, ALWAYS_UNSAFE_TYPES, idCounter, DEAD_CODE_FIX_ACTIONS, MustExportRuleSchema, MustExportDefaultRuleSchema, NoExportRuleSchema, MustImportRuleSchema, NoImportRuleSchema, NamingRuleSchema, MaxExportsRuleSchema, MaxLinesRuleSchema, RequireJSDocRuleSchema, RuleSchema, ConfigPatternSchema, PatternConfigSchema, DriftConfigSchema, DeadCodeConfigSchema, EntropyConfigSchema, BaselineManager, BenchmarkRunner, RegressionDetector, SKIP_DIRS, SOURCE_EXTENSIONS, FUNCTION_DECL_RE, CONST_DECL_RE, CriticalPathResolver, NoOpTelemetryAdapter, NoOpExecutor, ConsoleSink, feedbackConfig, ChecklistBuilder, AgentActionEmitter, globalEmitter, FileSink, NoOpSink, CategorySnapshotSchema, TimelineSnapshotSchema, TimelineFileSchema, TrendLineSchema, TrendResultSchema, DEFAULT_STABILITY_THRESHOLDS, ALL_CATEGORIES, TimelineManager, ConfidenceTierSchema, RegressionResultSchema, DirectionSchema, CategoryForecastSchema, SpecImpactSignalsSchema, SpecImpactEstimateSchema, ContributingFeatureSchema, AdjustedForecastSchema, PredictionWarningSchema, StabilityForecastSchema, PredictionResultSchema, PredictionOptionsSchema, VALID_STATUSES, EM_DASH, VALID_PRIORITIES, ALL_CATEGORIES2, DIRECTION_THRESHOLD, PredictionEngine, DEFAULT_COEFFICIENTS, SpecImpactEstimator, EMPTY_HISTORY, ViolationHistoryManager, NORMALIZERS, MAX_SAMPLES, DEFAULT_WINDOW_WEEKS, DEFAULT_MIN_OCCURRENCES, FailureEntrySchema, HandoffSchema, GateCheckSchema, GateResultSchema, GateConfigSchema, HarnessStateSchema, DEFAULT_STATE, StreamInfoSchema, StreamIndexSchema, DEFAULT_STREAM_INDEX, HARNESS_DIR, STATE_FILE, LEARNINGS_FILE, FAILURES_FILE, HANDOFF_FILE, GATE_CONFIG_FILE, INDEX_FILE, SESSIONS_DIR, SESSION_INDEX_FILE, SUMMARY_FILE, SESSION_STATE_FILE, ARCHIVE_DIR, CONTENT_HASHES_FILE, EVENTS_FILE, STREAMS_DIR, STREAM_NAME_REGEX, branchCache, BRANCH_CACHE_TTL_MS, STATE_FILES, MAX_CACHE_ENTRIES, learningsCacheMap, WEIGHTS, LOCK_RETRIES, LOCK_BACKOFFS, PROMOTABLE_OUTCOMES, failuresCacheMap, FAILURE_LINE_REGEX, SAFE_GATE_COMMAND, SkillEventSchema, knownHashesCache, EVENT_FORMATTERS, RuleRegistry, DEFAULT_SECURITY_CONFIG, RuleOverrideSchema, SecurityConfigSchema, secretRules, injectionRules, xssRules, cryptoRules, pathTraversalRules, networkRules, deserializationRules, agentConfigRules, mcpRules, insecureDefaultsRules, sharpEdgesRules, nodeRules, expressRules, reactRules, goRules, SecurityScanner, hiddenUnicodePatterns, reRolingPatterns, permissionEscalationPatterns, encodedPayloadPatterns, indirectInjectionPatterns, contextManipulationPatterns, socialEngineeringPatterns, suspiciousPatterns, ALL_PATTERNS, DESTRUCTIVE_BASH, TAINT_DURATION_MS, DEFAULT_SESSION_ID, SecurityCategorySnapshotSchema, SupplyChainSnapshotSchema, SecurityTimelineSnapshotSchema, FindingLifecycleSchema, SecurityTimelineFileSchema, DirectionSchema2, SecurityTrendLineSchema, TrendAttributionSchema, SecurityTrendResultSchema, TimeToFixStatsSchema, TimeToFixResultSchema, EMPTY_SUPPLY_CHAIN, SecurityTimelineManager, ALL_CHECKS, STATUS_ICONS, CINotifier, ExclusionSet, PREFIX_PATTERNS, TEST_FILE_PATTERN, MD_FILE_PATTERN, ALL_DOMAINS, SECURITY_PATTERNS, SEVERITY_RANK, SEVERITY_ORDER, SEVERITY_LABELS, VALIDATED_BY_RANK, VALIDATION_SCORES, DOMAIN_BASELINES, FACTOR_WEIGHTS, EVIDENCE_SATURATION, CORROBORATED_AGREEMENT, STANDALONE_AGREEMENT, AGREEMENT_LINE_GAP, COMPLIANCE_DESCRIPTOR, EXPORT_RE, BUG_DETECTION_DESCRIPTOR, SECURITY_DESCRIPTOR, EVAL_PATTERN, SECRET_PATTERNS, SQL_CONCAT_PATTERN, SHELL_EXEC_PATTERN, ARCHITECTURE_DESCRIPTOR, LARGE_FILE_THRESHOLD, VIOLATION_FILE_RE, LEARNINGS_DESCRIPTOR, RELEVANCE_THRESHOLD, AGENT_DESCRIPTORS, AGENT_RUNNERS, DOWNGRADE_MAP, DEFAULT_PROVIDER_TIERS, SMALL_SUGGESTION_LINE_LIMIT, FILE_LINE_RANGE_PATTERN, FILE_LINE_PATTERN, FILE_ONLY_PATTERN, SECURITY_SENSITIVE_PATH, MIGRATION_PATH, TEST_PATH, CONFIG_PATH, STAGE_DOMAINS, EM_DASH2, STATUS_RANK, RETRY_DEFAULTS, GitHubIssuesSyncAdapter, syncMutex, PRIORITY_RANK, POSITION_WEIGHT, DEPENDENTS_WEIGHT, AFFINITY_WEIGHT, InteractionTypeSchema, QuestionSchema, ConfirmationSchema, TransitionSchema, EmitInteractionInputSchema, ProjectScanner, SHELL_TEMPLATE, STYLES, SCRIPTS, MockLLMService, llmService, ContentPipeline, BlueprintGenerator, TOKENS_PER_MILLION, fallback_default, LITELLM_PRICING_URL, CACHE_TTL_MS, STALENESS_WARNING_DAYS, MICRODOLLARS_PER_DOLLAR, TOKENS_PER_MILLION2, StructuralStrategy, DEFAULT_TOKEN_BUDGET, CHARS_PER_TOKEN, TRUNCATION_MARKER, TruncationStrategy, CompactionPipeline, STABILITY_LOOKUP, TIER_ORDER, AnthropicCacheAdapter, TIER_ORDER2, OpenAICacheAdapter, TIER_ORDER3, CACHED_CONTENT_MARKER, GeminiCacheAdapter, VERSION, POSTHOG_BATCH_URL, MAX_ATTEMPTS, TIMEOUT_MS, CompoundLockHeldError, KNOWN_CATEGORIES, ALLOWED_FIELD_KEYS, PII_TOKENS, PII_FIELD_DENYLIST, PII_LINE_RE, ALLOWED_SET, PulseAdapterAlreadyRegisteredError, REGISTRY, MOCK_ADAPTER_NAME, ALLOWED_FIELD_SET, adapter, LOOKBACK_RE, MAX_LINES, INLINE_TEMPLATE, TRUNCATION_MARKER2, execFileAsync, FIX_RE, EMPTY_REPO_RE, execFileAsync2, TRACK_CATEGORIES2, STOPWORDS, KEYWORD_TO_CATEGORY;
 var init_dist3 = __esm({
   "../core/dist/index.mjs"() {
     init_chunk_H73442AZ();
@@ -14050,6 +14735,76 @@ var init_dist3 = __esm({
       "revert"
     ];
     CONVENTIONAL_PATTERN = /^(\w+)(\(([^)]+)\))?(!)?: (.+)$/;
+    LOOKBACK_PATTERN = /^\d+(h|d|w)$/;
+    PulseDbSourceSchema = z2.object({
+      enabled: z2.boolean(),
+      connectionEnv: z2.string().optional()
+    });
+    PulseSourcesSchema = z2.object({
+      analytics: z2.string().nullable(),
+      tracing: z2.string().nullable(),
+      payments: z2.string().nullable(),
+      db: PulseDbSourceSchema
+    });
+    PulseConfigSchema = z2.object({
+      enabled: z2.boolean(),
+      lookbackDefault: z2.string().regex(LOOKBACK_PATTERN, 'lookback must be like "24h", "7d", or "1w"'),
+      primaryEvent: z2.string(),
+      valueEvent: z2.string(),
+      completionEvents: z2.array(z2.string()),
+      qualityScoring: z2.boolean(),
+      qualityDimension: z2.string().nullable(),
+      sources: PulseSourcesSchema,
+      metricSourceOverrides: z2.record(z2.string(), z2.string()),
+      pendingMetrics: z2.array(z2.string()),
+      excludedMetrics: z2.array(z2.string())
+    });
+    BUG_TRACK_CATEGORIES = [
+      "build-errors",
+      "test-failures",
+      "runtime-errors",
+      "performance-issues",
+      "database-issues",
+      "security-issues",
+      "ui-bugs",
+      "integration-issues",
+      "logic-errors"
+    ];
+    KNOWLEDGE_TRACK_CATEGORIES = [
+      "architecture-patterns",
+      "design-patterns",
+      "tooling-decisions",
+      "conventions",
+      "dx",
+      "best-practices"
+    ];
+    ALL_SOLUTION_CATEGORIES = [
+      ...BUG_TRACK_CATEGORIES,
+      ...KNOWLEDGE_TRACK_CATEGORIES
+    ];
+    ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+    BugTrackSchema = z22.object({
+      track: z22.literal("bug-track"),
+      category: z22.enum(BUG_TRACK_CATEGORIES)
+    });
+    KnowledgeTrackSchema = z22.object({
+      track: z22.literal("knowledge-track"),
+      category: z22.enum(KNOWLEDGE_TRACK_CATEGORIES)
+    });
+    BaseFrontmatter = z22.object({
+      module: z22.string().min(1),
+      tags: z22.array(z22.string()),
+      problem_type: z22.string().min(1),
+      last_updated: z22.string().regex(ISO_DATE, "last_updated must be ISO date YYYY-MM-DD")
+    });
+    SolutionDocFrontmatterSchema = z22.discriminatedUnion("track", [
+      BaseFrontmatter.merge(BugTrackSchema),
+      BaseFrontmatter.merge(KnowledgeTrackSchema)
+    ]);
+    TRACK_CATEGORIES = [
+      ["bug-track", BUG_TRACK_CATEGORIES],
+      ["knowledge-track", KNOWLEDGE_TRACK_CATEGORIES]
+    ];
     DEFAULT_AGNIX_TIMEOUT_MS = 3e4;
     HARNESS_AGNIX_DISABLE = "HARNESS_AGNIX_DISABLE";
     HARNESS_AGNIX_BIN = "HARNESS_AGNIX_BIN";
@@ -14196,81 +14951,81 @@ var init_dist3 = __esm({
         { category: "config", patterns: ["harness.config.json", "package.json"], priority: 5 }
       ]
     };
-    ManifestSchema = z2.object({
-      name: z2.string(),
-      version: z2.string(),
-      description: z2.string().optional(),
-      include: z2.array(z2.string()).min(1),
-      minHarnessVersion: z2.string().optional(),
-      keywords: z2.array(z2.string()).optional().default([]),
-      layers: z2.record(z2.array(z2.string())).optional(),
-      boundaries: z2.array(
-        z2.object({
-          name: z2.string(),
-          layer: z2.string(),
-          direction: z2.enum(["input", "output"]),
-          schema: z2.string()
+    ManifestSchema = z3.object({
+      name: z3.string(),
+      version: z3.string(),
+      description: z3.string().optional(),
+      include: z3.array(z3.string()).min(1),
+      minHarnessVersion: z3.string().optional(),
+      keywords: z3.array(z3.string()).optional().default([]),
+      layers: z3.record(z3.array(z3.string())).optional(),
+      boundaries: z3.array(
+        z3.object({
+          name: z3.string(),
+          layer: z3.string(),
+          direction: z3.enum(["input", "output"]),
+          schema: z3.string()
         })
       ).optional()
     });
-    BundleConstraintsSchema = z2.object({
-      layers: z2.array(
-        z2.object({
-          name: z2.string(),
-          pattern: z2.string(),
-          allowedDependencies: z2.array(z2.string())
+    BundleConstraintsSchema = z3.object({
+      layers: z3.array(
+        z3.object({
+          name: z3.string(),
+          pattern: z3.string(),
+          allowedDependencies: z3.array(z3.string())
         })
       ).optional(),
-      forbiddenImports: z2.array(
-        z2.object({
-          from: z2.string(),
-          disallow: z2.array(z2.string()),
-          message: z2.string().optional()
+      forbiddenImports: z3.array(
+        z3.object({
+          from: z3.string(),
+          disallow: z3.array(z3.string()),
+          message: z3.string().optional()
         })
       ).optional(),
-      boundaries: z2.object({
-        requireSchema: z2.array(z2.string()).optional()
+      boundaries: z3.object({
+        requireSchema: z3.array(z3.string()).optional()
       }).optional(),
-      architecture: z2.object({
-        thresholds: z2.record(z2.unknown()).optional(),
-        modules: z2.record(z2.record(z2.unknown())).optional()
+      architecture: z3.object({
+        thresholds: z3.record(z3.unknown()).optional(),
+        modules: z3.record(z3.record(z3.unknown())).optional()
       }).optional(),
-      security: z2.object({
-        rules: z2.record(z2.string()).optional()
+      security: z3.object({
+        rules: z3.record(z3.string()).optional()
       }).optional()
     });
-    BundleSchema = z2.object({
-      name: z2.string(),
-      version: z2.string(),
-      description: z2.string().optional(),
-      minHarnessVersion: z2.string().optional(),
+    BundleSchema = z3.object({
+      name: z3.string(),
+      version: z3.string(),
+      description: z3.string().optional(),
+      minHarnessVersion: z3.string().optional(),
       manifest: ManifestSchema,
       constraints: BundleConstraintsSchema,
-      contributions: z2.record(z2.unknown()).optional()
+      contributions: z3.record(z3.unknown()).optional()
     });
-    ContributionsSchema = z2.record(z2.unknown());
-    LockfilePackageSchema = z2.object({
-      version: z2.string(),
-      source: z2.string(),
-      installedAt: z2.string(),
-      contributions: z2.record(z2.unknown()).optional().nullable(),
-      resolved: z2.string().optional(),
-      integrity: z2.string().optional(),
-      provenance: z2.array(z2.string()).optional()
+    ContributionsSchema = z3.record(z3.unknown());
+    LockfilePackageSchema = z3.object({
+      version: z3.string(),
+      source: z3.string(),
+      installedAt: z3.string(),
+      contributions: z3.record(z3.unknown()).optional().nullable(),
+      resolved: z3.string().optional(),
+      integrity: z3.string().optional(),
+      provenance: z3.array(z3.string()).optional()
     });
-    LockfileSchema = z2.object({
-      version: z2.literal(1).optional(),
+    LockfileSchema = z3.object({
+      version: z3.literal(1).optional(),
       // Used by some tests
-      lockfileVersion: z2.literal(1).optional(),
+      lockfileVersion: z3.literal(1).optional(),
       // Standard field
-      packages: z2.record(LockfilePackageSchema)
+      packages: z3.record(LockfilePackageSchema)
     }).refine((data) => data.version !== void 0 || data.lockfileVersion !== void 0, {
       message: "Either 'version' or 'lockfileVersion' must be present and equal to 1"
     });
-    SharableLayerSchema = z2.unknown();
-    SharableForbiddenImportSchema = z2.unknown();
-    SharableBoundaryConfigSchema = z2.unknown();
-    SharableSecurityRulesSchema = z2.unknown();
+    SharableLayerSchema = z3.unknown();
+    SharableForbiddenImportSchema = z3.unknown();
+    SharableBoundaryConfigSchema = z3.unknown();
+    SharableSecurityRulesSchema = z3.unknown();
     VALID_SCOPES = /* @__PURE__ */ new Set([
       "entropy",
       "architecture",
@@ -14541,11 +15296,11 @@ var init_dist3 = __esm({
         return detectPatternViolations(snapshotResult.value, config);
       }
     };
-    readFile42 = promisify2(fs3.readFile);
-    writeFile32 = promisify2(fs3.writeFile);
-    unlink22 = promisify2(fs3.unlink);
-    mkdir22 = promisify2(fs3.mkdir);
-    copyFile2 = promisify2(fs3.copyFile);
+    readFile62 = promisify2(fs5.readFile);
+    writeFile32 = promisify2(fs5.writeFile);
+    unlink22 = promisify2(fs5.unlink);
+    mkdir22 = promisify2(fs5.mkdir);
+    copyFile2 = promisify2(fs5.copyFile);
     DEFAULT_FIX_CONFIG = {
       dryRun: false,
       fixTypes: ["unused-imports", "dead-files"],
@@ -14573,45 +15328,45 @@ var init_dist3 = __esm({
       "commented-code": "Delete commented block",
       "unused-import": "Remove import"
     };
-    MustExportRuleSchema = z22.object({
-      type: z22.literal("must-export"),
-      names: z22.array(z22.string())
+    MustExportRuleSchema = z4.object({
+      type: z4.literal("must-export"),
+      names: z4.array(z4.string())
     });
-    MustExportDefaultRuleSchema = z22.object({
-      type: z22.literal("must-export-default"),
-      kind: z22.enum(["class", "function", "object"]).optional()
+    MustExportDefaultRuleSchema = z4.object({
+      type: z4.literal("must-export-default"),
+      kind: z4.enum(["class", "function", "object"]).optional()
     });
-    NoExportRuleSchema = z22.object({
-      type: z22.literal("no-export"),
-      names: z22.array(z22.string())
+    NoExportRuleSchema = z4.object({
+      type: z4.literal("no-export"),
+      names: z4.array(z4.string())
     });
-    MustImportRuleSchema = z22.object({
-      type: z22.literal("must-import"),
-      from: z22.string(),
-      names: z22.array(z22.string()).optional()
+    MustImportRuleSchema = z4.object({
+      type: z4.literal("must-import"),
+      from: z4.string(),
+      names: z4.array(z4.string()).optional()
     });
-    NoImportRuleSchema = z22.object({
-      type: z22.literal("no-import"),
-      from: z22.string()
+    NoImportRuleSchema = z4.object({
+      type: z4.literal("no-import"),
+      from: z4.string()
     });
-    NamingRuleSchema = z22.object({
-      type: z22.literal("naming"),
-      match: z22.string(),
-      convention: z22.enum(["camelCase", "PascalCase", "UPPER_SNAKE", "kebab-case"])
+    NamingRuleSchema = z4.object({
+      type: z4.literal("naming"),
+      match: z4.string(),
+      convention: z4.enum(["camelCase", "PascalCase", "UPPER_SNAKE", "kebab-case"])
     });
-    MaxExportsRuleSchema = z22.object({
-      type: z22.literal("max-exports"),
-      count: z22.number().positive()
+    MaxExportsRuleSchema = z4.object({
+      type: z4.literal("max-exports"),
+      count: z4.number().positive()
     });
-    MaxLinesRuleSchema = z22.object({
-      type: z22.literal("max-lines"),
-      count: z22.number().positive()
+    MaxLinesRuleSchema = z4.object({
+      type: z4.literal("max-lines"),
+      count: z4.number().positive()
     });
-    RequireJSDocRuleSchema = z22.object({
-      type: z22.literal("require-jsdoc"),
-      for: z22.array(z22.enum(["function", "class", "export"]))
+    RequireJSDocRuleSchema = z4.object({
+      type: z4.literal("require-jsdoc"),
+      for: z4.array(z4.enum(["function", "class", "export"]))
     });
-    RuleSchema = z22.discriminatedUnion("type", [
+    RuleSchema = z4.discriminatedUnion("type", [
       MustExportRuleSchema,
       MustExportDefaultRuleSchema,
       NoExportRuleSchema,
@@ -14622,52 +15377,52 @@ var init_dist3 = __esm({
       MaxLinesRuleSchema,
       RequireJSDocRuleSchema
     ]);
-    ConfigPatternSchema = z22.object({
-      name: z22.string().min(1),
-      description: z22.string(),
-      severity: z22.enum(["error", "warning"]),
-      files: z22.array(z22.string()),
+    ConfigPatternSchema = z4.object({
+      name: z4.string().min(1),
+      description: z4.string(),
+      severity: z4.enum(["error", "warning"]),
+      files: z4.array(z4.string()),
       rule: RuleSchema,
-      message: z22.string().optional()
+      message: z4.string().optional()
     });
-    PatternConfigSchema = z22.object({
-      patterns: z22.array(ConfigPatternSchema),
-      customPatterns: z22.array(z22.any()).optional(),
+    PatternConfigSchema = z4.object({
+      patterns: z4.array(ConfigPatternSchema),
+      customPatterns: z4.array(z4.any()).optional(),
       // Code patterns are functions, can't validate
-      ignoreFiles: z22.array(z22.string()).optional()
+      ignoreFiles: z4.array(z4.string()).optional()
     });
-    DriftConfigSchema = z22.object({
-      docPaths: z22.array(z22.string()).optional(),
-      checkApiSignatures: z22.boolean().optional(),
-      checkExamples: z22.boolean().optional(),
-      checkStructure: z22.boolean().optional(),
-      ignorePatterns: z22.array(z22.string()).optional()
+    DriftConfigSchema = z4.object({
+      docPaths: z4.array(z4.string()).optional(),
+      checkApiSignatures: z4.boolean().optional(),
+      checkExamples: z4.boolean().optional(),
+      checkStructure: z4.boolean().optional(),
+      ignorePatterns: z4.array(z4.string()).optional()
     });
-    DeadCodeConfigSchema = z22.object({
-      entryPoints: z22.array(z22.string()).optional(),
-      includeTypes: z22.boolean().optional(),
-      includeInternals: z22.boolean().optional(),
-      ignorePatterns: z22.array(z22.string()).optional(),
-      treatDynamicImportsAs: z22.enum(["used", "unknown"]).optional()
+    DeadCodeConfigSchema = z4.object({
+      entryPoints: z4.array(z4.string()).optional(),
+      includeTypes: z4.boolean().optional(),
+      includeInternals: z4.boolean().optional(),
+      ignorePatterns: z4.array(z4.string()).optional(),
+      treatDynamicImportsAs: z4.enum(["used", "unknown"]).optional()
     });
-    EntropyConfigSchema = z22.object({
-      rootDir: z22.string(),
-      parser: z22.any().optional(),
+    EntropyConfigSchema = z4.object({
+      rootDir: z4.string(),
+      parser: z4.any().optional(),
       // LanguageParser instance, can't validate
-      entryPoints: z22.array(z22.string()).optional(),
-      analyze: z22.object({
-        drift: z22.union([z22.boolean(), DriftConfigSchema]).optional(),
-        deadCode: z22.union([z22.boolean(), DeadCodeConfigSchema]).optional(),
-        patterns: z22.union([z22.boolean(), PatternConfigSchema]).optional()
+      entryPoints: z4.array(z4.string()).optional(),
+      analyze: z4.object({
+        drift: z4.union([z4.boolean(), DriftConfigSchema]).optional(),
+        deadCode: z4.union([z4.boolean(), DeadCodeConfigSchema]).optional(),
+        patterns: z4.union([z4.boolean(), PatternConfigSchema]).optional()
       }),
-      include: z22.array(z22.string()).optional(),
-      exclude: z22.array(z22.string()).optional(),
-      docPaths: z22.array(z22.string()).optional()
+      include: z4.array(z4.string()).optional(),
+      exclude: z4.array(z4.string()).optional(),
+      docPaths: z4.array(z4.string()).optional()
     });
     BaselineManager = class {
       baselinesPath;
       constructor(projectRoot) {
-        this.baselinesPath = join15(projectRoot, ".harness", "perf", "baselines.json");
+        this.baselinesPath = join17(projectRoot, ".harness", "perf", "baselines.json");
       }
       /**
        * Load the baselines file from disk.
@@ -14942,16 +15697,16 @@ var init_dist3 = __esm({
       walkDir(dir, entries) {
         let items;
         try {
-          items = fs4.readdirSync(dir, { withFileTypes: true });
+          items = fs6.readdirSync(dir, { withFileTypes: true });
         } catch {
           return;
         }
         for (const item of items) {
           if (item.isDirectory()) {
             if (SKIP_DIRS.has(item.name)) continue;
-            this.walkDir(path.join(dir, item.name), entries);
-          } else if (item.isFile() && SOURCE_EXTENSIONS.has(path.extname(item.name))) {
-            this.scanFile(path.join(dir, item.name), entries);
+            this.walkDir(path3.join(dir, item.name), entries);
+          } else if (item.isFile() && SOURCE_EXTENSIONS.has(path3.extname(item.name))) {
+            this.scanFile(path3.join(dir, item.name), entries);
           }
         }
       }
@@ -14966,12 +15721,12 @@ var init_dist3 = __esm({
       scanFile(filePath, entries) {
         let content;
         try {
-          content = fs4.readFileSync(filePath, "utf-8");
+          content = fs6.readFileSync(filePath, "utf-8");
         } catch {
           return;
         }
         const lines = content.split("\n");
-        const relativePath = path.relative(this.projectRoot, filePath).replace(/\\/g, "/");
+        const relativePath = path3.relative(this.projectRoot, filePath).replace(/\\/g, "/");
         for (let i = 0; i < lines.length; i++) {
           if (!lines[i].includes("@perf-critical")) continue;
           const fnName = this.resolveFunctionName(lines, i + 1);
@@ -15370,46 +16125,46 @@ var init_dist3 = __esm({
         return Ok(void 0);
       }
     };
-    CategorySnapshotSchema = z3.object({
+    CategorySnapshotSchema = z5.object({
       /** Aggregate metric value (e.g., violation count, avg complexity) */
-      value: z3.number(),
+      value: z5.number(),
       /** Count of violations in this category */
-      violationCount: z3.number()
+      violationCount: z5.number()
     });
-    TimelineSnapshotSchema = z3.object({
+    TimelineSnapshotSchema = z5.object({
       /** ISO 8601 timestamp of capture */
-      capturedAt: z3.string().datetime(),
+      capturedAt: z5.string().datetime(),
       /** Git commit hash at capture time */
-      commitHash: z3.string(),
+      commitHash: z5.string(),
       /** Composite stability score (0-100, higher is healthier) */
-      stabilityScore: z3.number().min(0).max(100),
+      stabilityScore: z5.number().min(0).max(100),
       /** Per-category metric aggregates */
-      metrics: z3.record(ArchMetricCategorySchema, CategorySnapshotSchema)
+      metrics: z5.record(ArchMetricCategorySchema, CategorySnapshotSchema)
     });
-    TimelineFileSchema = z3.object({
-      version: z3.literal(1),
-      snapshots: z3.array(TimelineSnapshotSchema)
+    TimelineFileSchema = z5.object({
+      version: z5.literal(1),
+      snapshots: z5.array(TimelineSnapshotSchema)
     });
-    TrendLineSchema = z3.object({
+    TrendLineSchema = z5.object({
       /** Current value */
-      current: z3.number(),
+      current: z5.number(),
       /** Previous value (from comparison snapshot) */
-      previous: z3.number(),
+      previous: z5.number(),
       /** Absolute delta (current - previous) */
-      delta: z3.number(),
+      delta: z5.number(),
       /** Direction indicator */
-      direction: z3.enum(["improving", "stable", "declining"])
+      direction: z5.enum(["improving", "stable", "declining"])
     });
-    TrendResultSchema = z3.object({
+    TrendResultSchema = z5.object({
       /** Overall stability trend */
       stability: TrendLineSchema,
       /** Per-category trends */
-      categories: z3.record(ArchMetricCategorySchema, TrendLineSchema),
+      categories: z5.record(ArchMetricCategorySchema, TrendLineSchema),
       /** Number of snapshots analyzed */
-      snapshotCount: z3.number(),
+      snapshotCount: z5.number(),
       /** Time range covered */
-      from: z3.string(),
-      to: z3.string()
+      from: z5.string(),
+      to: z5.string()
     });
     DEFAULT_STABILITY_THRESHOLDS = {
       "circular-deps": 5,
@@ -15424,7 +16179,7 @@ var init_dist3 = __esm({
     TimelineManager = class {
       timelinePath;
       constructor(rootDir) {
-        this.timelinePath = join17(rootDir, ".harness", "arch", "timeline.json");
+        this.timelinePath = join19(rootDir, ".harness", "arch", "timeline.json");
       }
       /**
        * Load timeline from disk.
@@ -15608,80 +16363,80 @@ var init_dist3 = __esm({
         };
       }
     };
-    ConfidenceTierSchema = z4.enum(["high", "medium", "low"]);
-    RegressionResultSchema = z4.object({
-      slope: z4.number(),
-      intercept: z4.number(),
-      rSquared: z4.number().min(0).max(1),
-      dataPoints: z4.number().int().min(0)
+    ConfidenceTierSchema = z6.enum(["high", "medium", "low"]);
+    RegressionResultSchema = z6.object({
+      slope: z6.number(),
+      intercept: z6.number(),
+      rSquared: z6.number().min(0).max(1),
+      dataPoints: z6.number().int().min(0)
     });
-    DirectionSchema = z4.enum(["improving", "stable", "declining"]);
-    CategoryForecastSchema = z4.object({
+    DirectionSchema = z6.enum(["improving", "stable", "declining"]);
+    CategoryForecastSchema = z6.object({
       category: ArchMetricCategorySchema,
-      current: z4.number(),
-      threshold: z4.number(),
-      projectedValue4w: z4.number(),
-      projectedValue8w: z4.number(),
-      projectedValue12w: z4.number(),
-      thresholdCrossingWeeks: z4.number().nullable(),
+      current: z6.number(),
+      threshold: z6.number(),
+      projectedValue4w: z6.number(),
+      projectedValue8w: z6.number(),
+      projectedValue12w: z6.number(),
+      thresholdCrossingWeeks: z6.number().nullable(),
       confidence: ConfidenceTierSchema,
       regression: RegressionResultSchema,
       direction: DirectionSchema
     });
-    SpecImpactSignalsSchema = z4.object({
-      newFileCount: z4.number().int().min(0),
-      affectedLayers: z4.array(z4.string()),
-      newDependencies: z4.number().int().min(0),
-      phaseCount: z4.number().int().min(0)
+    SpecImpactSignalsSchema = z6.object({
+      newFileCount: z6.number().int().min(0),
+      affectedLayers: z6.array(z6.string()),
+      newDependencies: z6.number().int().min(0),
+      phaseCount: z6.number().int().min(0)
     });
-    SpecImpactEstimateSchema = z4.object({
-      specPath: z4.string(),
-      featureName: z4.string(),
+    SpecImpactEstimateSchema = z6.object({
+      specPath: z6.string(),
+      featureName: z6.string(),
       signals: SpecImpactSignalsSchema,
-      deltas: z4.record(ArchMetricCategorySchema, z4.number()).optional()
+      deltas: z6.record(ArchMetricCategorySchema, z6.number()).optional()
     });
-    ContributingFeatureSchema = z4.object({
-      name: z4.string(),
-      specPath: z4.string(),
-      delta: z4.number()
+    ContributingFeatureSchema = z6.object({
+      name: z6.string(),
+      specPath: z6.string(),
+      delta: z6.number()
     });
-    AdjustedForecastSchema = z4.object({
+    AdjustedForecastSchema = z6.object({
       baseline: CategoryForecastSchema,
       adjusted: CategoryForecastSchema,
-      contributingFeatures: z4.array(ContributingFeatureSchema)
+      contributingFeatures: z6.array(ContributingFeatureSchema)
     });
-    PredictionWarningSchema = z4.object({
-      severity: z4.enum(["critical", "warning", "info"]),
+    PredictionWarningSchema = z6.object({
+      severity: z6.enum(["critical", "warning", "info"]),
       category: ArchMetricCategorySchema,
-      message: z4.string(),
-      weeksUntil: z4.number(),
+      message: z6.string(),
+      weeksUntil: z6.number(),
       confidence: ConfidenceTierSchema,
-      contributingFeatures: z4.array(z4.string())
+      contributingFeatures: z6.array(z6.string())
     });
-    StabilityForecastSchema = z4.object({
-      current: z4.number(),
-      projected4w: z4.number(),
-      projected8w: z4.number(),
-      projected12w: z4.number(),
+    StabilityForecastSchema = z6.object({
+      current: z6.number(),
+      projected4w: z6.number(),
+      projected8w: z6.number(),
+      projected12w: z6.number(),
       confidence: ConfidenceTierSchema,
       direction: DirectionSchema
     });
-    PredictionResultSchema = z4.object({
-      generatedAt: z4.string(),
-      snapshotsUsed: z4.number().int().min(0),
-      timelineRange: z4.object({
-        from: z4.string(),
-        to: z4.string()
+    PredictionResultSchema = z6.object({
+      generatedAt: z6.string(),
+      snapshotsUsed: z6.number().int().min(0),
+      timelineRange: z6.object({
+        from: z6.string(),
+        to: z6.string()
       }),
       stabilityForecast: StabilityForecastSchema,
-      categories: z4.record(ArchMetricCategorySchema, AdjustedForecastSchema),
-      warnings: z4.array(PredictionWarningSchema)
+      categories: z6.record(ArchMetricCategorySchema, AdjustedForecastSchema),
+      warnings: z6.array(PredictionWarningSchema)
     });
-    PredictionOptionsSchema = z4.object({
-      horizon: z4.number().int().min(1).default(12),
-      includeRoadmap: z4.boolean().default(true),
-      categories: z4.array(ArchMetricCategorySchema).optional(),
-      thresholds: z4.record(ArchMetricCategorySchema, z4.number()).optional()
+    PredictionOptionsSchema = z6.object({
+      horizon: z6.number().int().min(1).default(12),
+      includeRoadmap: z6.boolean().default(true),
+      categories: z6.array(ArchMetricCategorySchema).optional(),
+      thresholds: z6.record(ArchMetricCategorySchema, z6.number()).optional()
     });
     VALID_STATUSES = /* @__PURE__ */ new Set([
       "backlog",
@@ -16014,8 +16769,8 @@ var init_dist3 = __esm({
           return null;
         }
         try {
-          const roadmapPath = path2.join(this.rootDir, "roadmap.md");
-          const raw = fs5.readFileSync(roadmapPath, "utf-8");
+          const roadmapPath = path4.join(this.rootDir, "roadmap.md");
+          const raw = fs7.readFileSync(roadmapPath, "utf-8");
           const parseResult = parseRoadmap(raw);
           if (!parseResult.ok) return null;
           const features = parseResult.value.milestones.flatMap(
@@ -16050,8 +16805,8 @@ var init_dist3 = __esm({
        * @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 absolutePath = path5.join(this.rootDir, specPath);
+        const content = fs8.readFileSync(absolutePath, "utf-8");
         const newFileCount = this.extractNewFileCount(content);
         const affectedLayers = this.extractAffectedLayers(content);
         const newDependencies = this.extractNewDependencies(content);
@@ -16063,7 +16818,7 @@ var init_dist3 = __esm({
           phaseCount
         );
         const h1Match = content.match(/^#\s+(.+)$/m);
-        const featureName = h1Match ? h1Match[1].trim() : path3.basename(specPath, ".md");
+        const featureName = h1Match ? h1Match[1].trim() : path5.basename(specPath, ".md");
         return {
           specPath,
           featureName,
@@ -16084,8 +16839,8 @@ var init_dist3 = __esm({
         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 absolutePath = path5.join(this.rootDir, feature.spec);
+          if (!fs8.existsSync(absolutePath)) continue;
           const estimate = this.estimate(feature.spec);
           results.push({ ...estimate, featureName: feature.name });
         }
@@ -16113,8 +16868,8 @@ var init_dist3 = __esm({
         }
         let count = 0;
         for (const fp of filePaths) {
-          const absolute = path3.join(this.rootDir, fp);
-          if (!fs6.existsSync(absolute)) {
+          const absolute = path5.join(this.rootDir, fp);
+          if (!fs8.existsSync(absolute)) {
             count++;
           }
         }
@@ -16184,8 +16939,8 @@ var init_dist3 = __esm({
       // --- Private: Config Loading ---
       loadLayerNames() {
         try {
-          const configPath = path3.join(this.rootDir, "harness.config.json");
-          const raw = fs6.readFileSync(configPath, "utf-8");
+          const configPath = path5.join(this.rootDir, "harness.config.json");
+          const raw = fs8.readFileSync(configPath, "utf-8");
           const config = JSON.parse(raw);
           return (config.layers ?? []).map((l) => l.name);
         } catch {
@@ -16204,8 +16959,8 @@ var init_dist3 = __esm({
       historyPath;
       /** Load history from disk, returning empty history if file doesn't exist. */
       load() {
-        if (!fs7.existsSync(this.historyPath)) return { ...EMPTY_HISTORY, snapshots: [] };
-        const raw = fs7.readFileSync(this.historyPath, "utf-8");
+        if (!fs9.existsSync(this.historyPath)) return { ...EMPTY_HISTORY, snapshots: [] };
+        const raw = fs9.readFileSync(this.historyPath, "utf-8");
         return JSON.parse(raw);
       }
       /** Append a timestamped snapshot of current violations. */
@@ -16219,18 +16974,18 @@ var init_dist3 = __esm({
       }
       /** Prune snapshots older than retentionDays. */
       prune(retentionDays) {
-        if (!fs7.existsSync(this.historyPath)) return;
+        if (!fs9.existsSync(this.historyPath)) return;
         const history = this.load();
         const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
         history.snapshots = history.snapshots.filter((s) => new Date(s.timestamp).getTime() >= cutoff);
         this.write(history);
       }
       write(history) {
-        const dir = path4.dirname(this.historyPath);
-        if (!fs7.existsSync(dir)) {
-          fs7.mkdirSync(dir, { recursive: true });
+        const dir = path6.dirname(this.historyPath);
+        if (!fs9.existsSync(dir)) {
+          fs9.mkdirSync(dir, { recursive: true });
         }
-        fs7.writeFileSync(this.historyPath, JSON.stringify(history, null, 2), "utf-8");
+        fs9.writeFileSync(this.historyPath, JSON.stringify(history, null, 2), "utf-8");
       }
     };
     NORMALIZERS = {
@@ -16245,81 +17000,81 @@ var init_dist3 = __esm({
     MAX_SAMPLES = 5;
     DEFAULT_WINDOW_WEEKS = 4;
     DEFAULT_MIN_OCCURRENCES = 3;
-    FailureEntrySchema = z5.object({
-      date: z5.string(),
-      skill: z5.string(),
-      type: z5.string(),
-      description: z5.string()
+    FailureEntrySchema = z7.object({
+      date: z7.string(),
+      skill: z7.string(),
+      type: z7.string(),
+      description: z7.string()
     });
-    HandoffSchema = z5.object({
-      timestamp: z5.string(),
-      fromSkill: z5.string(),
-      phase: z5.string(),
-      summary: z5.string(),
-      completed: z5.array(z5.string()).default([]),
-      pending: z5.array(z5.string()).default([]),
-      concerns: z5.array(z5.string()).default([]),
-      decisions: z5.array(
-        z5.object({
-          what: z5.string(),
-          why: z5.string()
+    HandoffSchema = z7.object({
+      timestamp: z7.string(),
+      fromSkill: z7.string(),
+      phase: z7.string(),
+      summary: z7.string(),
+      completed: z7.array(z7.string()).default([]),
+      pending: z7.array(z7.string()).default([]),
+      concerns: z7.array(z7.string()).default([]),
+      decisions: z7.array(
+        z7.object({
+          what: z7.string(),
+          why: z7.string()
         })
       ).default([]),
-      blockers: z5.array(z5.string()).default([]),
-      contextKeywords: z5.array(z5.string()).default([]),
-      recommendedSkills: z5.object({
-        apply: z5.array(z5.string()),
-        reference: z5.array(z5.string()),
-        consider: z5.array(z5.string()),
-        skillsPath: z5.string()
+      blockers: z7.array(z7.string()).default([]),
+      contextKeywords: z7.array(z7.string()).default([]),
+      recommendedSkills: z7.object({
+        apply: z7.array(z7.string()),
+        reference: z7.array(z7.string()),
+        consider: z7.array(z7.string()),
+        skillsPath: z7.string()
       }).optional()
     });
-    GateCheckSchema = z5.object({
-      name: z5.string(),
-      passed: z5.boolean(),
-      command: z5.string(),
-      output: z5.string().optional(),
-      duration: z5.number().optional()
+    GateCheckSchema = z7.object({
+      name: z7.string(),
+      passed: z7.boolean(),
+      command: z7.string(),
+      output: z7.string().optional(),
+      duration: z7.number().optional()
     });
-    GateResultSchema = z5.object({
-      passed: z5.boolean(),
-      checks: z5.array(GateCheckSchema)
+    GateResultSchema = z7.object({
+      passed: z7.boolean(),
+      checks: z7.array(GateCheckSchema)
     });
-    GateConfigSchema = z5.object({
-      checks: z5.array(
-        z5.object({
-          name: z5.string(),
-          command: z5.string()
+    GateConfigSchema = z7.object({
+      checks: z7.array(
+        z7.object({
+          name: z7.string(),
+          command: z7.string()
         })
       ).optional(),
-      trace: z5.boolean().optional()
+      trace: z7.boolean().optional()
     });
-    HarnessStateSchema = z5.object({
-      schemaVersion: z5.literal(1),
-      position: z5.object({
-        phase: z5.string().optional(),
-        task: z5.string().optional()
+    HarnessStateSchema = z7.object({
+      schemaVersion: z7.literal(1),
+      position: z7.object({
+        phase: z7.string().optional(),
+        task: z7.string().optional()
       }).default({}),
-      decisions: z5.array(
-        z5.object({
-          date: z5.string(),
-          decision: z5.string(),
-          context: z5.string()
+      decisions: z7.array(
+        z7.object({
+          date: z7.string(),
+          decision: z7.string(),
+          context: z7.string()
         })
       ).default([]),
-      blockers: z5.array(
-        z5.object({
-          id: z5.string(),
-          description: z5.string(),
-          status: z5.enum(["open", "resolved"])
+      blockers: z7.array(
+        z7.object({
+          id: z7.string(),
+          description: z7.string(),
+          status: z7.enum(["open", "resolved"])
         })
       ).default([]),
-      progress: z5.record(z5.enum(["pending", "in_progress", "complete"])).default({}),
-      lastSession: z5.object({
-        date: z5.string(),
-        summary: z5.string(),
-        lastSkill: z5.string().optional(),
-        pendingTasks: z5.array(z5.string()).optional()
+      progress: z7.record(z7.enum(["pending", "in_progress", "complete"])).default({}),
+      lastSession: z7.object({
+        date: z7.string(),
+        summary: z7.string(),
+        lastSkill: z7.string().optional(),
+        pendingTasks: z7.array(z7.string()).optional()
       }).optional()
     });
     DEFAULT_STATE = {
@@ -16329,16 +17084,16 @@ var init_dist3 = __esm({
       blockers: [],
       progress: {}
     };
-    StreamInfoSchema = z6.object({
-      name: z6.string(),
-      branch: z6.string().optional(),
-      createdAt: z6.string(),
-      lastActiveAt: z6.string()
+    StreamInfoSchema = z8.object({
+      name: z8.string(),
+      branch: z8.string().optional(),
+      createdAt: z8.string(),
+      lastActiveAt: z8.string()
     });
-    StreamIndexSchema = z6.object({
-      schemaVersion: z6.literal(1),
-      activeStream: z6.string().nullable(),
-      streams: z6.record(StreamInfoSchema)
+    StreamIndexSchema = z8.object({
+      schemaVersion: z8.literal(1),
+      activeStream: z8.string().nullable(),
+      streams: z8.record(StreamInfoSchema)
     });
     DEFAULT_STREAM_INDEX = {
       schemaVersion: 1,
@@ -16379,15 +17134,15 @@ var init_dist3 = __esm({
     failuresCacheMap = /* @__PURE__ */ new Map();
     FAILURE_LINE_REGEX = /^- \*\*(\d{4}-\d{2}-\d{2}) \[skill:([^\]]+)\] \[type:([^\]]+)\]:\*\* (.+)$/;
     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:.-]+$/;
-    SkillEventSchema = z7.object({
-      timestamp: z7.string(),
-      skill: z7.string(),
-      session: z7.string().optional(),
-      type: z7.enum(["phase_transition", "decision", "gate_result", "handoff", "error", "checkpoint"]),
-      summary: z7.string(),
-      data: z7.record(z7.unknown()).optional(),
-      refs: z7.array(z7.string()).optional(),
-      contentHash: z7.string().optional()
+    SkillEventSchema = z9.object({
+      timestamp: z9.string(),
+      skill: z9.string(),
+      session: z9.string().optional(),
+      type: z9.enum(["phase_transition", "decision", "gate_result", "handoff", "error", "checkpoint"]),
+      summary: z9.string(),
+      data: z9.record(z9.unknown()).optional(),
+      refs: z9.array(z9.string()).optional(),
+      contentHash: z9.string().optional()
     });
     knownHashesCache = /* @__PURE__ */ new Map();
     EVENT_FORMATTERS = {
@@ -16430,19 +17185,19 @@ var init_dist3 = __esm({
       rules: {},
       exclude: ["**/node_modules/**", "**/dist/**", "**/*.test.ts", "**/fixtures/**"]
     };
-    RuleOverrideSchema = z8.enum(["off", "error", "warning", "info"]);
-    SecurityConfigSchema = z8.object({
-      enabled: z8.boolean().default(true),
-      strict: z8.boolean().default(false),
-      rules: z8.record(z8.string(), RuleOverrideSchema).optional().default({}),
-      exclude: z8.array(z8.string()).optional().default(["**/node_modules/**", "**/dist/**", "**/*.test.ts", "**/fixtures/**"]),
-      external: z8.object({
-        semgrep: z8.object({
-          enabled: z8.union([z8.literal("auto"), z8.boolean()]).default("auto"),
-          rulesets: z8.array(z8.string()).optional()
+    RuleOverrideSchema = z10.enum(["off", "error", "warning", "info"]);
+    SecurityConfigSchema = z10.object({
+      enabled: z10.boolean().default(true),
+      strict: z10.boolean().default(false),
+      rules: z10.record(z10.string(), RuleOverrideSchema).optional().default({}),
+      exclude: z10.array(z10.string()).optional().default(["**/node_modules/**", "**/dist/**", "**/*.test.ts", "**/fixtures/**"]),
+      external: z10.object({
+        semgrep: z10.object({
+          enabled: z10.union([z10.literal("auto"), z10.boolean()]).default("auto"),
+          rulesets: z10.array(z10.string()).optional()
         }).optional(),
-        gitleaks: z8.object({
-          enabled: z8.union([z8.literal("auto"), z8.boolean()]).default("auto")
+        gitleaks: z10.object({
+          enabled: z10.union([z10.literal("auto"), z10.boolean()]).default("auto")
         }).optional()
       }).optional()
     });
@@ -17232,7 +17987,7 @@ var init_dist3 = __esm({
       }
       async scanFile(filePath) {
         if (!this.config.enabled) return [];
-        const content = await fs25.readFile(filePath, "utf-8");
+        const content = await fs27.readFile(filePath, "utf-8");
         return this.scanContentForFile(content, filePath, 1);
       }
       scanContentForFile(content, filePath, startLine = 1) {
@@ -17541,88 +18296,88 @@ var init_dist3 = __esm({
     ];
     TAINT_DURATION_MS = 30 * 60 * 1e3;
     DEFAULT_SESSION_ID = "default";
-    SecurityCategorySnapshotSchema = z9.object({
-      findingCount: z9.number(),
-      errorCount: z9.number(),
-      warningCount: z9.number(),
-      infoCount: z9.number()
+    SecurityCategorySnapshotSchema = z11.object({
+      findingCount: z11.number(),
+      errorCount: z11.number(),
+      warningCount: z11.number(),
+      infoCount: z11.number()
     });
-    SupplyChainSnapshotSchema = z9.object({
-      critical: z9.number(),
-      high: z9.number(),
-      moderate: z9.number(),
-      low: z9.number(),
-      info: z9.number(),
-      total: z9.number()
+    SupplyChainSnapshotSchema = z11.object({
+      critical: z11.number(),
+      high: z11.number(),
+      moderate: z11.number(),
+      low: z11.number(),
+      info: z11.number(),
+      total: z11.number()
     });
-    SecurityTimelineSnapshotSchema = z9.object({
-      capturedAt: z9.string().datetime(),
-      commitHash: z9.string(),
-      securityScore: z9.number().min(0).max(100),
-      totalFindings: z9.number(),
-      bySeverity: z9.object({
-        error: z9.number(),
-        warning: z9.number(),
-        info: z9.number()
+    SecurityTimelineSnapshotSchema = z11.object({
+      capturedAt: z11.string().datetime(),
+      commitHash: z11.string(),
+      securityScore: z11.number().min(0).max(100),
+      totalFindings: z11.number(),
+      bySeverity: z11.object({
+        error: z11.number(),
+        warning: z11.number(),
+        info: z11.number()
       }),
-      byCategory: z9.record(z9.string(), SecurityCategorySnapshotSchema),
+      byCategory: z11.record(z11.string(), SecurityCategorySnapshotSchema),
       supplyChain: SupplyChainSnapshotSchema,
-      suppressionCount: z9.number(),
-      findingIds: z9.array(z9.string())
+      suppressionCount: z11.number(),
+      findingIds: z11.array(z11.string())
     });
-    FindingLifecycleSchema = z9.object({
-      findingId: z9.string(),
-      ruleId: z9.string(),
-      category: z9.string(),
-      severity: z9.string(),
-      file: z9.string(),
-      firstSeenAt: z9.string().datetime(),
-      firstSeenCommit: z9.string(),
-      resolvedAt: z9.string().datetime().nullable(),
-      resolvedCommit: z9.string().nullable()
+    FindingLifecycleSchema = z11.object({
+      findingId: z11.string(),
+      ruleId: z11.string(),
+      category: z11.string(),
+      severity: z11.string(),
+      file: z11.string(),
+      firstSeenAt: z11.string().datetime(),
+      firstSeenCommit: z11.string(),
+      resolvedAt: z11.string().datetime().nullable(),
+      resolvedCommit: z11.string().nullable()
     });
-    SecurityTimelineFileSchema = z9.object({
-      version: z9.literal(1),
-      snapshots: z9.array(SecurityTimelineSnapshotSchema),
-      findingLifecycles: z9.array(FindingLifecycleSchema)
+    SecurityTimelineFileSchema = z11.object({
+      version: z11.literal(1),
+      snapshots: z11.array(SecurityTimelineSnapshotSchema),
+      findingLifecycles: z11.array(FindingLifecycleSchema)
     });
-    DirectionSchema2 = z9.enum(["improving", "stable", "declining"]);
-    SecurityTrendLineSchema = z9.object({
-      current: z9.number(),
-      previous: z9.number(),
-      delta: z9.number(),
+    DirectionSchema2 = z11.enum(["improving", "stable", "declining"]);
+    SecurityTrendLineSchema = z11.object({
+      current: z11.number(),
+      previous: z11.number(),
+      delta: z11.number(),
       direction: DirectionSchema2
     });
-    TrendAttributionSchema = z9.object({
-      category: z9.string(),
-      delta: z9.number(),
+    TrendAttributionSchema = z11.object({
+      category: z11.string(),
+      delta: z11.number(),
       direction: DirectionSchema2,
-      description: z9.string()
+      description: z11.string()
     });
-    SecurityTrendResultSchema = z9.object({
+    SecurityTrendResultSchema = z11.object({
       score: SecurityTrendLineSchema,
       totalFindings: SecurityTrendLineSchema,
-      bySeverity: z9.object({
+      bySeverity: z11.object({
         error: SecurityTrendLineSchema,
         warning: SecurityTrendLineSchema,
         info: SecurityTrendLineSchema
       }),
       supplyChain: SecurityTrendLineSchema,
-      snapshotCount: z9.number(),
-      from: z9.string(),
-      to: z9.string(),
-      attribution: z9.array(TrendAttributionSchema)
+      snapshotCount: z11.number(),
+      from: z11.string(),
+      to: z11.string(),
+      attribution: z11.array(TrendAttributionSchema)
     });
-    TimeToFixStatsSchema = z9.object({
-      mean: z9.number(),
-      median: z9.number(),
-      count: z9.number()
+    TimeToFixStatsSchema = z11.object({
+      mean: z11.number(),
+      median: z11.number(),
+      count: z11.number()
     });
-    TimeToFixResultSchema = z9.object({
+    TimeToFixResultSchema = z11.object({
       overall: TimeToFixStatsSchema,
-      byCategory: z9.record(z9.string(), TimeToFixStatsSchema),
-      openFindings: z9.number(),
-      oldestOpenDays: z9.number().nullable()
+      byCategory: z11.record(z11.string(), TimeToFixStatsSchema),
+      openFindings: z11.number(),
+      oldestOpenDays: z11.number().nullable()
     });
     EMPTY_SUPPLY_CHAIN = {
       critical: 0,
@@ -17637,7 +18392,7 @@ var init_dist3 = __esm({
       timelinePath;
       constructor(rootDir) {
         this.rootDir = rootDir;
-        this.timelinePath = join372(rootDir, ".harness", "security", "timeline.json");
+        this.timelinePath = join39(rootDir, ".harness", "security", "timeline.json");
       }
       /**
        * Load timeline from disk.
@@ -18015,8 +18770,8 @@ var init_dist3 = __esm({
       skip: "\u23ED\uFE0F"
     };
     CINotifier = class {
-      constructor(adapter, repo) {
-        this.adapter = adapter;
+      constructor(adapter2, repo) {
+        this.adapter = adapter2;
         this.repo = repo;
       }
       adapter;
@@ -18667,28 +19422,28 @@ var init_dist3 = __esm({
     POSITION_WEIGHT = 0.5;
     DEPENDENTS_WEIGHT = 0.3;
     AFFINITY_WEIGHT = 0.2;
-    InteractionTypeSchema = z10.enum(["question", "confirmation", "transition"]);
-    QuestionSchema = z10.object({
-      text: z10.string(),
-      options: z10.array(z10.string()).optional(),
-      default: z10.string().optional()
+    InteractionTypeSchema = z12.enum(["question", "confirmation", "transition"]);
+    QuestionSchema = z12.object({
+      text: z12.string(),
+      options: z12.array(z12.string()).optional(),
+      default: z12.string().optional()
     });
-    ConfirmationSchema = z10.object({
-      text: z10.string(),
-      context: z10.string()
+    ConfirmationSchema = z12.object({
+      text: z12.string(),
+      context: z12.string()
     });
-    TransitionSchema = z10.object({
-      completedPhase: z10.string(),
-      suggestedNext: z10.string(),
-      reason: z10.string(),
-      artifacts: z10.array(z10.string()),
-      requiresConfirmation: z10.boolean(),
-      summary: z10.string()
+    TransitionSchema = z12.object({
+      completedPhase: z12.string(),
+      suggestedNext: z12.string(),
+      reason: z12.string(),
+      artifacts: z12.array(z12.string()),
+      requiresConfirmation: z12.boolean(),
+      summary: z12.string()
     });
-    EmitInteractionInputSchema = z10.object({
-      path: z10.string(),
+    EmitInteractionInputSchema = z12.object({
+      path: z12.string(),
       type: InteractionTypeSchema,
-      stream: z10.string().optional(),
+      stream: z12.string().optional(),
       question: QuestionSchema.optional(),
       confirmation: ConfirmationSchema.optional(),
       transition: TransitionSchema.optional()
@@ -18699,10 +19454,10 @@ var init_dist3 = __esm({
       }
       rootDir;
       async scan() {
-        let projectName = path28.basename(this.rootDir);
+        let projectName = path30.basename(this.rootDir);
         try {
-          const pkgPath = path28.join(this.rootDir, "package.json");
-          const pkgRaw = await fs29.readFile(pkgPath, "utf-8");
+          const pkgPath = path30.join(this.rootDir, "package.json");
+          const pkgRaw = await fs31.readFile(pkgPath, "utf-8");
           const pkg = JSON.parse(pkgRaw);
           if (pkg.name) projectName = pkg.name;
         } catch {
@@ -18815,8 +19570,8 @@ console.log('Blueprint player initialized.');
           styles: STYLES,
           scripts: SCRIPTS
         });
-        await fs30.mkdir(options.outputDir, { recursive: true });
-        await fs30.writeFile(path29.join(options.outputDir, "index.html"), html);
+        await fs32.mkdir(options.outputDir, { recursive: true });
+        await fs32.writeFile(path31.join(options.outputDir, "index.html"), html);
       }
     };
     TOKENS_PER_MILLION = 1e6;
@@ -19039,6 +19794,145 @@ console.log('Blueprint player initialized.');
     POSTHOG_BATCH_URL = "https://app.posthog.com/batch";
     MAX_ATTEMPTS = 3;
     TIMEOUT_MS = 5e3;
+    CompoundLockHeldError = class extends Error {
+      constructor(category, holderPid, lockPath) {
+        super(
+          `Compound lock for category "${category}" is held by pid ${holderPid} (lock file: ${lockPath}). If the holder is no longer running (e.g. it was SIGKILL'd), the lock is stale; recover with: rm ${lockPath}`
+        );
+        this.category = category;
+        this.holderPid = holderPid;
+        this.lockPath = lockPath;
+        this.name = "CompoundLockHeldError";
+      }
+      category;
+      holderPid;
+      lockPath;
+    };
+    KNOWN_CATEGORIES = new Set(ALL_SOLUTION_CATEGORIES);
+    ALLOWED_FIELD_KEYS = [
+      "event_name",
+      "count",
+      "timestamp_bucket",
+      "error_signature",
+      "latency_ms",
+      "category"
+    ];
+    PII_TOKENS = [
+      "email",
+      "user_id",
+      "session_id",
+      "ip",
+      "name",
+      "phone",
+      "address",
+      "message",
+      "content",
+      "payload"
+    ];
+    PII_FIELD_DENYLIST = new RegExp(`^(?:${PII_TOKENS.join("|")})$`, "i");
+    PII_LINE_RE = new RegExp(`\\b(?:${PII_TOKENS.join("|")})\\b`, "i");
+    ALLOWED_SET = new Set(ALLOWED_FIELD_KEYS);
+    PulseAdapterAlreadyRegisteredError = class extends Error {
+      constructor(adapterName) {
+        super(`Pulse adapter "${adapterName}" is already registered.`);
+        this.adapterName = adapterName;
+        this.name = "PulseAdapterAlreadyRegisteredError";
+      }
+      adapterName;
+    };
+    REGISTRY = /* @__PURE__ */ new Map();
+    MOCK_ADAPTER_NAME = "mock";
+    ALLOWED_FIELD_SET = new Set(ALLOWED_FIELD_KEYS);
+    adapter = {
+      async query(_window, _eventNames) {
+        return {
+          event_name: "mock.event",
+          count: 42,
+          timestamp_bucket: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+          latency_ms: 123
+        };
+      },
+      sanitize(raw) {
+        const fields = {};
+        if (raw && typeof raw === "object") {
+          for (const [key, value] of Object.entries(raw)) {
+            if (PII_FIELD_DENYLIST.test(key)) continue;
+            if (!ALLOWED_FIELD_SET.has(key)) continue;
+            fields[key] = value;
+          }
+        }
+        return { fields, distributions: {} };
+      }
+    };
+    registerMockAdapter();
+    LOOKBACK_RE = /^(\d+)(h|d)$/;
+    MAX_LINES = 40;
+    INLINE_TEMPLATE = `# {{productName}} Pulse \u2014 {{windowLabel}}
+
+## Headlines
+
+{{headlines}}
+
+## Usage
+
+{{usage}}
+
+## System performance
+
+{{systemPerformance}}
+
+## Followups
+
+{{followups}}
+`;
+    TRUNCATION_MARKER2 = "_(truncated to fit single-page constraint)_";
+    execFileAsync = promisify22(execFile);
+    FIX_RE = /^fix(\([^)]+\))?:/i;
+    EMPTY_REPO_RE = /(does not have any commits yet|not a git repository)/i;
+    execFileAsync2 = promisify3(execFile2);
+    TRACK_CATEGORIES2 = [
+      ["bug-track", BUG_TRACK_CATEGORIES],
+      ["knowledge-track", KNOWLEDGE_TRACK_CATEGORIES]
+    ];
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "fix",
+      "the",
+      "a",
+      "an",
+      "in",
+      "on",
+      "of",
+      "and",
+      "or",
+      "to",
+      "for",
+      "with",
+      "is",
+      "be",
+      "when",
+      "if",
+      "this",
+      "that",
+      "edge",
+      "case",
+      "handle"
+    ]);
+    KEYWORD_TO_CATEGORY = [
+      [/\b(test|flaky|spec)\b/i, "bug-track/test-failures"],
+      [/\b(perf|slow|latency|throughput|timeout|deadlock|n\+1|oom)\b/i, "bug-track/performance-issues"],
+      [
+        /\b(security|sqli|injection|xss|csrf|jwt|oauth|auth(?:n|z|entication)?|crypt(?:o|ographic|ography)?|encrypt(?:ion)?|decrypt(?:ion)?|password|token|session|tls|ssl)\b/i,
+        "bug-track/security-issues"
+      ],
+      [/\b(ui|css|color|contrast|layout|render)\b/i, "bug-track/ui-bugs"],
+      [/\b(build|compile|tsc|webpack|tsup)\b/i, "bug-track/build-errors"],
+      [
+        /\b(db|database|sql|postgres|mysql|query|migration|transaction|deadlock)\b/i,
+        "bug-track/database-issues"
+      ],
+      [/\b(runtime|crash|exception|panic)\b/i, "bug-track/runtime-errors"],
+      [/\(orchestrator\)|\bintegrat|\blease\b|\brace\b|\bconcurren/i, "bug-track/integration-issues"]
+    ];
   }
 });
 
@@ -19095,6 +19989,15 @@ export {
   validateFileStructure,
   validateConfig,
   validateCommitMessage,
+  PulseDbSourceSchema,
+  PulseSourcesSchema,
+  PulseConfigSchema,
+  validatePulseConfig,
+  BUG_TRACK_CATEGORIES,
+  KNOWLEDGE_TRACK_CATEGORIES,
+  ALL_SOLUTION_CATEGORIES,
+  SolutionDocFrontmatterSchema,
+  validateSolutionsDir,
   REQUIRED_SECTIONS,
   extractMarkdownLinks,
   extractSections,
@@ -19438,6 +20341,35 @@ export {
   VERSION,
   collectEvents,
   send,
+  CompoundLockHeldError,
+  acquireCompoundLock,
+  ALLOWED_FIELD_KEYS,
+  PII_TOKENS,
+  PII_FIELD_DENYLIST,
+  PII_LINE_RE,
+  isSanitizedResult,
+  assertSanitized,
+  writePulseConfig,
+  seedFromStrategy,
+  PulseAdapterAlreadyRegisteredError,
+  registerPulseAdapter,
+  getPulseAdapter,
+  listPulseAdapters,
+  clearPulseAdapters,
+  MOCK_ADAPTER_NAME,
+  registerMockAdapter,
+  parseLookback,
+  computeWindow,
+  runPulse,
+  assembleReport,
+  extractHeadlines,
+  isoWeek,
+  formatIsoWeek,
+  gitScan,
+  computeHotspots,
+  crossReferenceUndocumentedFixes,
+  suggestCategory,
+  assembleCandidateReport,
   dist_exports,
   init_dist3 as init_dist
 };