@harness-engineering/cli 2.8.0 → 3.0.1

package/dist/{chunk-GOHWCHCS.js → chunk-N24HCQA4.js}

@@ -1250,6 +1250,7 @@ __export(dist_exports, {
   AGENT_DESCRIPTORS: () => AGENT_DESCRIPTORS,
   AGREEMENT_LINE_GAP: () => AGREEMENT_LINE_GAP,
   ALLOWED_FIELD_KEYS: () => ALLOWED_FIELD_KEYS,
+  ALL_RULES: () => ALL_RULES,
   ALL_SOLUTION_CATEGORIES: () => ALL_SOLUTION_CATEGORIES,
   ARCHITECTURE_DESCRIPTOR: () => ARCHITECTURE_DESCRIPTOR,
   AdjustedForecastSchema: () => AdjustedForecastSchema,
@@ -1260,6 +1261,8 @@ __export(dist_exports, {
   ArchConfigSchema: () => ArchConfigSchema,
   ArchDiffResultSchema: () => ArchDiffResultSchema,
   ArchMetricCategorySchema: () => ArchMetricCategorySchema,
+  AuditResultSchema: () => AuditResultSchema,
+  AuditSummarySchema: () => AuditSummarySchema,
   AuthAuditEntrySchema: () => AuthAuditEntrySchema,
   AuthTokenPublicSchema: () => AuthTokenPublicSchema,
   AuthTokenSchema: () => AuthTokenSchema,
@@ -1273,6 +1276,10 @@ __export(dist_exports, {
   BundleSchema: () => BundleSchema,
   CACHE_TTL_MS: () => CACHE_TTL_MS,
   CINotifier: () => CINotifier,
+  CI_ASSESSMENTS: () => CI_ASSESSMENTS,
+  CI_REVIEW_DOMAINS: () => CI_REVIEW_DOMAINS,
+  CI_REVIEW_VERDICT_SCHEMA_VERSION: () => CI_REVIEW_VERDICT_SCHEMA_VERSION,
+  CI_RUNNERS: () => CI_RUNNERS,
   COMPLIANCE_DESCRIPTOR: () => COMPLIANCE_DESCRIPTOR,
   CONDITIONAL_SUBAGENT_DESCRIPTORS: () => CONDITIONAL_SUBAGENT_DESCRIPTORS,
   CORROBORATED_AGREEMENT: () => CORROBORATED_AGREEMENT,
@@ -1282,6 +1289,7 @@ __export(dist_exports, {
   CategoryRegressionSchema: () => CategoryRegressionSchema,
   CategorySnapshotSchema: () => CategorySnapshotSchema,
   ChecklistBuilder: () => ChecklistBuilder,
+  CiReviewVerdictSchema: () => CiReviewVerdictSchema,
   CircularDepsCollector: () => CircularDepsCollector,
   CompactionPipeline: () => CompactionPipeline,
   ComplexityCollector: () => ComplexityCollector,
@@ -1295,6 +1303,8 @@ __export(dist_exports, {
   ContributionsSchema: () => ContributionsSchema,
   CouplingCollector: () => CouplingCollector,
   CriticalPathResolver: () => CriticalPathResolver,
+  DEFAULT_EXEC_MAX_STDOUT_BYTES: () => DEFAULT_EXEC_MAX_STDOUT_BYTES,
+  DEFAULT_EXEC_TIMEOUT_MS: () => DEFAULT_EXEC_TIMEOUT_MS,
   DEFAULT_LOADER_CONFIG: () => DEFAULT_LOADER_CONFIG,
   DEFAULT_PROVIDER_TIERS: () => DEFAULT_PROVIDER_TIERS,
   DEFAULT_SECURITY_CONFIG: () => DEFAULT_SECURITY_CONFIG,
@@ -1333,7 +1343,10 @@ __export(dist_exports, {
   GeminiCacheAdapter: () => GeminiCacheAdapter,
   GitHubIssuesSyncAdapter: () => GitHubIssuesSyncAdapter,
   HandoffSchema: () => HandoffSchema,
+  HarnessConfigSubsetSchema: () => HarnessConfigSubsetSchema,
   HarnessStateSchema: () => HarnessStateSchema,
+  HarnessStrengthAuditor: () => HarnessStrengthAuditor,
+  HookFileSchema: () => HookFileSchema,
   INDEXED_FILE_KINDS: () => INDEXED_FILE_KINDS,
   INSIGHTS_KEYS: () => INSIGHTS_KEYS,
   InteractionTypeSchema: () => InteractionTypeSchema,
@@ -1345,6 +1358,7 @@ __export(dist_exports, {
   MOCK_ADAPTER_NAME: () => MOCK_ADAPTER_NAME,
   ManifestSchema: () => ManifestSchema,
   MetricResultSchema: () => MetricResultSchema,
+  ModeSchema: () => ModeSchema,
   ModuleSizeCollector: () => ModuleSizeCollector,
   NoOpExecutor: () => NoOpExecutor,
   NoOpSink: () => NoOpSink,
@@ -1371,6 +1385,7 @@ __export(dist_exports, {
   PredictionRegressionResultSchema: () => RegressionResultSchema,
   PredictionResultSchema: () => PredictionResultSchema,
   PredictionWarningSchema: () => PredictionWarningSchema,
+  ProjectContextSchema: () => ProjectContextSchema,
   ProjectScanner: () => ProjectScanner,
   PromptCacheStatsSchema: () => PromptCacheStatsSchema,
   ProposalConflictError: () => ProposalConflictError,
@@ -1390,11 +1405,13 @@ __export(dist_exports, {
   REQUIRED_SECTIONS: () => REQUIRED_SECTIONS,
   REQUIRED_STRATEGY_SECTIONS: () => REQUIRED_STRATEGY_SECTIONS,
   RISK_KEYWORDS: () => RISK_KEYWORDS,
+  RUNNER_PRESETS: () => RUNNER_PRESETS,
   RegressionDetector: () => RegressionDetector,
   RuleRegistry: () => RuleRegistry,
   SECURITY_DESCRIPTOR: () => SECURITY_DESCRIPTOR,
   SESSIONS_DEFAULTS: () => SESSIONS_DEFAULTS,
   SESSION_SECTION_NAMES: () => SESSION_SECTION_NAMES,
+  SEVERITY_WEIGHTS: () => SEVERITY_WEIGHTS,
   STALENESS_WARNING_DAYS: () => STALENESS_WARNING_DAYS,
   STANDALONE_AGREEMENT: () => STANDALONE_AGREEMENT,
   STANDARD_COGNITIVE_MODES: () => STANDARD_COGNITIVE_MODES,
@@ -1410,6 +1427,7 @@ __export(dist_exports, {
   SecurityTrendLineSchema: () => SecurityTrendLineSchema,
   SecurityTrendResultSchema: () => SecurityTrendResultSchema,
   SessionSummarySchema: () => SessionSummarySchema,
+  SeveritySchema: () => SeveritySchema,
   SharableBoundaryConfigSchema: () => SharableBoundaryConfigSchema,
   SharableForbiddenImportSchema: () => SharableForbiddenImportSchema,
   SharableLayerSchema: () => SharableLayerSchema,
@@ -1427,10 +1445,12 @@ __export(dist_exports, {
   StrategyFrontmatterSchema: () => StrategyFrontmatterSchema,
   StreamIndexSchema: () => StreamIndexSchema,
   StreamInfoSchema: () => StreamInfoSchema,
+  StrengthFindingSchema: () => StrengthFindingSchema,
   StructuralStrategy: () => StructuralStrategy,
   SupplyChainSnapshotSchema: () => SupplyChainSnapshotSchema,
   TYPESCRIPT_STRICT_DESCRIPTOR: () => TYPESCRIPT_STRICT_DESCRIPTOR,
   ThresholdConfigSchema: () => ThresholdConfigSchema,
+  TierSchema: () => TierSchema,
   TimeToFixResultSchema: () => TimeToFixResultSchema,
   TimeToFixStatsSchema: () => TimeToFixStatsSchema,
   TimelineFileSchema: () => TimelineFileSchema,
@@ -1485,8 +1505,10 @@ __export(dist_exports, {
   assertPortUsable: () => assertPortUsable,
   assertSanitized: () => assertSanitized,
   assignFeature: () => assignFeature,
+  buildCiReviewVerdict: () => buildCiReviewVerdict,
   buildDependencyGraph: () => buildDependencyGraph,
   buildExclusionSet: () => buildExclusionSet,
+  buildProjectContext: () => buildProjectContext,
   buildSnapshot: () => buildSnapshot,
   calculateCacheSavings: () => calculateCacheSavings,
   calculateCost: () => calculateCost,
@@ -1495,6 +1517,7 @@ __export(dist_exports, {
   checkEligibility: () => checkEligibility,
   checkEvidenceCoverage: () => checkEvidenceCoverage,
   checkOverlap: () => checkOverlap,
+  checkRoadmapHealth: () => checkRoadmapHealth,
   checkTaint: () => checkTaint,
   classifyConfidence: () => classifyConfidence,
   classifyFinding: () => classifyFinding,
@@ -1537,11 +1560,16 @@ __export(dist_exports, {
   createTrackerClient: () => createTrackerClient,
   crossReferenceUndocumentedFixes: () => crossReferenceUndocumentedFixes,
   cryptoRules: () => cryptoRules,
+  decidePromotionForRow: () => decidePromotionForRow,
   deduplicateCleanupFindings: () => deduplicateCleanupFindings,
   deduplicateFindings: () => deduplicateFindings,
   deepMergeConstraints: () => deepMergeConstraints,
   defaultCollectors: () => defaultCollectors,
+  defaultExecFile: () => defaultExecFile,
+  defaultIsArchive: () => defaultIsArchive,
   defineLayer: () => defineLayer,
+  deriveBlockingFindings: () => deriveBlockingFindings,
+  deriveExitCode: () => deriveExitCode,
   deriveSkillUsage: () => deriveSkillUsage,
   deserializationRules: () => deserializationRules,
   detectChangeType: () => detectChangeType,
@@ -1606,6 +1634,7 @@ __export(dist_exports, {
   getUpdateNotification: () => getUpdateNotification,
   gitScan: () => gitScan,
   goRules: () => goRules,
+  groomRoadmap: () => groomRoadmap,
   injectionRules: () => injectionRules,
   insecureDefaultsRules: () => insecureDefaultsRules,
   invalidateCheckState: () => invalidateCheckState,
@@ -1616,6 +1645,8 @@ __export(dist_exports, {
   isRegression: () => isRegression,
   isSanitizedResult: () => isSanitizedResult,
   isSmallSuggestion: () => isSmallSuggestion,
+  isSupportedRunner: () => isSupportedRunner,
+  isUnactionablePlanned: () => isUnactionablePlanned,
   isUpdateCheckEnabled: () => isUpdateCheckEnabled,
   isoWeek: () => isoWeek,
   listActiveSessions: () => listActiveSessions,
@@ -1651,14 +1682,20 @@ __export(dist_exports, {
   normalizeLearningContent: () => normalizeLearningContent,
   normalizeViolationPattern: () => normalizeViolationPattern,
   paginate: () => paginate,
+  parseAntigravityVerdict: () => parseAntigravityVerdict,
   parseCCRecords: () => parseCCRecords,
+  parseCiReviewVerdict: () => parseCiReviewVerdict,
+  parseClaudeVerdict: () => parseClaudeVerdict,
+  parseCodexVerdict: () => parseCodexVerdict,
   parseDateFromEntry: () => parseDateFromEntry,
   parseDiff: () => parseDiff,
   parseFile: () => parseFile,
   parseFileRegions: () => parseFileRegions,
   parseFrontmatter: () => parseFrontmatter2,
+  parseGeminiVerdict: () => parseGeminiVerdict,
   parseHarnessIgnore: () => parseHarnessIgnore,
   parseLiteLLMData: () => parseLiteLLMData,
+  parseLocalVerdict: () => parseLocalVerdict,
   parseLookback: () => parseLookback,
   parseManifest: () => parseManifest,
   parseProtectedRegions: () => parseProtectedRegions,
@@ -1668,8 +1705,10 @@ __export(dist_exports, {
   parseSize: () => parseSize,
   parseStrategyDoc: () => parseStrategyDoc,
   pathTraversalRules: () => pathTraversalRules,
+  presetKind: () => presetKind,
   previewFix: () => previewFix,
   projectValue: () => projectValue,
+  promoteFeature: () => promoteFeature,
   promoteSessionLearnings: () => promoteSessionLearnings,
   proposalsDir: () => proposalsDir,
   pruneLearnings: () => pruneLearnings,
@@ -1692,6 +1731,7 @@ __export(dist_exports, {
   resetParserCache: () => resetParserCache,
   resolveConsent: () => resolveConsent,
   resolveFileToLayer: () => resolveFileToLayer,
+  resolveMode: () => resolveMode,
   resolveModelTier: () => resolveModelTier,
   resolveReverseStatus: () => resolveReverseStatus,
   resolveRuleSeverity: () => resolveRuleSeverity,
@@ -1699,12 +1739,14 @@ __export(dist_exports, {
   resolveStability: () => resolveStability,
   resolveStreamPath: () => resolveStreamPath,
   resolveThresholds: () => resolveThresholds,
+  rollupScore: () => rollupScore,
   runAdversarialAgent: () => runAdversarialAgent,
   runAgentConfigFallbackRules: () => runFallbackRules,
   runAll: () => runAll,
   runArchitectureAgent: () => runArchitectureAgent,
   runBugDetectionAgent: () => runBugDetectionAgent,
   runCIChecks: () => runCIChecks,
+  runCiReview: () => runCiReview,
   runComplianceAgent: () => runComplianceAgent,
   runFrontendRacesAgent: () => runFrontendRacesAgent,
   runMechanicalChecks: () => runMechanicalChecks,
@@ -1829,41 +1871,41 @@ import * as fs7 from "fs";
 import { promisify } from "util";
 import { dirname as dirname5, basename as basename5, join as join16 } from "path";
 import { z as z5 } from "zod";
+import { readFileSync as readFileSync22, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync12 } from "fs";
+import { join as join17, dirname as dirname6 } from "path";
+import { execFileSync } from "child_process";
 import * as fs8 from "fs";
 import * as path5 from "path";
-import { readFileSync as readFileSync32, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync13 } from "fs";
-import { join as join18, dirname as dirname6 } from "path";
-import { execFileSync } from "child_process";
-import * as fs9 from "fs";
-import * as path6 from "path";
-import { appendFileSync, writeFileSync as writeFileSync22, existsSync as existsSync14, mkdirSync as mkdirSync22 } from "fs";
+import { appendFileSync, writeFileSync as writeFileSync22, existsSync as existsSync13, mkdirSync as mkdirSync22 } from "fs";
 import { dirname as dirname7 } from "path";
 import { z as z6 } from "zod";
+import * as fs9 from "fs";
+import * as path6 from "path";
 import * as fs10 from "fs";
 import * as path7 from "path";
 import * as fs11 from "fs";
 import * as path8 from "path";
-import * as fs12 from "fs";
-import * as path9 from "path";
 import { z as z7 } from "zod";
-import * as fs16 from "fs";
-import * as path13 from "path";
 import * as fs15 from "fs";
 import * as path12 from "path";
-import * as fs13 from "fs";
-import * as path10 from "path";
-import { execSync } from "child_process";
-import { z as z8 } from "zod";
 import * as fs14 from "fs";
 import * as path11 from "path";
+import * as fs12 from "fs";
+import * as path9 from "path";
+import { execSync } from "child_process";
+import { z as z8 } from "zod";
+import * as fs13 from "fs";
+import * as path10 from "path";
+import * as fs16 from "fs";
+import * as path13 from "path";
+import * as crypto2 from "crypto";
 import * as fs17 from "fs";
 import * as path14 from "path";
-import * as crypto2 from "crypto";
 import * as fs18 from "fs";
 import * as path15 from "path";
+import * as crypto3 from "crypto";
 import * as fs19 from "fs";
 import * as path16 from "path";
-import * as crypto3 from "crypto";
 import * as fs20 from "fs";
 import * as path17 from "path";
 import * as fs21 from "fs";
@@ -1872,95 +1914,100 @@ import * as fs22 from "fs";
 import * as path19 from "path";
 import * as fs23 from "fs";
 import * as path20 from "path";
+import { execSync as execSync2 } from "child_process";
 import * as fs24 from "fs";
 import * as path21 from "path";
-import { execSync as execSync2 } from "child_process";
 import * as fs25 from "fs";
 import * as path22 from "path";
 import * as fs26 from "fs";
 import * as path23 from "path";
 import * as fs27 from "fs";
 import * as path24 from "path";
-import * as fs28 from "fs";
-import * as path25 from "path";
 import { z as z9 } from "zod";
-import * as fs30 from "fs/promises";
+import * as fs29 from "fs/promises";
 import { minimatch as minimatch3 } from "minimatch";
 import { z as z10 } from "zod";
-import * as fs29 from "fs";
+import * as fs28 from "fs";
+import * as path25 from "path";
+import * as fs30 from "fs";
 import * as path26 from "path";
-import * as fs31 from "fs";
-import * as path27 from "path";
-import { readFileSync as readFileSync22, writeFileSync as writeFileSync14, unlinkSync as unlinkSync2, mkdirSync as mkdirSync13, readdirSync as readdirSync3 } from "fs";
-import { join as join39, dirname as dirname10 } from "path";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync14, unlinkSync as unlinkSync2, mkdirSync as mkdirSync13, readdirSync as readdirSync2 } from "fs";
+import { join as join38, dirname as dirname10 } from "path";
 import { createHash as createHash32 } from "crypto";
 import { z as z11 } from "zod";
-import { readFileSync as readFileSync23, writeFileSync as writeFileSync15, renameSync as renameSync72, mkdirSync as mkdirSync14, existsSync as existsSync342 } from "fs";
+import { readFileSync as readFileSync222, writeFileSync as writeFileSync15, renameSync as renameSync72, mkdirSync as mkdirSync14, existsSync as existsSync332 } from "fs";
 import { execSync as execSync3 } from "child_process";
 import { randomBytes as randomBytes2 } from "crypto";
-import { isAbsolute as isAbsolute4, join as join40, relative as relative3, dirname as dirname11 } from "path";
+import { isAbsolute as isAbsolute4, join as join39, relative as relative3, dirname as dirname11 } from "path";
+import * as path27 from "path";
 import * as path28 from "path";
 import * as path29 from "path";
 import * as path30 from "path";
+import { z as z12 } from "zod";
+import { execFile as nodeExecFile } from "child_process";
+import * as fs31 from "fs";
 import * as path31 from "path";
 import * as fs32 from "fs";
 import * as path32 from "path";
 import * as fs33 from "fs";
-import * as path33 from "path";
-import * as fs34 from "fs";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import * as fs34 from "fs";
+import * as path33 from "path";
 import * as fs35 from "fs";
 import * as path34 from "path";
-import * as fs36 from "fs";
-import * as path35 from "path";
 import { createHash as createHash4 } from "crypto";
+import * as path35 from "path";
+import { z as z13 } from "zod";
+import * as fs36 from "fs/promises";
 import * as path36 from "path";
-import { z as z12 } from "zod";
 import * as fs37 from "fs/promises";
 import * as path37 from "path";
-import * as fs38 from "fs/promises";
-import * as path38 from "path";
 import * as ejs from "ejs";
-import * as fs39 from "fs";
-import * as path39 from "path";
+import * as fs38 from "fs";
+import * as path38 from "path";
 import * as os from "os";
 import { spawn as spawn2 } from "child_process";
-import * as fs40 from "fs/promises";
+import * as fs39 from "fs/promises";
+import * as path39 from "path";
+import * as fs40 from "fs";
 import * as path40 from "path";
 import * as fs41 from "fs";
 import * as path41 from "path";
+import * as os2 from "os";
 import * as fs42 from "fs";
 import * as path42 from "path";
-import * as os2 from "os";
-import * as fs43 from "fs";
-import * as path43 from "path";
 import * as fs44 from "fs";
 import * as path44 from "path";
-import * as fs46 from "fs";
-import * as path46 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
+import * as fs43 from "fs";
+import * as path43 from "path";
+import * as crypto4 from "crypto";
+import { z as z14 } from "zod";
+import { existsSync as existsSync38, readFileSync as readFileSync34, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
+import { join as join582, basename as basename10, resolve as resolve6, relative as relative4 } from "path";
 import * as fs45 from "fs";
 import * as path45 from "path";
-import * as crypto4 from "crypto";
+import * as fs46 from "fs";
+import * as path46 from "path";
 import * as fs47 from "fs";
 import * as path47 from "path";
 import * as fs48 from "fs";
-import * as fs49 from "fs";
 import * as path48 from "path";
-import { readFileSync as readFileSync392 } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import * as fs49 from "fs";
+import * as fs50 from "fs";
+import * as path49 from "path";
+import { readFileSync as readFileSync41 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname16, join as join622 } from "path";
+import { dirname as dirname16, join as join642 } from "path";
 import { execFile } from "child_process";
 import { promisify as promisify2 } from "util";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify3 } from "util";
-import * as fs50 from "fs/promises";
-import * as path49 from "path";
-import * as fs51 from "fs";
+import * as fs51 from "fs/promises";
 import * as path50 from "path";
 import * as fs52 from "fs";
 import * as path51 from "path";
-import { randomUUID as randomUUID2 } from "crypto";
 function isBadPort(port) {
   return BAD_PORT_SET.has(port);
 }
@@ -2334,7 +2381,7 @@ function isAgnixDisabled() {
   return v === "1" || v === "true";
 }
 function runAgnix(cwd, strict, binPath, timeoutMs = DEFAULT_AGNIX_TIMEOUT_MS, spawnFn = spawn) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const args = ["--format", "json"];
     if (strict) args.push("--strict");
     args.push(cwd);
@@ -2348,7 +2395,7 @@ function runAgnix(cwd, strict, binPath, timeoutMs = DEFAULT_AGNIX_TIMEOUT_MS, sp
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve6(outcome);
+      resolve7(outcome);
     };
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
@@ -4938,139 +4985,6 @@ function validatePatternConfig(config) {
   }
   return Ok(result.data);
 }
-async function safeGather(key, fn, warnings) {
-  try {
-    return await fn();
-  } catch (e) {
-    warnings.push(`${key}: ${e instanceof Error ? e.message : String(e)}`);
-    return null;
-  }
-}
-function arrayLen(arr) {
-  return Array.isArray(arr) ? arr.length : 0;
-}
-async function gatherEntropyBlock(projectPath) {
-  const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./analyzer-V633GUHY-MBCQWKDU.js");
-  const analyzer = new EntropyAnalyzer2({
-    rootDir: projectPath,
-    include: ["src/**/*.ts", "src/**/*.tsx", "packages/*/src/**/*.ts"],
-    exclude: ["node_modules/**", "dist/**", "**/*.test.ts", "**/*.spec.ts"],
-    analyze: { drift: false, deadCode: true, patterns: false, complexity: false }
-  });
-  const result = await analyzer.analyze();
-  const empty = { driftCount: 0, deadFiles: 0, deadExports: 0 };
-  if (!result.ok) return empty;
-  const report = result.value;
-  return {
-    driftCount: arrayLen(report.drift?.drifts),
-    deadFiles: arrayLen(report.deadCode?.deadFiles),
-    deadExports: arrayLen(report.deadCode?.deadExports)
-  };
-}
-async function gatherDecayBlock(projectPath) {
-  const { TimelineManager: TimelineManager2 } = await import("./timeline-manager-FPYKJRHR-VVX7CSGW.js");
-  const mgr = new TimelineManager2(projectPath);
-  const trends = mgr.trends();
-  return {
-    recentBumps: arrayLen(trends.recentSnapshots),
-    topAffected: collectTopAffectedLabels(trends.topAffected)
-  };
-}
-function collectTopAffectedLabels(affected) {
-  if (!Array.isArray(affected)) return [];
-  const out = [];
-  for (const node of affected) {
-    const label = node.id ?? node.name;
-    if (typeof label === "string" && label.length > 0) out.push(label);
-    if (out.length >= MAX_TOP_AFFECTED) break;
-  }
-  return out;
-}
-async function gatherAttentionBlock(projectPath) {
-  const sessionsDir = path5.join(projectPath, ".harness", "sessions");
-  if (!fs8.existsSync(sessionsDir)) return { activeThreadCount: 0, staleThreadCount: 0 };
-  const now = Date.now();
-  const STALE_MS = 7 * 24 * 60 * 60 * 1e3;
-  let active = 0;
-  let stale = 0;
-  const entries = fs8.readdirSync(sessionsDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const dirPath = path5.join(sessionsDir, entry.name);
-    try {
-      const stat2 = fs8.statSync(dirPath);
-      if (now - stat2.mtimeMs > STALE_MS) {
-        stale++;
-      } else {
-        active++;
-      }
-    } catch {
-    }
-  }
-  return { activeThreadCount: active, staleThreadCount: stale };
-}
-async function gatherImpactBlock(projectPath) {
-  const cachePath = path5.join(projectPath, ".harness", "cache", "impact.json");
-  if (!fs8.existsSync(cachePath)) return { recentBlastRadius: [] };
-  try {
-    const raw = JSON.parse(fs8.readFileSync(cachePath, "utf8"));
-    const radii = raw.blastRadius ?? [];
-    return {
-      recentBlastRadius: radii.slice(0, 5).map((r) => ({
-        node: r.node,
-        affected: r.affected
-      }))
-    };
-  } catch {
-    return { recentBlastRadius: [] };
-  }
-}
-async function gatherHealthBlock(projectPath) {
-  const entropy = await gatherEntropyBlock(projectPath);
-  const signals = [];
-  if (entropy.driftCount > 0) signals.push(`${entropy.driftCount} drift findings`);
-  if (entropy.deadFiles > 0) signals.push(`${entropy.deadFiles} dead files`);
-  if (entropy.deadExports > 0) signals.push(`${entropy.deadExports} dead exports`);
-  const passed = signals.length === 0;
-  return {
-    passed,
-    signals,
-    summary: passed ? "No structural health findings." : signals.join("; ")
-  };
-}
-async function composeInsights(projectPath, opts = {}) {
-  const skip = new Set(opts.skip ?? []);
-  const warnings = [];
-  const wantedKeys = INSIGHTS_KEYS.filter((k) => !skip.has(k));
-  const [healthRes, entropyRes, decayRes, attentionRes, impactRes] = await Promise.all([
-    wantedKeys.includes("health") ? safeGather("health", () => gatherHealthBlock(projectPath), warnings) : Promise.resolve(null),
-    wantedKeys.includes("entropy") ? safeGather("entropy", () => gatherEntropyBlock(projectPath), warnings) : Promise.resolve(null),
-    wantedKeys.includes("decay") ? safeGather("decay", () => gatherDecayBlock(projectPath), warnings) : Promise.resolve(null),
-    wantedKeys.includes("attention") ? safeGather("attention", () => gatherAttentionBlock(projectPath), warnings) : Promise.resolve(null),
-    wantedKeys.includes("impact") ? safeGather("impact", () => gatherImpactBlock(projectPath), warnings) : Promise.resolve(null)
-  ]);
-  const projectName = pickProjectName(projectPath);
-  return {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    project: { root: projectPath, ...projectName && { name: projectName } },
-    health: healthRes,
-    entropy: entropyRes,
-    decay: decayRes,
-    attention: attentionRes,
-    impact: impactRes,
-    warnings
-  };
-}
-function pickProjectName(projectPath) {
-  try {
-    const pkgPath = path5.join(projectPath, "package.json");
-    if (!fs8.existsSync(pkgPath)) return void 0;
-    const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf8"));
-    return pkg.name;
-  } catch {
-    return void 0;
-  }
-}
 function mergeGraphInferred(highFanInFunctions, seen) {
   let added = 0;
   for (const item of highFanInFunctions) {
@@ -5941,10 +5855,10 @@ function detectEmergentConstraints(history, options) {
   return { suggestions, totalViolationsAnalyzed, windowWeeks, minOccurrences };
 }
 function streamsDir(projectPath) {
-  return path10.join(projectPath, HARNESS_DIR, STREAMS_DIR);
+  return path9.join(projectPath, HARNESS_DIR, STREAMS_DIR);
 }
 function indexPath(projectPath) {
-  return path10.join(streamsDir(projectPath), INDEX_FILE);
+  return path9.join(streamsDir(projectPath), INDEX_FILE);
 }
 function validateStreamName(name) {
   if (!STREAM_NAME_REGEX.test(name)) {
@@ -5958,11 +5872,11 @@ function validateStreamName(name) {
 }
 async function loadStreamIndex(projectPath) {
   const idxPath = indexPath(projectPath);
-  if (!fs13.existsSync(idxPath)) {
+  if (!fs12.existsSync(idxPath)) {
     return Ok({ ...DEFAULT_STREAM_INDEX, streams: {} });
   }
   try {
-    const raw = fs13.readFileSync(idxPath, "utf-8");
+    const raw = fs12.readFileSync(idxPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = StreamIndexSchema.safeParse(parsed);
     if (!result.success) {
@@ -5980,8 +5894,8 @@ async function loadStreamIndex(projectPath) {
 async function saveStreamIndex(projectPath, index) {
   const dir = streamsDir(projectPath);
   try {
-    fs13.mkdirSync(dir, { recursive: true });
-    fs13.writeFileSync(indexPath(projectPath), JSON.stringify(index, null, 2));
+    fs12.mkdirSync(dir, { recursive: true });
+    fs12.writeFileSync(indexPath(projectPath), JSON.stringify(index, null, 2));
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -6020,18 +5934,18 @@ async function resolveStreamPath(projectPath, options) {
         )
       );
     }
-    return Ok(path10.join(streamsDir(projectPath), options.stream));
+    return Ok(path9.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(path10.join(streamsDir(projectPath), name));
+        return Ok(path9.join(streamsDir(projectPath), name));
       }
     }
   }
   if (index.activeStream && index.streams[index.activeStream]) {
-    return Ok(path10.join(streamsDir(projectPath), index.activeStream));
+    return Ok(path9.join(streamsDir(projectPath), index.activeStream));
   }
   return Err(
     new Error(
@@ -6059,9 +5973,9 @@ async function createStream(projectPath, name, branch) {
   if (index.streams[name]) {
     return Err(new Error(`Stream '${name}' already exists`));
   }
-  const streamPath = path10.join(streamsDir(projectPath), name);
+  const streamPath = path9.join(streamsDir(projectPath), name);
   try {
-    fs13.mkdirSync(streamPath, { recursive: true });
+    fs12.mkdirSync(streamPath, { recursive: true });
   } catch (error) {
     return Err(
       new Error(
@@ -6102,12 +6016,12 @@ async function archiveStream(projectPath, name) {
   if (!index.streams[name]) {
     return Err(new Error(`Stream '${name}' not found`));
   }
-  const streamPath = path10.join(streamsDir(projectPath), name);
-  const archiveDir = path10.join(projectPath, HARNESS_DIR, "archive", "streams");
+  const streamPath = path9.join(streamsDir(projectPath), name);
+  const archiveDir = path9.join(projectPath, HARNESS_DIR, "archive", "streams");
   try {
-    fs13.mkdirSync(archiveDir, { recursive: true });
+    fs12.mkdirSync(archiveDir, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    fs13.renameSync(streamPath, path10.join(archiveDir, `${name}-${date}`));
+    fs12.renameSync(streamPath, path9.join(archiveDir, `${name}-${date}`));
   } catch (error) {
     return Err(
       new Error(
@@ -6128,19 +6042,19 @@ function getStreamForBranch(index, branch) {
   return null;
 }
 async function migrateToStreams(projectPath) {
-  const harnessDir = path10.join(projectPath, HARNESS_DIR);
-  if (fs13.existsSync(indexPath(projectPath))) {
+  const harnessDir = path9.join(projectPath, HARNESS_DIR);
+  if (fs12.existsSync(indexPath(projectPath))) {
     return Ok(void 0);
   }
-  const filesToMove = STATE_FILES.filter((f) => fs13.existsSync(path10.join(harnessDir, f)));
+  const filesToMove = STATE_FILES.filter((f) => fs12.existsSync(path9.join(harnessDir, f)));
   if (filesToMove.length === 0) {
     return Ok(void 0);
   }
-  const defaultDir = path10.join(streamsDir(projectPath), "default");
+  const defaultDir = path9.join(streamsDir(projectPath), "default");
   try {
-    fs13.mkdirSync(defaultDir, { recursive: true });
+    fs12.mkdirSync(defaultDir, { recursive: true });
     for (const file of filesToMove) {
-      fs13.renameSync(path10.join(harnessDir, file), path10.join(defaultDir, file));
+      fs12.renameSync(path9.join(harnessDir, file), path9.join(defaultDir, file));
     }
   } catch (error) {
     return Err(
@@ -6170,26 +6084,26 @@ function resolveSessionDir(projectPath, sessionSlug, options) {
       new Error(`Invalid session slug '${sessionSlug}': must not contain path traversal characters`)
     );
   }
-  const sessionDir = path11.join(projectPath, HARNESS_DIR, SESSIONS_DIR, sessionSlug);
+  const sessionDir = path10.join(projectPath, HARNESS_DIR, SESSIONS_DIR, sessionSlug);
   if (options?.create) {
-    fs14.mkdirSync(sessionDir, { recursive: true });
+    fs13.mkdirSync(sessionDir, { recursive: true });
   }
   return Ok(sessionDir);
 }
 function updateSessionIndex(projectPath, sessionSlug, description) {
-  const sessionsDir = path11.join(projectPath, HARNESS_DIR, SESSIONS_DIR);
-  fs14.mkdirSync(sessionsDir, { recursive: true });
-  const indexPath2 = path11.join(sessionsDir, SESSION_INDEX_FILE);
+  const sessionsDir = path10.join(projectPath, HARNESS_DIR, SESSIONS_DIR);
+  fs13.mkdirSync(sessionsDir, { recursive: true });
+  const indexPath2 = path10.join(sessionsDir, SESSION_INDEX_FILE);
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const newLine = `- [${sessionSlug}](${sessionSlug}/summary.md) \u2014 ${description} (${date})`;
-  if (!fs14.existsSync(indexPath2)) {
-    fs14.writeFileSync(indexPath2, `## Active Sessions
+  if (!fs13.existsSync(indexPath2)) {
+    fs13.writeFileSync(indexPath2, `## Active Sessions
 
 ${newLine}
 `);
     return;
   }
-  const content = fs14.readFileSync(indexPath2, "utf-8");
+  const content = fs13.readFileSync(indexPath2, "utf-8");
   const lines = content.split("\n");
   const slugPattern = `- [${sessionSlug}]`;
   const existingIdx = lines.findIndex((l) => l.startsWith(slugPattern));
@@ -6199,7 +6113,7 @@ ${newLine}
     const lastNonEmpty = lines.reduce((last, line, i) => line.trim() !== "" ? i : last, 0);
     lines.splice(lastNonEmpty + 1, 0, newLine);
   }
-  fs14.writeFileSync(indexPath2, lines.join("\n"));
+  fs13.writeFileSync(indexPath2, lines.join("\n"));
 }
 function evictIfNeeded(map) {
   if (map.size > MAX_CACHE_ENTRIES) {
@@ -6212,8 +6126,8 @@ async function getStateDir(projectPath, stream, session) {
     const sessionResult = resolveSessionDir(projectPath, session, { create: true });
     return sessionResult;
   }
-  const streamsIndexPath = path12.join(projectPath, HARNESS_DIR, "streams", INDEX_FILE);
-  const hasStreams = fs15.existsSync(streamsIndexPath);
+  const streamsIndexPath = path11.join(projectPath, HARNESS_DIR, "streams", INDEX_FILE);
+  const hasStreams = fs14.existsSync(streamsIndexPath);
   if (stream || hasStreams) {
     const result = await resolveStreamPath(projectPath, stream ? { stream } : void 0);
     if (result.ok) {
@@ -6223,18 +6137,18 @@ async function getStateDir(projectPath, stream, session) {
       return result;
     }
   }
-  return Ok(path12.join(projectPath, HARNESS_DIR));
+  return Ok(path11.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 = path13.join(stateDir, STATE_FILE);
-    if (!fs16.existsSync(statePath)) {
+    const statePath = path12.join(stateDir, STATE_FILE);
+    if (!fs15.existsSync(statePath)) {
       return Ok({ ...DEFAULT_STATE });
     }
-    const raw = fs16.readFileSync(statePath, "utf-8");
+    const raw = fs15.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = HarnessStateSchema.safeParse(parsed);
     if (!result.success) {
@@ -6252,11 +6166,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 = path13.join(stateDir, STATE_FILE);
-    fs16.mkdirSync(stateDir, { recursive: true });
+    const statePath = path12.join(stateDir, STATE_FILE);
+    fs15.mkdirSync(stateDir, { recursive: true });
     const tmpPath = statePath + ".tmp";
-    fs16.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
-    fs16.renameSync(tmpPath, statePath);
+    fs15.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
+    fs15.renameSync(tmpPath, statePath);
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -6342,10 +6256,10 @@ function computeContentHash(text) {
   return crypto2.createHash("sha256").update(text).digest("hex").slice(0, 16);
 }
 function loadContentHashes(stateDir) {
-  const hashesPath = path14.join(stateDir, CONTENT_HASHES_FILE);
-  if (!fs17.existsSync(hashesPath)) return {};
+  const hashesPath = path13.join(stateDir, CONTENT_HASHES_FILE);
+  if (!fs16.existsSync(hashesPath)) return {};
   try {
-    const raw = fs17.readFileSync(hashesPath, "utf-8");
+    const raw = fs16.readFileSync(hashesPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
     return parsed;
@@ -6354,15 +6268,15 @@ function loadContentHashes(stateDir) {
   }
 }
 function saveContentHashes(stateDir, index) {
-  const hashesPath = path14.join(stateDir, CONTENT_HASHES_FILE);
+  const hashesPath = path13.join(stateDir, CONTENT_HASHES_FILE);
   const tmpPath = hashesPath + ".tmp";
-  fs17.writeFileSync(tmpPath, JSON.stringify(index, null, 2) + "\n");
-  fs17.renameSync(tmpPath, hashesPath);
+  fs16.writeFileSync(tmpPath, JSON.stringify(index, null, 2) + "\n");
+  fs16.renameSync(tmpPath, hashesPath);
 }
 function rebuildContentHashes(stateDir, learningsFile) {
-  const learningsPath = path14.join(stateDir, learningsFile);
-  if (!fs17.existsSync(learningsPath)) return {};
-  const content = fs17.readFileSync(learningsPath, "utf-8");
+  const learningsPath = path13.join(stateDir, learningsFile);
+  if (!fs16.existsSync(learningsPath)) return {};
+  const content = fs16.readFileSync(learningsPath, "utf-8");
   const lines = content.split("\n");
   const index = {};
   for (let i = 0; i < lines.length; i++) {
@@ -6421,18 +6335,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 = path15.join(stateDir, LEARNINGS_FILE);
-    if (!fs18.existsSync(learningsPath)) {
+    const learningsPath = path14.join(stateDir, LEARNINGS_FILE);
+    if (!fs17.existsSync(learningsPath)) {
       return Ok([]);
     }
-    const stats = fs18.statSync(learningsPath);
+    const stats = fs17.statSync(learningsPath);
     const cacheKey = learningsPath;
     const cached = learningsCacheMap.get(cacheKey);
     let entries;
     if (cached && cached.mtimeMs === stats.mtimeMs) {
       entries = cached.entries;
     } else {
-      const content = fs18.readFileSync(learningsPath, "utf-8");
+      const content = fs17.readFileSync(learningsPath, "utf-8");
       const lines = content.split("\n");
       entries = [];
       let currentBlock = [];
@@ -6568,16 +6482,16 @@ function checkOverlap(newEntry, existingEntries, options) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 async function acquireFileLock(lockPath) {
   for (let attempt = 0; attempt < LOCK_RETRIES; attempt++) {
     try {
-      const fd = fs19.openSync(
+      const fd = fs18.openSync(
         lockPath,
-        fs19.constants.O_CREAT | fs19.constants.O_EXCL | fs19.constants.O_WRONLY
+        fs18.constants.O_CREAT | fs18.constants.O_EXCL | fs18.constants.O_WRONLY
       );
-      fs19.closeSync(fd);
+      fs18.closeSync(fd);
       return;
     } catch (err) {
       const isExist = err instanceof Error && "code" in err && err.code === "EEXIST";
@@ -6591,20 +6505,20 @@ async function acquireFileLock(lockPath) {
 }
 function releaseFileLock(lockPath) {
   try {
-    fs19.unlinkSync(lockPath);
+    fs18.unlinkSync(lockPath);
   } catch {
   }
 }
 function loadOrRebuildHashes(stateDir, learningsPath) {
-  const hashesPath = path16.join(stateDir, CONTENT_HASHES_FILE);
-  if (fs19.existsSync(hashesPath)) {
+  const hashesPath = path15.join(stateDir, CONTENT_HASHES_FILE);
+  if (fs18.existsSync(hashesPath)) {
     const hashes = loadContentHashes(stateDir);
-    if (Object.keys(hashes).length === 0 && fs19.existsSync(learningsPath)) {
+    if (Object.keys(hashes).length === 0 && fs18.existsSync(learningsPath)) {
       return rebuildContentHashes(stateDir, LEARNINGS_FILE);
     }
     return hashes;
   }
-  if (fs19.existsSync(learningsPath)) {
+  if (fs18.existsSync(learningsPath)) {
     return rebuildContentHashes(stateDir, LEARNINGS_FILE);
   }
   return {};
@@ -6628,8 +6542,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 = path16.join(stateDir, LEARNINGS_FILE);
-    fs19.mkdirSync(stateDir, { recursive: true });
+    const learningsPath = path15.join(stateDir, LEARNINGS_FILE);
+    fs18.mkdirSync(stateDir, { recursive: true });
     const lockPath = learningsPath + ".lock";
     await acquireFileLock(lockPath);
     try {
@@ -6659,17 +6573,17 @@ ${bulletLine}
 `;
       let overlapResult;
       let existingLineCount;
-      if (!fs19.existsSync(learningsPath)) {
-        fs19.writeFileSync(learningsPath, `# Learnings
+      if (!fs18.existsSync(learningsPath)) {
+        fs18.writeFileSync(learningsPath, `# Learnings
 ${entry}`);
         existingLineCount = 1;
       } else {
-        const existingContent = fs19.readFileSync(learningsPath, "utf-8");
+        const existingContent = fs18.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;
-        fs19.appendFileSync(learningsPath, entry);
+        fs18.appendFileSync(learningsPath, entry);
       }
       const bulletLineNum = existingLineCount + 2;
       contentHashes[contentHash] = { date: timestamp ?? "", line: bulletLineNum };
@@ -6774,11 +6688,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 = path16.join(stateDir, LEARNINGS_FILE);
-    if (!fs19.existsSync(learningsPath)) {
+    const learningsPath = path15.join(stateDir, LEARNINGS_FILE);
+    if (!fs18.existsSync(learningsPath)) {
       return Ok([]);
     }
-    const content = fs19.readFileSync(learningsPath, "utf-8");
+    const content = fs18.readFileSync(learningsPath, "utf-8");
     const lines = content.split("\n");
     const indexEntries = [];
     let pendingFrontmatter = null;
@@ -6820,16 +6734,16 @@ async function archiveLearnings(projectPath, entries, stream) {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const archiveDir = path17.join(stateDir, "learnings-archive");
-    fs20.mkdirSync(archiveDir, { recursive: true });
+    const archiveDir = path16.join(stateDir, "learnings-archive");
+    fs19.mkdirSync(archiveDir, { recursive: true });
     const now = /* @__PURE__ */ new Date();
     const yearMonth = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
-    const archivePath = path17.join(archiveDir, `${yearMonth}.md`);
+    const archivePath = path16.join(archiveDir, `${yearMonth}.md`);
     const archiveContent = entries.join("\n\n") + "\n";
-    if (fs20.existsSync(archivePath)) {
-      fs20.appendFileSync(archivePath, "\n" + archiveContent);
+    if (fs19.existsSync(archivePath)) {
+      fs19.appendFileSync(archivePath, "\n" + archiveContent);
     } else {
-      fs20.writeFileSync(archivePath, `# Learnings Archive
+      fs19.writeFileSync(archivePath, `# Learnings Archive
 
 ${archiveContent}`);
     }
@@ -6847,8 +6761,8 @@ async function pruneLearnings(projectPath, stream) {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const learningsPath = path17.join(stateDir, LEARNINGS_FILE);
-    if (!fs20.existsSync(learningsPath)) {
+    const learningsPath = path16.join(stateDir, LEARNINGS_FILE);
+    if (!fs19.existsSync(learningsPath)) {
       return Ok({ kept: 0, archived: 0, patterns: [] });
     }
     const loadResult = await loadRelevantLearnings(projectPath, void 0, stream);
@@ -6879,7 +6793,7 @@ async function pruneLearnings(projectPath, stream) {
       if (!archiveResult.ok) return archiveResult;
     }
     const newContent = "# Learnings\n\n" + toKeep.join("\n\n") + "\n";
-    fs20.writeFileSync(learningsPath, newContent);
+    fs19.writeFileSync(learningsPath, newContent);
     invalidateLearningsCacheEntry(learningsPath);
     return Ok({
       kept: toKeep.length,
@@ -6923,19 +6837,19 @@ async function promoteSessionLearnings(projectPath, sessionSlug, stream) {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const globalPath = path17.join(stateDir, LEARNINGS_FILE);
-    const existingGlobal = fs20.existsSync(globalPath) ? fs20.readFileSync(globalPath, "utf-8") : "";
+    const globalPath = path16.join(stateDir, LEARNINGS_FILE);
+    const existingGlobal = fs19.existsSync(globalPath) ? fs19.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) {
-      fs20.writeFileSync(globalPath, `# Learnings
+      fs19.writeFileSync(globalPath, `# Learnings
 
 ${promotedContent}`);
     } else {
-      fs20.appendFileSync(globalPath, "\n\n" + promotedContent);
+      fs19.appendFileSync(globalPath, "\n\n" + promotedContent);
     }
     invalidateLearningsCacheEntry(globalPath);
     return Ok({
@@ -6971,13 +6885,13 @@ async function detectStaleLearnings(projectPath, stream, session) {
         freshCount++;
         continue;
       }
-      const resolvedRoot = path18.resolve(projectPath);
+      const resolvedRoot = path17.resolve(projectPath);
       const missing = refs.filter((ref) => {
-        const absPath = path18.resolve(projectPath, ref);
-        if (!absPath.startsWith(resolvedRoot + path18.sep) && absPath !== resolvedRoot) {
+        const absPath = path17.resolve(projectPath, ref);
+        if (!absPath.startsWith(resolvedRoot + path17.sep) && absPath !== resolvedRoot) {
           return false;
         }
-        return !fs21.existsSync(absPath);
+        return !fs20.existsSync(absPath);
       });
       if (missing.length > 0) {
         const idx = extractIndexEntry(entry);
@@ -7012,17 +6926,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 = path19.join(stateDir, FAILURES_FILE);
-    fs22.mkdirSync(stateDir, { recursive: true });
+    const failuresPath = path18.join(stateDir, FAILURES_FILE);
+    fs21.mkdirSync(stateDir, { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const entry = `
 - **${timestamp} [skill:${skillName}] [type:${type}]:** ${description}
 `;
-    if (!fs22.existsSync(failuresPath)) {
-      fs22.writeFileSync(failuresPath, `# Failures
+    if (!fs21.existsSync(failuresPath)) {
+      fs21.writeFileSync(failuresPath, `# Failures
 ${entry}`);
     } else {
-      fs22.appendFileSync(failuresPath, entry);
+      fs21.appendFileSync(failuresPath, entry);
     }
     failuresCacheMap.delete(failuresPath);
     return Ok(void 0);
@@ -7039,17 +6953,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 = path19.join(stateDir, FAILURES_FILE);
-    if (!fs22.existsSync(failuresPath)) {
+    const failuresPath = path18.join(stateDir, FAILURES_FILE);
+    if (!fs21.existsSync(failuresPath)) {
       return Ok([]);
     }
-    const stats = fs22.statSync(failuresPath);
+    const stats = fs21.statSync(failuresPath);
     const cacheKey = failuresPath;
     const cached = failuresCacheMap.get(cacheKey);
     if (cached && cached.mtimeMs === stats.mtimeMs) {
       return Ok(cached.entries);
     }
-    const content = fs22.readFileSync(failuresPath, "utf-8");
+    const content = fs21.readFileSync(failuresPath, "utf-8");
     const entries = [];
     for (const line of content.split("\n")) {
       const match = line.match(FAILURE_LINE_REGEX);
@@ -7078,20 +6992,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 = path19.join(stateDir, FAILURES_FILE);
-    if (!fs22.existsSync(failuresPath)) {
+    const failuresPath = path18.join(stateDir, FAILURES_FILE);
+    if (!fs21.existsSync(failuresPath)) {
       return Ok(void 0);
     }
-    const archiveDir = path19.join(stateDir, "archive");
-    fs22.mkdirSync(archiveDir, { recursive: true });
+    const archiveDir = path18.join(stateDir, "archive");
+    fs21.mkdirSync(archiveDir, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     let archiveName = `failures-${date}.md`;
     let counter = 2;
-    while (fs22.existsSync(path19.join(archiveDir, archiveName))) {
+    while (fs21.existsSync(path18.join(archiveDir, archiveName))) {
       archiveName = `failures-${date}-${counter}.md`;
       counter++;
     }
-    fs22.renameSync(failuresPath, path19.join(archiveDir, archiveName));
+    fs21.renameSync(failuresPath, path18.join(archiveDir, archiveName));
     failuresCacheMap.delete(failuresPath);
     return Ok(void 0);
   } catch (error) {
@@ -7107,11 +7021,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 = path20.join(stateDir, HANDOFF_FILE);
-    fs23.mkdirSync(stateDir, { recursive: true });
+    const handoffPath = path19.join(stateDir, HANDOFF_FILE);
+    fs22.mkdirSync(stateDir, { recursive: true });
     const tmpPath = handoffPath + ".tmp";
-    fs23.writeFileSync(tmpPath, JSON.stringify(handoff, null, 2));
-    fs23.renameSync(tmpPath, handoffPath);
+    fs22.writeFileSync(tmpPath, JSON.stringify(handoff, null, 2));
+    fs22.renameSync(tmpPath, handoffPath);
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -7124,11 +7038,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 = path20.join(stateDir, HANDOFF_FILE);
-    if (!fs23.existsSync(handoffPath)) {
+    const handoffPath = path19.join(stateDir, HANDOFF_FILE);
+    if (!fs22.existsSync(handoffPath)) {
       return Ok(null);
     }
-    const raw = fs23.readFileSync(handoffPath, "utf-8");
+    const raw = fs22.readFileSync(handoffPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = HandoffSchema.safeParse(parsed);
     if (!result.success) {
@@ -7142,28 +7056,28 @@ async function loadHandoff(projectPath, stream, session) {
   }
 }
 function loadChecksFromConfig(gateConfigPath) {
-  if (!fs24.existsSync(gateConfigPath)) return [];
-  const raw = JSON.parse(fs24.readFileSync(gateConfigPath, "utf-8"));
+  if (!fs23.existsSync(gateConfigPath)) return [];
+  const raw = JSON.parse(fs23.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 = path21.join(projectPath, "package.json");
-  if (fs24.existsSync(packageJsonPath)) {
-    const pkg = JSON.parse(fs24.readFileSync(packageJsonPath, "utf-8"));
+  const packageJsonPath = path20.join(projectPath, "package.json");
+  if (fs23.existsSync(packageJsonPath)) {
+    const pkg = JSON.parse(fs23.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 (fs24.existsSync(path21.join(projectPath, "go.mod"))) {
+  if (fs23.existsSync(path20.join(projectPath, "go.mod"))) {
     checks.push({ name: "test", command: "go test ./..." });
     checks.push({ name: "build", command: "go build ./..." });
   }
-  if (fs24.existsSync(path21.join(projectPath, "pyproject.toml")) || fs24.existsSync(path21.join(projectPath, "setup.py"))) {
+  if (fs23.existsSync(path20.join(projectPath, "pyproject.toml")) || fs23.existsSync(path20.join(projectPath, "setup.py"))) {
     checks.push({ name: "test", command: "python -m pytest" });
   }
   return checks;
@@ -7203,8 +7117,8 @@ function executeCheck(check, projectPath) {
   }
 }
 async function runMechanicalGate(projectPath) {
-  const harnessDir = path21.join(projectPath, HARNESS_DIR);
-  const gateConfigPath = path21.join(harnessDir, GATE_CONFIG_FILE);
+  const harnessDir = path20.join(projectPath, HARNESS_DIR);
+  const gateConfigPath = path20.join(harnessDir, GATE_CONFIG_FILE);
   try {
     let checks = loadChecksFromConfig(gateConfigPath);
     if (checks.length === 0) {
@@ -7260,9 +7174,9 @@ function writeSessionSummary(projectPath, sessionSlug, data) {
     const dirResult = resolveSessionDir(projectPath, sessionSlug, { create: true });
     if (!dirResult.ok) return dirResult;
     const sessionDir = dirResult.value;
-    const summaryPath = path22.join(sessionDir, SUMMARY_FILE);
+    const summaryPath = path21.join(sessionDir, SUMMARY_FILE);
     const content = formatSummary(data);
-    fs25.writeFileSync(summaryPath, content);
+    fs24.writeFileSync(summaryPath, content);
     const description = deriveIndexDescription(data);
     updateSessionIndex(projectPath, sessionSlug, description);
     return Ok(void 0);
@@ -7279,11 +7193,11 @@ function loadSessionSummary(projectPath, sessionSlug) {
     const dirResult = resolveSessionDir(projectPath, sessionSlug);
     if (!dirResult.ok) return dirResult;
     const sessionDir = dirResult.value;
-    const summaryPath = path22.join(sessionDir, SUMMARY_FILE);
-    if (!fs25.existsSync(summaryPath)) {
+    const summaryPath = path21.join(sessionDir, SUMMARY_FILE);
+    if (!fs24.existsSync(summaryPath)) {
       return Ok(null);
     }
-    const content = fs25.readFileSync(summaryPath, "utf-8");
+    const content = fs24.readFileSync(summaryPath, "utf-8");
     return Ok(content);
   } catch (error) {
     return Err(
@@ -7295,11 +7209,11 @@ function loadSessionSummary(projectPath, sessionSlug) {
 }
 function listActiveSessions(projectPath) {
   try {
-    const indexPath2 = path22.join(projectPath, HARNESS_DIR, SESSIONS_DIR, SESSION_INDEX_FILE);
-    if (!fs25.existsSync(indexPath2)) {
+    const indexPath2 = path21.join(projectPath, HARNESS_DIR, SESSIONS_DIR, SESSION_INDEX_FILE);
+    if (!fs24.existsSync(indexPath2)) {
       return Ok(null);
     }
-    const content = fs25.readFileSync(indexPath2, "utf-8");
+    const content = fs24.readFileSync(indexPath2, "utf-8");
     return Ok(content);
   } catch (error) {
     return Err(
@@ -7320,12 +7234,12 @@ async function loadSessionState(projectPath, sessionSlug) {
   const dirResult = resolveSessionDir(projectPath, sessionSlug);
   if (!dirResult.ok) return dirResult;
   const sessionDir = dirResult.value;
-  const filePath = path23.join(sessionDir, SESSION_STATE_FILE);
-  if (!fs26.existsSync(filePath)) {
+  const filePath = path22.join(sessionDir, SESSION_STATE_FILE);
+  if (!fs25.existsSync(filePath)) {
     return Ok(emptySections());
   }
   try {
-    const raw = fs26.readFileSync(filePath, "utf-8");
+    const raw = fs25.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     const sections = emptySections();
     for (const name of SESSION_SECTION_NAMES) {
@@ -7346,9 +7260,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 = path23.join(sessionDir, SESSION_STATE_FILE);
+  const filePath = path22.join(sessionDir, SESSION_STATE_FILE);
   try {
-    fs26.writeFileSync(filePath, JSON.stringify(sections, null, 2));
+    fs25.writeFileSync(filePath, JSON.stringify(sections, null, 2));
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -7404,26 +7318,26 @@ async function archiveSession(projectPath, sessionSlug, options = {}) {
   const dirResult = resolveSessionDir(projectPath, sessionSlug);
   if (!dirResult.ok) return dirResult;
   const sessionDir = dirResult.value;
-  if (!fs27.existsSync(sessionDir)) {
+  if (!fs26.existsSync(sessionDir)) {
     return Err(new Error(`Session '${sessionSlug}' not found at ${sessionDir}`));
   }
-  const archiveBase = path24.join(projectPath, HARNESS_DIR, ARCHIVE_DIR, "sessions");
+  const archiveBase = path23.join(projectPath, HARNESS_DIR, ARCHIVE_DIR, "sessions");
   try {
-    fs27.mkdirSync(archiveBase, { recursive: true });
+    fs26.mkdirSync(archiveBase, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     let archiveName = `${sessionSlug}-${date}`;
     let counter = 1;
-    while (fs27.existsSync(path24.join(archiveBase, archiveName))) {
+    while (fs26.existsSync(path23.join(archiveBase, archiveName))) {
       archiveName = `${sessionSlug}-${date}-${counter}`;
       counter++;
     }
-    const dest = path24.join(archiveBase, archiveName);
+    const dest = path23.join(archiveBase, archiveName);
     try {
-      fs27.renameSync(sessionDir, dest);
+      fs26.renameSync(sessionDir, dest);
     } catch (renameErr) {
       if (renameErr instanceof Error && "code" in renameErr && renameErr.code === "EXDEV") {
-        fs27.cpSync(sessionDir, dest, { recursive: true });
-        fs27.rmSync(sessionDir, { recursive: true });
+        fs26.cpSync(sessionDir, dest, { recursive: true });
+        fs26.rmSync(sessionDir, { recursive: true });
       } else {
         throw renameErr;
       }
@@ -7458,8 +7372,8 @@ function loadKnownHashes(eventsPath) {
   const cached = knownHashesCache.get(eventsPath);
   if (cached) return cached;
   const hashes = /* @__PURE__ */ new Set();
-  if (fs28.existsSync(eventsPath)) {
-    const content = fs28.readFileSync(eventsPath, "utf-8");
+  if (fs27.existsSync(eventsPath)) {
+    const content = fs27.readFileSync(eventsPath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim() !== "");
     for (const line of lines) {
       try {
@@ -7482,8 +7396,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 = path25.join(stateDir, EVENTS_FILE);
-    fs28.mkdirSync(stateDir, { recursive: true });
+    const eventsPath = path24.join(stateDir, EVENTS_FILE);
+    fs27.mkdirSync(stateDir, { recursive: true });
     const contentHash = computeEventHash(event, options?.session);
     const knownHashes = loadKnownHashes(eventsPath);
     if (knownHashes.has(contentHash)) {
@@ -7497,7 +7411,7 @@ async function emitEvent(projectPath, event, options) {
     if (options?.session) {
       fullEvent.session = options.session;
     }
-    fs28.appendFileSync(eventsPath, JSON.stringify(fullEvent) + "\n");
+    fs27.appendFileSync(eventsPath, JSON.stringify(fullEvent) + "\n");
     knownHashes.add(contentHash);
     return Ok({ written: true });
   } catch (error) {
@@ -7511,11 +7425,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 = path25.join(stateDir, EVENTS_FILE);
-    if (!fs28.existsSync(eventsPath)) {
+    const eventsPath = path24.join(stateDir, EVENTS_FILE);
+    if (!fs27.existsSync(eventsPath)) {
       return Ok([]);
     }
-    const content = fs28.readFileSync(eventsPath, "utf-8");
+    const content = fs27.readFileSync(eventsPath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim() !== "");
     const events = [];
     for (const line of lines) {
@@ -7764,11 +7678,11 @@ function nodeSubStacks(allDeps) {
   return found;
 }
 function detectNodeStacks(projectRoot) {
-  const pkgJsonPath = path26.join(projectRoot, "package.json");
-  if (!fs29.existsSync(pkgJsonPath)) return [];
+  const pkgJsonPath = path25.join(projectRoot, "package.json");
+  if (!fs28.existsSync(pkgJsonPath)) return [];
   const stacks = ["node"];
   try {
-    const pkgJson = JSON.parse(fs29.readFileSync(pkgJsonPath, "utf-8"));
+    const pkgJson = JSON.parse(fs28.readFileSync(pkgJsonPath, "utf-8"));
     const allDeps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
     stacks.push(...nodeSubStacks(allDeps));
   } catch {
@@ -7777,10 +7691,10 @@ function detectNodeStacks(projectRoot) {
 }
 function detectStack(projectRoot) {
   const stacks = [...detectNodeStacks(projectRoot)];
-  if (fs29.existsSync(path26.join(projectRoot, "go.mod"))) {
+  if (fs28.existsSync(path25.join(projectRoot, "go.mod"))) {
     stacks.push("go");
   }
-  const hasPython = fs29.existsSync(path26.join(projectRoot, "requirements.txt")) || fs29.existsSync(path26.join(projectRoot, "pyproject.toml"));
+  const hasPython = fs28.existsSync(path25.join(projectRoot, "requirements.txt")) || fs28.existsSync(path25.join(projectRoot, "pyproject.toml"));
   if (hasPython) {
     stacks.push("python");
   }
@@ -7803,7 +7717,7 @@ function createOsvClient(options = {}) {
   return {
     async check(pkg) {
       const cacheKey = `${pkg.ecosystem}-${sanitizePkgName(pkg.name)}@${pkg.version ?? "latest"}.json`;
-      const cachePath = path27.join(cacheDir, cacheKey);
+      const cachePath = path26.join(cacheDir, cacheKey);
       const cached = await readCache(cachePath, ttlMs);
       if (cached) {
         return { ...cached, source: "cache" };
@@ -7824,7 +7738,7 @@ function createOsvClient(options = {}) {
     },
     async clearCache() {
       try {
-        await fs31.promises.rm(cacheDir, { recursive: true, force: true });
+        await fs30.promises.rm(cacheDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -7860,9 +7774,9 @@ function classify(advisories) {
 }
 async function readCache(cachePath, ttlMs) {
   try {
-    const stat2 = await fs31.promises.stat(cachePath);
+    const stat2 = await fs30.promises.stat(cachePath);
     if (Date.now() - stat2.mtimeMs > ttlMs) return null;
-    const buf = await fs31.promises.readFile(cachePath, "utf-8");
+    const buf = await fs30.promises.readFile(cachePath, "utf-8");
     const parsed = JSON.parse(buf);
     return { malicious: parsed.malicious ?? [], other: parsed.other ?? [] };
   } catch {
@@ -7871,8 +7785,8 @@ async function readCache(cachePath, ttlMs) {
 }
 async function writeCache(cachePath, payload) {
   try {
-    await fs31.promises.mkdir(path27.dirname(cachePath), { recursive: true });
-    await fs31.promises.writeFile(cachePath, JSON.stringify(payload, null, 2), "utf-8");
+    await fs30.promises.mkdir(path26.dirname(cachePath), { recursive: true });
+    await fs30.promises.writeFile(cachePath, JSON.stringify(payload, null, 2), "utf-8");
   } catch {
   }
 }
@@ -7908,13 +7822,13 @@ function getInjectionPatterns() {
 }
 function getTaintFilePath(projectRoot, sessionId) {
   const id = sessionId || DEFAULT_SESSION_ID;
-  return join39(projectRoot, ".harness", `session-taint-${id}.json`);
+  return join38(projectRoot, ".harness", `session-taint-${id}.json`);
 }
 function readTaint(projectRoot, sessionId) {
   const filePath = getTaintFilePath(projectRoot, sessionId);
   let content;
   try {
-    content = readFileSync22(filePath, "utf8");
+    content = readFileSync21(filePath, "utf8");
   } catch {
     return null;
   }
@@ -7990,14 +7904,14 @@ function clearTaint(projectRoot, sessionId) {
       return 0;
     }
   }
-  const harnessDir = join39(projectRoot, ".harness");
+  const harnessDir = join38(projectRoot, ".harness");
   let count = 0;
   try {
-    const files = readdirSync3(harnessDir);
+    const files = readdirSync2(harnessDir);
     for (const file of files) {
       if (file.startsWith("session-taint-") && file.endsWith(".json")) {
         try {
-          unlinkSync2(join39(harnessDir, file));
+          unlinkSync2(join38(harnessDir, file));
           count++;
         } catch {
         }
@@ -8008,10 +7922,10 @@ function clearTaint(projectRoot, sessionId) {
   return count;
 }
 function listTaintedSessions(projectRoot) {
-  const harnessDir = join39(projectRoot, ".harness");
+  const harnessDir = join38(projectRoot, ".harness");
   const sessions = [];
   try {
-    const files = readdirSync3(harnessDir);
+    const files = readdirSync2(harnessDir);
     for (const file of files) {
       if (file.startsWith("session-taint-") && file.endsWith(".json")) {
         const sessionId = file.replace("session-taint-", "").replace(".json", "");
@@ -8080,7 +7994,7 @@ function securityFindingId(finding) {
 }
 async function runValidateCheck(projectRoot, config) {
   const issues = [];
-  const agentsPath = path28.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
+  const agentsPath = path27.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
   const result = await validateAgentsMap(agentsPath);
   if (!result.ok) {
     issues.push({ severity: "error", message: result.error.message });
@@ -8137,7 +8051,7 @@ async function runDepsCheck(projectRoot, config) {
 }
 async function runDocsCheck(projectRoot, config) {
   const issues = [];
-  const docsDir = path28.join(projectRoot, config.docsDir ?? "docs");
+  const docsDir = path27.join(projectRoot, config.docsDir ?? "docs");
   const entropyConfig = config.entropy || {};
   const result = await checkDocCoverage("project", {
     docsDir,
@@ -8316,7 +8230,7 @@ async function runTraceabilityCheck(projectRoot, config) {
   const issues = [];
   const traceConfig = config.traceability || {};
   if (traceConfig.enabled === false) return issues;
-  const graphDir = path28.join(projectRoot, ".harness", "graph");
+  const graphDir = path27.join(projectRoot, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);
   if (!loaded) {
@@ -8494,7 +8408,7 @@ async function runMechanicalChecks(options) {
   };
   if (!skip.includes("validate")) {
     try {
-      const agentsPath = path29.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
+      const agentsPath = path28.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
       const result = await validateAgentsMap(agentsPath);
       if (!result.ok) {
         statuses.validate = "fail";
@@ -8531,7 +8445,7 @@ async function runMechanicalChecks(options) {
       statuses.validate = "fail";
       findings.push({
         tool: "validate",
-        file: path29.join(projectRoot, "AGENTS.md"),
+        file: path28.join(projectRoot, "AGENTS.md"),
         message: err instanceof Error ? err.message : String(err),
         severity: "error"
       });
@@ -8595,7 +8509,7 @@ async function runMechanicalChecks(options) {
       (async () => {
         const localFindings = [];
         try {
-          const docsDir = path29.join(projectRoot, config.docsDir ?? "docs");
+          const docsDir = path28.join(projectRoot, config.docsDir ?? "docs");
           const result = await checkDocCoverage("project", { docsDir });
           if (!result.ok) {
             statuses["check-docs"] = "warn";
@@ -8622,7 +8536,7 @@ async function runMechanicalChecks(options) {
           statuses["check-docs"] = "warn";
           localFindings.push({
             tool: "check-docs",
-            file: path29.join(projectRoot, "docs"),
+            file: path28.join(projectRoot, "docs"),
             message: err instanceof Error ? err.message : String(err),
             severity: "warning"
           });
@@ -8719,18 +8633,18 @@ function computeContextBudget(diffLines) {
   return diffLines;
 }
 function isWithinProject(absPath, projectRoot) {
-  const resolvedRoot = path30.resolve(projectRoot) + path30.sep;
-  const resolvedPath = path30.resolve(absPath);
-  return resolvedPath.startsWith(resolvedRoot) || resolvedPath === path30.resolve(projectRoot);
+  const resolvedRoot = path29.resolve(projectRoot) + path29.sep;
+  const resolvedPath = path29.resolve(absPath);
+  return resolvedPath.startsWith(resolvedRoot) || resolvedPath === path29.resolve(projectRoot);
 }
 async function readContextFile(projectRoot, filePath, reason) {
-  const absPath = path30.isAbsolute(filePath) ? filePath : path30.join(projectRoot, filePath);
+  const absPath = path29.isAbsolute(filePath) ? filePath : path29.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 = path30.isAbsolute(filePath) ? relativePosix(projectRoot, filePath) : filePath;
+  const relPath2 = path29.isAbsolute(filePath) ? relativePosix(projectRoot, filePath) : filePath;
   return { path: relPath2, content, reason, lines };
 }
 function extractImportSources2(content) {
@@ -8745,24 +8659,24 @@ function extractImportSources2(content) {
 }
 async function resolveImportPath(projectRoot, fromFile, importSource) {
   if (!importSource.startsWith(".")) return null;
-  const fromDir = path30.dirname(path30.join(projectRoot, fromFile));
-  const basePath = path30.resolve(fromDir, importSource);
+  const fromDir = path29.dirname(path29.join(projectRoot, fromFile));
+  const basePath = path29.resolve(fromDir, importSource);
   if (!isWithinProject(basePath, projectRoot)) return null;
   const relBase = relativePosix(projectRoot, basePath);
-  const sourceExt = path30.extname(relBase);
+  const sourceExt = path29.extname(relBase);
   const candidates = [];
   const fallbacks = JS_EXT_FALLBACKS[sourceExt];
   if (fallbacks) {
     const stripped = relBase.slice(0, -sourceExt.length);
     for (const ext of fallbacks) candidates.push(stripped + ext);
-    candidates.push(path30.join(stripped, "index.ts"));
-    candidates.push(path30.join(stripped, "index.tsx"));
-    candidates.push(path30.join(stripped, "index.jsx"));
+    candidates.push(path29.join(stripped, "index.ts"));
+    candidates.push(path29.join(stripped, "index.tsx"));
+    candidates.push(path29.join(stripped, "index.jsx"));
   }
   candidates.push(relBase + ".ts", relBase + ".tsx", relBase + ".mts");
-  candidates.push(path30.join(relBase, "index.ts"));
+  candidates.push(path29.join(relBase, "index.ts"));
   for (const candidate of candidates) {
-    const absCandidate = path30.join(projectRoot, candidate);
+    const absCandidate = path29.join(projectRoot, candidate);
     if (await fileExists(absCandidate)) {
       return candidate;
     }
@@ -8770,7 +8684,7 @@ async function resolveImportPath(projectRoot, fromFile, importSource) {
   return null;
 }
 async function findTestFiles(projectRoot, sourceFile) {
-  const baseName = path30.basename(sourceFile, path30.extname(sourceFile));
+  const baseName = path29.basename(sourceFile, path29.extname(sourceFile));
   const pattern = `**/${baseName}.{test,spec}.{ts,tsx,mts}`;
   const results = await findFiles(pattern, projectRoot);
   return results.map((f) => relativePosix(projectRoot, f));
@@ -10069,7 +9983,7 @@ function normalizePath(filePath, projectRoot) {
   let normalized = filePath;
   normalized = normalized.replace(/\\/g, "/");
   const normalizedRoot = projectRoot.replace(/\\/g, "/");
-  if (path31.isAbsolute(normalized)) {
+  if (path30.isAbsolute(normalized)) {
     const root = normalizedRoot.endsWith("/") ? normalizedRoot : normalizedRoot + "/";
     if (normalized.startsWith(root)) {
       normalized = normalized.slice(root.length);
@@ -10081,12 +9995,12 @@ function normalizePath(filePath, projectRoot) {
   return normalized;
 }
 function resolveImportPath2(currentFile, importPath) {
-  const dir = path31.dirname(currentFile);
-  let resolved = path31.join(dir, importPath).replace(/\\/g, "/");
+  const dir = path30.dirname(currentFile);
+  let resolved = path30.join(dir, importPath).replace(/\\/g, "/");
   if (!resolved.match(/\.(ts|tsx|js|jsx)$/)) {
     resolved += ".ts";
   }
-  return path31.normalize(resolved).replace(/\\/g, "/");
+  return path30.normalize(resolved).replace(/\\/g, "/");
 }
 function enqueueImports(content, current, visited, queue, maxDepth) {
   const importRegex = /import\s+.*?from\s+['"]([^'"]+)['"]/g;
@@ -10118,7 +10032,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 = path31.isAbsolute(finding.file) ? finding.file : path31.join(projectRoot, finding.file).replace(/\\/g, "/");
+  const absoluteFile = path30.isAbsolute(finding.file) ? finding.file : path30.join(projectRoot, finding.file).replace(/\\/g, "/");
   return exclusionSet.isExcluded(absoluteFile, finding.lineRange);
 }
 async function validateWithGraph(crossFileRefs, graph) {
@@ -11112,45 +11026,363 @@ function findParallelGroups(nodes) {
     orphaned: [...index.orphaned].sort()
   };
 }
-function serializeRoadmap(roadmap) {
-  const lines = [];
-  lines.push("---");
-  lines.push(`project: ${roadmap.frontmatter.project}`);
-  lines.push(`version: ${roadmap.frontmatter.version}`);
-  if (roadmap.frontmatter.created) {
-    lines.push(`created: ${roadmap.frontmatter.created}`);
+function findingsMatch(a, b) {
+  if (a.id && b.id) return a.id === b.id;
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function deriveBlockingFindings(findings) {
+  return findings.filter((f) => f.severity === "critical");
+}
+function deriveExitCode(assessment, blockingFindings) {
+  return blockingFindings.length > 0 || assessment === "request-changes" ? 1 : 0;
+}
+function parseCiReviewVerdict(input) {
+  return CiReviewVerdictSchema.parse(input);
+}
+function buildCiReviewVerdict(parts) {
+  const findings = z12.array(ReviewFindingSchema).parse(parts.findings ?? []);
+  const blockingFindings = deriveBlockingFindings(findings);
+  const exitCode = deriveExitCode(parts.assessment, blockingFindings);
+  return parseCiReviewVerdict({
+    schemaVersion: CI_REVIEW_VERDICT_SCHEMA_VERSION,
+    runner: parts.runner,
+    ranLlmTier: parts.ranLlmTier,
+    assessment: parts.assessment,
+    findings,
+    blockingFindings,
+    exitCode,
+    skipped: parts.skipped ?? false,
+    skipReason: parts.skipReason
+  });
+}
+function parseClaudeVerdict(raw) {
+  const envelope = JSON.parse(raw);
+  if (envelope.is_error === true) {
+    throw new Error(
+      `parseClaudeVerdict: claude transcript reported is_error=true (subtype=${envelope.subtype ?? "unknown"})`
+    );
   }
-  if (roadmap.frontmatter.updated) {
-    lines.push(`updated: ${roadmap.frontmatter.updated}`);
+  if (typeof envelope.result !== "string") {
+    throw new Error(
+      "parseClaudeVerdict: claude transcript envelope is missing a string `.result` field"
+    );
   }
-  lines.push(`last_synced: ${roadmap.frontmatter.lastSynced}`);
-  lines.push(`last_manual_edit: ${roadmap.frontmatter.lastManualEdit}`);
-  lines.push("---");
-  lines.push("");
-  lines.push("# Roadmap");
-  for (const milestone of roadmap.milestones) {
-    lines.push("");
-    lines.push(serializeMilestoneHeading(milestone));
-    for (const feature of milestone.features) {
-      lines.push("");
-      lines.push(...serializeFeature(feature));
+  const inner = JSON.parse(envelope.result);
+  return buildCiReviewVerdict({
+    runner: "claude",
+    ranLlmTier: true,
+    assessment: inner.assessment,
+    findings: inner.findings
+  });
+}
+function parseCodexVerdict(raw) {
+  let lastAgentMessageText;
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (event.type === "item.completed" && event.item?.type === "agent_message" && typeof event.item.text === "string") {
+      lastAgentMessageText = event.item.text;
     }
   }
-  if (roadmap.assignmentHistory && roadmap.assignmentHistory.length > 0) {
-    lines.push("");
-    lines.push(...serializeAssignmentHistory(roadmap.assignmentHistory));
+  if (lastAgentMessageText === void 0) {
+    throw new Error(
+      "parseCodexVerdict: no `item.completed` agent_message event found in codex JSONL stream"
+    );
   }
-  lines.push("");
-  return lines.join("\n");
+  const inner = JSON.parse(lastAgentMessageText);
+  return buildCiReviewVerdict({
+    runner: "codex",
+    ranLlmTier: true,
+    assessment: inner.assessment,
+    findings: inner.findings
+  });
 }
-function serializeMilestoneHeading(milestone) {
-  return milestone.isBacklog ? "## Backlog" : `## ${milestone.name}`;
+function stripJsonFence(text) {
+  const fence = /^```(?:json)?\s*\n?([\s\S]*?)\n?```$/i.exec(text.trim());
+  const inner = fence?.[1];
+  return inner !== void 0 ? inner.trim() : text;
 }
-function orDash(value) {
-  return value ?? EM_DASH2;
+function extractFirstJsonObject(text) {
+  const start = text.indexOf("{");
+  if (start === -1) return void 0;
+  let depth = 0;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return text.slice(start, i + 1);
+    }
+  }
+  return void 0;
 }
-function listOrDash(items) {
-  return items.length > 0 ? items.join(", ") : EM_DASH2;
+function parseAntigravityVerdict(raw) {
+  const unfenced = stripJsonFence(raw.trim());
+  let inner;
+  try {
+    inner = JSON.parse(unfenced);
+  } catch {
+    const candidate = extractFirstJsonObject(unfenced);
+    if (candidate === void 0) {
+      throw new Error(
+        "parseAntigravityVerdict: no parseable JSON object found in antigravity (`agy --print`) output"
+      );
+    }
+    try {
+      inner = JSON.parse(candidate);
+    } catch {
+      throw new Error(
+        "parseAntigravityVerdict: extracted candidate from antigravity output was not valid JSON"
+      );
+    }
+  }
+  return buildCiReviewVerdict({
+    runner: "antigravity",
+    ranLlmTier: true,
+    assessment: inner.assessment,
+    findings: inner.findings
+  });
+}
+function parseLocalVerdict(raw) {
+  const parsed = JSON.parse(raw);
+  const assessment = VERDICT_MAP[parsed.assessment ?? "comment"] ?? "comment";
+  return buildCiReviewVerdict({
+    runner: "local",
+    ranLlmTier: true,
+    assessment,
+    findings: parsed.findings
+  });
+}
+function presetKind(id) {
+  return RUNNER_PRESETS[id].kind;
+}
+function isSupportedRunner(id) {
+  return RUNNER_PRESETS[id].supported === true;
+}
+function parseGeminiVerdict(raw) {
+  const parsed = JSON.parse(raw);
+  const assessment = VERDICT_MAP2[parsed.review?.verdict ?? "comment"] ?? "comment";
+  return buildCiReviewVerdict({
+    runner: "gemini",
+    ranLlmTier: true,
+    assessment,
+    findings: parsed.review?.issues
+  });
+}
+function diffToStdin(diff2) {
+  return Array.from(diff2.fileDiffs.values()).join("\n");
+}
+function deriveAssessment(findings) {
+  if (findings.some((f) => f.severity === "critical")) return "request-changes";
+  if (findings.some((f) => f.severity === "important")) return "comment";
+  return "approve";
+}
+function maxAssessment(a, b) {
+  return CI_ASSESSMENTS.indexOf(a) >= CI_ASSESSMENTS.indexOf(b) ? a : b;
+}
+function floorOnlyResult(args) {
+  const verdict = buildCiReviewVerdict({
+    runner: "floor-only",
+    ranLlmTier: false,
+    assessment: args.assessment,
+    findings: args.findings,
+    skipped: args.skipped,
+    skipReason: args.skipReason
+  });
+  return {
+    verdict,
+    exitCode: applyThreshold(verdict, args.blockOn, args.requiredRunnerFailed),
+    terminalOutput: summarize(verdict),
+    llmSkipReason: args.skipReason,
+    ranLlmTier: false
+  };
+}
+async function runAgentCliRunner(preset, ctx) {
+  const instruction = "Run the harness code-review skill on the unified diff piped via STDIN. Emit ONLY the CiReviewVerdict JSON ({assessment, findings}).";
+  const { command, args } = preset.headlessInvocation({ instruction });
+  const { stdout } = await ctx.execFile(command, args, {
+    stdin: diffToStdin(ctx.diff),
+    env: ctx.env,
+    timeoutMs: ctx.options.execTimeoutMs ?? DEFAULT_EXEC_TIMEOUT_MS,
+    maxStdoutBytes: ctx.options.execMaxStdoutBytes ?? DEFAULT_EXEC_MAX_STDOUT_BYTES
+  });
+  return preset.verdictParser(stdout).findings;
+}
+async function runEndpointRunner(preset, endpoint, model, invoke, ctx) {
+  const instruction = "Review the unified diff and emit ONLY the CiReviewVerdict JSON ({assessment, findings}).";
+  const raw = await invoke({ endpoint, model, instruction, diff: diffToStdin(ctx.diff) });
+  return preset.verdictParser(raw).findings;
+}
+async function runLlmTier(runner, ctx) {
+  const preset = RUNNER_PRESETS[runner];
+  if (preset.supported !== true) {
+    return { ...EMPTY_TIER, skipReason: `LLM tier skipped \u2014 runner '${runner}' is unsupported` };
+  }
+  if (preset.kind === "agent-cli") {
+    if (!ctx.env[preset.secretEnvVar]) {
+      return {
+        ...EMPTY_TIER,
+        skipReason: `LLM tier skipped \u2014 secret ${preset.secretEnvVar} not set (floor-only)`
+      };
+    }
+    try {
+      return {
+        findings: await runAgentCliRunner(preset, ctx),
+        ranLlmTier: true,
+        requiredRunnerFailed: false
+      };
+    } catch (err) {
+      return {
+        ...EMPTY_TIER,
+        requiredRunnerFailed: true,
+        skipReason: `LLM tier failed \u2014 ${err.message}`
+      };
+    }
+  }
+  const invoke = ctx.options.localInvoke ?? preset.invoke;
+  const endpoint = ctx.env[preset.endpointEnvVar];
+  const model = ctx.env[preset.modelEnvVar];
+  if (!invoke || !endpoint || !model) {
+    return {
+      ...EMPTY_TIER,
+      skipReason: "LLM tier skipped \u2014 local endpoint not configured (no invoke seam or missing endpoint/model env)"
+    };
+  }
+  try {
+    return {
+      findings: await runEndpointRunner(preset, endpoint, model, invoke, ctx),
+      ranLlmTier: true,
+      requiredRunnerFailed: false
+    };
+  } catch (err) {
+    return {
+      ...EMPTY_TIER,
+      requiredRunnerFailed: true,
+      skipReason: `LLM tier failed \u2014 ${err.message}`
+    };
+  }
+}
+async function runCiReview(options) {
+  const { projectRoot, diff: diff2, commitMessage = "", runner, blockOn = "request-changes" } = options;
+  const floor = await runReviewPipeline({
+    projectRoot,
+    diff: diff2,
+    commitMessage,
+    flags: { ci: true, comment: false, deep: false, noMechanical: false }
+  });
+  if (floor.skipped) {
+    return floorOnlyResult({
+      assessment: "request-changes",
+      findings: [],
+      skipped: true,
+      skipReason: `floor review skipped \u2014 ${floor.skipReason ?? "ineligible"} (CI fails closed)`,
+      blockOn,
+      requiredRunnerFailed: true
+    });
+  }
+  const floorFindings = floor.findings;
+  const floorAssessment = maxAssessment(
+    floor.assessment ?? "approve",
+    deriveAssessment(floorFindings)
+  );
+  if (floor.stoppedByMechanical) {
+    return floorOnlyResult({
+      assessment: floorAssessment,
+      findings: floorFindings,
+      skipped: false,
+      skipReason: "LLM tier skipped \u2014 floor mechanical-stop (short-circuit)",
+      blockOn,
+      requiredRunnerFailed: false
+    });
+  }
+  const env = options.env ?? process.env;
+  const execFile3 = options.execFile ?? defaultExecFile;
+  const tier = runner ? await runLlmTier(runner, { diff: diff2, env, execFile: execFile3, options }) : EMPTY_TIER;
+  const {
+    findings: llmFindings,
+    ranLlmTier,
+    requiredRunnerFailed,
+    skipReason: llmSkipReason
+  } = tier;
+  const mergedFindings = [...floorFindings, ...llmFindings];
+  const mergedAssessment = maxAssessment(floorAssessment, deriveAssessment(mergedFindings));
+  const verdict = buildCiReviewVerdict({
+    runner: ranLlmTier ? runner : "floor-only",
+    ranLlmTier,
+    assessment: mergedAssessment,
+    findings: mergedFindings,
+    ...llmSkipReason ? { skipReason: llmSkipReason } : {}
+  });
+  return {
+    verdict,
+    exitCode: applyThreshold(verdict, blockOn, requiredRunnerFailed),
+    terminalOutput: summarize(verdict),
+    ...llmSkipReason ? { llmSkipReason } : {},
+    ranLlmTier
+  };
+}
+function applyThreshold(v, blockOn, requiredRunnerFailed) {
+  if (requiredRunnerFailed) return 1;
+  if (blockOn === "none") return 0;
+  const rank = (a) => CI_ASSESSMENTS.indexOf(a);
+  return rank(v.assessment) >= rank(blockOn) ? 1 : 0;
+}
+function summarize(v) {
+  const lines = [
+    `runner: ${v.runner}`,
+    `ranLlmTier: ${v.ranLlmTier}`,
+    `assessment: ${v.assessment}`,
+    `findings: ${v.findings.length} (blocking: ${v.blockingFindings.length})`,
+    `exitCode: ${v.exitCode}`
+  ];
+  if (v.skipReason) lines.push(`note: ${v.skipReason}`);
+  return lines.join("\n");
+}
+function serializeRoadmap(roadmap) {
+  const lines = [];
+  lines.push("---");
+  lines.push(`project: ${roadmap.frontmatter.project}`);
+  lines.push(`version: ${roadmap.frontmatter.version}`);
+  if (roadmap.frontmatter.created) {
+    lines.push(`created: ${roadmap.frontmatter.created}`);
+  }
+  if (roadmap.frontmatter.updated) {
+    lines.push(`updated: ${roadmap.frontmatter.updated}`);
+  }
+  lines.push(`last_synced: ${roadmap.frontmatter.lastSynced}`);
+  lines.push(`last_manual_edit: ${roadmap.frontmatter.lastManualEdit}`);
+  lines.push("---");
+  lines.push("");
+  lines.push("# Roadmap");
+  for (const milestone of roadmap.milestones) {
+    lines.push("");
+    lines.push(serializeMilestoneHeading(milestone));
+    for (const feature of milestone.features) {
+      lines.push("");
+      lines.push(...serializeFeature(feature));
+    }
+  }
+  if (roadmap.assignmentHistory && roadmap.assignmentHistory.length > 0) {
+    lines.push("");
+    lines.push(...serializeAssignmentHistory(roadmap.assignmentHistory));
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function serializeMilestoneHeading(milestone) {
+  return milestone.isBacklog ? "## Backlog" : `## ${milestone.name}`;
+}
+function orDash(value) {
+  return value ?? EM_DASH2;
+}
+function listOrDash(items) {
+  return items.length > 0 ? items.join(", ") : EM_DASH2;
 }
 function serializeExtendedLines(feature) {
   const hasExtended = feature.assignee !== null || feature.priority !== null || feature.externalId !== null || feature.updatedAt !== null;
@@ -11194,7 +11426,7 @@ function isRegression(from, to) {
 }
 function collectAutopilotStatuses(autopilotPath, featurePlans, allTaskStatuses) {
   try {
-    const raw = fs32.readFileSync(autopilotPath, "utf-8");
+    const raw = fs31.readFileSync(autopilotPath, "utf-8");
     const autopilot = JSON.parse(raw);
     if (!autopilot.phases) return;
     const linkedPhases = autopilot.phases.filter(
@@ -11226,10 +11458,10 @@ function inferStatus(feature, projectPath, allFeatures) {
   const featuresWithPlans = allFeatures.filter((f) => f.plans.length > 0);
   const useRootState = featuresWithPlans.length <= 1;
   if (useRootState) {
-    const rootStatePath = path32.join(projectPath, ".harness", "state.json");
-    if (fs32.existsSync(rootStatePath)) {
+    const rootStatePath = path31.join(projectPath, ".harness", "state.json");
+    if (fs31.existsSync(rootStatePath)) {
       try {
-        const raw = fs32.readFileSync(rootStatePath, "utf-8");
+        const raw = fs31.readFileSync(rootStatePath, "utf-8");
         const state = JSON.parse(raw);
         if (state.progress) {
           for (const status of Object.values(state.progress)) {
@@ -11240,14 +11472,14 @@ function inferStatus(feature, projectPath, allFeatures) {
       }
     }
   }
-  const sessionsDir = path32.join(projectPath, ".harness", "sessions");
-  if (fs32.existsSync(sessionsDir)) {
+  const sessionsDir = path31.join(projectPath, ".harness", "sessions");
+  if (fs31.existsSync(sessionsDir)) {
     try {
-      const sessionDirs = fs32.readdirSync(sessionsDir, { withFileTypes: true });
+      const sessionDirs = fs31.readdirSync(sessionsDir, { withFileTypes: true });
       for (const entry of sessionDirs) {
         if (!entry.isDirectory()) continue;
-        const autopilotPath = path32.join(sessionsDir, entry.name, "autopilot-state.json");
-        if (!fs32.existsSync(autopilotPath)) continue;
+        const autopilotPath = path31.join(sessionsDir, entry.name, "autopilot-state.json");
+        if (!fs31.existsSync(autopilotPath)) continue;
         collectAutopilotStatuses(autopilotPath, feature.plans, allTaskStatuses);
       }
     } catch {
@@ -11289,6 +11521,171 @@ function applySyncChanges(roadmap, changes) {
   }
   roadmap.frontmatter.lastSynced = (/* @__PURE__ */ new Date()).toISOString();
 }
+function isEmptySummary(summary) {
+  const trimmed = summary.trim();
+  return trimmed === "" || trimmed === EM_DASH3;
+}
+function rowWouldChange(currentSpec, currentSummary, args) {
+  const specChanges = currentSpec !== args.spec;
+  const summaryChanges = args.summary !== void 0 && args.summary !== "" && isEmptySummary(currentSummary);
+  return specChanges || summaryChanges;
+}
+function decidePromotionForRow(status, currentSpec, currentSummary, args) {
+  switch (status) {
+    case "in-progress":
+      return { action: "refuse", reason: "in-progress" };
+    case "done":
+      return { action: "refuse", reason: "done" };
+    case "backlog":
+      return { action: "set-planned" };
+    // planned, blocked, needs-human — lateral states (see status-rank.ts).
+    // Refresh the spec link but preserve status; warn upstream.
+    default:
+      return rowWouldChange(currentSpec, currentSummary, args) ? { action: "update-spec" } : { action: "noop" };
+  }
+}
+function applySpecAndSummary(feature, args) {
+  feature.spec = args.spec;
+  if (args.summary !== void 0 && args.summary !== "" && isEmptySummary(feature.summary)) {
+    feature.summary = args.summary;
+  }
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  const row = new Array(n + 1);
+  for (let j = 0; j <= n; j++) row[j] = j;
+  for (let i = 1; i <= m; i++) {
+    let prevDiag = row[0];
+    row[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const above = row[j];
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prevDiag + cost);
+      prevDiag = above;
+    }
+  }
+  return row[n];
+}
+function isProbableTypo(distance, queryLen) {
+  if (distance === 0) return false;
+  return distance <= Math.max(2, Math.floor(queryLen / 4));
+}
+function locateRows(roadmap) {
+  const rows = [];
+  roadmap.milestones.forEach((milestone, milestoneIndex) => {
+    milestone.features.forEach((feature, featureIndex) => {
+      rows.push({ milestoneIndex, featureIndex, milestoneName: milestone.name, feature });
+    });
+  });
+  return rows;
+}
+function cloneRoadmap(roadmap) {
+  return structuredClone(roadmap);
+}
+function makeCreatedFeature(args) {
+  return {
+    name: args.feature.trim(),
+    status: "planned",
+    spec: args.spec,
+    plans: [],
+    blockedBy: [],
+    summary: args.summary ?? "",
+    assignee: null,
+    priority: null,
+    externalId: null,
+    updatedAt: null
+  };
+}
+function appendCreatedRow(roadmap, args) {
+  const next = cloneRoadmap(roadmap);
+  let milestone = next.milestones.find(
+    (m) => m.name.toLowerCase() === DEFAULT_MILESTONE.toLowerCase()
+  );
+  if (!milestone) {
+    milestone = { name: DEFAULT_MILESTONE, isBacklog: false, features: [] };
+    next.milestones.push(milestone);
+  }
+  milestone.features.push(makeCreatedFeature(args));
+  return next;
+}
+function promoteFeature(roadmap, args) {
+  const query = args.feature.trim();
+  const queryLower = query.toLowerCase();
+  const rows = locateRows(roadmap);
+  const exact = rows.filter((r) => r.feature.name.trim().toLowerCase() === queryLower);
+  if (exact.length > 1) {
+    const matches = exact.map((r) => `${r.milestoneName} > ${r.feature.name}`);
+    return {
+      result: {
+        ok: false,
+        reason: "ambiguous",
+        feature: query,
+        detail: `"${query}" matches ${matches.length} rows across milestones. Re-invoke milestone-qualified: ${matches.join(", ")}.`,
+        matches
+      },
+      nextRoadmap: roadmap
+    };
+  }
+  if (exact.length === 1) {
+    const located = exact[0];
+    const decision = decidePromotionForRow(
+      located.feature.status,
+      located.feature.spec,
+      located.feature.summary,
+      args
+    );
+    if (decision.action === "refuse") {
+      const detail = decision.reason === "in-progress" ? `"${query}" is in-progress: an agent is dispatched against this row. Stop the agent or use a different feature name.` : `"${query}" is already 'done'. To revise a shipped feature, use a new name.`;
+      return {
+        result: { ok: false, reason: decision.reason, detail, feature: query },
+        nextRoadmap: roadmap
+      };
+    }
+    if (decision.action === "noop") {
+      return { result: { ok: true, transitioned: "noop", feature: query }, nextRoadmap: roadmap };
+    }
+    const next = cloneRoadmap(roadmap);
+    const target = next.milestones[located.milestoneIndex].features[located.featureIndex];
+    if (decision.action === "set-planned") {
+      target.status = "planned";
+      applySpecAndSummary(target, args);
+      return {
+        result: { ok: true, transitioned: "backlog\u2192planned", feature: query },
+        nextRoadmap: next
+      };
+    }
+    applySpecAndSummary(target, args);
+    return {
+      result: { ok: true, transitioned: "spec-updated", feature: query },
+      nextRoadmap: next
+    };
+  }
+  const ranked = rows.map((r) => ({
+    name: r.feature.name,
+    distance: levenshtein(queryLower, r.feature.name.toLowerCase())
+  })).sort((a, b) => a.distance - b.distance);
+  const nearest = ranked[0];
+  if (nearest && isProbableTypo(nearest.distance, queryLower.length)) {
+    const closestMatches = ranked.slice(0, MAX_CLOSEST_MATCHES).map((r) => r.name);
+    return {
+      result: {
+        ok: false,
+        reason: "not-found",
+        feature: query,
+        detail: `"${query}" not found. Did you mean: ${closestMatches.join(", ")}?`,
+        closestMatches
+      },
+      nextRoadmap: roadmap
+    };
+  }
+  return {
+    result: { ok: true, transitioned: "created", feature: query },
+    nextRoadmap: appendCreatedRow(roadmap, args)
+  };
+}
 function resolveReverseStatus(externalStatus, labels, config) {
   const reverseMap = config.reverseStatusMap;
   if (!reverseMap) return null;
@@ -11329,7 +11726,7 @@ function parseRepoParts(repo) {
   return { owner: parts[0], repo: parts[1] };
 }
 function sleep2(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 async function fetchWithRetry(fetchFn, input, init, opts = RETRY_DEFAULTS) {
   let lastResponse;
@@ -11362,9 +11759,9 @@ function isValidTrackerShape(tracker) {
 }
 function loadTrackerSyncConfig(projectRoot) {
   try {
-    const configPath = path33.join(projectRoot, "harness.config.json");
-    if (!fs33.existsSync(configPath)) return null;
-    const raw = fs33.readFileSync(configPath, "utf-8");
+    const configPath = path32.join(projectRoot, "harness.config.json");
+    if (!fs32.existsSync(configPath)) return null;
+    const raw = fs32.readFileSync(configPath, "utf-8");
     const config = JSON.parse(raw);
     const tracker = config.roadmap?.tracker;
     if (!isValidTrackerShape(tracker)) return null;
@@ -11479,12 +11876,12 @@ async function syncFromExternal(roadmap, adapter2, config, options, prefetchedTi
 async function fullSync(roadmapPath, adapter2, config, options) {
   const previousSync = syncMutex;
   let releaseMutex;
-  syncMutex = new Promise((resolve6) => {
-    releaseMutex = resolve6;
+  syncMutex = new Promise((resolve7) => {
+    releaseMutex = resolve7;
   });
   await previousSync;
   try {
-    const raw = fs34.readFileSync(roadmapPath, "utf-8");
+    const raw = fs33.readFileSync(roadmapPath, "utf-8");
     const parseResult = parseRoadmap(raw);
     if (!parseResult.ok) {
       return {
@@ -11497,7 +11894,7 @@ async function fullSync(roadmapPath, adapter2, config, options) {
     const tickets = fetchResult.ok ? fetchResult.value : void 0;
     const pushResult = await syncToExternal(roadmap, adapter2, config, tickets);
     const pullResult = await syncFromExternal(roadmap, adapter2, config, options);
-    fs34.writeFileSync(roadmapPath, serializeRoadmap(roadmap), "utf-8");
+    fs33.writeFileSync(roadmapPath, serializeRoadmap(roadmap), "utf-8");
     return {
       created: pushResult.created,
       updated: pushResult.updated,
@@ -11857,9 +12254,9 @@ function makeTrackerConflictBody(err, opts = {}) {
 }
 function loadProjectRoadmapMode(projectRoot) {
   try {
-    const configPath = path34.join(projectRoot, "harness.config.json");
-    if (!fs35.existsSync(configPath)) return getRoadmapMode(null);
-    const raw = fs35.readFileSync(configPath, "utf-8");
+    const configPath = path33.join(projectRoot, "harness.config.json");
+    if (!fs34.existsSync(configPath)) return getRoadmapMode(null);
+    const raw = fs34.readFileSync(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     return getRoadmapMode(parsed);
   } catch {
@@ -11868,11 +12265,11 @@ function loadProjectRoadmapMode(projectRoot) {
 }
 function loadTrackerClientConfigFromProject(projectRoot) {
   try {
-    const configPath = path35.join(projectRoot, "harness.config.json");
-    if (!fs36.existsSync(configPath)) {
+    const configPath = path34.join(projectRoot, "harness.config.json");
+    if (!fs35.existsSync(configPath)) {
       return Err(new Error("harness.config.json not found"));
     }
-    const cfg = JSON.parse(fs36.readFileSync(configPath, "utf-8"));
+    const cfg = JSON.parse(fs35.readFileSync(configPath, "utf-8"));
     const tracker = cfg.roadmap?.tracker;
     if (!tracker) {
       return Err(
@@ -12087,10 +12484,10 @@ function mapAction(action) {
 }
 async function runMigrationPlan(plan, deps, opts) {
   const projectRoot = opts.projectRoot;
-  const roadmapPath = path36.join(projectRoot, "docs", "roadmap.md");
-  const archivedPath = path36.join(projectRoot, "docs", "roadmap.md.archived");
-  const configPath = path36.join(projectRoot, "harness.config.json");
-  const configBackupPath = path36.join(projectRoot, "harness.config.json.pre-migration");
+  const roadmapPath = path35.join(projectRoot, "docs", "roadmap.md");
+  const archivedPath = path35.join(projectRoot, "docs", "roadmap.md.archived");
+  const configPath = path35.join(projectRoot, "harness.config.json");
+  const configBackupPath = path35.join(projectRoot, "harness.config.json.pre-migration");
   const createdSoFar = [];
   const report = {
     created: 0,
@@ -12200,9 +12597,111 @@ async function runMigrationPlan(plan, deps, opts) {
   }
   return Ok(report);
 }
+function defaultIsArchive(name) {
+  return /^v\d/.test(name) || name === "Shipped" || name === "Hermes Adoption";
+}
+function isUnactionablePlanned(feature) {
+  return feature.status === "planned" && feature.spec === null && feature.plans.length === 0;
+}
+function resolveOptions(options) {
+  return {
+    isArchive: options?.isArchive ?? defaultIsArchive,
+    maxActiveMilestoneSize: options?.maxActiveMilestoneSize ?? DEFAULT_MAX_ACTIVE,
+    catchAllMilestones: options?.catchAllMilestones ?? DEFAULT_CATCH_ALL,
+    intakeMilestone: options?.intakeMilestone ?? DEFAULT_INTAKE
+  };
+}
+function checkRoadmapHealth(roadmap, options) {
+  const opts = resolveOptions(options);
+  const findings = [];
+  for (const milestone of roadmap.milestones) {
+    const archive = opts.isArchive(milestone.name);
+    const isIntake = milestone.name === opts.intakeMilestone;
+    if (opts.catchAllMilestones.some((n) => n.toLowerCase() === milestone.name.toLowerCase())) {
+      findings.push({
+        ruleId: "RMH003",
+        severity: "error",
+        milestone: milestone.name,
+        message: `Lifecycle catch-all milestone "${milestone.name}" exists. Milestones should be themes, not stages.`,
+        suggestion: `Rename to a theme or run the roadmap skill's --groom mode to drain it into themed milestones.`
+      });
+    }
+    if (!archive && !isIntake && milestone.features.length > opts.maxActiveMilestoneSize) {
+      findings.push({
+        ruleId: "RMH004",
+        severity: "warning",
+        milestone: milestone.name,
+        message: `Active milestone "${milestone.name}" has ${milestone.features.length} features (cap ${opts.maxActiveMilestoneSize}); it is becoming a dump.`,
+        suggestion: `Split it into sub-themes.`
+      });
+    }
+    for (const feature of milestone.features) {
+      if (feature.status === "done" && !archive && !isIntake) {
+        findings.push({
+          ruleId: "RMH001",
+          severity: "warning",
+          milestone: milestone.name,
+          feature: feature.name,
+          message: `Completed feature "${feature.name}" is still in active milestone "${milestone.name}".`,
+          suggestion: `Archive it (move to Shipped) \u2014 run the roadmap skill's --groom mode.`
+        });
+      }
+      if (isUnactionablePlanned(feature)) {
+        findings.push({
+          ruleId: "RMH002",
+          severity: "warning",
+          milestone: milestone.name,
+          feature: feature.name,
+          message: `"${feature.name}" is "planned" with no spec and no plan; the orchestrator cannot auto-execute it (it escalates to a human).`,
+          suggestion: `Link a spec/plan to make it actionable, or demote it to "backlog".`
+        });
+      }
+    }
+  }
+  return findings;
+}
+function groomRoadmap(roadmap, options) {
+  const opts = resolveOptions(options);
+  const archiveDone = options?.archiveDone ?? true;
+  const next = structuredClone(roadmap);
+  const archived = [];
+  const changes = [];
+  for (const milestone of next.milestones) {
+    const archive = opts.isArchive(milestone.name);
+    const isIntake = milestone.name === opts.intakeMilestone;
+    const kept = [];
+    for (const feature of milestone.features) {
+      if (isUnactionablePlanned(feature)) {
+        feature.status = "backlog";
+        changes.push({
+          kind: "demoted",
+          feature: feature.name,
+          from: milestone.name,
+          to: "backlog"
+        });
+      }
+      if (archiveDone && feature.status === "done" && !archive && !isIntake) {
+        archived.push(feature);
+        changes.push({
+          kind: "archived",
+          feature: feature.name,
+          from: milestone.name,
+          to: "Shipped"
+        });
+        continue;
+      }
+      kept.push(feature);
+    }
+    milestone.features = kept;
+  }
+  next.milestones = next.milestones.filter(
+    (m) => m.features.length > 0 || m.name === opts.intakeMilestone
+  );
+  return { roadmap: next, archived, changes };
+}
 function getStatePath() {
   const home = process.env["HOME"] || os.homedir();
-  return path39.join(home, ".harness", "update-check.json");
+  return path38.join(home, ".harness", "update-check.json");
 }
 function isUpdateCheckEnabled(configInterval) {
   if (process.env["HARNESS_NO_UPDATE_CHECK"] === "1") return false;
@@ -12215,13 +12714,13 @@ function shouldRunCheck(state, intervalMs) {
 }
 function invalidateCheckState() {
   try {
-    fs39.unlinkSync(getStatePath());
+    fs38.unlinkSync(getStatePath());
   } catch {
   }
 }
 function readCheckState() {
   try {
-    const raw = fs39.readFileSync(getStatePath(), "utf-8");
+    const raw = fs38.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;
@@ -12238,7 +12737,7 @@ function readCheckState() {
 }
 function spawnBackgroundCheck(currentVersion) {
   const statePath = getStatePath();
-  const stateDir = path39.dirname(statePath);
+  const stateDir = path38.dirname(statePath);
   const script = `
 const { execSync } = require('child_process');
 const fs = require('fs');
@@ -12481,14 +12980,14 @@ function getModelPrice(model, dataset) {
   return pricing;
 }
 function getCachePath(projectRoot) {
-  return path40.join(projectRoot, ".harness", "cache", "pricing.json");
+  return path39.join(projectRoot, ".harness", "cache", "pricing.json");
 }
 function getStalenessMarkerPath(projectRoot) {
-  return path40.join(projectRoot, ".harness", "cache", "staleness-marker.json");
+  return path39.join(projectRoot, ".harness", "cache", "staleness-marker.json");
 }
 async function readDiskCache(projectRoot) {
   try {
-    const raw = await fs40.readFile(getCachePath(projectRoot), "utf-8");
+    const raw = await fs39.readFile(getCachePath(projectRoot), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -12496,8 +12995,8 @@ async function readDiskCache(projectRoot) {
 }
 async function writeDiskCache(projectRoot, data) {
   const cachePath = getCachePath(projectRoot);
-  await fs40.mkdir(path40.dirname(cachePath), { recursive: true });
-  await fs40.writeFile(cachePath, JSON.stringify(data, null, 2));
+  await fs39.mkdir(path39.dirname(cachePath), { recursive: true });
+  await fs39.writeFile(cachePath, JSON.stringify(data, null, 2));
 }
 async function fetchFromNetwork() {
   try {
@@ -12524,7 +13023,7 @@ function loadFallbackDataset() {
 async function checkAndWarnStaleness(projectRoot) {
   const markerPath = getStalenessMarkerPath(projectRoot);
   try {
-    const raw = await fs40.readFile(markerPath, "utf-8");
+    const raw = await fs39.readFile(markerPath, "utf-8");
     const marker = JSON.parse(raw);
     const firstUse = new Date(marker.firstFallbackUse).getTime();
     const now = Date.now();
@@ -12536,8 +13035,8 @@ async function checkAndWarnStaleness(projectRoot) {
     }
   } catch {
     try {
-      await fs40.mkdir(path40.dirname(markerPath), { recursive: true });
-      await fs40.writeFile(
+      await fs39.mkdir(path39.dirname(markerPath), { recursive: true });
+      await fs39.writeFile(
         markerPath,
         JSON.stringify({ firstFallbackUse: (/* @__PURE__ */ new Date()).toISOString() })
       );
@@ -12547,7 +13046,7 @@ async function checkAndWarnStaleness(projectRoot) {
 }
 async function clearStalenessMarker(projectRoot) {
   try {
-    await fs40.unlink(getStalenessMarkerPath(projectRoot));
+    await fs39.unlink(getStalenessMarkerPath(projectRoot));
   } catch {
   }
 }
@@ -12784,10 +13283,10 @@ function parseLine(line, lineNumber) {
   return record;
 }
 function readCostRecords(projectRoot) {
-  const costsFile = path41.join(projectRoot, ".harness", "metrics", "costs.jsonl");
+  const costsFile = path40.join(projectRoot, ".harness", "metrics", "costs.jsonl");
   let raw;
   try {
-    raw = fs41.readFileSync(costsFile, "utf-8");
+    raw = fs40.readFileSync(costsFile, "utf-8");
   } catch {
     return [];
   }
@@ -12837,7 +13336,7 @@ function parseCCLine(line, filePath, lineNumber) {
     entry = JSON.parse(line);
   } catch {
     console.warn(
-      `[harness usage] Skipping malformed CC JSONL line ${lineNumber} in ${path42.basename(filePath)}`
+      `[harness usage] Skipping malformed CC JSONL line ${lineNumber} in ${path41.basename(filePath)}`
     );
     return null;
   }
@@ -12851,7 +13350,7 @@ function parseCCLine(line, filePath, lineNumber) {
 function readCCFile(filePath) {
   let raw;
   try {
-    raw = fs42.readFileSync(filePath, "utf-8");
+    raw = fs41.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -12873,10 +13372,10 @@ function readCCFile(filePath) {
 }
 function parseCCRecords() {
   const homeDir = process.env.HOME ?? os2.homedir();
-  const projectsDir = path42.join(homeDir, ".claude", "projects");
+  const projectsDir = path41.join(homeDir, ".claude", "projects");
   let projectDirs;
   try {
-    projectDirs = fs42.readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path42.join(projectsDir, d.name));
+    projectDirs = fs41.readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path41.join(projectsDir, d.name));
   } catch {
     return [];
   }
@@ -12884,7 +13383,7 @@ function parseCCRecords() {
   for (const dir of projectDirs) {
     let files;
     try {
-      files = fs42.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path42.join(dir, f));
+      files = fs41.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path41.join(dir, f));
     } catch {
       continue;
     }
@@ -12912,10 +13411,10 @@ function parseLine2(line, lineNumber) {
   }
 }
 function readAdoptionRecords(projectRoot) {
-  const adoptionFile = path43.join(projectRoot, ".harness", "metrics", "adoption.jsonl");
+  const adoptionFile = path42.join(projectRoot, ".harness", "metrics", "adoption.jsonl");
   let raw;
   try {
-    raw = fs43.readFileSync(adoptionFile, "utf-8");
+    raw = fs42.readFileSync(adoptionFile, "utf-8");
   } catch {
     return [];
   }
@@ -12987,38 +13486,6 @@ function aggregateByDay2(records) {
 function topSkills(records, n) {
   return aggregateBySkill(records).slice(0, n);
 }
-function loadNotificationsConfig(projectRoot) {
-  const configPath = path44.join(projectRoot, "harness.config.json");
-  if (!fs44.existsSync(configPath)) {
-    return Ok({ sinks: [] });
-  }
-  let raw;
-  try {
-    raw = fs44.readFileSync(configPath, "utf-8");
-  } catch (err) {
-    return Err(err instanceof Error ? err : new Error(String(err)));
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    return Err(
-      new Error(
-        `Failed to parse harness.config.json: ${err instanceof Error ? err.message : String(err)}`
-      )
-    );
-  }
-  if (parsed.notifications === void 0) {
-    return Ok({ sinks: [] });
-  }
-  const result = NotificationsConfigSchema.safeParse(parsed.notifications);
-  if (!result.success) {
-    const issues = result.error.issues.map((i) => `  - notifications.${i.path.join(".")}: ${i.message}`).join("\n");
-    return Err(new Error(`Invalid notifications config:
-${issues}`));
-  }
-  return Ok(result.data);
-}
 function isEmptyObject(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v) && Object.keys(v).length === 0;
 }
@@ -13095,25 +13562,25 @@ function resolveStability(contentType) {
   return STABILITY_LOOKUP[contentType] ?? "ephemeral";
 }
 function getOrCreateInstallId(projectRoot) {
-  const harnessDir = path45.join(projectRoot, ".harness");
-  const installIdFile = path45.join(harnessDir, ".install-id");
+  const harnessDir = path43.join(projectRoot, ".harness");
+  const installIdFile = path43.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 = fs45.readFileSync(installIdFile, "utf-8").trim();
+    const existing = fs43.readFileSync(installIdFile, "utf-8").trim();
     if (UUID_V4_RE.test(existing)) {
       return existing;
     }
   } catch {
   }
   const id = crypto4.randomUUID();
-  fs45.mkdirSync(harnessDir, { recursive: true });
-  fs45.writeFileSync(installIdFile, id, { encoding: "utf-8", mode: 384 });
+  fs43.mkdirSync(harnessDir, { recursive: true });
+  fs43.writeFileSync(installIdFile, id, { encoding: "utf-8", mode: 384 });
   return id;
 }
 function parseIdentityFromTelemetryFile(filePath) {
   const identity = {};
   try {
-    const raw = fs46.readFileSync(filePath, "utf-8");
+    const raw = fs44.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     const src = parsed?.identity;
     if (!src || typeof src !== "object") return identity;
@@ -13126,7 +13593,7 @@ function parseIdentityFromTelemetryFile(filePath) {
 }
 function readProjectNameFallback(configPath) {
   try {
-    const raw = fs46.readFileSync(configPath, "utf-8");
+    const raw = fs44.readFileSync(configPath, "utf-8");
     const config = JSON.parse(raw);
     return typeof config?.name === "string" ? config.name : void 0;
   } catch {
@@ -13147,10 +13614,10 @@ function readGitAliasFallback(cwd) {
   }
 }
 function readIdentity(projectRoot) {
-  const filePath = path46.join(projectRoot, ".harness", "telemetry.json");
+  const filePath = path44.join(projectRoot, ".harness", "telemetry.json");
   const identity = parseIdentityFromTelemetryFile(filePath);
   if (!identity.project) {
-    const fallbackProject = readProjectNameFallback(path46.join(projectRoot, "harness.config.json"));
+    const fallbackProject = readProjectNameFallback(path44.join(projectRoot, "harness.config.json"));
     if (fallbackProject) identity.project = fallbackProject;
   }
   if (!identity.alias) {
@@ -13197,7 +13664,7 @@ function collectEvents(projectRoot, consent) {
   );
 }
 function sleep3(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 async function send(events, apiKey) {
   if (events.length === 0) return;
@@ -13273,36 +13740,383 @@ function spanToOTLP(s) {
   if (s.statusCode !== void 0) span["status"] = { code: s.statusCode };
   return span;
 }
-function acquireCompoundLock(category, opts = {}) {
-  if (!KNOWN_CATEGORIES.has(category)) {
-    throw new Error(
-      `Unknown category "${category}". Must be one of: ${[...KNOWN_CATEGORIES].join(", ")}`
-    );
+function tierFor(score) {
+  if (score >= 85) return "solid";
+  if (score >= 50) return "at-risk";
+  return "theatre";
+}
+function rollupScore(findings) {
+  const deduction = findings.reduce((sum, f) => sum + SEVERITY_WEIGHTS[f.severity], 0);
+  const score = clamp(100 - deduction, 0, 100);
+  return { score, tier: tierFor(score) };
+}
+function resolveMode(opts, root) {
+  if (opts.mode) return opts.mode;
+  const hasTemplates = existsSync38(join582(root, "templates"));
+  const hasSkills = existsSync38(join582(root, "agents", "skills"));
+  return hasTemplates && hasSkills ? "toolkit" : "adopter";
+}
+function readTextOrNull(path52) {
+  try {
+    return existsSync38(path52) ? readFileSync34(path52, "utf8") : null;
+  } catch {
+    return null;
   }
-  const cwd = opts.cwd ?? process.cwd();
-  const lockDir = path47.join(cwd, ".harness", "locks");
-  fs47.mkdirSync(lockDir, { recursive: true });
-  const lockPath = path47.join(lockDir, `compound-${category}.lock`);
-  let fd;
+}
+function readJsonOrNull(path52) {
+  const text = readTextOrNull(path52);
+  if (text === null) return null;
   try {
-    fd = fs47.openSync(lockPath, "wx");
-  } catch (e) {
-    const err = e;
-    if (err.code === "EEXIST") {
-      const holderPid = readHolderPid(lockPath);
-      throw new CompoundLockHeldError(category, holderPid, lockPath);
-    }
-    throw err;
+    return JSON.parse(text);
+  } catch {
+    return null;
   }
-  fs47.writeSync(fd, String(process.pid));
-  fs47.closeSync(fd);
-  let released = false;
-  const release = () => {
-    if (released) return;
-    released = true;
-    try {
-      fs47.unlinkSync(lockPath);
-    } catch {
+}
+function toRootRelative(root, abs) {
+  return relative4(root, abs).replaceAll("\\", "/");
+}
+function readConfig(root) {
+  const raw = readJsonOrNull(join582(root, "harness.config.json"));
+  if (raw === null) return null;
+  const parsed = HarnessConfigSubsetSchema.safeParse(raw);
+  return parsed.success ? parsed.data : null;
+}
+function readHookDir(root, dir) {
+  if (!existsSync38(dir)) return [];
+  try {
+    return readdirSync5(dir).map((name) => ({ name, full: join582(dir, name) })).filter(({ full }) => {
+      try {
+        return statSync4(full).isFile();
+      } catch {
+        return false;
+      }
+    }).map(({ name, full }) => ({
+      name,
+      path: toRootRelative(root, full),
+      text: readTextOrNull(full) ?? ""
+    }));
+  } catch {
+    return [];
+  }
+}
+function resolveHookFiles(root) {
+  const collected = /* @__PURE__ */ new Map();
+  for (const h of [
+    ...readHookDir(root, join582(root, ".husky")),
+    ...readHookDir(root, join582(root, ".claude", "hooks")),
+    ...readHookDir(root, join582(root, ".harness", "hooks"))
+  ]) {
+    collected.set(resolve6(root, h.path), h);
+  }
+  const settings = readJsonOrNull(join582(root, ".claude", "settings.json"));
+  for (const ref of extractSettingsHookScripts(settings, root)) {
+    const abs = resolve6(root, ref);
+    if (collected.has(abs)) continue;
+    const text = readTextOrNull(abs);
+    if (text !== null) {
+      collected.set(abs, { name: basename10(abs), path: toRootRelative(root, abs), text });
+    }
+  }
+  return [...collected.values()];
+}
+function extractSettingsHookScripts(settings, root) {
+  const out = [];
+  if (settings === null || typeof settings !== "object") return out;
+  const hooks = settings.hooks;
+  const walk3 = (v) => {
+    if (typeof v === "string") {
+      for (const m of v.matchAll(HOOK_SCRIPT_TOKEN)) {
+        const token = m[1];
+        if (token) out.push(normalizeHookRef(token, root));
+      }
+    } else if (Array.isArray(v)) {
+      v.forEach(walk3);
+    } else if (v && typeof v === "object") {
+      Object.values(v).forEach(walk3);
+    }
+  };
+  walk3(hooks);
+  return out;
+}
+function normalizeHookRef(token, root) {
+  let ref = token.replace(/^["']|["']$/g, "");
+  ref = ref.replace(/^\$\(git rev-parse --show-toplevel\)\/?/, `${root}/`);
+  return ref;
+}
+function readWorkflows(root) {
+  const dir = join582(root, ".github", "workflows");
+  if (!existsSync38(dir)) return [];
+  try {
+    return readdirSync5(dir).filter((n) => n.endsWith(".yml") || n.endsWith(".yaml")).map((n) => join582(dir, n)).filter((p) => {
+      try {
+        return statSync4(p).isFile();
+      } catch {
+        return false;
+      }
+    }).map((p) => ({ path: toRootRelative(root, p), text: readTextOrNull(p) ?? "" }));
+  } catch {
+    return [];
+  }
+}
+function readTemplates(root) {
+  const dir = join582(root, "templates");
+  if (!existsSync38(dir)) return [];
+  const out = [];
+  const walk3 = (d) => {
+    let entries;
+    try {
+      entries = readdirSync5(d);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      const full = join582(d, name);
+      let st;
+      try {
+        st = statSync4(full);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) walk3(full);
+      else if (name.endsWith(".hbs"))
+        out.push({ path: toRootRelative(root, full), text: readTextOrNull(full) ?? "" });
+    }
+  };
+  walk3(dir);
+  return out;
+}
+function readInitSkill(root) {
+  return readTextOrNull(
+    join582(root, "agents", "skills", "claude-code", "initialize-harness-project", "SKILL.md")
+  );
+}
+function buildProjectContext(root, mode) {
+  const ctx = {
+    root,
+    mode,
+    config: readConfig(root),
+    preCommit: readTextOrNull(join582(root, ".husky", "pre-commit")),
+    hookFiles: resolveHookFiles(root),
+    workflows: readWorkflows(root),
+    healthSnapshot: readJsonOrNull(join582(root, ".harness", "health-snapshot.json"))
+  };
+  if (mode === "toolkit") {
+    ctx.templates = readTemplates(root);
+    ctx.initSkill = readInitSkill(root);
+  }
+  return ctx;
+}
+function stripComments(text) {
+  return text.split("\n").map((l) => l.replace(/(^|\s)#.*$/, "$1")).join("\n");
+}
+function findRewriteInFailureBranch(lines) {
+  const ifStack = [];
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i];
+    const ifCount = (l.match(/\bif\b/g) ?? []).length;
+    const fiCount = (l.match(/\bfi\b/g) ?? []).length;
+    const opensFailure = /\bif\s+!/.test(l);
+    for (let k = 0; k < ifCount; k++) ifStack.push(opensFailure);
+    const inFailureBranch = ifStack.includes(true);
+    for (let k = 0; k < fiCount; k++) ifStack.pop();
+    if (inFailureBranch && BASELINE_REWRITE.test(l)) return i;
+  }
+  return -1;
+}
+function thresholdsEmpty(cfg) {
+  if (!cfg) return false;
+  const hasLayers = (cfg.layers?.length ?? 0) > 0;
+  if (!hasLayers) return false;
+  const thresholds = cfg.architecture?.thresholds;
+  return !thresholds || Object.keys(thresholds).length === 0;
+}
+function makeFinding3(file) {
+  return {
+    id: "STRENGTH-004",
+    gearPiece: "architecture-thresholds",
+    file,
+    message: "Architecture layers are declared but no thresholds are set \u2014 the architecture check has nothing to enforce, so drift goes undetected.",
+    remediation: "Add concrete `architecture.thresholds` (e.g. maxFanOut, maxDependencyDepth) so layer/coupling regressions actually fail the check."
+  };
+}
+function isAutoLine(line) {
+  return AUTO_PATTERN.test(line) && !COMMENT_LINE.test(line) && !NAME_VALUE_LINE.test(line);
+}
+function hasAutoStep(text) {
+  return text.split("\n").some(isAutoLine);
+}
+function isSnapshot(value) {
+  if (value === null || typeof value !== "object") return false;
+  const checks = value.checks;
+  return checks !== null && typeof checks === "object";
+}
+function severityFor(rule, ctx) {
+  const override = ctx.config?.audit?.harnessStrength?.severities?.[rule.id];
+  return override ?? rule.defaultSeverity;
+}
+async function safeGather(key, fn, warnings) {
+  try {
+    return await fn();
+  } catch (e) {
+    warnings.push(`${key}: ${e instanceof Error ? e.message : String(e)}`);
+    return null;
+  }
+}
+function arrayLen(arr) {
+  return Array.isArray(arr) ? arr.length : 0;
+}
+async function gatherEntropyBlock(projectPath) {
+  const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./analyzer-V633GUHY-MBCQWKDU.js");
+  const analyzer = new EntropyAnalyzer2({
+    rootDir: projectPath,
+    include: ["src/**/*.ts", "src/**/*.tsx", "packages/*/src/**/*.ts"],
+    exclude: ["node_modules/**", "dist/**", "**/*.test.ts", "**/*.spec.ts"],
+    analyze: { drift: false, deadCode: true, patterns: false, complexity: false }
+  });
+  const result = await analyzer.analyze();
+  const empty = { driftCount: 0, deadFiles: 0, deadExports: 0 };
+  if (!result.ok) return empty;
+  const report = result.value;
+  return {
+    driftCount: arrayLen(report.drift?.drifts),
+    deadFiles: arrayLen(report.deadCode?.deadFiles),
+    deadExports: arrayLen(report.deadCode?.deadExports)
+  };
+}
+async function gatherDecayBlock(projectPath) {
+  const { TimelineManager: TimelineManager2 } = await import("./timeline-manager-FPYKJRHR-VVX7CSGW.js");
+  const mgr = new TimelineManager2(projectPath);
+  const trends = mgr.trends();
+  return {
+    recentBumps: arrayLen(trends.recentSnapshots),
+    topAffected: collectTopAffectedLabels(trends.topAffected)
+  };
+}
+function collectTopAffectedLabels(affected) {
+  if (!Array.isArray(affected)) return [];
+  const out = [];
+  for (const node of affected) {
+    const label = node.id ?? node.name;
+    if (typeof label === "string" && label.length > 0) out.push(label);
+    if (out.length >= MAX_TOP_AFFECTED) break;
+  }
+  return out;
+}
+async function gatherAttentionBlock(projectPath) {
+  const sessionsDir = path45.join(projectPath, ".harness", "sessions");
+  if (!fs45.existsSync(sessionsDir)) return { activeThreadCount: 0, staleThreadCount: 0 };
+  const now = Date.now();
+  const STALE_MS = 7 * 24 * 60 * 60 * 1e3;
+  let active = 0;
+  let stale = 0;
+  const entries = fs45.readdirSync(sessionsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const dirPath = path45.join(sessionsDir, entry.name);
+    try {
+      const stat2 = fs45.statSync(dirPath);
+      if (now - stat2.mtimeMs > STALE_MS) {
+        stale++;
+      } else {
+        active++;
+      }
+    } catch {
+    }
+  }
+  return { activeThreadCount: active, staleThreadCount: stale };
+}
+async function gatherImpactBlock(projectPath) {
+  const cachePath = path45.join(projectPath, ".harness", "cache", "impact.json");
+  if (!fs45.existsSync(cachePath)) return { recentBlastRadius: [] };
+  try {
+    const raw = JSON.parse(fs45.readFileSync(cachePath, "utf8"));
+    const radii = raw.blastRadius ?? [];
+    return {
+      recentBlastRadius: radii.slice(0, 5).map((r) => ({
+        node: r.node,
+        affected: r.affected
+      }))
+    };
+  } catch {
+    return { recentBlastRadius: [] };
+  }
+}
+async function gatherHealthBlock(projectPath) {
+  const entropy = await gatherEntropyBlock(projectPath);
+  const signals = [];
+  if (entropy.driftCount > 0) signals.push(`${entropy.driftCount} drift findings`);
+  if (entropy.deadFiles > 0) signals.push(`${entropy.deadFiles} dead files`);
+  if (entropy.deadExports > 0) signals.push(`${entropy.deadExports} dead exports`);
+  const passed = signals.length === 0;
+  return {
+    passed,
+    signals,
+    summary: passed ? "No structural health findings." : signals.join("; ")
+  };
+}
+async function composeInsights(projectPath, opts = {}) {
+  const skip = new Set(opts.skip ?? []);
+  const warnings = [];
+  const wantedKeys = INSIGHTS_KEYS.filter((k) => !skip.has(k));
+  const [healthRes, entropyRes, decayRes, attentionRes, impactRes] = await Promise.all([
+    wantedKeys.includes("health") ? safeGather("health", () => gatherHealthBlock(projectPath), warnings) : Promise.resolve(null),
+    wantedKeys.includes("entropy") ? safeGather("entropy", () => gatherEntropyBlock(projectPath), warnings) : Promise.resolve(null),
+    wantedKeys.includes("decay") ? safeGather("decay", () => gatherDecayBlock(projectPath), warnings) : Promise.resolve(null),
+    wantedKeys.includes("attention") ? safeGather("attention", () => gatherAttentionBlock(projectPath), warnings) : Promise.resolve(null),
+    wantedKeys.includes("impact") ? safeGather("impact", () => gatherImpactBlock(projectPath), warnings) : Promise.resolve(null)
+  ]);
+  const projectName = pickProjectName(projectPath);
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    project: { root: projectPath, ...projectName && { name: projectName } },
+    health: healthRes,
+    entropy: entropyRes,
+    decay: decayRes,
+    attention: attentionRes,
+    impact: impactRes,
+    warnings
+  };
+}
+function pickProjectName(projectPath) {
+  try {
+    const pkgPath = path45.join(projectPath, "package.json");
+    if (!fs45.existsSync(pkgPath)) return void 0;
+    const pkg = JSON.parse(fs45.readFileSync(pkgPath, "utf8"));
+    return pkg.name;
+  } catch {
+    return void 0;
+  }
+}
+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 = path46.join(cwd, ".harness", "locks");
+  fs46.mkdirSync(lockDir, { recursive: true });
+  const lockPath = path46.join(lockDir, `compound-${category}.lock`);
+  let fd;
+  try {
+    fd = fs46.openSync(lockPath, "wx");
+  } catch (e) {
+    const err = e;
+    if (err.code === "EEXIST") {
+      const holderPid = readHolderPid(lockPath);
+      throw new CompoundLockHeldError(category, holderPid, lockPath);
+    }
+    throw err;
+  }
+  fs46.writeSync(fd, String(process.pid));
+  fs46.closeSync(fd);
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    try {
+      fs46.unlinkSync(lockPath);
+    } catch {
     }
     process.removeListener("exit", onExit);
     process.removeListener("SIGINT", onSignal);
@@ -13327,13 +14141,151 @@ function acquireCompoundLock(category, opts = {}) {
 }
 function readHolderPid(lockPath) {
   try {
-    const raw = fs47.readFileSync(lockPath, "utf-8").trim();
+    const raw = fs46.readFileSync(lockPath, "utf-8").trim();
     const n = Number.parseInt(raw, 10);
     return Number.isFinite(n) ? n : -1;
   } catch {
     return -1;
   }
 }
+function loadNotificationsConfig(projectRoot) {
+  const configPath = path47.join(projectRoot, "harness.config.json");
+  if (!fs47.existsSync(configPath)) {
+    return Ok({ sinks: [] });
+  }
+  let raw;
+  try {
+    raw = fs47.readFileSync(configPath, "utf-8");
+  } catch (err) {
+    return Err(err instanceof Error ? err : new Error(String(err)));
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    return Err(
+      new Error(
+        `Failed to parse harness.config.json: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+  }
+  if (parsed.notifications === void 0) {
+    return Ok({ sinks: [] });
+  }
+  const result = NotificationsConfigSchema.safeParse(parsed.notifications);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  - notifications.${i.path.join(".")}: ${i.message}`).join("\n");
+    return Err(new Error(`Invalid notifications config:
+${issues}`));
+  }
+  return Ok(result.data);
+}
+function proposalsDir(projectPath) {
+  return path48.join(projectPath, ".harness", "proposals");
+}
+function proposalPath(projectPath, id) {
+  return path48.join(proposalsDir(projectPath), `${id}.json`);
+}
+function ensureDir(dir) {
+  fs48.mkdirSync(dir, { recursive: true });
+}
+function writeAtomic(filePath, content) {
+  const tmpPath = `${filePath}.tmp`;
+  fs48.writeFileSync(tmpPath, content);
+  fs48.renameSync(tmpPath, filePath);
+}
+async function createProposal(projectPath, input) {
+  const validated = EmitSkillProposalInputSchema.parse(input);
+  const id = `proposal_${randomUUID2().replace(/-/g, "")}`;
+  const proposal = SkillProposalSchema.parse({
+    id,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    kind: validated.kind,
+    targetSkill: validated.targetSkill,
+    proposedBy: validated.proposedBy,
+    source: {
+      sessionId: validated.sessionId,
+      taskId: validated.taskId,
+      justification: validated.justification
+    },
+    content: validated.content,
+    status: "open"
+  });
+  if (proposal.kind === "refinement" && proposal.targetSkill) {
+    const existing = await listProposals(projectPath, { status: "open" });
+    const clash = existing.find(
+      (p) => p.kind === "refinement" && p.targetSkill === proposal.targetSkill
+    );
+    if (clash) {
+      throw new ProposalConflictError(
+        `An open refinement proposal already exists for skill "${proposal.targetSkill}" (id: ${clash.id})`
+      );
+    }
+  }
+  const dir = proposalsDir(projectPath);
+  ensureDir(dir);
+  writeAtomic(proposalPath(projectPath, id), JSON.stringify(proposal, null, 2));
+  return proposal;
+}
+async function getProposal(projectPath, id) {
+  const file = proposalPath(projectPath, id);
+  try {
+    const raw = fs48.readFileSync(file, "utf-8");
+    const parsed = SkillProposalSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+async function listProposals(projectPath, opts = {}) {
+  const dir = proposalsDir(projectPath);
+  let files;
+  try {
+    files = fs48.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const file of files) {
+    if (!file.endsWith(".json")) continue;
+    const id = file.slice(0, -".json".length);
+    const proposal = await getProposal(projectPath, id);
+    if (!proposal) continue;
+    if (opts.status && opts.status !== "all" && proposal.status !== opts.status) continue;
+    out.push(proposal);
+  }
+  out.sort((a, b) => a.createdAt > b.createdAt ? -1 : a.createdAt < b.createdAt ? 1 : 0);
+  return out;
+}
+async function updateProposal(projectPath, id, patch) {
+  const current = await getProposal(projectPath, id);
+  if (!current) throw new ProposalNotFoundError(id);
+  const next = SkillProposalSchema.parse({
+    ...current,
+    ...patch,
+    id: current.id,
+    createdAt: current.createdAt,
+    kind: current.kind
+  });
+  writeAtomic(proposalPath(projectPath, id), JSON.stringify(next, null, 2));
+  return next;
+}
+function deriveSkillUsage(projectRoot, skillName, windowDays = 30) {
+  const records = readAdoptionRecords(projectRoot);
+  const cutoffMs = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+  let count = 0;
+  let lastUsed;
+  for (const rec of records) {
+    if (rec.skill !== skillName) continue;
+    const startedMs = Date.parse(rec.startedAt);
+    if (Number.isFinite(startedMs) && startedMs < cutoffMs) continue;
+    count += 1;
+    if (!lastUsed || rec.startedAt > lastUsed) lastUsed = rec.startedAt;
+  }
+  const stats = { count, windowDays };
+  if (lastUsed) stats.lastUsed = lastUsed;
+  return stats;
+}
 function isObject(value) {
   return Boolean(value) && typeof value === "object";
 }
@@ -13359,10 +14311,10 @@ function assertSanitized(value) {
 }
 function writePulseConfig(config, opts) {
   PulseConfigSchema.parse(config);
-  if (!fs48.existsSync(opts.configPath)) {
+  if (!fs49.existsSync(opts.configPath)) {
     throw new Error(`harness.config.json not found at ${opts.configPath}`);
   }
-  const raw = fs48.readFileSync(opts.configPath, "utf-8");
+  const raw = fs49.readFileSync(opts.configPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -13370,18 +14322,18 @@ function writePulseConfig(config, opts) {
     throw new Error(`Invalid JSON in ${opts.configPath}: ${e.message}`, { cause: e });
   }
   const bakPath = `${opts.configPath}.bak`;
-  if (!opts.skipBackup && !fs48.existsSync(bakPath)) {
-    fs48.writeFileSync(bakPath, raw, "utf-8");
+  if (!opts.skipBackup && !fs49.existsSync(bakPath)) {
+    fs49.writeFileSync(bakPath, raw, "utf-8");
   }
   parsed.pulse = config;
   const serialized = JSON.stringify(parsed, null, 2) + "\n";
   const tmpPath = `${opts.configPath}.tmp-${process.pid}`;
-  fs48.writeFileSync(tmpPath, serialized, "utf-8");
+  fs49.writeFileSync(tmpPath, serialized, "utf-8");
   try {
-    fs48.renameSync(tmpPath, opts.configPath);
+    fs49.renameSync(tmpPath, opts.configPath);
   } catch (e) {
     try {
-      fs48.unlinkSync(tmpPath);
+      fs49.unlinkSync(tmpPath);
     } catch {
     }
     throw e;
@@ -13389,12 +14341,12 @@ function writePulseConfig(config, opts) {
 }
 function seedFromStrategy(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const strategyPath = path48.join(cwd, "STRATEGY.md");
+  const strategyPath = path49.join(cwd, "STRATEGY.md");
   const warnings = [];
-  if (!fs49.existsSync(strategyPath)) {
+  if (!fs50.existsSync(strategyPath)) {
     return { name: null, keyMetrics: [], warnings: ["STRATEGY.md not found"] };
   }
-  const raw = fs49.readFileSync(strategyPath, "utf-8");
+  const raw = fs50.readFileSync(strategyPath, "utf-8");
   let name = null;
   const fmMatch = /^---\s*\n([\s\S]*?)\n---\s*\n/.exec(raw);
   const fm = fmMatch?.[1];
@@ -13546,7 +14498,7 @@ function loadTemplate() {
     const url = import.meta?.url;
     if (!url) return INLINE_TEMPLATE;
     const here = dirname16(fileURLToPath(url));
-    return readFileSync392(join622(here, "template.md"), "utf-8");
+    return readFileSync41(join642(here, "template.md"), "utf-8");
   } catch {
     return INLINE_TEMPLATE;
   }
@@ -13749,12 +14701,12 @@ function tokenize(text) {
 async function* walk2(dir) {
   let entries;
   try {
-    entries = await fs50.readdir(dir, { withFileTypes: true });
+    entries = await fs51.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
-    const p = path49.join(dir, e.name);
+    const p = path50.join(dir, e.name);
     if (e.isDirectory()) yield* walk2(p);
     else if (e.isFile() && e.name.endsWith(".md")) yield p;
   }
@@ -13763,11 +14715,11 @@ async function readDocumentedTokens(solutionsDir) {
   const docs = [];
   for (const [track, categories] of TRACK_CATEGORIES2) {
     for (const category of categories) {
-      const dir = path49.join(solutionsDir, track, category);
+      const dir = path50.join(solutionsDir, track, category);
       for await (const file of walk2(dir)) {
-        const raw = await fs50.readFile(file, "utf-8");
+        const raw = await fs51.readFile(file, "utf-8");
         const m = /^#\s+(.+)$/m.exec(raw);
-        const title = m?.[1] ?? path49.basename(file, ".md");
+        const title = m?.[1] ?? path50.basename(file, ".md");
         docs.push(tokenize(title));
       }
     }
@@ -13852,161 +14804,55 @@ function emitSection(name, body) {
 ` : `## ${name}
 
 ${trimmed}
-`;
-}
-function serializeStrategyDoc(doc, opts = {}) {
-  const sectionByName = new Map(doc.sections.map((s) => [s.name, s.body]));
-  const sectionBlocks = [];
-  for (const name of SECTION_ORDER) {
-    const body = sectionByName.get(name);
-    if (body === void 0) continue;
-    sectionBlocks.push(emitSection(name, body));
-  }
-  const blocks = [emitFrontmatter(doc), "", emitH1(doc, opts), "", sectionBlocks.join("\n")];
-  const out = blocks.join("\n");
-  return out.endsWith("\n") ? out : out + "\n";
-}
-function readExistingH1(filePath) {
-  if (!fs51.existsSync(filePath)) return void 0;
-  const raw = fs51.readFileSync(filePath, "utf-8");
-  const lines = raw.split("\n").slice(0, 50);
-  for (const line of lines) {
-    if (line.startsWith("# ")) return line.trimEnd();
-  }
-  return void 0;
-}
-function writeStrategyDoc(doc, opts) {
-  StrategyDocSchema.parse(doc);
-  const targetPath = path50.join(opts.cwd, FILENAME);
-  const bakPath = `${targetPath}.bak`;
-  const tmpPath = `${targetPath}.tmp-${process.pid}`;
-  const preservedH1 = readExistingH1(targetPath);
-  if (fs51.existsSync(targetPath) && !opts.skipBackup && !fs51.existsSync(bakPath)) {
-    const raw = fs51.readFileSync(targetPath, "utf-8");
-    fs51.writeFileSync(bakPath, raw, "utf-8");
-  }
-  const serialized = serializeStrategyDoc(
-    doc,
-    preservedH1 !== void 0 ? { h1: preservedH1 } : {}
-  );
-  fs51.writeFileSync(tmpPath, serialized, "utf-8");
-  try {
-    fs51.renameSync(tmpPath, targetPath);
-  } catch (e) {
-    try {
-      fs51.unlinkSync(tmpPath);
-    } catch {
-    }
-    throw e;
-  }
-}
-function proposalsDir(projectPath) {
-  return path51.join(projectPath, ".harness", "proposals");
-}
-function proposalPath(projectPath, id) {
-  return path51.join(proposalsDir(projectPath), `${id}.json`);
-}
-function ensureDir(dir) {
-  fs52.mkdirSync(dir, { recursive: true });
-}
-function writeAtomic(filePath, content) {
-  const tmpPath = `${filePath}.tmp`;
-  fs52.writeFileSync(tmpPath, content);
-  fs52.renameSync(tmpPath, filePath);
-}
-async function createProposal(projectPath, input) {
-  const validated = EmitSkillProposalInputSchema.parse(input);
-  const id = `proposal_${randomUUID2().replace(/-/g, "")}`;
-  const proposal = SkillProposalSchema.parse({
-    id,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    kind: validated.kind,
-    targetSkill: validated.targetSkill,
-    proposedBy: validated.proposedBy,
-    source: {
-      sessionId: validated.sessionId,
-      taskId: validated.taskId,
-      justification: validated.justification
-    },
-    content: validated.content,
-    status: "open"
-  });
-  if (proposal.kind === "refinement" && proposal.targetSkill) {
-    const existing = await listProposals(projectPath, { status: "open" });
-    const clash = existing.find(
-      (p) => p.kind === "refinement" && p.targetSkill === proposal.targetSkill
-    );
-    if (clash) {
-      throw new ProposalConflictError(
-        `An open refinement proposal already exists for skill "${proposal.targetSkill}" (id: ${clash.id})`
-      );
-    }
-  }
-  const dir = proposalsDir(projectPath);
-  ensureDir(dir);
-  writeAtomic(proposalPath(projectPath, id), JSON.stringify(proposal, null, 2));
-  return proposal;
+`;
 }
-async function getProposal(projectPath, id) {
-  const file = proposalPath(projectPath, id);
-  try {
-    const raw = fs52.readFileSync(file, "utf-8");
-    const parsed = SkillProposalSchema.safeParse(JSON.parse(raw));
-    return parsed.success ? parsed.data : null;
-  } catch {
-    return null;
+function serializeStrategyDoc(doc, opts = {}) {
+  const sectionByName = new Map(doc.sections.map((s) => [s.name, s.body]));
+  const sectionBlocks = [];
+  for (const name of SECTION_ORDER) {
+    const body = sectionByName.get(name);
+    if (body === void 0) continue;
+    sectionBlocks.push(emitSection(name, body));
   }
+  const blocks = [emitFrontmatter(doc), "", emitH1(doc, opts), "", sectionBlocks.join("\n")];
+  const out = blocks.join("\n");
+  return out.endsWith("\n") ? out : out + "\n";
 }
-async function listProposals(projectPath, opts = {}) {
-  const dir = proposalsDir(projectPath);
-  let files;
-  try {
-    files = fs52.readdirSync(dir);
-  } catch {
-    return [];
-  }
-  const out = [];
-  for (const file of files) {
-    if (!file.endsWith(".json")) continue;
-    const id = file.slice(0, -".json".length);
-    const proposal = await getProposal(projectPath, id);
-    if (!proposal) continue;
-    if (opts.status && opts.status !== "all" && proposal.status !== opts.status) continue;
-    out.push(proposal);
+function readExistingH1(filePath) {
+  if (!fs52.existsSync(filePath)) return void 0;
+  const raw = fs52.readFileSync(filePath, "utf-8");
+  const lines = raw.split("\n").slice(0, 50);
+  for (const line of lines) {
+    if (line.startsWith("# ")) return line.trimEnd();
   }
-  out.sort((a, b) => a.createdAt > b.createdAt ? -1 : a.createdAt < b.createdAt ? 1 : 0);
-  return out;
-}
-async function updateProposal(projectPath, id, patch) {
-  const current = await getProposal(projectPath, id);
-  if (!current) throw new ProposalNotFoundError(id);
-  const next = SkillProposalSchema.parse({
-    ...current,
-    ...patch,
-    id: current.id,
-    createdAt: current.createdAt,
-    kind: current.kind
-  });
-  writeAtomic(proposalPath(projectPath, id), JSON.stringify(next, null, 2));
-  return next;
+  return void 0;
 }
-function deriveSkillUsage(projectRoot, skillName, windowDays = 30) {
-  const records = readAdoptionRecords(projectRoot);
-  const cutoffMs = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
-  let count = 0;
-  let lastUsed;
-  for (const rec of records) {
-    if (rec.skill !== skillName) continue;
-    const startedMs = Date.parse(rec.startedAt);
-    if (Number.isFinite(startedMs) && startedMs < cutoffMs) continue;
-    count += 1;
-    if (!lastUsed || rec.startedAt > lastUsed) lastUsed = rec.startedAt;
+function writeStrategyDoc(doc, opts) {
+  StrategyDocSchema.parse(doc);
+  const targetPath = path51.join(opts.cwd, FILENAME);
+  const bakPath = `${targetPath}.bak`;
+  const tmpPath = `${targetPath}.tmp-${process.pid}`;
+  const preservedH1 = readExistingH1(targetPath);
+  if (fs52.existsSync(targetPath) && !opts.skipBackup && !fs52.existsSync(bakPath)) {
+    const raw = fs52.readFileSync(targetPath, "utf-8");
+    fs52.writeFileSync(bakPath, raw, "utf-8");
+  }
+  const serialized = serializeStrategyDoc(
+    doc,
+    preservedH1 !== void 0 ? { h1: preservedH1 } : {}
+  );
+  fs52.writeFileSync(tmpPath, serialized, "utf-8");
+  try {
+    fs52.renameSync(tmpPath, targetPath);
+  } catch (e) {
+    try {
+      fs52.unlinkSync(tmpPath);
+    } catch {
+    }
+    throw e;
   }
-  const stats = { count, windowDays };
-  if (lastUsed) stats.lastUsed = lastUsed;
-  return stats;
 }
-var WHATWG_BAD_PORTS, BAD_PORT_SET, VALID_TYPES, CONVENTIONAL_PATTERN, LOOKBACK_PATTERN, PulseDbSourceSchema, PulseSourcesSchema, PulseConfigSchema, KNOWN_SECTION_NAMES, ISO_DATE, PLACEHOLDER_INLINE, REQUIRED, ALLOWED, StrategyFrontmatterSchema, StrategySectionSchema, StrategyDocSchema, BUG_TRACK_CATEGORIES, KNOWLEDGE_TRACK_CATEGORIES, ALL_SOLUTION_CATEGORIES, ISO_DATE2, 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, KEBAB_CASE, TICKET_ID, 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, readFile72, 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, MAX_TOP_AFFECTED, BaselineManager, BenchmarkRunner, RegressionDetector, SOURCE_EXTENSIONS, FUNCTION_DECL_RE, CONST_DECL_RE, CriticalPathResolver, NoOpTelemetryAdapter, NoOpExecutor, ConsoleSink, feedbackConfig, ChecklistBuilder, AgentActionEmitter, globalEmitter, FileSink, NoOpSink, ConfidenceTierSchema, RegressionResultSchema, DirectionSchema, CategoryForecastSchema, SpecImpactSignalsSchema, SpecImpactEstimateSchema, ContributingFeatureSchema, AdjustedForecastSchema, PredictionWarningSchema, StabilityForecastSchema, PredictionResultSchema, PredictionOptionsSchema, VALID_STATUSES, EM_DASH, VALID_PRIORITIES, ALL_CATEGORIES, 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, OSV_ENDPOINT, DEFAULT_CACHE_DIR, DEFAULT_TTL_HOURS, hiddenUnicodePatterns, reRolingPatterns, permissionEscalationPatterns, encodedPayloadPatterns, indirectInjectionPatterns, contextManipulationPatterns, socialEngineeringPatterns, suspiciousPatterns, ALL_PATTERNS, DESTRUCTIVE_BASH, TAINT_DURATION_MS, DEFAULT_SESSION_ID, SecurityCategorySnapshotSchema, SupplyChainSnapshotSchema, SecurityTimelineSnapshotSchema, FindingLifecycleSchema, SecurityTimelineFileSchema, DirectionSchema2, SecurityTrendLineSchema, TrendAttributionSchema, SecurityTrendResultSchema, TimeToFixStatsSchema, TimeToFixResultSchema, EMPTY_SUPPLY_CHAIN, SecurityTimelineManager, ALL_CHECKS, STATUS_ICONS, CINotifier, ExclusionSet, PREFIX_PATTERNS, TEST_FILE_PATTERN, MD_FILE_PATTERN, ALL_DOMAINS, SECURITY_PATTERNS, JS_EXT_FALLBACKS, 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, ADVERSARIAL_DESCRIPTOR, UNVERIFIED_INPUT_PATTERN, PROMISE_NO_REJECT_PATTERN, UNGUARDED_OPTIONAL_CALL, COMPOSE_NO_AWAIT, FETCH_NO_TIMEOUT, TYPESCRIPT_STRICT_DESCRIPTOR, EXPLICIT_ANY_PATTERN, TS_IGNORE_PATTERN, UNSAFE_AS_UNKNOWN, NON_NULL_ASSERTION, VAGUE_HELPER_NAME, FRONTEND_RACES_DESCRIPTOR, AGENT_DESCRIPTORS, CONDITIONAL_SUBAGENT_DESCRIPTORS, AGENT_RUNNERS, SUBAGENT_ORDER, RISK_KEYWORDS, EXCLUDED_PATH_PATTERNS, ASYNC_UI_SIGNALS, WORD_BOUNDARY, DOWNGRADE_MAP, DEFAULT_PROVIDER_TIERS, SMALL_SUGGESTION_LINE_LIMIT, FILE_LINE_RANGE_PATTERN, FILE_LINE_PATTERN, FILE_ONLY_PATTERN, SECURITY_SENSITIVE_PATH, MIGRATION_PATH, TEST_PATH, CONFIG_PATH, STAGE_DOMAINS, EM_DASH2, STATUS_RANK, RETRY_DEFAULTS, GitHubIssuesSyncAdapter, syncMutex, PRIORITY_RANK, PRIORITY_RANK2, POSITION_WEIGHT, DEPENDENTS_WEIGHT, AFFINITY_WEIGHT, ConflictError, DEFAULTS, GitHubHttp, ETagStore, START_MARKER, END_MARKER, SERIALIZER_FIELDS, GitHubIssuesTrackerAdapter, migrate_exports, HASH_RE, InteractionTypeSchema, QuestionSchema, ConfirmationSchema, TransitionSchema, EmitInteractionInputSchema, ProjectScanner, SHELL_TEMPLATE, STYLES, SCRIPTS, MockLLMService, llmService, ContentPipeline, BlueprintGenerator, TOKENS_PER_MILLION, fallback_default, LITELLM_PRICING_URL, CACHE_TTL_MS, STALENESS_WARNING_DAYS, MICRODOLLARS_PER_DOLLAR, TOKENS_PER_MILLION2, StructuralStrategy, DEFAULT_TOKEN_BUDGET, CHARS_PER_TOKEN, TRUNCATION_MARKER, TruncationStrategy, CompactionPipeline, STABILITY_LOOKUP, TIER_ORDER, AnthropicCacheAdapter, TIER_ORDER2, OpenAICacheAdapter, TIER_ORDER3, CACHED_CONTENT_MARKER, GeminiCacheAdapter, VERSION, POSTHOG_BATCH_URL, MAX_ATTEMPTS, TIMEOUT_MS, DEFAULT_CAPACITY, CacheMetricsRecorder, RETRY_BACKOFFS_MS, DEFAULT_FLUSH_INTERVAL_MS, DEFAULT_BATCH_SIZE, defaultFetch, defaultWarn, OTLPExporter, SERVICE_NAME_ATTR, SpanKind, 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, SECTION_ORDER, FILENAME, ProposalNotFoundError, ProposalConflictError;
+var WHATWG_BAD_PORTS, BAD_PORT_SET, VALID_TYPES, CONVENTIONAL_PATTERN, LOOKBACK_PATTERN, PulseDbSourceSchema, PulseSourcesSchema, PulseConfigSchema, KNOWN_SECTION_NAMES, ISO_DATE, PLACEHOLDER_INLINE, REQUIRED, ALLOWED, StrategyFrontmatterSchema, StrategySectionSchema, StrategyDocSchema, BUG_TRACK_CATEGORIES, KNOWLEDGE_TRACK_CATEGORIES, ALL_SOLUTION_CATEGORIES, ISO_DATE2, 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, KEBAB_CASE, TICKET_ID, 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, readFile72, 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, SOURCE_EXTENSIONS, FUNCTION_DECL_RE, CONST_DECL_RE, CriticalPathResolver, NoOpTelemetryAdapter, NoOpExecutor, ConsoleSink, feedbackConfig, ChecklistBuilder, AgentActionEmitter, globalEmitter, FileSink, NoOpSink, ConfidenceTierSchema, RegressionResultSchema, DirectionSchema, CategoryForecastSchema, SpecImpactSignalsSchema, SpecImpactEstimateSchema, ContributingFeatureSchema, AdjustedForecastSchema, PredictionWarningSchema, StabilityForecastSchema, PredictionResultSchema, PredictionOptionsSchema, VALID_STATUSES, EM_DASH, VALID_PRIORITIES, ALL_CATEGORIES, 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, OSV_ENDPOINT, DEFAULT_CACHE_DIR, DEFAULT_TTL_HOURS, hiddenUnicodePatterns, reRolingPatterns, permissionEscalationPatterns, encodedPayloadPatterns, indirectInjectionPatterns, contextManipulationPatterns, socialEngineeringPatterns, suspiciousPatterns, ALL_PATTERNS, DESTRUCTIVE_BASH, TAINT_DURATION_MS, DEFAULT_SESSION_ID, SecurityCategorySnapshotSchema, SupplyChainSnapshotSchema, SecurityTimelineSnapshotSchema, FindingLifecycleSchema, SecurityTimelineFileSchema, DirectionSchema2, SecurityTrendLineSchema, TrendAttributionSchema, SecurityTrendResultSchema, TimeToFixStatsSchema, TimeToFixResultSchema, EMPTY_SUPPLY_CHAIN, SecurityTimelineManager, ALL_CHECKS, STATUS_ICONS, CINotifier, ExclusionSet, PREFIX_PATTERNS, TEST_FILE_PATTERN, MD_FILE_PATTERN, ALL_DOMAINS, SECURITY_PATTERNS, JS_EXT_FALLBACKS, 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, ADVERSARIAL_DESCRIPTOR, UNVERIFIED_INPUT_PATTERN, PROMISE_NO_REJECT_PATTERN, UNGUARDED_OPTIONAL_CALL, COMPOSE_NO_AWAIT, FETCH_NO_TIMEOUT, TYPESCRIPT_STRICT_DESCRIPTOR, EXPLICIT_ANY_PATTERN, TS_IGNORE_PATTERN, UNSAFE_AS_UNKNOWN, NON_NULL_ASSERTION, VAGUE_HELPER_NAME, FRONTEND_RACES_DESCRIPTOR, AGENT_DESCRIPTORS, CONDITIONAL_SUBAGENT_DESCRIPTORS, AGENT_RUNNERS, SUBAGENT_ORDER, RISK_KEYWORDS, EXCLUDED_PATH_PATTERNS, ASYNC_UI_SIGNALS, WORD_BOUNDARY, 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, CI_REVIEW_VERDICT_SCHEMA_VERSION, CI_RUNNERS, CI_ASSESSMENTS, CI_REVIEW_DOMAINS, ReviewFindingSchema, CiReviewVerdictSchema, VERDICT_MAP, RUNNER_PRESETS, VERDICT_MAP2, DEFAULT_EXEC_TIMEOUT_MS, DEFAULT_EXEC_MAX_STDOUT_BYTES, STDERR_CAP_BYTES, STDERR_TAIL_BYTES, defaultExecFile, EMPTY_TIER, EM_DASH2, STATUS_RANK, EM_DASH3, DEFAULT_MILESTONE, MAX_CLOSEST_MATCHES, RETRY_DEFAULTS, GitHubIssuesSyncAdapter, syncMutex, PRIORITY_RANK, PRIORITY_RANK2, POSITION_WEIGHT, DEPENDENTS_WEIGHT, AFFINITY_WEIGHT, ConflictError, DEFAULTS, GitHubHttp, ETagStore, START_MARKER, END_MARKER, SERIALIZER_FIELDS, GitHubIssuesTrackerAdapter, migrate_exports, HASH_RE, DEFAULT_CATCH_ALL, DEFAULT_INTAKE, DEFAULT_MAX_ACTIVE, 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, DEFAULT_CAPACITY, CacheMetricsRecorder, RETRY_BACKOFFS_MS, DEFAULT_FLUSH_INTERVAL_MS, DEFAULT_BATCH_SIZE, defaultFetch, defaultWarn, OTLPExporter, SERVICE_NAME_ATTR, SpanKind, ModeSchema, SeveritySchema, TierSchema, StrengthFindingSchema, HarnessConfigSubsetSchema, HookFileSchema, ProjectContextSchema, AuditSummarySchema, AuditResultSchema, SEVERITY_WEIGHTS, clamp, HOOK_SCRIPT_TOKEN, NEVER_BLOCKS, ALWAYS_EXIT_ZERO, EXIT_ZERO_LINE, NONZERO_EXIT, GATE, ERREXIT, strength001NonblockingHooks, BASELINE_REWRITE, strength002Autobaseline, SKIP_RE, strength003SkipList, strength004EmptyThresholds, INIT_SKILL_PATH, DEFAULT_BASIC, strength005LowestTier, AUTO_PATTERN, COMMENT_LINE, NAME_VALUE_LINE, PAT_GATING, REVIEW_SIGNAL, strength006AutoapproveBaseline, CHECK_SIGNAL_MAP, strength007SnapshotSignalMismatch, ALL_RULES, HarnessStrengthAuditor, MAX_TOP_AFFECTED, CompoundLockHeldError, KNOWN_CATEGORIES, ProposalNotFoundError, ProposalConflictError, 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, SECTION_ORDER, FILENAME;
 var init_dist3 = __esm({
   "../core/dist/index.mjs"() {
     init_chunk_FYTJQ2ZY();
@@ -14018,7 +14864,6 @@ var init_dist3 = __esm({
     init_dist();
     init_dist();
     init_dist();
-    init_dist();
     init_dist2();
     init_dist();
     init_dist();
@@ -14032,11 +14877,12 @@ var init_dist3 = __esm({
     init_dist();
     init_dist();
     init_dist();
-    init_dist();
     init_dist2();
     init_dist();
     init_dist();
     init_dist();
+    init_dist();
+    init_dist();
     WHATWG_BAD_PORTS = Object.freeze([
       1,
       7,
@@ -14623,22 +15469,21 @@ var init_dist3 = __esm({
       exclude: z5.array(z5.string()).optional(),
       docPaths: z5.array(z5.string()).optional()
     });
-    MAX_TOP_AFFECTED = 5;
     BaselineManager = class {
       baselinesPath;
       constructor(projectRoot) {
-        this.baselinesPath = join18(projectRoot, ".harness", "perf", "baselines.json");
+        this.baselinesPath = join17(projectRoot, ".harness", "perf", "baselines.json");
       }
       /**
        * Load the baselines file from disk.
        * Returns null if the file does not exist or contains invalid JSON.
        */
       load() {
-        if (!existsSync13(this.baselinesPath)) {
+        if (!existsSync12(this.baselinesPath)) {
           return null;
         }
         try {
-          const raw = readFileSync32(this.baselinesPath, "utf-8");
+          const raw = readFileSync22(this.baselinesPath, "utf-8");
           return JSON.parse(raw);
         } catch {
           return null;
@@ -14668,7 +15513,7 @@ var init_dist3 = __esm({
           benchmarks
         };
         const dir = dirname6(this.baselinesPath);
-        if (!existsSync13(dir)) {
+        if (!existsSync12(dir)) {
           mkdirSync2(dir, { recursive: true });
         }
         writeFileSync2(this.baselinesPath, JSON.stringify(file, null, 2));
@@ -14901,16 +15746,16 @@ var init_dist3 = __esm({
       walkDir(dir, entries) {
         let items;
         try {
-          items = fs9.readdirSync(dir, { withFileTypes: true });
+          items = fs8.readdirSync(dir, { withFileTypes: true });
         } catch {
           return;
         }
         for (const item of items) {
           if (item.isDirectory()) {
             if (DEFAULT_SKIP_DIRS.has(item.name)) continue;
-            this.walkDir(path6.join(dir, item.name), entries);
-          } else if (item.isFile() && SOURCE_EXTENSIONS.has(path6.extname(item.name))) {
-            this.scanFile(path6.join(dir, item.name), entries);
+            this.walkDir(path5.join(dir, item.name), entries);
+          } else if (item.isFile() && SOURCE_EXTENSIONS.has(path5.extname(item.name))) {
+            this.scanFile(path5.join(dir, item.name), entries);
           }
         }
       }
@@ -14925,12 +15770,12 @@ var init_dist3 = __esm({
       scanFile(filePath, entries) {
         let content;
         try {
-          content = fs9.readFileSync(filePath, "utf-8");
+          content = fs8.readFileSync(filePath, "utf-8");
         } catch {
           return;
         }
         const lines = content.split("\n");
-        const relativePath = path6.relative(this.projectRoot, filePath).replace(/\\/g, "/");
+        const relativePath = path5.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);
@@ -15270,7 +16115,7 @@ var init_dist3 = __esm({
       ensureDirectory() {
         if (!this.initialized) {
           const dir = dirname7(this.filePath);
-          if (!existsSync14(dir)) {
+          if (!existsSync13(dir)) {
             mkdirSync22(dir, { recursive: true });
           }
           this.initialized = true;
@@ -15301,7 +16146,7 @@ var init_dist3 = __esm({
           this.ensureDirectory();
           const content = this.buffer.join("");
           this.buffer = [];
-          if (this.options.mode === "overwrite" && !existsSync14(this.filePath)) {
+          if (this.options.mode === "overwrite" && !existsSync13(this.filePath)) {
             writeFileSync22(this.filePath, content);
           } else {
             appendFileSync(this.filePath, content);
@@ -15735,8 +16580,8 @@ var init_dist3 = __esm({
           return null;
         }
         try {
-          const roadmapPath = path7.join(this.rootDir, "roadmap.md");
-          const raw = fs10.readFileSync(roadmapPath, "utf-8");
+          const roadmapPath = path6.join(this.rootDir, "roadmap.md");
+          const raw = fs9.readFileSync(roadmapPath, "utf-8");
           const parseResult = parseRoadmap(raw);
           if (!parseResult.ok) return null;
           const features = parseResult.value.milestones.flatMap(
@@ -15771,8 +16616,8 @@ var init_dist3 = __esm({
        * @param specPath - Relative path from rootDir to the spec file.
        */
       estimate(specPath) {
-        const absolutePath = path8.join(this.rootDir, specPath);
-        const content = fs11.readFileSync(absolutePath, "utf-8");
+        const absolutePath = path7.join(this.rootDir, specPath);
+        const content = fs10.readFileSync(absolutePath, "utf-8");
         const newFileCount = this.extractNewFileCount(content);
         const affectedLayers = this.extractAffectedLayers(content);
         const newDependencies = this.extractNewDependencies(content);
@@ -15784,7 +16629,7 @@ var init_dist3 = __esm({
           phaseCount
         );
         const h1Match = content.match(/^#\s+(.+)$/m);
-        const featureName = h1Match ? h1Match[1].trim() : path8.basename(specPath, ".md");
+        const featureName = h1Match ? h1Match[1].trim() : path7.basename(specPath, ".md");
         return {
           specPath,
           featureName,
@@ -15805,8 +16650,8 @@ var init_dist3 = __esm({
         const results = [];
         for (const feature of features) {
           if (!feature.spec) continue;
-          const absolutePath = path8.join(this.rootDir, feature.spec);
-          if (!fs11.existsSync(absolutePath)) continue;
+          const absolutePath = path7.join(this.rootDir, feature.spec);
+          if (!fs10.existsSync(absolutePath)) continue;
           const estimate = this.estimate(feature.spec);
           results.push({ ...estimate, featureName: feature.name });
         }
@@ -15834,8 +16679,8 @@ var init_dist3 = __esm({
         }
         let count = 0;
         for (const fp of filePaths) {
-          const absolute = path8.join(this.rootDir, fp);
-          if (!fs11.existsSync(absolute)) {
+          const absolute = path7.join(this.rootDir, fp);
+          if (!fs10.existsSync(absolute)) {
             count++;
           }
         }
@@ -15905,8 +16750,8 @@ var init_dist3 = __esm({
       // --- Private: Config Loading ---
       loadLayerNames() {
         try {
-          const configPath = path8.join(this.rootDir, "harness.config.json");
-          const raw = fs11.readFileSync(configPath, "utf-8");
+          const configPath = path7.join(this.rootDir, "harness.config.json");
+          const raw = fs10.readFileSync(configPath, "utf-8");
           const config = JSON.parse(raw);
           return (config.layers ?? []).map((l) => l.name);
         } catch {
@@ -15925,8 +16770,8 @@ var init_dist3 = __esm({
       historyPath;
       /** Load history from disk, returning empty history if file doesn't exist. */
       load() {
-        if (!fs12.existsSync(this.historyPath)) return { ...EMPTY_HISTORY, snapshots: [] };
-        const raw = fs12.readFileSync(this.historyPath, "utf-8");
+        if (!fs11.existsSync(this.historyPath)) return { ...EMPTY_HISTORY, snapshots: [] };
+        const raw = fs11.readFileSync(this.historyPath, "utf-8");
         return JSON.parse(raw);
       }
       /** Append a timestamped snapshot of current violations. */
@@ -15940,18 +16785,18 @@ var init_dist3 = __esm({
       }
       /** Prune snapshots older than retentionDays. */
       prune(retentionDays) {
-        if (!fs12.existsSync(this.historyPath)) return;
+        if (!fs11.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 = path9.dirname(this.historyPath);
-        if (!fs12.existsSync(dir)) {
-          fs12.mkdirSync(dir, { recursive: true });
+        const dir = path8.dirname(this.historyPath);
+        if (!fs11.existsSync(dir)) {
+          fs11.mkdirSync(dir, { recursive: true });
         }
-        fs12.writeFileSync(this.historyPath, JSON.stringify(history, null, 2), "utf-8");
+        fs11.writeFileSync(this.historyPath, JSON.stringify(history, null, 2), "utf-8");
       }
     };
     NORMALIZERS = {
@@ -16953,7 +17798,7 @@ var init_dist3 = __esm({
       }
       async scanFile(filePath) {
         if (!this.config.enabled) return [];
-        const content = await fs30.readFile(filePath, "utf-8");
+        const content = await fs29.readFile(filePath, "utf-8");
         return this.scanContentForFile(content, filePath, 1);
       }
       scanContentForFile(content, filePath, startLine = 1) {
@@ -17075,7 +17920,7 @@ var init_dist3 = __esm({
       }
     };
     OSV_ENDPOINT = "https://api.osv.dev/v1/query";
-    DEFAULT_CACHE_DIR = path27.join(".harness", "cache", "osv");
+    DEFAULT_CACHE_DIR = path26.join(".harness", "cache", "osv");
     DEFAULT_TTL_HOURS = 24;
     hiddenUnicodePatterns = [
       {
@@ -17382,7 +18227,7 @@ var init_dist3 = __esm({
       timelinePath;
       constructor(rootDir) {
         this.rootDir = rootDir;
-        this.timelinePath = join40(rootDir, ".harness", "security", "timeline.json");
+        this.timelinePath = join39(rootDir, ".harness", "security", "timeline.json");
       }
       /**
        * Load timeline from disk.
@@ -17393,11 +18238,11 @@ var init_dist3 = __esm({
        * fixup is one-shot.
        */
       load() {
-        if (!existsSync342(this.timelinePath)) {
+        if (!existsSync332(this.timelinePath)) {
           return { version: 1, snapshots: [], findingLifecycles: [] };
         }
         try {
-          const raw = readFileSync23(this.timelinePath, "utf-8");
+          const raw = readFileSync222(this.timelinePath, "utf-8");
           const data = JSON.parse(raw);
           const parsed = SecurityTimelineFileSchema.safeParse(data);
           if (!parsed.success) {
@@ -17427,7 +18272,7 @@ var init_dist3 = __esm({
        */
       save(timeline) {
         const dir = dirname11(this.timelinePath);
-        if (!existsSync342(dir)) {
+        if (!existsSync332(dir)) {
           mkdirSync14(dir, { recursive: true });
         }
         const tmp = this.timelinePath + "." + randomBytes2(4).toString("hex") + ".tmp";
@@ -18151,6 +18996,244 @@ var init_dist3 = __esm({
       "spec-compliance": ["compliance", "architecture"],
       "code-quality": ["bug", "security"]
     };
+    CI_REVIEW_VERDICT_SCHEMA_VERSION = 1;
+    CI_RUNNERS = [
+      "claude",
+      "gemini",
+      "antigravity",
+      "codex",
+      "cursor",
+      "local",
+      "floor-only"
+    ];
+    CI_ASSESSMENTS = ["approve", "comment", "request-changes"];
+    CI_REVIEW_DOMAINS = [
+      "compliance",
+      "bug",
+      "security",
+      "architecture",
+      "learnings"
+    ];
+    ReviewFindingSchema = z12.object({
+      id: z12.string().min(1),
+      file: z12.string().min(1),
+      lineRange: z12.tuple([z12.number(), z12.number()]),
+      domain: z12.enum(CI_REVIEW_DOMAINS),
+      severity: z12.enum(["critical", "important", "suggestion"]),
+      title: z12.string().min(1),
+      rationale: z12.string().min(1),
+      suggestion: z12.string().optional(),
+      evidence: z12.array(z12.string()),
+      validatedBy: z12.enum(["mechanical", "graph", "heuristic"]),
+      cweId: z12.string().optional(),
+      owaspCategory: z12.string().optional(),
+      confidence: z12.union([
+        z12.enum(["high", "medium", "low"]),
+        z12.literal(25),
+        z12.literal(50),
+        z12.literal(75),
+        z12.literal(100)
+      ]).optional(),
+      remediation: z12.string().optional(),
+      references: z12.array(z12.string()).optional(),
+      trustScore: z12.number().optional(),
+      rubricItemId: z12.string().optional(),
+      subagent: z12.string().optional()
+    }).passthrough();
+    CiReviewVerdictSchema = z12.object({
+      schemaVersion: z12.literal(CI_REVIEW_VERDICT_SCHEMA_VERSION),
+      runner: z12.enum(CI_RUNNERS),
+      ranLlmTier: z12.boolean(),
+      assessment: z12.enum(CI_ASSESSMENTS),
+      findings: z12.array(ReviewFindingSchema),
+      blockingFindings: z12.array(ReviewFindingSchema),
+      exitCode: z12.number().int(),
+      skipped: z12.boolean(),
+      skipReason: z12.string().optional()
+    }).superRefine((v, ctx) => {
+      for (const [i, f] of v.blockingFindings.entries()) {
+        if (f.severity !== "critical") {
+          ctx.addIssue({
+            code: z12.ZodIssueCode.custom,
+            path: ["blockingFindings", i, "severity"],
+            message: `blockingFindings[${i}] has severity '${f.severity}'; only 'critical' findings may block`
+          });
+        }
+      }
+      for (const [i, bf] of v.blockingFindings.entries()) {
+        const present = v.findings.some((f) => findingsMatch(f, bf));
+        if (!present) {
+          ctx.addIssue({
+            code: z12.ZodIssueCode.custom,
+            path: ["blockingFindings", i],
+            message: `blockingFindings[${i}] (id='${bf.id}') is not present in findings`
+          });
+        }
+      }
+      const criticalCount = v.findings.filter((f) => f.severity === "critical").length;
+      if (v.blockingFindings.length !== criticalCount) {
+        ctx.addIssue({
+          code: z12.ZodIssueCode.custom,
+          path: ["blockingFindings"],
+          message: `blockingFindings (${v.blockingFindings.length}) must equal the critical findings in findings (${criticalCount})`
+        });
+      }
+      const blocking = v.blockingFindings.length > 0;
+      if (blocking && v.assessment !== "request-changes") {
+        ctx.addIssue({
+          code: z12.ZodIssueCode.custom,
+          path: ["assessment"],
+          message: `assessment must be 'request-changes' when blockingFindings is non-empty (got '${v.assessment}')`
+        });
+      }
+      const mustExitNonZero = blocking || v.assessment === "request-changes";
+      if (mustExitNonZero && v.exitCode === 0) {
+        ctx.addIssue({
+          code: z12.ZodIssueCode.custom,
+          path: ["exitCode"],
+          message: `exitCode must be non-zero when blockingFindings is non-empty or assessment is 'request-changes'`
+        });
+      }
+      if (!mustExitNonZero && v.exitCode !== 0) {
+        ctx.addIssue({
+          code: z12.ZodIssueCode.custom,
+          path: ["exitCode"],
+          message: `exitCode must be 0 when there are no blocking findings and assessment is not 'request-changes'`
+        });
+      }
+    });
+    VERDICT_MAP = {
+      approve: "approve",
+      comment: "comment",
+      "request-changes": "request-changes"
+    };
+    RUNNER_PRESETS = {
+      claude: {
+        kind: "agent-cli",
+        supported: true,
+        secretEnvVar: "ANTHROPIC_API_KEY",
+        // Verified (Task 10 smoke test): diff piped via STDIN, instruction as the
+        // `-p` prompt, JSON transcript on stdout. There is NO `--input-file` flag.
+        headlessInvocation: ({ instruction }) => ({
+          command: "claude",
+          args: ["-p", instruction, "--output-format", "json"]
+        }),
+        verdictParser: parseClaudeVerdict
+      },
+      gemini: {
+        kind: "agent-cli",
+        supported: false,
+        // argv corrected from `gemini --help` (NOT `--json`; it is `-o json`, and there
+        // is no `--file` flag — the diff goes on STDIN):
+        //   command: 'gemini'
+        //   args: ['-p', instruction, '-o', 'json']   // diff piped via STDIN
+        // Re-enable by restoring `supported: true`, `secretEnvVar: 'GEMINI_API_KEY'`,
+        // the headlessInvocation above, and `verdictParser: parseGeminiVerdict` once
+        // the output envelope is captured in CI.
+        unsupportedReason: "SUPERSEDED by the `antigravity` runner (use `--runner antigravity`): the Gemini agentic CLI was renamed to Antigravity (command `agy`), which authenticates locally and produces a capturable verdict where this `gemini` CLI did not. Retained as a valid runner id for back-compat. Original deferral note: gemini argv corrected from --help (`gemini -p <instruction> -o json`, diff on STDIN), but the JSON output envelope is UNVERIFIED: no GEMINI_API_KEY was available in the authoring environment, so the CLI fell through to interactive OAuth and produced no capturable result. Verification deferred to a real CI run with credentials."
+      },
+      antigravity: {
+        kind: "agent-cli",
+        supported: true,
+        // agy is authenticated locally via OAuth here (no API key needed for local
+        // runs). For CI, the gating secret is uncertain — this is a BEST-GUESS pending
+        // CI verification: antigravity is Gemini-family (the renamed `gemini` CLI), so
+        // GEMINI_API_KEY is the most likely credential. Local auth is OAuth-based and
+        // needs no secret; confirm/correct this against a real CI run.
+        secretEnvVar: "GEMINI_API_KEY",
+        // Verified live against the real CLI: diff piped via STDIN, instruction as the
+        // `--print` prompt. There is NO `--output-format`/`--json` flag (it errors
+        // `flags provided but not defined: -output-format`); `--print` (alias
+        // `--prompt`) runs a single non-interactive prompt and emits the model's
+        // response as plain text. Consistent with the claude/codex STDIN diff model.
+        headlessInvocation: ({ instruction }) => ({
+          command: "agy",
+          args: ["--print", instruction]
+        }),
+        verdictParser: parseAntigravityVerdict
+      },
+      codex: {
+        kind: "agent-cli",
+        supported: true,
+        secretEnvVar: "OPENAI_API_KEY",
+        // Verified (Task 10 smoke test): diff piped via STDIN, instruction as the
+        // positional prompt, JSONL event stream on stdout. There is NO `--file` flag.
+        headlessInvocation: ({ instruction }) => ({
+          command: "codex",
+          args: ["exec", "--json", instruction]
+        }),
+        verdictParser: parseCodexVerdict
+      },
+      cursor: {
+        kind: "agent-cli",
+        supported: false,
+        unsupportedReason: "cursor headless CI invocation is unverified and the CLI is not present in this environment; deferred to a real CI run per the required-review-ci re-scope decision."
+      },
+      local: {
+        kind: "endpoint",
+        supported: true,
+        endpointEnvVar: "HARNESS_LOCAL_ENDPOINT",
+        modelEnvVar: "HARNESS_LOCAL_MODEL",
+        // `invoke` is intentionally left unset here — it is the injected seam Phase 2
+        // wires to the openai-compatible provider (see LocalEndpointInvoke). The
+        // deterministic surface (env-var seams + verdictParser) is what Phase 1 ships
+        // and unit-tests; live single-pass verification is DEFERRED (no endpoint here).
+        verdictParser: parseLocalVerdict
+      }
+    };
+    VERDICT_MAP2 = {
+      approve: "approve",
+      comment: "comment",
+      "request-changes": "request-changes"
+    };
+    DEFAULT_EXEC_TIMEOUT_MS = 12e4;
+    DEFAULT_EXEC_MAX_STDOUT_BYTES = 1024 * 1024 * 64;
+    STDERR_CAP_BYTES = 1024 * 1024;
+    STDERR_TAIL_BYTES = 2048;
+    defaultExecFile = async (command, args, opts) => {
+      const timeout = opts.timeoutMs ?? DEFAULT_EXEC_TIMEOUT_MS;
+      const maxStdoutBytes = opts.maxStdoutBytes ?? DEFAULT_EXEC_MAX_STDOUT_BYTES;
+      const child = nodeExecFile(command, args, {
+        env: opts.env,
+        timeout,
+        killSignal: "SIGTERM"
+      });
+      child.stdin?.end(opts.stdin);
+      return new Promise((resolve7, reject) => {
+        let out = "";
+        let outBytes = 0;
+        let err = "";
+        let errBytes = 0;
+        let overflowed = false;
+        child.stdout?.on("data", (d) => {
+          const chunk = Buffer.isBuffer(d) ? d : Buffer.from(String(d));
+          outBytes += chunk.length;
+          out += chunk.toString();
+          if (!overflowed && outBytes > maxStdoutBytes) {
+            overflowed = true;
+            child.kill("SIGTERM");
+            reject(new Error(`runner output exceeded ${maxStdoutBytes} bytes`));
+          }
+        });
+        child.stderr?.on("data", (d) => {
+          const chunk = Buffer.isBuffer(d) ? d : Buffer.from(String(d));
+          errBytes += chunk.length;
+          err += chunk.toString();
+          if (errBytes > STDERR_CAP_BYTES) err = err.slice(-STDERR_CAP_BYTES);
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+          if (overflowed) return;
+          if (code === 0) {
+            resolve7({ stdout: out });
+            return;
+          }
+          const tail = err.length > 0 ? ` \u2014 stderr: ${err.slice(-STDERR_TAIL_BYTES)}` : "";
+          reject(new Error(`exited with code ${code}${tail}`));
+        });
+      });
+    };
+    EMPTY_TIER = { findings: [], ranLlmTier: false, requiredRunnerFailed: false };
     EM_DASH2 = "\u2014";
     STATUS_RANK = {
       backlog: 0,
@@ -18162,6 +19245,9 @@ var init_dist3 = __esm({
       "in-progress": 2,
       done: 3
     };
+    EM_DASH3 = "\u2014";
+    DEFAULT_MILESTONE = "Intake";
+    MAX_CLOSEST_MATCHES = 3;
     RETRY_DEFAULTS = { maxRetries: 5, baseDelayMs: 1e3 };
     GitHubIssuesSyncAdapter = class {
       token;
@@ -19130,28 +20216,31 @@ ${JSON.stringify(event)}`;
       runMigrationPlan: () => runMigrationPlan
     });
     HASH_RE = /<!--\s*harness-history\s+hash:([0-9a-f]{8})\s*-->/i;
-    InteractionTypeSchema = z12.enum(["question", "confirmation", "transition"]);
-    QuestionSchema = z12.object({
-      text: z12.string(),
-      options: z12.array(z12.string()).optional(),
-      default: z12.string().optional()
+    DEFAULT_CATCH_ALL = ["Backlog", "Current Work"];
+    DEFAULT_INTAKE = "Intake";
+    DEFAULT_MAX_ACTIVE = 25;
+    InteractionTypeSchema = z13.enum(["question", "confirmation", "transition"]);
+    QuestionSchema = z13.object({
+      text: z13.string(),
+      options: z13.array(z13.string()).optional(),
+      default: z13.string().optional()
     });
-    ConfirmationSchema = z12.object({
-      text: z12.string(),
-      context: z12.string()
+    ConfirmationSchema = z13.object({
+      text: z13.string(),
+      context: z13.string()
     });
-    TransitionSchema = z12.object({
-      completedPhase: z12.string(),
-      suggestedNext: z12.string(),
-      reason: z12.string(),
-      artifacts: z12.array(z12.string()),
-      requiresConfirmation: z12.boolean(),
-      summary: z12.string()
+    TransitionSchema = z13.object({
+      completedPhase: z13.string(),
+      suggestedNext: z13.string(),
+      reason: z13.string(),
+      artifacts: z13.array(z13.string()),
+      requiresConfirmation: z13.boolean(),
+      summary: z13.string()
     });
-    EmitInteractionInputSchema = z12.object({
-      path: z12.string(),
+    EmitInteractionInputSchema = z13.object({
+      path: z13.string(),
       type: InteractionTypeSchema,
-      stream: z12.string().optional(),
+      stream: z13.string().optional(),
       question: QuestionSchema.optional(),
       confirmation: ConfirmationSchema.optional(),
       transition: TransitionSchema.optional()
@@ -19162,10 +20251,10 @@ ${JSON.stringify(event)}`;
       }
       rootDir;
       async scan() {
-        let projectName = path37.basename(this.rootDir);
+        let projectName = path36.basename(this.rootDir);
         try {
-          const pkgPath = path37.join(this.rootDir, "package.json");
-          const pkgRaw = await fs37.readFile(pkgPath, "utf-8");
+          const pkgPath = path36.join(this.rootDir, "package.json");
+          const pkgRaw = await fs36.readFile(pkgPath, "utf-8");
           const pkg = JSON.parse(pkgRaw);
           if (pkg.name) projectName = pkg.name;
         } catch {
@@ -19278,8 +20367,8 @@ console.log('Blueprint player initialized.');
           styles: STYLES,
           scripts: SCRIPTS
         });
-        await fs38.mkdir(options.outputDir, { recursive: true });
-        await fs38.writeFile(path38.join(options.outputDir, "index.html"), html);
+        await fs37.mkdir(options.outputDir, { recursive: true });
+        await fs37.writeFile(path37.join(options.outputDir, "index.html"), html);
       }
     };
     TOKENS_PER_MILLION = 1e6;
@@ -19641,7 +20730,7 @@ console.log('Blueprint player initialized.');
             }
             const backoff = RETRY_BACKOFFS_MS[attempt] ?? 0;
             if (attempt < RETRY_BACKOFFS_MS.length - 1) {
-              await new Promise((resolve6) => setTimeout(resolve6, backoff));
+              await new Promise((resolve7) => setTimeout(resolve7, backoff));
             }
           }
           this.warn(
@@ -19678,6 +20767,342 @@ console.log('Blueprint player initialized.');
       SpanKind2[SpanKind2["CONSUMER"] = 5] = "CONSUMER";
       return SpanKind2;
     })(SpanKind || {});
+    ModeSchema = z14.enum(["adopter", "toolkit"]);
+    SeveritySchema = z14.enum(["error", "warning", "info"]);
+    TierSchema = z14.enum(["solid", "at-risk", "theatre"]);
+    StrengthFindingSchema = z14.object({
+      id: z14.string(),
+      // e.g. "STRENGTH-001"
+      gearPiece: z14.string(),
+      // label only (v1) — gear piece this defends
+      severity: SeveritySchema,
+      file: z14.string(),
+      // relative to root
+      line: z14.number().int().positive().optional(),
+      // when locatable
+      message: z14.string(),
+      // what's wrong
+      remediation: z14.string()
+      // concrete fix
+    });
+    HarnessConfigSubsetSchema = z14.object({
+      layers: z14.array(z14.unknown()).optional(),
+      architecture: z14.object({ thresholds: z14.record(z14.unknown()).optional() }).passthrough().optional(),
+      template: z14.object({ level: z14.string().optional() }).passthrough().optional(),
+      audit: z14.object({
+        harnessStrength: z14.object({ severities: z14.record(SeveritySchema).optional() }).passthrough().optional()
+      }).passthrough().optional()
+    }).passthrough();
+    HookFileSchema = z14.object({
+      name: z14.string(),
+      path: z14.string(),
+      text: z14.string()
+    });
+    ProjectContextSchema = z14.object({
+      root: z14.string(),
+      mode: ModeSchema,
+      config: HarnessConfigSubsetSchema.nullable(),
+      preCommit: z14.string().nullable(),
+      hookFiles: z14.array(HookFileSchema),
+      workflows: z14.array(z14.object({ path: z14.string(), text: z14.string() })),
+      healthSnapshot: z14.unknown().nullable(),
+      templates: z14.array(z14.object({ path: z14.string(), text: z14.string() })).optional(),
+      initSkill: z14.string().nullable().optional()
+    });
+    AuditSummarySchema = z14.object({
+      errors: z14.number().int().nonnegative(),
+      warnings: z14.number().int().nonnegative(),
+      info: z14.number().int().nonnegative(),
+      rulesRun: z14.number().int().nonnegative(),
+      rulesPassing: z14.number().int().nonnegative()
+    });
+    AuditResultSchema = z14.object({
+      mode: ModeSchema,
+      score: z14.number().min(0).max(100),
+      tier: TierSchema,
+      findings: z14.array(StrengthFindingSchema),
+      summary: AuditSummarySchema
+    });
+    SEVERITY_WEIGHTS = {
+      error: 14,
+      warning: 6,
+      info: 2
+    };
+    clamp = (n, lo, hi) => Math.max(lo, Math.min(hi, n));
+    HOOK_SCRIPT_TOKEN = /(?:^|[\s"'])([^\s"']+\.(?:sh|mjs|cjs|js|ts))(?=$|[\s"'])/g;
+    NEVER_BLOCKS = /never\s+blocks/i;
+    ALWAYS_EXIT_ZERO = /always\s+exits?\s+0/i;
+    EXIT_ZERO_LINE = /^\s*exit\s+0\s*$/;
+    NONZERO_EXIT = /\bexit\s+[1-9]\b/;
+    GATE = /\bif\b|\|\||&&|\bthen\b/;
+    ERREXIT = /\bset\s+-(?:[a-df-z]*e[a-z]*|o\s+errexit)\b/;
+    strength001NonblockingHooks = {
+      id: "STRENGTH-001",
+      gearPiece: "blocking-gate",
+      defaultSeverity: "error",
+      appliesIn: () => true,
+      evaluable: (ctx) => ctx.hookFiles.length > 0,
+      detect(ctx) {
+        const findings = [];
+        for (const hook of ctx.hookFiles) {
+          const lines = hook.text.split("\n");
+          let line;
+          const markerIdx = lines.findIndex((l) => NEVER_BLOCKS.test(l) || ALWAYS_EXIT_ZERO.test(l));
+          if (markerIdx >= 0) {
+            line = markerIdx + 1;
+          } else {
+            const exitIdx = lines.findIndex((l) => EXIT_ZERO_LINE.test(l));
+            const code = stripComments(hook.text);
+            const hasGuard = NONZERO_EXIT.test(code) || GATE.test(code) || ERREXIT.test(code);
+            if (exitIdx >= 0 && !hasGuard) {
+              line = exitIdx + 1;
+            }
+          }
+          if (line !== void 0) {
+            findings.push({
+              id: "STRENGTH-001",
+              gearPiece: "blocking-gate",
+              file: hook.path,
+              line,
+              message: `Hook "${hook.name}" cannot block the commit \u2014 it always succeeds, so a regression passes through.`,
+              remediation: 'Remove the unconditional `exit 0` / "never blocks" escape hatch so the hook fails (non-zero exit) when a check fails.'
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    BASELINE_REWRITE = /--update-baseline|(?:check-arch|baselines?\.json).*(?:--update-baseline|>\s*\S*baselines?\.json)/i;
+    strength002Autobaseline = {
+      id: "STRENGTH-002",
+      gearPiece: "regression-baseline",
+      defaultSeverity: "error",
+      appliesIn: () => true,
+      evaluable: (ctx) => ctx.preCommit !== null,
+      detect(ctx) {
+        if (ctx.preCommit === null) return [];
+        const idx = findRewriteInFailureBranch(ctx.preCommit.split("\n"));
+        if (idx < 0) return [];
+        return [
+          {
+            id: "STRENGTH-002",
+            gearPiece: "regression-baseline",
+            file: ".husky/pre-commit",
+            line: idx + 1,
+            message: "pre-commit auto-rewrites the baseline inside a failure branch \u2014 regressions are silently absorbed instead of blocking the commit.",
+            remediation: "Remove the auto `--update-baseline` from the failure path; let the hook fail and update baselines deliberately in a separate, reviewed step."
+          }
+        ];
+      }
+    };
+    SKIP_RE = /--skip[= ]+([\w,-]+)/;
+    strength003SkipList = {
+      id: "STRENGTH-003",
+      gearPiece: "skip-discipline",
+      defaultSeverity: "warning",
+      appliesIn: () => true,
+      evaluable: (ctx) => ctx.preCommit !== null,
+      detect(ctx) {
+        if (ctx.preCommit === null) return [];
+        const lines = ctx.preCommit.split("\n");
+        const findings = [];
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          const m = SKIP_RE.exec(line);
+          if (!m) continue;
+          const categories = m[1].split(",").filter(Boolean);
+          if (categories.length <= 2) continue;
+          const afterSkip = line.slice(m.index + m[0].length);
+          if (/(^|\s)#/.test(afterSkip)) continue;
+          findings.push({
+            id: "STRENGTH-003",
+            gearPiece: "skip-discipline",
+            file: ".husky/pre-commit",
+            line: i + 1,
+            message: `pre-commit skips ${categories.length} check categories (${categories.join(", ")}) with no inline justification \u2014 the local gate barely guards anything.`,
+            remediation: "Reduce the --skip list to at most 2 categories, or add an inline `# justified: ...` comment explaining why each is deferred (e.g. runs in CI)."
+          });
+        }
+        return findings;
+      }
+    };
+    strength004EmptyThresholds = {
+      id: "STRENGTH-004",
+      gearPiece: "architecture-thresholds",
+      defaultSeverity: "error",
+      appliesIn: () => true,
+      evaluable: (ctx) => ctx.config !== null || ctx.mode === "toolkit" && (ctx.templates?.length ?? 0) > 0,
+      detect(ctx) {
+        const findings = [];
+        if (thresholdsEmpty(ctx.config)) {
+          findings.push(makeFinding3("harness.config.json"));
+        }
+        if (ctx.mode === "toolkit") {
+          for (const tpl of ctx.templates ?? []) {
+            if (!tpl.path.endsWith("harness.config.json.hbs")) continue;
+            let parsed;
+            try {
+              parsed = JSON.parse(tpl.text);
+            } catch {
+              continue;
+            }
+            if (thresholdsEmpty(parsed)) findings.push(makeFinding3(tpl.path));
+          }
+        }
+        return findings;
+      }
+    };
+    INIT_SKILL_PATH = "agents/skills/claude-code/initialize-harness-project/SKILL.md";
+    DEFAULT_BASIC = /default(?:s| recommendation)?[^\n]*\bbasic\b|\bbasic\b[^\n]*\b(?:default|recommend)/i;
+    strength005LowestTier = {
+      id: "STRENGTH-005",
+      gearPiece: "tier-default",
+      defaultSeverity: "warning",
+      appliesIn: () => true,
+      evaluable: (ctx) => ctx.mode === "adopter" ? ctx.config !== null : (ctx.initSkill ?? null) !== null,
+      detect(ctx) {
+        if (ctx.mode === "adopter") {
+          if (ctx.config?.template?.level === "basic") {
+            return [
+              {
+                id: "STRENGTH-005",
+                gearPiece: "tier-default",
+                file: "harness.config.json",
+                message: "Project is pinned to the `basic` tier \u2014 the weakest gate set. Most projects warrant `standard` or higher.",
+                remediation: "Raise `template.level` to `standard` (or higher) unless `basic` is a deliberate, documented choice."
+              }
+            ];
+          }
+          return [];
+        }
+        const text = ctx.initSkill ?? null;
+        if (text === null) return [];
+        const lines = text.split("\n");
+        const idx = lines.findIndex((l) => DEFAULT_BASIC.test(l));
+        if (idx < 0) return [];
+        return [
+          {
+            id: "STRENGTH-005",
+            gearPiece: "tier-default",
+            file: INIT_SKILL_PATH,
+            line: idx + 1,
+            message: "The init skill recommends the `basic` tier by default \u2014 new projects ship with the weakest gate set.",
+            remediation: "Change the default recommendation to `standard` so new projects start with a meaningful gate set."
+          }
+        ];
+      }
+    };
+    AUTO_PATTERN = /auto-?approve|auto-?merge|--auto\b|enable-pull-request-automerge/i;
+    COMMENT_LINE = /^\s*#/;
+    NAME_VALUE_LINE = /^\s*(?:-\s*)?name\s*:/i;
+    PAT_GATING = /secrets\.(?!GITHUB_TOKEN\b)\w*(?:PAT|TOKEN)\w*/;
+    REVIEW_SIGNAL = /required_reviewers|approvals?\s*:\s*[1-9]|CODEOWNERS|github\.event\.review\.state\s*==\s*['"]approved['"]/i;
+    strength006AutoapproveBaseline = {
+      id: "STRENGTH-006",
+      gearPiece: "review-gate",
+      defaultSeverity: "error",
+      appliesIn: () => true,
+      evaluable: (ctx) => ctx.workflows.length > 0,
+      detect(ctx) {
+        const findings = [];
+        for (const wf of ctx.workflows) {
+          const hasAuto = hasAutoStep(wf.text);
+          const hasPat = PAT_GATING.test(wf.text);
+          const hasReview = REVIEW_SIGNAL.test(wf.text);
+          if (hasAuto && hasPat && !hasReview) {
+            const lines = wf.text.split("\n");
+            const idx = lines.findIndex(isAutoLine);
+            findings.push({
+              id: "STRENGTH-006",
+              gearPiece: "review-gate",
+              file: wf.path,
+              ...idx >= 0 ? { line: idx + 1 } : {},
+              message: "Workflow auto-approves/auto-merges a PR using a token with no independent-review gate \u2014 the bot can rubber-stamp its own changes.",
+              remediation: "Gate auto-merge behind a human review (e.g. require an approved review, required_reviewers, or CODEOWNERS) instead of a PAT alone."
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    CHECK_SIGNAL_MAP = {
+      security: "security-findings",
+      entropy: "entropy-drift",
+      deps: "dependency-violations",
+      perf: "perf-regression",
+      docs: "doc-coverage",
+      lint: "lint-issues"
+    };
+    strength007SnapshotSignalMismatch = {
+      id: "STRENGTH-007",
+      gearPiece: "snapshot-honesty",
+      defaultSeverity: "error",
+      appliesIn: () => true,
+      evaluable: (ctx) => isSnapshot(ctx.healthSnapshot),
+      detect(ctx) {
+        if (!isSnapshot(ctx.healthSnapshot)) return [];
+        const { checks, signals } = ctx.healthSnapshot;
+        const present = new Set(Array.isArray(signals) ? signals : []);
+        const findings = [];
+        for (const [check, result] of Object.entries(checks)) {
+          const signal = CHECK_SIGNAL_MAP[check];
+          if (signal === void 0) continue;
+          if (result?.passed === true && present.has(signal)) {
+            findings.push({
+              id: "STRENGTH-007",
+              gearPiece: "snapshot-honesty",
+              file: ".harness/health-snapshot.json",
+              message: `Health snapshot reports the "${check}" check as passing while the contradicting signal "${signal}" is present \u2014 the snapshot is dishonest.`,
+              remediation: `Reconcile the snapshot: either the "${check}" check did not actually pass, or the "${signal}" signal is stale. Regenerate the snapshot from a clean run.`
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    ALL_RULES = [
+      strength001NonblockingHooks,
+      strength002Autobaseline,
+      strength003SkipList,
+      strength004EmptyThresholds,
+      strength005LowestTier,
+      strength006AutoapproveBaseline,
+      strength007SnapshotSignalMismatch
+    ];
+    HarnessStrengthAuditor = class {
+      audit(root, opts = {}) {
+        try {
+          const mode = resolveMode(opts, root);
+          const ctx = buildProjectContext(root, mode);
+          const evaluable = ALL_RULES.filter(
+            (r) => r.appliesIn(mode) && (r.evaluable ? r.evaluable(ctx) : true)
+          );
+          const findings = [];
+          let rulesPassing = 0;
+          for (const rule of evaluable) {
+            const raw = rule.detect(ctx);
+            if (raw.length === 0) {
+              rulesPassing++;
+              continue;
+            }
+            const severity = severityFor(rule, ctx);
+            for (const f of raw) findings.push({ ...f, severity });
+          }
+          const { score, tier } = rollupScore(findings);
+          const summary = {
+            errors: findings.filter((f) => f.severity === "error").length,
+            warnings: findings.filter((f) => f.severity === "warning").length,
+            info: findings.filter((f) => f.severity === "info").length,
+            rulesRun: evaluable.length,
+            rulesPassing
+          };
+          return Ok({ mode, score, tier, findings, summary });
+        } catch (err) {
+          return Err(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+    };
+    MAX_TOP_AFFECTED = 5;
     CompoundLockHeldError = class extends Error {
       constructor(category, holderPid, lockPath) {
         super(
@@ -19693,6 +21118,18 @@ console.log('Blueprint player initialized.');
       lockPath;
     };
     KNOWN_CATEGORIES = new Set(ALL_SOLUTION_CATEGORIES);
+    ProposalNotFoundError = class extends Error {
+      constructor(id) {
+        super(`proposal not found: ${id}`);
+        this.name = "ProposalNotFoundError";
+      }
+    };
+    ProposalConflictError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "ProposalConflictError";
+      }
+    };
     ALLOWED_FIELD_KEYS = [
       "event_name",
       "count",
@@ -19822,18 +21259,6 @@ console.log('Blueprint player initialized.');
       ...OPTIONAL_STRATEGY_SECTIONS
     ];
     FILENAME = "STRATEGY.md";
-    ProposalNotFoundError = class extends Error {
-      constructor(id) {
-        super(`proposal not found: ${id}`);
-        this.name = "ProposalNotFoundError";
-      }
-    };
-    ProposalConflictError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "ProposalConflictError";
-      }
-    };
   }
 });
 
@@ -19933,7 +21358,6 @@ export {
   PatternConfigSchema,
   EntropyConfigSchema,
   validatePatternConfig,
-  composeInsights,
   BaselineManager,
   BenchmarkRunner,
   RegressionDetector,
@@ -20165,11 +21589,34 @@ export {
   splitBundlesByStage,
   runReviewPipeline,
   findParallelGroups,
+  CI_REVIEW_VERDICT_SCHEMA_VERSION,
+  CI_RUNNERS,
+  CI_ASSESSMENTS,
+  CI_REVIEW_DOMAINS,
+  deriveBlockingFindings,
+  deriveExitCode,
+  CiReviewVerdictSchema,
+  parseCiReviewVerdict,
+  buildCiReviewVerdict,
+  parseClaudeVerdict,
+  parseCodexVerdict,
+  parseAntigravityVerdict,
+  parseLocalVerdict,
+  RUNNER_PRESETS,
+  presetKind,
+  isSupportedRunner,
+  parseGeminiVerdict,
+  DEFAULT_EXEC_TIMEOUT_MS,
+  DEFAULT_EXEC_MAX_STDOUT_BYTES,
+  defaultExecFile,
+  runCiReview,
   serializeRoadmap,
   STATUS_RANK,
   isRegression,
   syncRoadmap,
   applySyncChanges,
+  decidePromotionForRow,
+  promoteFeature,
   resolveReverseStatus,
   GitHubIssuesSyncAdapter,
   loadTrackerSyncConfig,
@@ -20187,6 +21634,10 @@ export {
   loadProjectRoadmapMode,
   loadTrackerClientConfigFromProject,
   migrate_exports,
+  defaultIsArchive,
+  isUnactionablePlanned,
+  checkRoadmapHealth,
+  groomRoadmap,
   InteractionTypeSchema,
   QuestionSchema,
   ConfirmationSchema,
@@ -20219,7 +21670,6 @@ export {
   aggregateBySkill,
   aggregateByDay2,
   topSkills,
-  loadNotificationsConfig,
   StructuralStrategy,
   DEFAULT_TOKEN_BUDGET,
   TruncationStrategy,
@@ -20238,8 +21688,33 @@ export {
   CacheMetricsRecorder,
   OTLPExporter,
   SpanKind,
+  ModeSchema,
+  SeveritySchema,
+  TierSchema,
+  StrengthFindingSchema,
+  HarnessConfigSubsetSchema,
+  HookFileSchema,
+  ProjectContextSchema,
+  AuditSummarySchema,
+  AuditResultSchema,
+  SEVERITY_WEIGHTS,
+  rollupScore,
+  resolveMode,
+  buildProjectContext,
+  ALL_RULES,
+  HarnessStrengthAuditor,
+  composeInsights,
   CompoundLockHeldError,
   acquireCompoundLock,
+  loadNotificationsConfig,
+  proposalsDir,
+  ProposalNotFoundError,
+  ProposalConflictError,
+  createProposal,
+  getProposal,
+  listProposals,
+  updateProposal,
+  deriveSkillUsage,
   ALLOWED_FIELD_KEYS,
   PII_TOKENS,
   PII_FIELD_DENYLIST,
@@ -20269,14 +21744,6 @@ export {
   assembleCandidateReport,
   serializeStrategyDoc,
   writeStrategyDoc,
-  proposalsDir,
-  ProposalNotFoundError,
-  ProposalConflictError,
-  createProposal,
-  getProposal,
-  listProposals,
-  updateProposal,
-  deriveSkillUsage,
   dist_exports,
   init_dist3 as init_dist
 };