@harness-engineering/core 0.10.1 → 0.11.0

package/dist/index.js

@@ -34,33 +34,58 @@ __export(index_exports, {
   AGENT_DESCRIPTORS: () => AGENT_DESCRIPTORS,
   ARCHITECTURE_DESCRIPTOR: () => ARCHITECTURE_DESCRIPTOR,
   AgentActionEmitter: () => AgentActionEmitter,
+  ArchBaselineManager: () => ArchBaselineManager,
+  ArchBaselineSchema: () => ArchBaselineSchema,
+  ArchConfigSchema: () => ArchConfigSchema,
+  ArchDiffResultSchema: () => ArchDiffResultSchema,
+  ArchMetricCategorySchema: () => ArchMetricCategorySchema,
   BUG_DETECTION_DESCRIPTOR: () => BUG_DETECTION_DESCRIPTOR,
   BaselineManager: () => BaselineManager,
   BenchmarkRunner: () => BenchmarkRunner,
+  BlueprintGenerator: () => BlueprintGenerator,
+  BundleConstraintsSchema: () => BundleConstraintsSchema,
+  BundleSchema: () => BundleSchema,
   COMPLIANCE_DESCRIPTOR: () => COMPLIANCE_DESCRIPTOR,
+  CategoryBaselineSchema: () => CategoryBaselineSchema,
+  CategoryRegressionSchema: () => CategoryRegressionSchema,
   ChecklistBuilder: () => ChecklistBuilder,
+  CircularDepsCollector: () => CircularDepsCollector,
+  ComplexityCollector: () => ComplexityCollector,
   ConfirmationSchema: () => ConfirmationSchema,
   ConsoleSink: () => ConsoleSink,
+  ConstraintRuleSchema: () => ConstraintRuleSchema,
+  ContentPipeline: () => ContentPipeline,
+  ContributionsSchema: () => ContributionsSchema,
+  CouplingCollector: () => CouplingCollector,
   CriticalPathResolver: () => CriticalPathResolver,
   DEFAULT_PROVIDER_TIERS: () => DEFAULT_PROVIDER_TIERS,
   DEFAULT_SECURITY_CONFIG: () => DEFAULT_SECURITY_CONFIG,
   DEFAULT_STATE: () => DEFAULT_STATE,
   DEFAULT_STREAM_INDEX: () => DEFAULT_STREAM_INDEX,
+  DepDepthCollector: () => DepDepthCollector,
   EmitInteractionInputSchema: () => EmitInteractionInputSchema,
   EntropyAnalyzer: () => EntropyAnalyzer,
   EntropyConfigSchema: () => EntropyConfigSchema,
   ExclusionSet: () => ExclusionSet,
   FailureEntrySchema: () => FailureEntrySchema,
   FileSink: () => FileSink,
+  ForbiddenImportCollector: () => ForbiddenImportCollector,
   GateConfigSchema: () => GateConfigSchema,
   GateResultSchema: () => GateResultSchema,
   HandoffSchema: () => HandoffSchema,
   HarnessStateSchema: () => HarnessStateSchema,
   InteractionTypeSchema: () => InteractionTypeSchema,
+  LayerViolationCollector: () => LayerViolationCollector,
+  LockfilePackageSchema: () => LockfilePackageSchema,
+  LockfileSchema: () => LockfileSchema,
+  ManifestSchema: () => ManifestSchema,
+  MetricResultSchema: () => MetricResultSchema,
+  ModuleSizeCollector: () => ModuleSizeCollector,
   NoOpExecutor: () => NoOpExecutor,
   NoOpSink: () => NoOpSink,
   NoOpTelemetryAdapter: () => NoOpTelemetryAdapter,
   PatternConfigSchema: () => PatternConfigSchema,
+  ProjectScanner: () => ProjectScanner,
   QuestionSchema: () => QuestionSchema,
   REQUIRED_SECTIONS: () => REQUIRED_SECTIONS,
   RegressionDetector: () => RegressionDetector,
@@ -68,16 +93,26 @@ __export(index_exports, {
   SECURITY_DESCRIPTOR: () => SECURITY_DESCRIPTOR,
   SecurityConfigSchema: () => SecurityConfigSchema,
   SecurityScanner: () => SecurityScanner,
+  SharableBoundaryConfigSchema: () => SharableBoundaryConfigSchema,
+  SharableForbiddenImportSchema: () => SharableForbiddenImportSchema,
+  SharableLayerSchema: () => SharableLayerSchema,
+  SharableSecurityRulesSchema: () => SharableSecurityRulesSchema,
   StreamIndexSchema: () => StreamIndexSchema,
   StreamInfoSchema: () => StreamInfoSchema,
+  ThresholdConfigSchema: () => ThresholdConfigSchema,
   TransitionSchema: () => TransitionSchema,
   TypeScriptParser: () => TypeScriptParser,
   VERSION: () => VERSION,
+  ViolationSchema: () => ViolationSchema,
+  addProvenance: () => addProvenance,
   analyzeDiff: () => analyzeDiff,
   appendFailure: () => appendFailure,
   appendLearning: () => appendLearning,
   applyFixes: () => applyFixes,
   applyHotspotDowngrade: () => applyHotspotDowngrade,
+  archMatchers: () => archMatchers,
+  archModule: () => archModule,
+  architecture: () => architecture,
   archiveFailures: () => archiveFailures,
   archiveStream: () => archiveStream,
   buildDependencyGraph: () => buildDependencyGraph,
@@ -87,6 +122,7 @@ __export(index_exports, {
   checkEligibility: () => checkEligibility,
   classifyFinding: () => classifyFinding,
   configureFeedback: () => configureFeedback,
+  constraintRuleId: () => constraintRuleId,
   contextBudget: () => contextBudget,
   contextFilter: () => contextFilter,
   createBoundaryValidator: () => createBoundaryValidator,
@@ -101,6 +137,8 @@ __export(index_exports, {
   cryptoRules: () => cryptoRules,
   deduplicateCleanupFindings: () => deduplicateCleanupFindings,
   deduplicateFindings: () => deduplicateFindings,
+  deepMergeConstraints: () => deepMergeConstraints,
+  defaultCollectors: () => defaultCollectors,
   defineLayer: () => defineLayer,
   deserializationRules: () => deserializationRules,
   detectChangeType: () => detectChangeType,
@@ -113,9 +151,12 @@ __export(index_exports, {
   detectPatternViolations: () => detectPatternViolations,
   detectSizeBudgetViolations: () => detectSizeBudgetViolations,
   detectStack: () => detectStack,
+  detectStaleConstraints: () => detectStaleConstraints,
   determineAssessment: () => determineAssessment,
+  diff: () => diff,
   executeWorkflow: () => executeWorkflow,
   expressRules: () => expressRules,
+  extractBundle: () => extractBundle,
   extractMarkdownLinks: () => extractMarkdownLinks,
   extractSections: () => extractSections,
   fanOutReview: () => fanOutReview,
@@ -146,6 +187,7 @@ __export(index_exports, {
   networkRules: () => networkRules,
   nodeRules: () => nodeRules,
   parseDiff: () => parseDiff,
+  parseManifest: () => parseManifest,
   parseRoadmap: () => parseRoadmap,
   parseSecurityConfig: () => parseSecurityConfig,
   parseSize: () => parseSize,
@@ -153,6 +195,8 @@ __export(index_exports, {
   previewFix: () => previewFix,
   reactRules: () => reactRules,
   readCheckState: () => readCheckState,
+  readLockfile: () => readLockfile,
+  removeProvenance: () => removeProvenance,
   requestMultiplePeerReviews: () => requestMultiplePeerReviews,
   requestPeerReview: () => requestPeerReview,
   resetFeedbackConfig: () => resetFeedbackConfig,
@@ -160,6 +204,8 @@ __export(index_exports, {
   resolveModelTier: () => resolveModelTier,
   resolveRuleSeverity: () => resolveRuleSeverity,
   resolveStreamPath: () => resolveStreamPath,
+  resolveThresholds: () => resolveThresholds,
+  runAll: () => runAll,
   runArchitectureAgent: () => runArchitectureAgent,
   runBugDetectionAgent: () => runBugDetectionAgent,
   runCIChecks: () => runCIChecks,
@@ -179,6 +225,7 @@ __export(index_exports, {
   setActiveStream: () => setActiveStream,
   shouldRunCheck: () => shouldRunCheck,
   spawnBackgroundCheck: () => spawnBackgroundCheck,
+  syncConstraintNodes: () => syncConstraintNodes,
   syncRoadmap: () => syncRoadmap,
   touchStream: () => touchStream,
   trackAction: () => trackAction,
@@ -191,6 +238,9 @@ __export(index_exports, {
   validateFindings: () => validateFindings,
   validateKnowledgeMap: () => validateKnowledgeMap,
   validatePatternConfig: () => validatePatternConfig,
+  violationId: () => violationId,
+  writeConfig: () => writeConfig,
+  writeLockfile: () => writeLockfile,
   xssRules: () => xssRules
 });
 module.exports = __toCommonJS(index_exports);
@@ -213,17 +263,17 @@ var import_util = require("util");
 var import_glob = require("glob");
 var accessAsync = (0, import_util.promisify)(import_fs.access);
 var readFileAsync = (0, import_util.promisify)(import_fs.readFile);
-async function fileExists(path11) {
+async function fileExists(path13) {
   try {
-    await accessAsync(path11, import_fs.constants.F_OK);
+    await accessAsync(path13, import_fs.constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function readFileContent(path11) {
+async function readFileContent(path13) {
   try {
-    const content = await readFileAsync(path11, "utf-8");
+    const content = await readFileAsync(path13, "utf-8");
     return (0, import_types.Ok)(content);
   } catch (error) {
     return (0, import_types.Err)(error);
@@ -271,15 +321,15 @@ function validateConfig(data, schema) {
   let message = "Configuration validation failed";
   const suggestions = [];
   if (firstError) {
-    const path11 = firstError.path.join(".");
-    const pathDisplay = path11 ? ` at "${path11}"` : "";
+    const path13 = firstError.path.join(".");
+    const pathDisplay = path13 ? ` at "${path13}"` : "";
     if (firstError.code === "invalid_type") {
       const received = firstError.received;
       const expected = firstError.expected;
       if (received === "undefined") {
         code = "MISSING_FIELD";
         message = `Missing required field${pathDisplay}: ${firstError.message}`;
-        suggestions.push(`Field "${path11}" is required and must be of type "${expected}"`);
+        suggestions.push(`Field "${path13}" is required and must be of type "${expected}"`);
       } else {
         code = "INVALID_TYPE";
         message = `Invalid type${pathDisplay}: ${firstError.message}`;
@@ -492,30 +542,30 @@ function extractSections(content) {
     return result;
   });
 }
-function isExternalLink(path11) {
-  return path11.startsWith("http://") || path11.startsWith("https://") || path11.startsWith("#") || path11.startsWith("mailto:");
+function isExternalLink(path13) {
+  return path13.startsWith("http://") || path13.startsWith("https://") || path13.startsWith("#") || path13.startsWith("mailto:");
 }
 function resolveLinkPath(linkPath, baseDir) {
   return linkPath.startsWith(".") ? (0, import_path.join)(baseDir, linkPath) : linkPath;
 }
-async function validateAgentsMap(path11 = "./AGENTS.md") {
+async function validateAgentsMap(path13 = "./AGENTS.md") {
   console.warn(
     "[harness] validateAgentsMap() is deprecated. Use graph-based validation via Assembler.checkCoverage() from @harness-engineering/graph"
   );
-  const contentResult = await readFileContent(path11);
+  const contentResult = await readFileContent(path13);
   if (!contentResult.ok) {
     return (0, import_types.Err)(
       createError(
         "PARSE_ERROR",
         `Failed to read AGENTS.md: ${contentResult.error.message}`,
-        { path: path11 },
+        { path: path13 },
         ["Ensure the file exists", "Check file permissions"]
       )
     );
   }
   const content = contentResult.value;
   const sections = extractSections(content);
-  const baseDir = (0, import_path.dirname)(path11);
+  const baseDir = (0, import_path.dirname)(path13);
   const sectionTitles = sections.map((s) => s.title);
   const missingSections = REQUIRED_SECTIONS.filter(
     (required) => !sectionTitles.some((title) => title.toLowerCase().includes(required.toLowerCase()))
@@ -555,6 +605,7 @@ async function validateAgentsMap(path11 = "./AGENTS.md") {
 }
 
 // src/context/doc-coverage.ts
+var import_minimatch = require("minimatch");
 var import_path2 = require("path");
 function determineImportance(filePath) {
   const name = (0, import_path2.basename)(filePath).toLowerCase();
@@ -577,7 +628,7 @@ function suggestSection(filePath, domain) {
   return `${domain} Reference`;
 }
 async function checkDocCoverage(domain, options = {}) {
-  const { docsDir = "./docs", sourceDir = "./src", excludePatterns = [], graphCoverage } = options;
+  const { docsDir = "./docs", sourceDir = ".", excludePatterns = [], graphCoverage } = options;
   if (graphCoverage) {
     const gaps = graphCoverage.undocumented.map((file) => ({
       file,
@@ -597,9 +648,7 @@ async function checkDocCoverage(domain, options = {}) {
     const filteredSourceFiles = sourceFiles.filter((file) => {
       const relativePath = (0, import_path2.relative)(sourceDir, file);
       return !excludePatterns.some((pattern) => {
-        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
-        const regex = new RegExp("^" + escaped + "$");
-        return regex.test(relativePath) || regex.test(file);
+        return (0, import_minimatch.minimatch)(relativePath, pattern, { dot: true }) || (0, import_minimatch.minimatch)(file, pattern, { dot: true });
       });
     });
     const docFiles = await findFiles("**/*.md", docsDir);
@@ -657,8 +706,8 @@ async function checkDocCoverage(domain, options = {}) {
 
 // src/context/knowledge-map.ts
 var import_path3 = require("path");
-function suggestFix(path11, existingFiles) {
-  const targetName = (0, import_path3.basename)(path11).toLowerCase();
+function suggestFix(path13, existingFiles) {
+  const targetName = (0, import_path3.basename)(path13).toLowerCase();
   const similar = existingFiles.find((file) => {
     const fileName = (0, import_path3.basename)(file).toLowerCase();
     return fileName.includes(targetName) || targetName.includes(fileName);
@@ -666,7 +715,7 @@ function suggestFix(path11, existingFiles) {
   if (similar) {
     return `Did you mean "${similar}"?`;
   }
-  return `Create the file "${path11}" or remove the link`;
+  return `Create the file "${path13}" or remove the link`;
 }
 async function validateKnowledgeMap(rootDir = process.cwd()) {
   console.warn(
@@ -1011,7 +1060,7 @@ function getPhaseCategories(phase) {
 }
 
 // src/constraints/layers.ts
-var import_minimatch = require("minimatch");
+var import_minimatch2 = require("minimatch");
 function defineLayer(name, patterns, allowedDependencies) {
   return {
     name,
@@ -1022,7 +1071,7 @@ function defineLayer(name, patterns, allowedDependencies) {
 function resolveFileToLayer(file, layers) {
   for (const layer of layers) {
     for (const pattern of layer.patterns) {
-      if ((0, import_minimatch.minimatch)(file, pattern)) {
+      if ((0, import_minimatch2.minimatch)(file, pattern)) {
         return layer;
       }
     }
@@ -1269,8 +1318,8 @@ function createBoundaryValidator(schema, name) {
         return (0, import_types.Ok)(result.data);
       }
       const suggestions = result.error.issues.map((issue) => {
-        const path11 = issue.path.join(".");
-        return path11 ? `${path11}: ${issue.message}` : issue.message;
+        const path13 = issue.path.join(".");
+        return path13 ? `${path13}: ${issue.message}` : issue.message;
       });
       return (0, import_types.Err)(
         createError(
@@ -1314,6 +1363,422 @@ function validateBoundaries(boundaries, data) {
   });
 }
 
+// src/constraints/sharing/types.ts
+var import_zod = require("zod");
+var ManifestSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  version: import_zod.z.string(),
+  description: import_zod.z.string().optional(),
+  include: import_zod.z.array(import_zod.z.string()).min(1),
+  minHarnessVersion: import_zod.z.string().optional(),
+  keywords: import_zod.z.array(import_zod.z.string()).optional().default([]),
+  layers: import_zod.z.record(import_zod.z.array(import_zod.z.string())).optional(),
+  boundaries: import_zod.z.array(
+    import_zod.z.object({
+      name: import_zod.z.string(),
+      layer: import_zod.z.string(),
+      direction: import_zod.z.enum(["input", "output"]),
+      schema: import_zod.z.string()
+    })
+  ).optional()
+});
+var BundleConstraintsSchema = import_zod.z.object({
+  layers: import_zod.z.array(
+    import_zod.z.object({
+      name: import_zod.z.string(),
+      pattern: import_zod.z.string(),
+      allowedDependencies: import_zod.z.array(import_zod.z.string())
+    })
+  ).optional(),
+  forbiddenImports: import_zod.z.array(
+    import_zod.z.object({
+      from: import_zod.z.string(),
+      disallow: import_zod.z.array(import_zod.z.string()),
+      message: import_zod.z.string().optional()
+    })
+  ).optional(),
+  boundaries: import_zod.z.object({
+    requireSchema: import_zod.z.array(import_zod.z.string()).optional()
+  }).optional(),
+  architecture: import_zod.z.object({
+    thresholds: import_zod.z.record(import_zod.z.unknown()).optional(),
+    modules: import_zod.z.record(import_zod.z.record(import_zod.z.unknown())).optional()
+  }).optional(),
+  security: import_zod.z.object({
+    rules: import_zod.z.record(import_zod.z.string()).optional()
+  }).optional()
+});
+var BundleSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  version: import_zod.z.string(),
+  description: import_zod.z.string().optional(),
+  minHarnessVersion: import_zod.z.string().optional(),
+  manifest: ManifestSchema,
+  constraints: BundleConstraintsSchema,
+  contributions: import_zod.z.record(import_zod.z.unknown()).optional()
+});
+var ContributionsSchema = import_zod.z.record(import_zod.z.unknown());
+var LockfilePackageSchema = import_zod.z.object({
+  version: import_zod.z.string(),
+  source: import_zod.z.string(),
+  installedAt: import_zod.z.string(),
+  contributions: import_zod.z.record(import_zod.z.unknown()).optional().nullable(),
+  resolved: import_zod.z.string().optional(),
+  integrity: import_zod.z.string().optional(),
+  provenance: import_zod.z.array(import_zod.z.string()).optional()
+});
+var LockfileSchema = import_zod.z.object({
+  version: import_zod.z.literal(1).optional(),
+  // Used by some tests
+  lockfileVersion: import_zod.z.literal(1).optional(),
+  // Standard field
+  packages: import_zod.z.record(LockfilePackageSchema)
+}).refine((data) => data.version !== void 0 || data.lockfileVersion !== void 0, {
+  message: "Either 'version' or 'lockfileVersion' must be present and equal to 1"
+});
+var SharableLayerSchema = import_zod.z.unknown();
+var SharableForbiddenImportSchema = import_zod.z.unknown();
+var SharableBoundaryConfigSchema = import_zod.z.unknown();
+var SharableSecurityRulesSchema = import_zod.z.unknown();
+
+// src/constraints/sharing/write-config.ts
+var fs = __toESM(require("fs/promises"));
+async function writeConfig(filePath, content) {
+  try {
+    const json = JSON.stringify(content, null, 2) + "\n";
+    await fs.writeFile(filePath, json, "utf-8");
+    return (0, import_types.Ok)(void 0);
+  } catch (error) {
+    return (0, import_types.Err)(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+
+// src/constraints/sharing/manifest.ts
+function parseManifest(parsed) {
+  const result = ManifestSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+    return { ok: false, error: `Invalid manifest: ${issues}` };
+  }
+  return { ok: true, value: result.data };
+}
+
+// src/constraints/sharing/bundle.ts
+function resolveDotPath(obj, dotPath) {
+  const segments = dotPath.split(".");
+  let current = obj;
+  for (const segment of segments) {
+    if (current === null || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function setDotPath(obj, dotPath, value) {
+  const segments = dotPath.split(".");
+  const lastSegment = segments[segments.length - 1];
+  const parentSegments = segments.slice(0, -1);
+  let current = obj;
+  for (const segment of parentSegments) {
+    if (current[segment] === void 0 || current[segment] === null || typeof current[segment] !== "object") {
+      current[segment] = {};
+    }
+    current = current[segment];
+  }
+  if (lastSegment !== void 0) {
+    current[lastSegment] = value;
+  }
+}
+function extractBundle(manifest, config) {
+  const constraints = {};
+  for (const includePath of manifest.include) {
+    const value = resolveDotPath(config, includePath);
+    if (value !== void 0) {
+      setDotPath(constraints, includePath, value);
+    }
+  }
+  const bundle = {
+    name: manifest.name,
+    version: manifest.version,
+    ...manifest.minHarnessVersion !== void 0 && {
+      minHarnessVersion: manifest.minHarnessVersion
+    },
+    ...manifest.description !== void 0 && {
+      description: manifest.description
+    },
+    manifest,
+    constraints
+  };
+  const parsed = BundleSchema.safeParse(bundle);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+    return { ok: false, error: `Invalid bundle: ${issues}` };
+  }
+  return { ok: true, value: parsed.data };
+}
+
+// src/constraints/sharing/merge.ts
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((val, i) => deepEqual(val, b[i]));
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  return keysA.every(
+    (key) => deepEqual(a[key], b[key])
+  );
+}
+function stringArraysEqual(a, b) {
+  if (a.length !== b.length) return false;
+  const sortedA = [...a].sort();
+  const sortedB = [...b].sort();
+  return sortedA.every((val, i) => val === sortedB[i]);
+}
+function deepMergeConstraints(localConfig, bundleConstraints, _existingContributions) {
+  const config = { ...localConfig };
+  const contributions = {};
+  const conflicts = [];
+  if (bundleConstraints.layers && bundleConstraints.layers.length > 0) {
+    const localLayers = Array.isArray(localConfig.layers) ? localConfig.layers : [];
+    const mergedLayers = [...localLayers];
+    const contributedLayerNames = [];
+    for (const bundleLayer of bundleConstraints.layers) {
+      const existing = localLayers.find((l) => l.name === bundleLayer.name);
+      if (!existing) {
+        mergedLayers.push(bundleLayer);
+        contributedLayerNames.push(bundleLayer.name);
+      } else {
+        const same = existing.pattern === bundleLayer.pattern && stringArraysEqual(existing.allowedDependencies, bundleLayer.allowedDependencies);
+        if (!same) {
+          conflicts.push({
+            section: "layers",
+            key: bundleLayer.name,
+            localValue: existing,
+            packageValue: bundleLayer,
+            description: `Layer '${bundleLayer.name}' already exists locally with different configuration`
+          });
+        }
+      }
+    }
+    config.layers = mergedLayers;
+    if (contributedLayerNames.length > 0) {
+      contributions.layers = contributedLayerNames;
+    }
+  }
+  if (bundleConstraints.forbiddenImports && bundleConstraints.forbiddenImports.length > 0) {
+    const localFI = Array.isArray(localConfig.forbiddenImports) ? localConfig.forbiddenImports : [];
+    const mergedFI = [...localFI];
+    const contributedFromKeys = [];
+    for (const bundleRule of bundleConstraints.forbiddenImports) {
+      const existing = localFI.find((r) => r.from === bundleRule.from);
+      if (!existing) {
+        const entry = {
+          from: bundleRule.from,
+          disallow: bundleRule.disallow
+        };
+        if (bundleRule.message !== void 0) {
+          entry.message = bundleRule.message;
+        }
+        mergedFI.push(entry);
+        contributedFromKeys.push(bundleRule.from);
+      } else {
+        const same = stringArraysEqual(existing.disallow, bundleRule.disallow);
+        if (!same) {
+          conflicts.push({
+            section: "forbiddenImports",
+            key: bundleRule.from,
+            localValue: existing,
+            packageValue: bundleRule,
+            description: `Forbidden import rule for '${bundleRule.from}' already exists locally with different disallow list`
+          });
+        }
+      }
+    }
+    config.forbiddenImports = mergedFI;
+    if (contributedFromKeys.length > 0) {
+      contributions.forbiddenImports = contributedFromKeys;
+    }
+  }
+  if (bundleConstraints.boundaries) {
+    const localBoundaries = localConfig.boundaries ?? { requireSchema: [] };
+    const localSchemas = new Set(localBoundaries.requireSchema ?? []);
+    const bundleSchemas = bundleConstraints.boundaries.requireSchema ?? [];
+    const newSchemas = [];
+    for (const schema of bundleSchemas) {
+      if (!localSchemas.has(schema)) {
+        newSchemas.push(schema);
+        localSchemas.add(schema);
+      }
+    }
+    config.boundaries = {
+      requireSchema: [...localBoundaries.requireSchema ?? [], ...newSchemas]
+    };
+    if (newSchemas.length > 0) {
+      contributions.boundaries = newSchemas;
+    }
+  }
+  if (bundleConstraints.architecture) {
+    const localArch = localConfig.architecture ?? {
+      enabled: true,
+      baselinePath: ".harness/arch/baselines.json",
+      thresholds: {},
+      modules: {}
+    };
+    const mergedThresholds = { ...localArch.thresholds };
+    const contributedThresholdKeys = [];
+    const bundleThresholds = bundleConstraints.architecture.thresholds ?? {};
+    for (const [category, value] of Object.entries(bundleThresholds)) {
+      if (!(category in mergedThresholds)) {
+        mergedThresholds[category] = value;
+        contributedThresholdKeys.push(category);
+      } else if (!deepEqual(mergedThresholds[category], value)) {
+        conflicts.push({
+          section: "architecture.thresholds",
+          key: category,
+          localValue: mergedThresholds[category],
+          packageValue: value,
+          description: `Architecture threshold '${category}' already exists locally with a different value`
+        });
+      }
+    }
+    const mergedModules = { ...localArch.modules };
+    const contributedModuleKeys = [];
+    const bundleModules = bundleConstraints.architecture.modules ?? {};
+    for (const [modulePath, bundleCategoryMap] of Object.entries(bundleModules)) {
+      if (!(modulePath in mergedModules)) {
+        mergedModules[modulePath] = bundleCategoryMap;
+        for (const cat of Object.keys(bundleCategoryMap)) {
+          contributedModuleKeys.push(`${modulePath}:${cat}`);
+        }
+      } else {
+        const localCategoryMap = mergedModules[modulePath];
+        const mergedCategoryMap = { ...localCategoryMap };
+        for (const [category, value] of Object.entries(bundleCategoryMap)) {
+          if (!(category in mergedCategoryMap)) {
+            mergedCategoryMap[category] = value;
+            contributedModuleKeys.push(`${modulePath}:${category}`);
+          } else if (!deepEqual(mergedCategoryMap[category], value)) {
+            conflicts.push({
+              section: "architecture.modules",
+              key: `${modulePath}:${category}`,
+              localValue: mergedCategoryMap[category],
+              packageValue: value,
+              description: `Architecture module override '${modulePath}' category '${category}' already exists locally with a different value`
+            });
+          }
+        }
+        mergedModules[modulePath] = mergedCategoryMap;
+      }
+    }
+    config.architecture = {
+      ...localArch,
+      thresholds: mergedThresholds,
+      modules: mergedModules
+    };
+    if (contributedThresholdKeys.length > 0) {
+      contributions["architecture.thresholds"] = contributedThresholdKeys;
+    }
+    if (contributedModuleKeys.length > 0) {
+      contributions["architecture.modules"] = contributedModuleKeys;
+    }
+  }
+  if (bundleConstraints.security?.rules) {
+    const localSecurity = localConfig.security ?? { rules: {} };
+    const localRules = localSecurity.rules ?? {};
+    const mergedRules = { ...localRules };
+    const contributedRuleIds = [];
+    for (const [ruleId, severity] of Object.entries(bundleConstraints.security.rules)) {
+      if (!(ruleId in mergedRules)) {
+        mergedRules[ruleId] = severity;
+        contributedRuleIds.push(ruleId);
+      } else if (mergedRules[ruleId] !== severity) {
+        conflicts.push({
+          section: "security.rules",
+          key: ruleId,
+          localValue: mergedRules[ruleId],
+          packageValue: severity,
+          description: `Security rule '${ruleId}' already exists locally with severity '${mergedRules[ruleId]}', bundle has '${severity}'`
+        });
+      }
+    }
+    config.security = { ...localSecurity, rules: mergedRules };
+    if (contributedRuleIds.length > 0) {
+      contributions["security.rules"] = contributedRuleIds;
+    }
+  }
+  return { config, contributions, conflicts };
+}
+
+// src/constraints/sharing/lockfile.ts
+var fs2 = __toESM(require("fs/promises"));
+async function readLockfile(lockfilePath) {
+  let raw;
+  try {
+    raw = await fs2.readFile(lockfilePath, "utf-8");
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") {
+      return { ok: true, value: null };
+    }
+    return {
+      ok: false,
+      error: `Failed to read lockfile: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {
+      ok: false,
+      error: `Failed to parse lockfile as JSON: file contains invalid JSON`
+    };
+  }
+  const result = LockfileSchema.safeParse(parsed);
+  if (!result.success) {
+    return {
+      ok: false,
+      error: `Lockfile schema validation failed: ${result.error.issues.map((i) => i.message).join(", ")}`
+    };
+  }
+  return { ok: true, value: result.data };
+}
+async function writeLockfile(lockfilePath, lockfile) {
+  await writeConfig(lockfilePath, lockfile);
+}
+function addProvenance(lockfile, packageName, entry) {
+  return {
+    ...lockfile,
+    packages: {
+      ...lockfile.packages,
+      [packageName]: entry
+    }
+  };
+}
+function removeProvenance(lockfile, packageName) {
+  const existing = lockfile.packages[packageName];
+  if (!existing) {
+    return { lockfile, contributions: null };
+  }
+  const { [packageName]: _removed, ...remaining } = lockfile.packages;
+  return {
+    lockfile: {
+      ...lockfile,
+      packages: remaining
+    },
+    contributions: existing.contributions ?? null
+  };
+}
+function isNodeError(err) {
+  return err instanceof Error && "code" in err;
+}
+
 // src/shared/parsers/typescript.ts
 var import_typescript_estree = require("@typescript-eslint/typescript-estree");
 
@@ -1339,11 +1804,11 @@ function walk(node, visitor) {
 var TypeScriptParser = class {
   name = "typescript";
   extensions = [".ts", ".tsx", ".mts", ".cts"];
-  async parseFile(path11) {
-    const contentResult = await readFileContent(path11);
+  async parseFile(path13) {
+    const contentResult = await readFileContent(path13);
     if (!contentResult.ok) {
       return (0, import_types.Err)(
-        createParseError("NOT_FOUND", `File not found: ${path11}`, { path: path11 }, [
+        createParseError("NOT_FOUND", `File not found: ${path13}`, { path: path13 }, [
           "Check that the file exists",
           "Verify the path is correct"
         ])
@@ -1353,7 +1818,7 @@ var TypeScriptParser = class {
       const ast = (0, import_typescript_estree.parse)(contentResult.value, {
         loc: true,
         range: true,
-        jsx: path11.endsWith(".tsx"),
+        jsx: path13.endsWith(".tsx"),
         errorOnUnknownASTType: false
       });
       return (0, import_types.Ok)({
@@ -1364,7 +1829,7 @@ var TypeScriptParser = class {
     } catch (e) {
       const error = e;
       return (0, import_types.Err)(
-        createParseError("SYNTAX_ERROR", `Failed to parse ${path11}: ${error.message}`, { path: path11 }, [
+        createParseError("SYNTAX_ERROR", `Failed to parse ${path13}: ${error.message}`, { path: path13 }, [
           "Check for syntax errors in the file",
           "Ensure valid TypeScript syntax"
         ])
@@ -1531,7 +1996,7 @@ var TypeScriptParser = class {
 
 // src/entropy/snapshot.ts
 var import_path6 = require("path");
-var import_minimatch2 = require("minimatch");
+var import_minimatch3 = require("minimatch");
 async function resolveEntryPoints(rootDir, explicitEntries) {
   if (explicitEntries && explicitEntries.length > 0) {
     const resolved = explicitEntries.map((e) => (0, import_path6.resolve)(rootDir, e));
@@ -1648,22 +2113,22 @@ function extractInlineRefs(content) {
   }
   return refs;
 }
-async function parseDocumentationFile(path11) {
-  const contentResult = await readFileContent(path11);
+async function parseDocumentationFile(path13) {
+  const contentResult = await readFileContent(path13);
   if (!contentResult.ok) {
     return (0, import_types.Err)(
       createEntropyError(
         "PARSE_ERROR",
-        `Failed to read documentation file: ${path11}`,
-        { file: path11 },
+        `Failed to read documentation file: ${path13}`,
+        { file: path13 },
         ["Check that the file exists"]
       )
     );
   }
   const content = contentResult.value;
-  const type = path11.endsWith(".md") ? "markdown" : "text";
+  const type = path13.endsWith(".md") ? "markdown" : "text";
   return (0, import_types.Ok)({
-    path: path11,
+    path: path13,
     type,
     content,
     codeBlocks: extractCodeBlocks(content),
@@ -1795,7 +2260,7 @@ async function buildSnapshot(config) {
   }
   sourceFilePaths = sourceFilePaths.filter((f) => {
     const rel = (0, import_path6.relative)(rootDir, f);
-    return !excludePatterns.some((p) => (0, import_minimatch2.minimatch)(rel, p));
+    return !excludePatterns.some((p) => (0, import_minimatch3.minimatch)(rel, p));
   });
   const files = [];
   for (const filePath of sourceFilePaths) {
@@ -2325,11 +2790,11 @@ async function detectDeadCode(snapshot, graphDeadCodeData) {
 }
 
 // src/entropy/detectors/patterns.ts
-var import_minimatch3 = require("minimatch");
+var import_minimatch4 = require("minimatch");
 var import_path9 = require("path");
 function fileMatchesPattern(filePath, pattern, rootDir) {
   const relativePath = (0, import_path9.relative)(rootDir, filePath);
-  return (0, import_minimatch3.minimatch)(relativePath, pattern);
+  return (0, import_minimatch4.minimatch)(relativePath, pattern);
 }
 function checkConfigPattern(pattern, file, rootDir) {
   const matches = [];
@@ -3331,14 +3796,14 @@ var EntropyAnalyzer = class {
 };
 
 // src/entropy/fixers/safe-fixes.ts
-var fs = __toESM(require("fs"));
+var fs3 = __toESM(require("fs"));
 var import_util2 = require("util");
 var import_path10 = require("path");
-var readFile4 = (0, import_util2.promisify)(fs.readFile);
-var writeFile2 = (0, import_util2.promisify)(fs.writeFile);
-var unlink2 = (0, import_util2.promisify)(fs.unlink);
-var mkdir2 = (0, import_util2.promisify)(fs.mkdir);
-var copyFile2 = (0, import_util2.promisify)(fs.copyFile);
+var readFile5 = (0, import_util2.promisify)(fs3.readFile);
+var writeFile3 = (0, import_util2.promisify)(fs3.writeFile);
+var unlink2 = (0, import_util2.promisify)(fs3.unlink);
+var mkdir2 = (0, import_util2.promisify)(fs3.mkdir);
+var copyFile2 = (0, import_util2.promisify)(fs3.copyFile);
 var DEFAULT_FIX_CONFIG = {
   dryRun: false,
   fixTypes: ["unused-imports", "dead-files"],
@@ -3465,25 +3930,25 @@ async function applySingleFix(fix, config) {
         break;
       case "delete-lines":
         if (fix.line !== void 0) {
-          const content = await readFile4(fix.file, "utf-8");
+          const content = await readFile5(fix.file, "utf-8");
           const lines = content.split("\n");
           lines.splice(fix.line - 1, 1);
-          await writeFile2(fix.file, lines.join("\n"));
+          await writeFile3(fix.file, lines.join("\n"));
         }
         break;
       case "replace":
         if (fix.oldContent && fix.newContent !== void 0) {
-          const content = await readFile4(fix.file, "utf-8");
+          const content = await readFile5(fix.file, "utf-8");
           const newContent = content.replace(fix.oldContent, fix.newContent);
-          await writeFile2(fix.file, newContent);
+          await writeFile3(fix.file, newContent);
         }
         break;
       case "insert":
         if (fix.line !== void 0 && fix.newContent) {
-          const content = await readFile4(fix.file, "utf-8");
+          const content = await readFile5(fix.file, "utf-8");
           const lines = content.split("\n");
           lines.splice(fix.line - 1, 0, fix.newContent);
-          await writeFile2(fix.file, lines.join("\n"));
+          await writeFile3(fix.file, lines.join("\n"));
         }
         break;
     }
@@ -3660,46 +4125,46 @@ function deduplicateCleanupFindings(findings) {
 }
 
 // src/entropy/config/schema.ts
-var import_zod = require("zod");
-var MustExportRuleSchema = import_zod.z.object({
-  type: import_zod.z.literal("must-export"),
-  names: import_zod.z.array(import_zod.z.string())
+var import_zod2 = require("zod");
+var MustExportRuleSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("must-export"),
+  names: import_zod2.z.array(import_zod2.z.string())
 });
-var MustExportDefaultRuleSchema = import_zod.z.object({
-  type: import_zod.z.literal("must-export-default"),
-  kind: import_zod.z.enum(["class", "function", "object"]).optional()
+var MustExportDefaultRuleSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("must-export-default"),
+  kind: import_zod2.z.enum(["class", "function", "object"]).optional()
 });
-var NoExportRuleSchema = import_zod.z.object({
-  type: import_zod.z.literal("no-export"),
-  names: import_zod.z.array(import_zod.z.string())
+var NoExportRuleSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("no-export"),
+  names: import_zod2.z.array(import_zod2.z.string())
 });
-var MustImportRuleSchema = import_zod.z.object({
-  type: import_zod.z.literal("must-import"),
-  from: import_zod.z.string(),
-  names: import_zod.z.array(import_zod.z.string()).optional()
+var MustImportRuleSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("must-import"),
+  from: import_zod2.z.string(),
+  names: import_zod2.z.array(import_zod2.z.string()).optional()
 });
-var NoImportRuleSchema = import_zod.z.object({
-  type: import_zod.z.literal("no-import"),
-  from: import_zod.z.string()
+var NoImportRuleSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("no-import"),
+  from: import_zod2.z.string()
 });
-var NamingRuleSchema = import_zod.z.object({
-  type: import_zod.z.literal("naming"),
-  match: import_zod.z.string(),
-  convention: import_zod.z.enum(["camelCase", "PascalCase", "UPPER_SNAKE", "kebab-case"])
+var NamingRuleSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("naming"),
+  match: import_zod2.z.string(),
+  convention: import_zod2.z.enum(["camelCase", "PascalCase", "UPPER_SNAKE", "kebab-case"])
 });
-var MaxExportsRuleSchema = import_zod.z.object({
-  type: import_zod.z.literal("max-exports"),
-  count: import_zod.z.number().positive()
+var MaxExportsRuleSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("max-exports"),
+  count: import_zod2.z.number().positive()
 });
-var MaxLinesRuleSchema = import_zod.z.object({
-  type: import_zod.z.literal("max-lines"),
-  count: import_zod.z.number().positive()
+var MaxLinesRuleSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("max-lines"),
+  count: import_zod2.z.number().positive()
 });
-var RequireJSDocRuleSchema = import_zod.z.object({
-  type: import_zod.z.literal("require-jsdoc"),
-  for: import_zod.z.array(import_zod.z.enum(["function", "class", "export"]))
+var RequireJSDocRuleSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("require-jsdoc"),
+  for: import_zod2.z.array(import_zod2.z.enum(["function", "class", "export"]))
 });
-var RuleSchema = import_zod.z.discriminatedUnion("type", [
+var RuleSchema = import_zod2.z.discriminatedUnion("type", [
   MustExportRuleSchema,
   MustExportDefaultRuleSchema,
   NoExportRuleSchema,
@@ -3710,47 +4175,47 @@ var RuleSchema = import_zod.z.discriminatedUnion("type", [
   MaxLinesRuleSchema,
   RequireJSDocRuleSchema
 ]);
-var ConfigPatternSchema = import_zod.z.object({
-  name: import_zod.z.string().min(1),
-  description: import_zod.z.string(),
-  severity: import_zod.z.enum(["error", "warning"]),
-  files: import_zod.z.array(import_zod.z.string()),
+var ConfigPatternSchema = import_zod2.z.object({
+  name: import_zod2.z.string().min(1),
+  description: import_zod2.z.string(),
+  severity: import_zod2.z.enum(["error", "warning"]),
+  files: import_zod2.z.array(import_zod2.z.string()),
   rule: RuleSchema,
-  message: import_zod.z.string().optional()
+  message: import_zod2.z.string().optional()
 });
-var PatternConfigSchema = import_zod.z.object({
-  patterns: import_zod.z.array(ConfigPatternSchema),
-  customPatterns: import_zod.z.array(import_zod.z.any()).optional(),
+var PatternConfigSchema = import_zod2.z.object({
+  patterns: import_zod2.z.array(ConfigPatternSchema),
+  customPatterns: import_zod2.z.array(import_zod2.z.any()).optional(),
   // Code patterns are functions, can't validate
-  ignoreFiles: import_zod.z.array(import_zod.z.string()).optional()
+  ignoreFiles: import_zod2.z.array(import_zod2.z.string()).optional()
 });
-var DriftConfigSchema = import_zod.z.object({
-  docPaths: import_zod.z.array(import_zod.z.string()).optional(),
-  checkApiSignatures: import_zod.z.boolean().optional(),
-  checkExamples: import_zod.z.boolean().optional(),
-  checkStructure: import_zod.z.boolean().optional(),
-  ignorePatterns: import_zod.z.array(import_zod.z.string()).optional()
+var DriftConfigSchema = import_zod2.z.object({
+  docPaths: import_zod2.z.array(import_zod2.z.string()).optional(),
+  checkApiSignatures: import_zod2.z.boolean().optional(),
+  checkExamples: import_zod2.z.boolean().optional(),
+  checkStructure: import_zod2.z.boolean().optional(),
+  ignorePatterns: import_zod2.z.array(import_zod2.z.string()).optional()
 });
-var DeadCodeConfigSchema = import_zod.z.object({
-  entryPoints: import_zod.z.array(import_zod.z.string()).optional(),
-  includeTypes: import_zod.z.boolean().optional(),
-  includeInternals: import_zod.z.boolean().optional(),
-  ignorePatterns: import_zod.z.array(import_zod.z.string()).optional(),
-  treatDynamicImportsAs: import_zod.z.enum(["used", "unknown"]).optional()
+var DeadCodeConfigSchema = import_zod2.z.object({
+  entryPoints: import_zod2.z.array(import_zod2.z.string()).optional(),
+  includeTypes: import_zod2.z.boolean().optional(),
+  includeInternals: import_zod2.z.boolean().optional(),
+  ignorePatterns: import_zod2.z.array(import_zod2.z.string()).optional(),
+  treatDynamicImportsAs: import_zod2.z.enum(["used", "unknown"]).optional()
 });
-var EntropyConfigSchema = import_zod.z.object({
-  rootDir: import_zod.z.string(),
-  parser: import_zod.z.any().optional(),
+var EntropyConfigSchema = import_zod2.z.object({
+  rootDir: import_zod2.z.string(),
+  parser: import_zod2.z.any().optional(),
   // LanguageParser instance, can't validate
-  entryPoints: import_zod.z.array(import_zod.z.string()).optional(),
-  analyze: import_zod.z.object({
-    drift: import_zod.z.union([import_zod.z.boolean(), DriftConfigSchema]).optional(),
-    deadCode: import_zod.z.union([import_zod.z.boolean(), DeadCodeConfigSchema]).optional(),
-    patterns: import_zod.z.union([import_zod.z.boolean(), PatternConfigSchema]).optional()
+  entryPoints: import_zod2.z.array(import_zod2.z.string()).optional(),
+  analyze: import_zod2.z.object({
+    drift: import_zod2.z.union([import_zod2.z.boolean(), DriftConfigSchema]).optional(),
+    deadCode: import_zod2.z.union([import_zod2.z.boolean(), DeadCodeConfigSchema]).optional(),
+    patterns: import_zod2.z.union([import_zod2.z.boolean(), PatternConfigSchema]).optional()
   }),
-  include: import_zod.z.array(import_zod.z.string()).optional(),
-  exclude: import_zod.z.array(import_zod.z.string()).optional(),
-  docPaths: import_zod.z.array(import_zod.z.string()).optional()
+  include: import_zod2.z.array(import_zod2.z.string()).optional(),
+  exclude: import_zod2.z.array(import_zod2.z.string()).optional(),
+  docPaths: import_zod2.z.array(import_zod2.z.string()).optional()
 });
 function validatePatternConfig(config) {
   const result = PatternConfigSchema.safeParse(config);
@@ -4007,7 +4472,7 @@ var RegressionDetector = class {
 };
 
 // src/performance/critical-path.ts
-var fs2 = __toESM(require("fs"));
+var fs4 = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git"]);
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
@@ -4059,7 +4524,7 @@ var CriticalPathResolver = class {
   walkDir(dir, entries) {
     let items;
     try {
-      items = fs2.readdirSync(dir, { withFileTypes: true });
+      items = fs4.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -4075,7 +4540,7 @@ var CriticalPathResolver = class {
   scanFile(filePath, entries) {
     let content;
     try {
-      content = fs2.readFileSync(filePath, "utf-8");
+      content = fs4.readFileSync(filePath, "utf-8");
     } catch {
       return;
     }
@@ -4254,17 +4719,17 @@ function resetFeedbackConfig() {
 }
 
 // src/feedback/review/diff-analyzer.ts
-function parseDiff(diff) {
+function parseDiff(diff2) {
   try {
-    if (!diff.trim()) {
-      return (0, import_types.Ok)({ diff, files: [] });
+    if (!diff2.trim()) {
+      return (0, import_types.Ok)({ diff: diff2, files: [] });
     }
     const files = [];
     const newFileRegex = /new file mode/;
     const deletedFileRegex = /deleted file mode/;
     const additionRegex = /^\+(?!\+\+)/gm;
     const deletionRegex = /^-(?!--)/gm;
-    const diffParts = diff.split(/(?=diff --git)/);
+    const diffParts = diff2.split(/(?=diff --git)/);
     for (const part of diffParts) {
       if (!part.trim()) continue;
       const headerMatch = /diff --git a\/(.+?) b\/(.+?)(?:\n|$)/.exec(part);
@@ -4287,7 +4752,7 @@ function parseDiff(diff) {
         deletions
       });
     }
-    return (0, import_types.Ok)({ diff, files });
+    return (0, import_types.Ok)({ diff: diff2, files });
   } catch (error) {
     return (0, import_types.Err)({
       code: "DIFF_PARSE_ERROR",
@@ -4891,77 +5356,1265 @@ var NoOpSink = class {
   }
 };
 
+// src/architecture/types.ts
+var import_zod3 = require("zod");
+var ArchMetricCategorySchema = import_zod3.z.enum([
+  "circular-deps",
+  "layer-violations",
+  "complexity",
+  "coupling",
+  "forbidden-imports",
+  "module-size",
+  "dependency-depth"
+]);
+var ViolationSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  // stable hash: sha256(relativePath + ':' + category + ':' + normalizedDetail)
+  file: import_zod3.z.string(),
+  // relative to project root
+  category: ArchMetricCategorySchema.optional(),
+  // context for baseline reporting
+  detail: import_zod3.z.string(),
+  // human-readable description
+  severity: import_zod3.z.enum(["error", "warning"])
+});
+var MetricResultSchema = import_zod3.z.object({
+  category: ArchMetricCategorySchema,
+  scope: import_zod3.z.string(),
+  // e.g., 'project', 'src/services', 'src/api/routes.ts'
+  value: import_zod3.z.number(),
+  // numeric metric (violation count, complexity score, etc.)
+  violations: import_zod3.z.array(ViolationSchema),
+  metadata: import_zod3.z.record(import_zod3.z.unknown()).optional()
+});
+var CategoryBaselineSchema = import_zod3.z.object({
+  value: import_zod3.z.number(),
+  // aggregate metric value at baseline time
+  violationIds: import_zod3.z.array(import_zod3.z.string())
+  // stable IDs of known violations (the allowlist)
+});
+var ArchBaselineSchema = import_zod3.z.object({
+  version: import_zod3.z.literal(1),
+  updatedAt: import_zod3.z.string().datetime(),
+  // ISO 8601
+  updatedFrom: import_zod3.z.string(),
+  // commit hash
+  metrics: import_zod3.z.record(ArchMetricCategorySchema, CategoryBaselineSchema)
+});
+var CategoryRegressionSchema = import_zod3.z.object({
+  category: ArchMetricCategorySchema,
+  baselineValue: import_zod3.z.number(),
+  currentValue: import_zod3.z.number(),
+  delta: import_zod3.z.number()
+});
+var ArchDiffResultSchema = import_zod3.z.object({
+  passed: import_zod3.z.boolean(),
+  newViolations: import_zod3.z.array(ViolationSchema),
+  // in current but not in baseline -> FAIL
+  resolvedViolations: import_zod3.z.array(import_zod3.z.string()),
+  // in baseline but not in current -> celebrate
+  preExisting: import_zod3.z.array(import_zod3.z.string()),
+  // in both -> allowed, tracked
+  regressions: import_zod3.z.array(CategoryRegressionSchema)
+  // aggregate value exceeded baseline
+});
+var ThresholdConfigSchema = import_zod3.z.record(
+  ArchMetricCategorySchema,
+  import_zod3.z.union([import_zod3.z.number(), import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number())])
+);
+var ArchConfigSchema = import_zod3.z.object({
+  enabled: import_zod3.z.boolean().default(true),
+  baselinePath: import_zod3.z.string().default(".harness/arch/baselines.json"),
+  thresholds: ThresholdConfigSchema.default({}),
+  modules: import_zod3.z.record(import_zod3.z.string(), ThresholdConfigSchema).default({})
+});
+var ConstraintRuleSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  // stable hash: sha256(category + ':' + scope + ':' + description)
+  category: ArchMetricCategorySchema,
+  description: import_zod3.z.string(),
+  // e.g., "Layer 'services' must not import from 'ui'"
+  scope: import_zod3.z.string(),
+  // e.g., 'src/services/', 'project'
+  targets: import_zod3.z.array(import_zod3.z.string()).optional()
+  // forward-compat for governs edges
+});
+
+// src/architecture/collectors/circular-deps.ts
+var import_node_path3 = require("path");
+
+// src/architecture/collectors/hash.ts
+var import_node_crypto = require("crypto");
+function violationId(relativePath, category, normalizedDetail) {
+  const path13 = relativePath.replace(/\\/g, "/");
+  const input = `${path13}:${category}:${normalizedDetail}`;
+  return (0, import_node_crypto.createHash)("sha256").update(input).digest("hex");
+}
+function constraintRuleId(category, scope, description) {
+  const input = `${category}:${scope}:${description}`;
+  return (0, import_node_crypto.createHash)("sha256").update(input).digest("hex");
+}
+
+// src/architecture/collectors/circular-deps.ts
+var CircularDepsCollector = class {
+  category = "circular-deps";
+  getRules(_config, _rootDir) {
+    const description = "No circular dependencies allowed";
+    return [
+      {
+        id: constraintRuleId(this.category, "project", description),
+        category: this.category,
+        description,
+        scope: "project"
+      }
+    ];
+  }
+  async collect(_config, rootDir) {
+    const files = await findFiles("**/*.ts", rootDir);
+    const stubParser = {
+      name: "typescript",
+      extensions: [".ts", ".tsx"],
+      parseFile: async () => ({ ok: false, error: { code: "PARSE_ERROR", message: "not needed" } }),
+      extractImports: () => ({
+        ok: false,
+        error: { code: "EXTRACT_ERROR", message: "not needed" }
+      }),
+      extractExports: () => ({
+        ok: false,
+        error: { code: "EXTRACT_ERROR", message: "not needed" }
+      }),
+      health: async () => ({ ok: true, value: { available: true } })
+    };
+    const graphResult = await buildDependencyGraph(files, stubParser);
+    if (!graphResult.ok) {
+      return [
+        {
+          category: this.category,
+          scope: "project",
+          value: 0,
+          violations: [],
+          metadata: { error: "Failed to build dependency graph" }
+        }
+      ];
+    }
+    const result = detectCircularDeps(graphResult.value);
+    if (!result.ok) {
+      return [
+        {
+          category: this.category,
+          scope: "project",
+          value: 0,
+          violations: [],
+          metadata: { error: "Failed to detect circular deps" }
+        }
+      ];
+    }
+    const { cycles, largestCycle } = result.value;
+    const violations = cycles.map((cycle) => {
+      const cyclePath = cycle.cycle.map((f) => (0, import_node_path3.relative)(rootDir, f)).join(" -> ");
+      const firstFile = (0, import_node_path3.relative)(rootDir, cycle.cycle[0]);
+      return {
+        id: violationId(firstFile, this.category, cyclePath),
+        file: firstFile,
+        detail: `Circular dependency: ${cyclePath}`,
+        severity: cycle.severity
+      };
+    });
+    return [
+      {
+        category: this.category,
+        scope: "project",
+        value: cycles.length,
+        violations,
+        metadata: { largestCycle, cycleCount: cycles.length }
+      }
+    ];
+  }
+};
+
+// src/architecture/collectors/layer-violations.ts
+var import_node_path4 = require("path");
+var LayerViolationCollector = class {
+  category = "layer-violations";
+  getRules(_config, _rootDir) {
+    const description = "No layer boundary violations allowed";
+    return [
+      {
+        id: constraintRuleId(this.category, "project", description),
+        category: this.category,
+        description,
+        scope: "project"
+      }
+    ];
+  }
+  async collect(_config, rootDir) {
+    const stubParser = {
+      name: "typescript",
+      extensions: [".ts", ".tsx"],
+      parseFile: async () => ({ ok: false, error: { code: "PARSE_ERROR", message: "" } }),
+      extractImports: () => ({ ok: false, error: { code: "EXTRACT_ERROR", message: "" } }),
+      extractExports: () => ({ ok: false, error: { code: "EXTRACT_ERROR", message: "" } }),
+      health: async () => ({ ok: true, value: { available: true } })
+    };
+    const result = await validateDependencies({
+      layers: [],
+      rootDir,
+      parser: stubParser,
+      fallbackBehavior: "skip"
+    });
+    if (!result.ok) {
+      return [
+        {
+          category: this.category,
+          scope: "project",
+          value: 0,
+          violations: [],
+          metadata: { error: "Failed to validate dependencies" }
+        }
+      ];
+    }
+    const layerViolations = result.value.violations.filter(
+      (v) => v.reason === "WRONG_LAYER"
+    );
+    const violations = layerViolations.map((v) => {
+      const relFile = (0, import_node_path4.relative)(rootDir, v.file);
+      const relImport = (0, import_node_path4.relative)(rootDir, v.imports);
+      const detail = `${v.fromLayer} -> ${v.toLayer}: ${relFile} imports ${relImport}`;
+      return {
+        id: violationId(relFile, this.category, detail),
+        file: relFile,
+        category: this.category,
+        detail,
+        severity: "error"
+      };
+    });
+    return [
+      {
+        category: this.category,
+        scope: "project",
+        value: violations.length,
+        violations
+      }
+    ];
+  }
+};
+
+// src/architecture/collectors/complexity.ts
+var import_node_path5 = require("path");
+var ComplexityCollector = class {
+  category = "complexity";
+  getRules(_config, _rootDir) {
+    const description = "Cyclomatic complexity must stay within thresholds";
+    return [
+      {
+        id: constraintRuleId(this.category, "project", description),
+        category: this.category,
+        description,
+        scope: "project"
+      }
+    ];
+  }
+  async collect(_config, rootDir) {
+    const files = await findFiles("**/*.ts", rootDir);
+    const snapshot = {
+      files: files.map((f) => ({
+        path: f,
+        ast: { type: "Program", body: null, language: "typescript" },
+        imports: [],
+        exports: [],
+        internalSymbols: [],
+        jsDocComments: []
+      })),
+      dependencyGraph: { nodes: [], edges: [] },
+      exportMap: { byFile: /* @__PURE__ */ new Map(), byName: /* @__PURE__ */ new Map() },
+      docs: [],
+      codeReferences: [],
+      entryPoints: [],
+      rootDir,
+      config: { rootDir, analyze: {} },
+      buildTime: 0
+    };
+    const complexityThreshold = _config.thresholds.complexity;
+    const maxComplexity = typeof complexityThreshold === "number" ? complexityThreshold : complexityThreshold?.max ?? 15;
+    const complexityConfig = {
+      thresholds: {
+        cyclomaticComplexity: {
+          error: maxComplexity,
+          warn: Math.floor(maxComplexity * 0.7)
+        }
+      }
+    };
+    const result = await detectComplexityViolations(snapshot, complexityConfig);
+    if (!result.ok) {
+      return [
+        {
+          category: this.category,
+          scope: "project",
+          value: 0,
+          violations: [],
+          metadata: { error: "Failed to detect complexity violations" }
+        }
+      ];
+    }
+    const { violations: complexityViolations, stats } = result.value;
+    const filtered = complexityViolations.filter(
+      (v) => v.severity === "error" || v.severity === "warning"
+    );
+    const violations = filtered.map((v) => {
+      const relFile = (0, import_node_path5.relative)(rootDir, v.file);
+      const idDetail = `${v.metric}:${v.function}`;
+      return {
+        id: violationId(relFile, this.category, idDetail),
+        file: relFile,
+        category: this.category,
+        detail: `${v.metric}=${v.value} in ${v.function} (threshold: ${v.threshold})`,
+        severity: v.severity
+      };
+    });
+    return [
+      {
+        category: this.category,
+        scope: "project",
+        value: violations.length,
+        violations,
+        metadata: {
+          filesAnalyzed: stats.filesAnalyzed,
+          functionsAnalyzed: stats.functionsAnalyzed
+        }
+      }
+    ];
+  }
+};
+
+// src/architecture/collectors/coupling.ts
+var import_node_path6 = require("path");
+var CouplingCollector = class {
+  category = "coupling";
+  getRules(_config, _rootDir) {
+    const description = "Coupling metrics must stay within thresholds";
+    return [
+      {
+        id: constraintRuleId(this.category, "project", description),
+        category: this.category,
+        description,
+        scope: "project"
+      }
+    ];
+  }
+  async collect(_config, rootDir) {
+    const files = await findFiles("**/*.ts", rootDir);
+    const snapshot = {
+      files: files.map((f) => ({
+        path: f,
+        ast: { type: "Program", body: null, language: "typescript" },
+        imports: [],
+        exports: [],
+        internalSymbols: [],
+        jsDocComments: []
+      })),
+      dependencyGraph: { nodes: [], edges: [] },
+      exportMap: { byFile: /* @__PURE__ */ new Map(), byName: /* @__PURE__ */ new Map() },
+      docs: [],
+      codeReferences: [],
+      entryPoints: [],
+      rootDir,
+      config: { rootDir, analyze: {} },
+      buildTime: 0
+    };
+    const result = await detectCouplingViolations(snapshot);
+    if (!result.ok) {
+      return [
+        {
+          category: this.category,
+          scope: "project",
+          value: 0,
+          violations: [],
+          metadata: { error: "Failed to detect coupling violations" }
+        }
+      ];
+    }
+    const { violations: couplingViolations, stats } = result.value;
+    const filtered = couplingViolations.filter(
+      (v) => v.severity === "error" || v.severity === "warning"
+    );
+    const violations = filtered.map((v) => {
+      const relFile = (0, import_node_path6.relative)(rootDir, v.file);
+      const idDetail = `${v.metric}`;
+      return {
+        id: violationId(relFile, this.category, idDetail),
+        file: relFile,
+        category: this.category,
+        detail: `${v.metric}=${v.value} (threshold: ${v.threshold})`,
+        severity: v.severity
+      };
+    });
+    return [
+      {
+        category: this.category,
+        scope: "project",
+        value: violations.length,
+        violations,
+        metadata: { filesAnalyzed: stats.filesAnalyzed }
+      }
+    ];
+  }
+};
+
+// src/architecture/collectors/forbidden-imports.ts
+var import_node_path7 = require("path");
+var ForbiddenImportCollector = class {
+  category = "forbidden-imports";
+  getRules(_config, _rootDir) {
+    const description = "No forbidden imports allowed";
+    return [
+      {
+        id: constraintRuleId(this.category, "project", description),
+        category: this.category,
+        description,
+        scope: "project"
+      }
+    ];
+  }
+  async collect(_config, rootDir) {
+    const stubParser = {
+      name: "typescript",
+      extensions: [".ts", ".tsx"],
+      parseFile: async () => ({ ok: false, error: { code: "PARSE_ERROR", message: "" } }),
+      extractImports: () => ({ ok: false, error: { code: "EXTRACT_ERROR", message: "" } }),
+      extractExports: () => ({ ok: false, error: { code: "EXTRACT_ERROR", message: "" } }),
+      health: async () => ({ ok: true, value: { available: true } })
+    };
+    const result = await validateDependencies({
+      layers: [],
+      rootDir,
+      parser: stubParser,
+      fallbackBehavior: "skip"
+    });
+    if (!result.ok) {
+      return [
+        {
+          category: this.category,
+          scope: "project",
+          value: 0,
+          violations: [],
+          metadata: { error: "Failed to validate dependencies" }
+        }
+      ];
+    }
+    const forbidden = result.value.violations.filter(
+      (v) => v.reason === "FORBIDDEN_IMPORT"
+    );
+    const violations = forbidden.map((v) => {
+      const relFile = (0, import_node_path7.relative)(rootDir, v.file);
+      const relImport = (0, import_node_path7.relative)(rootDir, v.imports);
+      const detail = `forbidden import: ${relFile} -> ${relImport}`;
+      return {
+        id: violationId(relFile, this.category, detail),
+        file: relFile,
+        category: this.category,
+        detail,
+        severity: "error"
+      };
+    });
+    return [
+      {
+        category: this.category,
+        scope: "project",
+        value: violations.length,
+        violations
+      }
+    ];
+  }
+};
+
+// src/architecture/collectors/module-size.ts
+var import_promises2 = require("fs/promises");
+var import_node_path8 = require("path");
+async function discoverModules(rootDir) {
+  const modules = [];
+  async function scanDir(dir) {
+    let entries;
+    try {
+      entries = await (0, import_promises2.readdir)(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const tsFiles = [];
+    const subdirs = [];
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") {
+        continue;
+      }
+      const fullPath = (0, import_node_path8.join)(dir, entry.name);
+      if (entry.isDirectory()) {
+        subdirs.push(fullPath);
+      } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) && !entry.name.endsWith(".test.ts") && !entry.name.endsWith(".test.tsx") && !entry.name.endsWith(".spec.ts")) {
+        tsFiles.push(fullPath);
+      }
+    }
+    if (tsFiles.length > 0) {
+      let totalLoc = 0;
+      for (const f of tsFiles) {
+        try {
+          const content = await (0, import_promises2.readFile)(f, "utf-8");
+          totalLoc += content.split("\n").filter((line) => line.trim().length > 0).length;
+        } catch {
+        }
+      }
+      modules.push({
+        modulePath: (0, import_node_path8.relative)(rootDir, dir),
+        fileCount: tsFiles.length,
+        totalLoc,
+        files: tsFiles.map((f) => (0, import_node_path8.relative)(rootDir, f))
+      });
+    }
+    for (const sub of subdirs) {
+      await scanDir(sub);
+    }
+  }
+  await scanDir(rootDir);
+  return modules;
+}
+var ModuleSizeCollector = class {
+  category = "module-size";
+  getRules(config, _rootDir) {
+    const thresholds = config.thresholds["module-size"];
+    let maxLoc = Infinity;
+    let maxFiles = Infinity;
+    if (typeof thresholds === "object" && thresholds !== null) {
+      const t = thresholds;
+      if (t.maxLoc !== void 0) maxLoc = t.maxLoc;
+      if (t.maxFiles !== void 0) maxFiles = t.maxFiles;
+    }
+    const rules = [];
+    if (maxLoc < Infinity) {
+      const desc = `Module LOC must not exceed ${maxLoc}`;
+      rules.push({
+        id: constraintRuleId(this.category, "project", desc),
+        category: this.category,
+        description: desc,
+        scope: "project"
+      });
+    }
+    if (maxFiles < Infinity) {
+      const desc = `Module file count must not exceed ${maxFiles}`;
+      rules.push({
+        id: constraintRuleId(this.category, "project", desc),
+        category: this.category,
+        description: desc,
+        scope: "project"
+      });
+    }
+    if (rules.length === 0) {
+      const desc = "Module size must stay within thresholds";
+      rules.push({
+        id: constraintRuleId(this.category, "project", desc),
+        category: this.category,
+        description: desc,
+        scope: "project"
+      });
+    }
+    return rules;
+  }
+  async collect(config, rootDir) {
+    const modules = await discoverModules(rootDir);
+    const thresholds = config.thresholds["module-size"];
+    let maxLoc = Infinity;
+    let maxFiles = Infinity;
+    if (typeof thresholds === "object" && thresholds !== null) {
+      const t = thresholds;
+      if (t.maxLoc !== void 0) maxLoc = t.maxLoc;
+      if (t.maxFiles !== void 0) maxFiles = t.maxFiles;
+    }
+    return modules.map((mod) => {
+      const violations = [];
+      if (mod.totalLoc > maxLoc) {
+        violations.push({
+          id: violationId(mod.modulePath, this.category, "totalLoc-exceeded"),
+          file: mod.modulePath,
+          detail: `Module has ${mod.totalLoc} lines of code (threshold: ${maxLoc})`,
+          severity: "warning"
+        });
+      }
+      if (mod.fileCount > maxFiles) {
+        violations.push({
+          id: violationId(mod.modulePath, this.category, "fileCount-exceeded"),
+          file: mod.modulePath,
+          detail: `Module has ${mod.fileCount} files (threshold: ${maxFiles})`,
+          severity: "warning"
+        });
+      }
+      return {
+        category: this.category,
+        scope: mod.modulePath,
+        value: mod.totalLoc,
+        violations,
+        metadata: { fileCount: mod.fileCount, totalLoc: mod.totalLoc }
+      };
+    });
+  }
+};
+
+// src/architecture/collectors/dep-depth.ts
+var import_promises3 = require("fs/promises");
+var import_node_path9 = require("path");
+function extractImportSources(content, filePath) {
+  const importRegex = /(?:import|export)\s+.*?from\s+['"](\.[^'"]+)['"]/g;
+  const dynamicRegex = /import\s*\(\s*['"](\.[^'"]+)['"]\s*\)/g;
+  const sources = [];
+  const dir = (0, import_node_path9.dirname)(filePath);
+  for (const regex of [importRegex, dynamicRegex]) {
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      let resolved = (0, import_node_path9.resolve)(dir, match[1]);
+      if (!resolved.endsWith(".ts") && !resolved.endsWith(".tsx")) {
+        resolved += ".ts";
+      }
+      sources.push(resolved);
+    }
+  }
+  return sources;
+}
+async function collectTsFiles(dir) {
+  const results = [];
+  async function scan(d) {
+    let entries;
+    try {
+      entries = await (0, import_promises3.readdir)(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist")
+        continue;
+      const fullPath = (0, import_node_path9.join)(d, entry.name);
+      if (entry.isDirectory()) {
+        await scan(fullPath);
+      } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) && !entry.name.endsWith(".test.ts") && !entry.name.endsWith(".test.tsx") && !entry.name.endsWith(".spec.ts")) {
+        results.push(fullPath);
+      }
+    }
+  }
+  await scan(dir);
+  return results;
+}
+function computeLongestChain(file, graph, visited, memo) {
+  if (memo.has(file)) return memo.get(file);
+  if (visited.has(file)) return 0;
+  visited.add(file);
+  const deps = graph.get(file) || [];
+  let maxDepth = 0;
+  for (const dep of deps) {
+    const depth = 1 + computeLongestChain(dep, graph, visited, memo);
+    if (depth > maxDepth) maxDepth = depth;
+  }
+  visited.delete(file);
+  memo.set(file, maxDepth);
+  return maxDepth;
+}
+var DepDepthCollector = class {
+  category = "dependency-depth";
+  getRules(config, _rootDir) {
+    const threshold = typeof config.thresholds["dependency-depth"] === "number" ? config.thresholds["dependency-depth"] : null;
+    const desc = threshold !== null ? `Dependency chain depth must not exceed ${threshold}` : "Dependency chain depth must stay within thresholds";
+    return [
+      {
+        id: constraintRuleId(this.category, "project", desc),
+        category: this.category,
+        description: desc,
+        scope: "project"
+      }
+    ];
+  }
+  async collect(config, rootDir) {
+    const allFiles = await collectTsFiles(rootDir);
+    const graph = /* @__PURE__ */ new Map();
+    const fileSet = new Set(allFiles);
+    for (const file of allFiles) {
+      try {
+        const content = await (0, import_promises3.readFile)(file, "utf-8");
+        const imports = extractImportSources(content, file).filter((imp) => fileSet.has(imp));
+        graph.set(file, imports);
+      } catch {
+        graph.set(file, []);
+      }
+    }
+    const moduleMap = /* @__PURE__ */ new Map();
+    for (const file of allFiles) {
+      const relDir = (0, import_node_path9.relative)(rootDir, (0, import_node_path9.dirname)(file));
+      if (!moduleMap.has(relDir)) moduleMap.set(relDir, []);
+      moduleMap.get(relDir).push(file);
+    }
+    const memo = /* @__PURE__ */ new Map();
+    const threshold = typeof config.thresholds["dependency-depth"] === "number" ? config.thresholds["dependency-depth"] : Infinity;
+    const results = [];
+    for (const [modulePath, files] of moduleMap) {
+      let longestChain = 0;
+      for (const file of files) {
+        const depth = computeLongestChain(file, graph, /* @__PURE__ */ new Set(), memo);
+        if (depth > longestChain) longestChain = depth;
+      }
+      const violations = [];
+      if (longestChain > threshold) {
+        violations.push({
+          id: violationId(modulePath, this.category, "depth-exceeded"),
+          file: modulePath,
+          detail: `Import chain depth is ${longestChain} (threshold: ${threshold})`,
+          severity: "warning"
+        });
+      }
+      results.push({
+        category: this.category,
+        scope: modulePath,
+        value: longestChain,
+        violations,
+        metadata: { longestChain }
+      });
+    }
+    return results;
+  }
+};
+
+// src/architecture/collectors/index.ts
+var defaultCollectors = [
+  new CircularDepsCollector(),
+  new LayerViolationCollector(),
+  new ComplexityCollector(),
+  new CouplingCollector(),
+  new ForbiddenImportCollector(),
+  new ModuleSizeCollector(),
+  new DepDepthCollector()
+];
+async function runAll(config, rootDir, collectors = defaultCollectors) {
+  const results = await Promise.allSettled(collectors.map((c) => c.collect(config, rootDir)));
+  const allResults = [];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result.status === "fulfilled") {
+      allResults.push(...result.value);
+    } else {
+      allResults.push({
+        category: collectors[i].category,
+        scope: "project",
+        value: 0,
+        violations: [],
+        metadata: { error: String(result.reason) }
+      });
+    }
+  }
+  return allResults;
+}
+
+// src/architecture/sync-constraints.ts
+function syncConstraintNodes(store, rules, violations) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const ruleIds = new Set(rules.map((r) => r.id));
+  const violationsByCategory = /* @__PURE__ */ new Map();
+  for (const result of violations) {
+    const files = result.violations.map((v) => v.file);
+    const existing = violationsByCategory.get(result.category) ?? [];
+    violationsByCategory.set(result.category, [...existing, ...files]);
+  }
+  const existingNodesById = /* @__PURE__ */ new Map();
+  for (const node of store.findNodes({ type: "constraint" })) {
+    existingNodesById.set(node.id, node);
+  }
+  for (const rule of rules) {
+    const existing = existingNodesById.get(rule.id);
+    const createdAt = existing?.createdAt ?? now;
+    const previousLastViolatedAt = existing?.lastViolatedAt ?? null;
+    const hasViolation = hasMatchingViolation(rule, violationsByCategory);
+    const lastViolatedAt = hasViolation ? now : previousLastViolatedAt;
+    store.upsertNode({
+      id: rule.id,
+      type: "constraint",
+      name: rule.description,
+      category: rule.category,
+      scope: rule.scope,
+      createdAt,
+      lastViolatedAt
+    });
+  }
+  const existingConstraints = store.findNodes({ type: "constraint" });
+  for (const node of existingConstraints) {
+    if (!ruleIds.has(node.id)) {
+      store.removeNode(node.id);
+    }
+  }
+}
+function hasMatchingViolation(rule, violationsByCategory) {
+  const files = violationsByCategory.get(rule.category);
+  if (!files || files.length === 0) return false;
+  if (rule.scope === "project") return true;
+  return files.some((file) => file.startsWith(rule.scope));
+}
+
+// src/architecture/detect-stale.ts
+function detectStaleConstraints(store, windowDays = 30, category) {
+  const now = Date.now();
+  const windowMs = windowDays * 24 * 60 * 60 * 1e3;
+  const cutoff = now - windowMs;
+  let constraints = store.findNodes({ type: "constraint" });
+  if (category) {
+    constraints = constraints.filter((n) => n.category === category);
+  }
+  const totalConstraints = constraints.length;
+  const staleConstraints = [];
+  for (const node of constraints) {
+    const lastViolatedAt = node.lastViolatedAt ?? null;
+    const createdAt = node.createdAt;
+    const comparisonTimestamp = lastViolatedAt ?? createdAt;
+    if (!comparisonTimestamp) continue;
+    const timestampMs = new Date(comparisonTimestamp).getTime();
+    if (timestampMs < cutoff) {
+      const daysSince = Math.floor((now - timestampMs) / (24 * 60 * 60 * 1e3));
+      staleConstraints.push({
+        id: node.id,
+        category: node.category,
+        description: node.name ?? "",
+        scope: node.scope ?? "project",
+        lastViolatedAt,
+        daysSinceLastViolation: daysSince
+      });
+    }
+  }
+  staleConstraints.sort((a, b) => b.daysSinceLastViolation - a.daysSinceLastViolation);
+  return { staleConstraints, totalConstraints, windowDays };
+}
+
+// src/architecture/baseline-manager.ts
+var import_node_fs3 = require("fs");
+var import_node_crypto2 = require("crypto");
+var import_node_path10 = require("path");
+var ArchBaselineManager = class {
+  baselinesPath;
+  constructor(projectRoot, baselinePath) {
+    this.baselinesPath = baselinePath ? (0, import_node_path10.join)(projectRoot, baselinePath) : (0, import_node_path10.join)(projectRoot, ".harness", "arch", "baselines.json");
+  }
+  /**
+   * Snapshot the current metric results into an ArchBaseline.
+   * Aggregates multiple MetricResults for the same category by summing values
+   * and concatenating violation IDs.
+   */
+  capture(results, commitHash) {
+    const metrics = {};
+    for (const result of results) {
+      const existing = metrics[result.category];
+      if (existing) {
+        existing.value += result.value;
+        existing.violationIds.push(...result.violations.map((v) => v.id));
+      } else {
+        metrics[result.category] = {
+          value: result.value,
+          violationIds: result.violations.map((v) => v.id)
+        };
+      }
+    }
+    return {
+      version: 1,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedFrom: commitHash,
+      metrics
+    };
+  }
+  /**
+   * Load the baselines file from disk.
+   * Returns null if the file does not exist, contains invalid JSON,
+   * or fails ArchBaselineSchema validation.
+   */
+  load() {
+    if (!(0, import_node_fs3.existsSync)(this.baselinesPath)) {
+      console.error(`Baseline file not found at: ${this.baselinesPath}`);
+      return null;
+    }
+    try {
+      const raw = (0, import_node_fs3.readFileSync)(this.baselinesPath, "utf-8");
+      const data = JSON.parse(raw);
+      const parsed = ArchBaselineSchema.safeParse(data);
+      if (!parsed.success) {
+        console.error(
+          `Baseline validation failed for ${this.baselinesPath}:`,
+          parsed.error.format()
+        );
+        return null;
+      }
+      return parsed.data;
+    } catch (error) {
+      console.error(`Error loading baseline from ${this.baselinesPath}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Save an ArchBaseline to disk.
+   * Creates parent directories if they do not exist.
+   * Uses atomic write (write to temp file, then rename) to prevent corruption.
+   */
+  save(baseline) {
+    const dir = (0, import_node_path10.dirname)(this.baselinesPath);
+    if (!(0, import_node_fs3.existsSync)(dir)) {
+      (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
+    }
+    const tmp = this.baselinesPath + "." + (0, import_node_crypto2.randomBytes)(4).toString("hex") + ".tmp";
+    (0, import_node_fs3.writeFileSync)(tmp, JSON.stringify(baseline, null, 2));
+    (0, import_node_fs3.renameSync)(tmp, this.baselinesPath);
+  }
+};
+
+// src/architecture/diff.ts
+function aggregateByCategory(results) {
+  const map = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const existing = map.get(result.category);
+    if (existing) {
+      existing.value += result.value;
+      existing.violations.push(...result.violations);
+    } else {
+      map.set(result.category, {
+        value: result.value,
+        violations: [...result.violations]
+      });
+    }
+  }
+  return map;
+}
+function diff(current, baseline) {
+  const aggregated = aggregateByCategory(current);
+  const newViolations = [];
+  const resolvedViolations = [];
+  const preExisting = [];
+  const regressions = [];
+  const visitedCategories = /* @__PURE__ */ new Set();
+  for (const [category, agg] of aggregated) {
+    visitedCategories.add(category);
+    const baselineCategory = baseline.metrics[category];
+    const baselineViolationIds = new Set(baselineCategory?.violationIds ?? []);
+    const baselineValue = baselineCategory?.value ?? 0;
+    for (const violation of agg.violations) {
+      if (baselineViolationIds.has(violation.id)) {
+        preExisting.push(violation.id);
+      } else {
+        newViolations.push(violation);
+      }
+    }
+    const currentViolationIds = new Set(agg.violations.map((v) => v.id));
+    if (baselineCategory) {
+      for (const id of baselineCategory.violationIds) {
+        if (!currentViolationIds.has(id)) {
+          resolvedViolations.push(id);
+        }
+      }
+    }
+    if (baselineCategory && agg.value > baselineValue) {
+      regressions.push({
+        category,
+        baselineValue,
+        currentValue: agg.value,
+        delta: agg.value - baselineValue
+      });
+    }
+  }
+  for (const [category, baselineCategory] of Object.entries(baseline.metrics)) {
+    if (!visitedCategories.has(category) && baselineCategory) {
+      for (const id of baselineCategory.violationIds) {
+        resolvedViolations.push(id);
+      }
+    }
+  }
+  const passed = newViolations.length === 0 && regressions.length === 0;
+  return {
+    passed,
+    newViolations,
+    resolvedViolations,
+    preExisting,
+    regressions
+  };
+}
+
+// src/architecture/config.ts
+function resolveThresholds(scope, config) {
+  const projectThresholds = {};
+  for (const [key, val] of Object.entries(config.thresholds)) {
+    projectThresholds[key] = typeof val === "object" && val !== null && !Array.isArray(val) ? { ...val } : val;
+  }
+  if (scope === "project") {
+    return projectThresholds;
+  }
+  const moduleOverrides = config.modules[scope];
+  if (!moduleOverrides) {
+    return projectThresholds;
+  }
+  const merged = { ...projectThresholds };
+  for (const [category, moduleValue] of Object.entries(moduleOverrides)) {
+    const projectValue = projectThresholds[category];
+    if (projectValue !== void 0 && typeof projectValue === "object" && !Array.isArray(projectValue) && typeof moduleValue === "object" && !Array.isArray(moduleValue)) {
+      merged[category] = {
+        ...projectValue,
+        ...moduleValue
+      };
+    } else {
+      merged[category] = moduleValue;
+    }
+  }
+  return merged;
+}
+
+// src/architecture/matchers.ts
+function architecture(options) {
+  return {
+    kind: "arch-handle",
+    scope: "project",
+    rootDir: options?.rootDir ?? process.cwd(),
+    config: options?.config
+  };
+}
+function archModule(modulePath, options) {
+  return {
+    kind: "arch-handle",
+    scope: modulePath,
+    rootDir: options?.rootDir ?? process.cwd(),
+    config: options?.config
+  };
+}
+function resolveConfig(handle) {
+  return ArchConfigSchema.parse(handle.config ?? {});
+}
+async function collectCategory(handle, collector) {
+  if ("_mockResults" in handle && handle._mockResults) {
+    return handle._mockResults;
+  }
+  const config = resolveConfig(handle);
+  return collector.collect(config, handle.rootDir);
+}
+function formatViolationList(violations, limit = 10) {
+  const lines = violations.slice(0, limit).map((v) => `  - ${v.file}: ${v.detail}`);
+  if (violations.length > limit) {
+    lines.push(`  ... and ${violations.length - limit} more`);
+  }
+  return lines.join("\n");
+}
+async function toHaveNoCircularDeps(received) {
+  const results = await collectCategory(received, new CircularDepsCollector());
+  const violations = results.flatMap((r) => r.violations);
+  const pass = violations.length === 0;
+  return {
+    pass,
+    message: () => pass ? "Expected circular dependencies but found none" : `Found ${violations.length} circular dependenc${violations.length === 1 ? "y" : "ies"}:
+${formatViolationList(violations)}`
+  };
+}
+async function toHaveNoLayerViolations(received) {
+  const results = await collectCategory(received, new LayerViolationCollector());
+  const violations = results.flatMap((r) => r.violations);
+  const pass = violations.length === 0;
+  return {
+    pass,
+    message: () => pass ? "Expected layer violations but found none" : `Found ${violations.length} layer violation${violations.length === 1 ? "" : "s"}:
+${formatViolationList(violations)}`
+  };
+}
+async function toMatchBaseline(received, options) {
+  let diffResult;
+  if ("_mockDiff" in received && received._mockDiff) {
+    diffResult = received._mockDiff;
+  } else {
+    const config = resolveConfig(received);
+    const results = await runAll(config, received.rootDir);
+    const manager = new ArchBaselineManager(received.rootDir, config.baselinePath);
+    const baseline = manager.load();
+    if (!baseline) {
+      return {
+        pass: false,
+        message: () => "No baseline found. Run `harness check-arch --update-baseline` to create one."
+      };
+    }
+    diffResult = diff(results, baseline);
+  }
+  const tolerance = options?.tolerance ?? 0;
+  const effectiveNewCount = Math.max(0, diffResult.newViolations.length - tolerance);
+  const pass = effectiveNewCount === 0 && diffResult.regressions.length === 0;
+  return {
+    pass,
+    message: () => {
+      if (pass) {
+        return "Expected baseline regression but architecture matches baseline";
+      }
+      const parts = [];
+      if (diffResult.newViolations.length > 0) {
+        parts.push(
+          `${diffResult.newViolations.length} new violation${diffResult.newViolations.length === 1 ? "" : "s"}${tolerance > 0 ? ` (tolerance: ${tolerance})` : ""}:
+${formatViolationList(diffResult.newViolations)}`
+        );
+      }
+      if (diffResult.regressions.length > 0) {
+        const regLines = diffResult.regressions.map(
+          (r) => `  - ${r.category}: ${r.baselineValue} -> ${r.currentValue} (+${r.delta})`
+        );
+        parts.push(`Regressions:
+${regLines.join("\n")}`);
+      }
+      return `Baseline check failed:
+${parts.join("\n\n")}`;
+    }
+  };
+}
+function filterByScope(results, scope) {
+  return results.filter(
+    (r) => r.scope === scope || r.scope.startsWith(scope + "/") || r.scope === "project"
+  );
+}
+async function toHaveMaxComplexity(received, maxComplexity) {
+  const results = await collectCategory(received, new ComplexityCollector());
+  const scoped = filterByScope(results, received.scope);
+  const violations = scoped.flatMap((r) => r.violations);
+  const totalValue = scoped.reduce((sum, r) => sum + r.value, 0);
+  const pass = totalValue <= maxComplexity && violations.length === 0;
+  return {
+    pass,
+    message: () => pass ? `Expected complexity to exceed ${maxComplexity} but it was within limits` : `Module '${received.scope}' has complexity violations (${violations.length} violation${violations.length === 1 ? "" : "s"}):
+${formatViolationList(violations)}`
+  };
+}
+async function toHaveMaxCoupling(received, limits) {
+  const config = resolveConfig(received);
+  if (limits.fanIn !== void 0 || limits.fanOut !== void 0) {
+    config.thresholds.coupling = {
+      ...typeof config.thresholds.coupling === "object" ? config.thresholds.coupling : {},
+      ...limits.fanIn !== void 0 ? { maxFanIn: limits.fanIn } : {},
+      ...limits.fanOut !== void 0 ? { maxFanOut: limits.fanOut } : {}
+    };
+  }
+  const collector = new CouplingCollector();
+  const results = "_mockResults" in received && received._mockResults ? received._mockResults : await collector.collect(config, received.rootDir);
+  const scoped = filterByScope(results, received.scope);
+  const violations = scoped.flatMap((r) => r.violations);
+  const pass = violations.length === 0;
+  return {
+    pass,
+    message: () => pass ? `Expected coupling violations in '${received.scope}' but found none` : `Module '${received.scope}' has ${violations.length} coupling violation${violations.length === 1 ? "" : "s"} (fanIn limit: ${limits.fanIn ?? "none"}, fanOut limit: ${limits.fanOut ?? "none"}):
+${formatViolationList(violations)}`
+  };
+}
+async function toHaveMaxFileCount(received, maxFiles) {
+  const results = await collectCategory(received, new ModuleSizeCollector());
+  const scoped = filterByScope(results, received.scope);
+  const fileCount = scoped.reduce((max, r) => {
+    const meta = r.metadata;
+    const fc = typeof meta?.fileCount === "number" ? meta.fileCount : 0;
+    return fc > max ? fc : max;
+  }, 0);
+  const pass = fileCount <= maxFiles;
+  return {
+    pass,
+    message: () => pass ? `Expected file count in '${received.scope}' to exceed ${maxFiles} but it was ${fileCount}` : `Module '${received.scope}' has ${fileCount} files (limit: ${maxFiles})`
+  };
+}
+async function toNotDependOn(received, forbiddenModule) {
+  const results = await collectCategory(received, new ForbiddenImportCollector());
+  const allViolations = results.flatMap((r) => r.violations);
+  const scopePrefix = received.scope.replace(/\/+$/, "");
+  const forbiddenPrefix = forbiddenModule.replace(/\/+$/, "");
+  const relevantViolations = allViolations.filter(
+    (v) => (v.file === scopePrefix || v.file.startsWith(scopePrefix + "/")) && (v.detail.includes(forbiddenPrefix + "/") || v.detail.endsWith(forbiddenPrefix))
+  );
+  const pass = relevantViolations.length === 0;
+  return {
+    pass,
+    message: () => pass ? `Expected '${received.scope}' to depend on '${forbiddenModule}' but no such imports found` : `Module '${received.scope}' depends on '${forbiddenModule}' (${relevantViolations.length} import${relevantViolations.length === 1 ? "" : "s"}):
+${formatViolationList(relevantViolations)}`
+  };
+}
+async function toHaveMaxDepDepth(received, maxDepth) {
+  const results = await collectCategory(received, new DepDepthCollector());
+  const scoped = filterByScope(results, received.scope);
+  const maxActual = scoped.reduce((max, r) => r.value > max ? r.value : max, 0);
+  const pass = maxActual <= maxDepth;
+  return {
+    pass,
+    message: () => pass ? `Expected dependency depth in '${received.scope}' to exceed ${maxDepth} but it was ${maxActual}` : `Module '${received.scope}' has dependency depth ${maxActual} (limit: ${maxDepth})`
+  };
+}
+var archMatchers = {
+  toHaveNoCircularDeps,
+  toHaveNoLayerViolations,
+  toMatchBaseline,
+  toHaveMaxComplexity,
+  toHaveMaxCoupling,
+  toHaveMaxFileCount,
+  toNotDependOn,
+  toHaveMaxDepDepth
+};
+
 // src/state/types.ts
-var import_zod2 = require("zod");
-var FailureEntrySchema = import_zod2.z.object({
-  date: import_zod2.z.string(),
-  skill: import_zod2.z.string(),
-  type: import_zod2.z.string(),
-  description: import_zod2.z.string()
+var import_zod4 = require("zod");
+var FailureEntrySchema = import_zod4.z.object({
+  date: import_zod4.z.string(),
+  skill: import_zod4.z.string(),
+  type: import_zod4.z.string(),
+  description: import_zod4.z.string()
 });
-var HandoffSchema = import_zod2.z.object({
-  timestamp: import_zod2.z.string(),
-  fromSkill: import_zod2.z.string(),
-  phase: import_zod2.z.string(),
-  summary: import_zod2.z.string(),
-  completed: import_zod2.z.array(import_zod2.z.string()).default([]),
-  pending: import_zod2.z.array(import_zod2.z.string()).default([]),
-  concerns: import_zod2.z.array(import_zod2.z.string()).default([]),
-  decisions: import_zod2.z.array(
-    import_zod2.z.object({
-      what: import_zod2.z.string(),
-      why: import_zod2.z.string()
+var HandoffSchema = import_zod4.z.object({
+  timestamp: import_zod4.z.string(),
+  fromSkill: import_zod4.z.string(),
+  phase: import_zod4.z.string(),
+  summary: import_zod4.z.string(),
+  completed: import_zod4.z.array(import_zod4.z.string()).default([]),
+  pending: import_zod4.z.array(import_zod4.z.string()).default([]),
+  concerns: import_zod4.z.array(import_zod4.z.string()).default([]),
+  decisions: import_zod4.z.array(
+    import_zod4.z.object({
+      what: import_zod4.z.string(),
+      why: import_zod4.z.string()
     })
   ).default([]),
-  blockers: import_zod2.z.array(import_zod2.z.string()).default([]),
-  contextKeywords: import_zod2.z.array(import_zod2.z.string()).default([])
+  blockers: import_zod4.z.array(import_zod4.z.string()).default([]),
+  contextKeywords: import_zod4.z.array(import_zod4.z.string()).default([])
 });
-var GateCheckSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  passed: import_zod2.z.boolean(),
-  command: import_zod2.z.string(),
-  output: import_zod2.z.string().optional(),
-  duration: import_zod2.z.number().optional()
+var GateCheckSchema = import_zod4.z.object({
+  name: import_zod4.z.string(),
+  passed: import_zod4.z.boolean(),
+  command: import_zod4.z.string(),
+  output: import_zod4.z.string().optional(),
+  duration: import_zod4.z.number().optional()
 });
-var GateResultSchema = import_zod2.z.object({
-  passed: import_zod2.z.boolean(),
-  checks: import_zod2.z.array(GateCheckSchema)
+var GateResultSchema = import_zod4.z.object({
+  passed: import_zod4.z.boolean(),
+  checks: import_zod4.z.array(GateCheckSchema)
 });
-var GateConfigSchema = import_zod2.z.object({
-  checks: import_zod2.z.array(
-    import_zod2.z.object({
-      name: import_zod2.z.string(),
-      command: import_zod2.z.string()
+var GateConfigSchema = import_zod4.z.object({
+  checks: import_zod4.z.array(
+    import_zod4.z.object({
+      name: import_zod4.z.string(),
+      command: import_zod4.z.string()
     })
   ).optional(),
-  trace: import_zod2.z.boolean().optional()
+  trace: import_zod4.z.boolean().optional()
 });
-var HarnessStateSchema = import_zod2.z.object({
-  schemaVersion: import_zod2.z.literal(1),
-  position: import_zod2.z.object({
-    phase: import_zod2.z.string().optional(),
-    task: import_zod2.z.string().optional()
+var HarnessStateSchema = import_zod4.z.object({
+  schemaVersion: import_zod4.z.literal(1),
+  position: import_zod4.z.object({
+    phase: import_zod4.z.string().optional(),
+    task: import_zod4.z.string().optional()
   }).default({}),
-  decisions: import_zod2.z.array(
-    import_zod2.z.object({
-      date: import_zod2.z.string(),
-      decision: import_zod2.z.string(),
-      context: import_zod2.z.string()
+  decisions: import_zod4.z.array(
+    import_zod4.z.object({
+      date: import_zod4.z.string(),
+      decision: import_zod4.z.string(),
+      context: import_zod4.z.string()
     })
   ).default([]),
-  blockers: import_zod2.z.array(
-    import_zod2.z.object({
-      id: import_zod2.z.string(),
-      description: import_zod2.z.string(),
-      status: import_zod2.z.enum(["open", "resolved"])
+  blockers: import_zod4.z.array(
+    import_zod4.z.object({
+      id: import_zod4.z.string(),
+      description: import_zod4.z.string(),
+      status: import_zod4.z.enum(["open", "resolved"])
     })
   ).default([]),
-  progress: import_zod2.z.record(import_zod2.z.enum(["pending", "in_progress", "complete"])).default({}),
-  lastSession: import_zod2.z.object({
-    date: import_zod2.z.string(),
-    summary: import_zod2.z.string(),
-    lastSkill: import_zod2.z.string().optional(),
-    pendingTasks: import_zod2.z.array(import_zod2.z.string()).optional()
+  progress: import_zod4.z.record(import_zod4.z.enum(["pending", "in_progress", "complete"])).default({}),
+  lastSession: import_zod4.z.object({
+    date: import_zod4.z.string(),
+    summary: import_zod4.z.string(),
+    lastSkill: import_zod4.z.string().optional(),
+    pendingTasks: import_zod4.z.array(import_zod4.z.string()).optional()
   }).optional()
 });
 var DEFAULT_STATE = {
@@ -4973,27 +6626,27 @@ var DEFAULT_STATE = {
 };
 
 // src/state/state-manager.ts
-var fs4 = __toESM(require("fs"));
+var fs6 = __toESM(require("fs"));
 var path3 = __toESM(require("path"));
 var import_child_process2 = require("child_process");
 
 // src/state/stream-resolver.ts
-var fs3 = __toESM(require("fs"));
+var fs5 = __toESM(require("fs"));
 var path2 = __toESM(require("path"));
 var import_child_process = require("child_process");
 
 // src/state/stream-types.ts
-var import_zod3 = require("zod");
-var StreamInfoSchema = import_zod3.z.object({
-  name: import_zod3.z.string(),
-  branch: import_zod3.z.string().optional(),
-  createdAt: import_zod3.z.string(),
-  lastActiveAt: import_zod3.z.string()
+var import_zod5 = require("zod");
+var StreamInfoSchema = import_zod5.z.object({
+  name: import_zod5.z.string(),
+  branch: import_zod5.z.string().optional(),
+  createdAt: import_zod5.z.string(),
+  lastActiveAt: import_zod5.z.string()
 });
-var StreamIndexSchema = import_zod3.z.object({
-  schemaVersion: import_zod3.z.literal(1),
-  activeStream: import_zod3.z.string().nullable(),
-  streams: import_zod3.z.record(StreamInfoSchema)
+var StreamIndexSchema = import_zod5.z.object({
+  schemaVersion: import_zod5.z.literal(1),
+  activeStream: import_zod5.z.string().nullable(),
+  streams: import_zod5.z.record(StreamInfoSchema)
 });
 var DEFAULT_STREAM_INDEX = {
   schemaVersion: 1,
@@ -5024,11 +6677,11 @@ function validateStreamName(name) {
 }
 async function loadStreamIndex(projectPath) {
   const idxPath = indexPath(projectPath);
-  if (!fs3.existsSync(idxPath)) {
+  if (!fs5.existsSync(idxPath)) {
     return (0, import_types.Ok)({ ...DEFAULT_STREAM_INDEX, streams: {} });
   }
   try {
-    const raw = fs3.readFileSync(idxPath, "utf-8");
+    const raw = fs5.readFileSync(idxPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = StreamIndexSchema.safeParse(parsed);
     if (!result.success) {
@@ -5046,8 +6699,8 @@ async function loadStreamIndex(projectPath) {
 async function saveStreamIndex(projectPath, index) {
   const dir = streamsDir(projectPath);
   try {
-    fs3.mkdirSync(dir, { recursive: true });
-    fs3.writeFileSync(indexPath(projectPath), JSON.stringify(index, null, 2));
+    fs5.mkdirSync(dir, { recursive: true });
+    fs5.writeFileSync(indexPath(projectPath), JSON.stringify(index, null, 2));
     return (0, import_types.Ok)(void 0);
   } catch (error) {
     return (0, import_types.Err)(
@@ -5129,7 +6782,7 @@ async function createStream(projectPath, name, branch) {
   }
   const streamPath = path2.join(streamsDir(projectPath), name);
   try {
-    fs3.mkdirSync(streamPath, { recursive: true });
+    fs5.mkdirSync(streamPath, { recursive: true });
   } catch (error) {
     return (0, import_types.Err)(
       new Error(
@@ -5173,9 +6826,9 @@ async function archiveStream(projectPath, name) {
   const streamPath = path2.join(streamsDir(projectPath), name);
   const archiveDir = path2.join(projectPath, HARNESS_DIR, "archive", "streams");
   try {
-    fs3.mkdirSync(archiveDir, { recursive: true });
+    fs5.mkdirSync(archiveDir, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    fs3.renameSync(streamPath, path2.join(archiveDir, `${name}-${date}`));
+    fs5.renameSync(streamPath, path2.join(archiveDir, `${name}-${date}`));
   } catch (error) {
     return (0, import_types.Err)(
       new Error(
@@ -5198,18 +6851,18 @@ function getStreamForBranch(index, branch) {
 var STATE_FILES = ["state.json", "handoff.json", "learnings.md", "failures.md"];
 async function migrateToStreams(projectPath) {
   const harnessDir = path2.join(projectPath, HARNESS_DIR);
-  if (fs3.existsSync(indexPath(projectPath))) {
+  if (fs5.existsSync(indexPath(projectPath))) {
     return (0, import_types.Ok)(void 0);
   }
-  const filesToMove = STATE_FILES.filter((f) => fs3.existsSync(path2.join(harnessDir, f)));
+  const filesToMove = STATE_FILES.filter((f) => fs5.existsSync(path2.join(harnessDir, f)));
   if (filesToMove.length === 0) {
     return (0, import_types.Ok)(void 0);
   }
   const defaultDir = path2.join(streamsDir(projectPath), "default");
   try {
-    fs3.mkdirSync(defaultDir, { recursive: true });
+    fs5.mkdirSync(defaultDir, { recursive: true });
     for (const file of filesToMove) {
-      fs3.renameSync(path2.join(harnessDir, file), path2.join(defaultDir, file));
+      fs5.renameSync(path2.join(harnessDir, file), path2.join(defaultDir, file));
     }
   } catch (error) {
     return (0, import_types.Err)(
@@ -5250,7 +6903,7 @@ function evictIfNeeded(map) {
 }
 async function getStateDir(projectPath, stream) {
   const streamsIndexPath = path3.join(projectPath, HARNESS_DIR2, "streams", INDEX_FILE2);
-  const hasStreams = fs4.existsSync(streamsIndexPath);
+  const hasStreams = fs6.existsSync(streamsIndexPath);
   if (stream || hasStreams) {
     const result = await resolveStreamPath(projectPath, stream ? { stream } : void 0);
     if (result.ok) {
@@ -5268,10 +6921,10 @@ async function loadState(projectPath, stream) {
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
     const statePath = path3.join(stateDir, STATE_FILE);
-    if (!fs4.existsSync(statePath)) {
+    if (!fs6.existsSync(statePath)) {
       return (0, import_types.Ok)({ ...DEFAULT_STATE });
     }
-    const raw = fs4.readFileSync(statePath, "utf-8");
+    const raw = fs6.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = HarnessStateSchema.safeParse(parsed);
     if (!result.success) {
@@ -5290,8 +6943,8 @@ async function saveState(projectPath, state, stream) {
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
     const statePath = path3.join(stateDir, STATE_FILE);
-    fs4.mkdirSync(stateDir, { recursive: true });
-    fs4.writeFileSync(statePath, JSON.stringify(state, null, 2));
+    fs6.mkdirSync(stateDir, { recursive: true });
+    fs6.writeFileSync(statePath, JSON.stringify(state, null, 2));
     return (0, import_types.Ok)(void 0);
   } catch (error) {
     return (0, import_types.Err)(
@@ -5305,7 +6958,7 @@ async function appendLearning(projectPath, learning, skillName, outcome, stream)
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
     const learningsPath = path3.join(stateDir, LEARNINGS_FILE);
-    fs4.mkdirSync(stateDir, { recursive: true });
+    fs6.mkdirSync(stateDir, { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     let entry;
     if (skillName && outcome) {
@@ -5321,11 +6974,11 @@ async function appendLearning(projectPath, learning, skillName, outcome, stream)
 - **${timestamp}:** ${learning}
 `;
     }
-    if (!fs4.existsSync(learningsPath)) {
-      fs4.writeFileSync(learningsPath, `# Learnings
+    if (!fs6.existsSync(learningsPath)) {
+      fs6.writeFileSync(learningsPath, `# Learnings
 ${entry}`);
     } else {
-      fs4.appendFileSync(learningsPath, entry);
+      fs6.appendFileSync(learningsPath, entry);
     }
     learningsCacheMap.delete(learningsPath);
     return (0, import_types.Ok)(void 0);
@@ -5343,17 +6996,17 @@ async function loadRelevantLearnings(projectPath, skillName, stream) {
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
     const learningsPath = path3.join(stateDir, LEARNINGS_FILE);
-    if (!fs4.existsSync(learningsPath)) {
+    if (!fs6.existsSync(learningsPath)) {
       return (0, import_types.Ok)([]);
     }
-    const stats = fs4.statSync(learningsPath);
+    const stats = fs6.statSync(learningsPath);
     const cacheKey = learningsPath;
     const cached = learningsCacheMap.get(cacheKey);
     let entries;
     if (cached && cached.mtimeMs === stats.mtimeMs) {
       entries = cached.entries;
     } else {
-      const content = fs4.readFileSync(learningsPath, "utf-8");
+      const content = fs6.readFileSync(learningsPath, "utf-8");
       const lines = content.split("\n");
       entries = [];
       let currentBlock = [];
@@ -5396,16 +7049,16 @@ async function appendFailure(projectPath, description, skillName, type, stream)
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
     const failuresPath = path3.join(stateDir, FAILURES_FILE);
-    fs4.mkdirSync(stateDir, { recursive: true });
+    fs6.mkdirSync(stateDir, { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const entry = `
 - **${timestamp} [skill:${skillName}] [type:${type}]:** ${description}
 `;
-    if (!fs4.existsSync(failuresPath)) {
-      fs4.writeFileSync(failuresPath, `# Failures
+    if (!fs6.existsSync(failuresPath)) {
+      fs6.writeFileSync(failuresPath, `# Failures
 ${entry}`);
     } else {
-      fs4.appendFileSync(failuresPath, entry);
+      fs6.appendFileSync(failuresPath, entry);
     }
     failuresCacheMap.delete(failuresPath);
     return (0, import_types.Ok)(void 0);
@@ -5423,16 +7076,16 @@ async function loadFailures(projectPath, stream) {
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
     const failuresPath = path3.join(stateDir, FAILURES_FILE);
-    if (!fs4.existsSync(failuresPath)) {
+    if (!fs6.existsSync(failuresPath)) {
       return (0, import_types.Ok)([]);
     }
-    const stats = fs4.statSync(failuresPath);
+    const stats = fs6.statSync(failuresPath);
     const cacheKey = failuresPath;
     const cached = failuresCacheMap.get(cacheKey);
     if (cached && cached.mtimeMs === stats.mtimeMs) {
       return (0, import_types.Ok)(cached.entries);
     }
-    const content = fs4.readFileSync(failuresPath, "utf-8");
+    const content = fs6.readFileSync(failuresPath, "utf-8");
     const entries = [];
     for (const line of content.split("\n")) {
       const match = line.match(FAILURE_LINE_REGEX);
@@ -5462,19 +7115,19 @@ async function archiveFailures(projectPath, stream) {
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
     const failuresPath = path3.join(stateDir, FAILURES_FILE);
-    if (!fs4.existsSync(failuresPath)) {
+    if (!fs6.existsSync(failuresPath)) {
       return (0, import_types.Ok)(void 0);
     }
     const archiveDir = path3.join(stateDir, "archive");
-    fs4.mkdirSync(archiveDir, { recursive: true });
+    fs6.mkdirSync(archiveDir, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     let archiveName = `failures-${date}.md`;
     let counter = 2;
-    while (fs4.existsSync(path3.join(archiveDir, archiveName))) {
+    while (fs6.existsSync(path3.join(archiveDir, archiveName))) {
       archiveName = `failures-${date}-${counter}.md`;
       counter++;
     }
-    fs4.renameSync(failuresPath, path3.join(archiveDir, archiveName));
+    fs6.renameSync(failuresPath, path3.join(archiveDir, archiveName));
     failuresCacheMap.delete(failuresPath);
     return (0, import_types.Ok)(void 0);
   } catch (error) {
@@ -5491,8 +7144,8 @@ async function saveHandoff(projectPath, handoff, stream) {
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
     const handoffPath = path3.join(stateDir, HANDOFF_FILE);
-    fs4.mkdirSync(stateDir, { recursive: true });
-    fs4.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2));
+    fs6.mkdirSync(stateDir, { recursive: true });
+    fs6.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2));
     return (0, import_types.Ok)(void 0);
   } catch (error) {
     return (0, import_types.Err)(
@@ -5506,10 +7159,10 @@ async function loadHandoff(projectPath, stream) {
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
     const handoffPath = path3.join(stateDir, HANDOFF_FILE);
-    if (!fs4.existsSync(handoffPath)) {
+    if (!fs6.existsSync(handoffPath)) {
       return (0, import_types.Ok)(null);
     }
-    const raw = fs4.readFileSync(handoffPath, "utf-8");
+    const raw = fs6.readFileSync(handoffPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = HandoffSchema.safeParse(parsed);
     if (!result.success) {
@@ -5527,8 +7180,8 @@ async function runMechanicalGate(projectPath) {
   const gateConfigPath = path3.join(harnessDir, GATE_CONFIG_FILE);
   try {
     let checks = [];
-    if (fs4.existsSync(gateConfigPath)) {
-      const raw = JSON.parse(fs4.readFileSync(gateConfigPath, "utf-8"));
+    if (fs6.existsSync(gateConfigPath)) {
+      const raw = JSON.parse(fs6.readFileSync(gateConfigPath, "utf-8"));
       const config = GateConfigSchema.safeParse(raw);
       if (config.success && config.data.checks) {
         checks = config.data.checks;
@@ -5536,19 +7189,19 @@ async function runMechanicalGate(projectPath) {
     }
     if (checks.length === 0) {
       const packageJsonPath = path3.join(projectPath, "package.json");
-      if (fs4.existsSync(packageJsonPath)) {
-        const pkg = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
+      if (fs6.existsSync(packageJsonPath)) {
+        const pkg = JSON.parse(fs6.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 (fs4.existsSync(path3.join(projectPath, "go.mod"))) {
+      if (fs6.existsSync(path3.join(projectPath, "go.mod"))) {
         checks.push({ name: "test", command: "go test ./..." });
         checks.push({ name: "build", command: "go build ./..." });
       }
-      if (fs4.existsSync(path3.join(projectPath, "pyproject.toml")) || fs4.existsSync(path3.join(projectPath, "setup.py"))) {
+      if (fs6.existsSync(path3.join(projectPath, "pyproject.toml")) || fs6.existsSync(path3.join(projectPath, "setup.py"))) {
         checks.push({ name: "test", command: "python -m pytest" });
       }
     }
@@ -5751,7 +7404,7 @@ async function runMultiTurnPipeline(initialContext, turnExecutor, options) {
 }
 
 // src/security/scanner.ts
-var fs6 = __toESM(require("fs/promises"));
+var fs8 = __toESM(require("fs/promises"));
 
 // src/security/rules/registry.ts
 var RuleRegistry = class {
@@ -5782,7 +7435,7 @@ var RuleRegistry = class {
 };
 
 // src/security/config.ts
-var import_zod4 = require("zod");
+var import_zod6 = require("zod");
 
 // src/security/types.ts
 var DEFAULT_SECURITY_CONFIG = {
@@ -5793,19 +7446,19 @@ var DEFAULT_SECURITY_CONFIG = {
 };
 
 // src/security/config.ts
-var RuleOverrideSchema = import_zod4.z.enum(["off", "error", "warning", "info"]);
-var SecurityConfigSchema = import_zod4.z.object({
-  enabled: import_zod4.z.boolean().default(true),
-  strict: import_zod4.z.boolean().default(false),
-  rules: import_zod4.z.record(import_zod4.z.string(), RuleOverrideSchema).optional().default({}),
-  exclude: import_zod4.z.array(import_zod4.z.string()).optional().default(["**/node_modules/**", "**/dist/**", "**/*.test.ts", "**/fixtures/**"]),
-  external: import_zod4.z.object({
-    semgrep: import_zod4.z.object({
-      enabled: import_zod4.z.union([import_zod4.z.literal("auto"), import_zod4.z.boolean()]).default("auto"),
-      rulesets: import_zod4.z.array(import_zod4.z.string()).optional()
+var RuleOverrideSchema = import_zod6.z.enum(["off", "error", "warning", "info"]);
+var SecurityConfigSchema = import_zod6.z.object({
+  enabled: import_zod6.z.boolean().default(true),
+  strict: import_zod6.z.boolean().default(false),
+  rules: import_zod6.z.record(import_zod6.z.string(), RuleOverrideSchema).optional().default({}),
+  exclude: import_zod6.z.array(import_zod6.z.string()).optional().default(["**/node_modules/**", "**/dist/**", "**/*.test.ts", "**/fixtures/**"]),
+  external: import_zod6.z.object({
+    semgrep: import_zod6.z.object({
+      enabled: import_zod6.z.union([import_zod6.z.literal("auto"), import_zod6.z.boolean()]).default("auto"),
+      rulesets: import_zod6.z.array(import_zod6.z.string()).optional()
     }).optional(),
-    gitleaks: import_zod4.z.object({
-      enabled: import_zod4.z.union([import_zod4.z.literal("auto"), import_zod4.z.boolean()]).default("auto")
+    gitleaks: import_zod6.z.object({
+      enabled: import_zod6.z.union([import_zod6.z.literal("auto"), import_zod6.z.boolean()]).default("auto")
     }).optional()
   }).optional()
 });
@@ -5838,15 +7491,15 @@ function resolveRuleSeverity(ruleId, defaultSeverity, overrides, strict) {
 }
 
 // src/security/stack-detector.ts
-var fs5 = __toESM(require("fs"));
+var fs7 = __toESM(require("fs"));
 var path4 = __toESM(require("path"));
 function detectStack(projectRoot) {
   const stacks = [];
   const pkgJsonPath = path4.join(projectRoot, "package.json");
-  if (fs5.existsSync(pkgJsonPath)) {
+  if (fs7.existsSync(pkgJsonPath)) {
     stacks.push("node");
     try {
-      const pkgJson = JSON.parse(fs5.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
       const allDeps = {
         ...pkgJson.dependencies,
         ...pkgJson.devDependencies
@@ -5862,12 +7515,12 @@ function detectStack(projectRoot) {
     }
   }
   const goModPath = path4.join(projectRoot, "go.mod");
-  if (fs5.existsSync(goModPath)) {
+  if (fs7.existsSync(goModPath)) {
     stacks.push("go");
   }
   const requirementsPath = path4.join(projectRoot, "requirements.txt");
   const pyprojectPath = path4.join(projectRoot, "pyproject.toml");
-  if (fs5.existsSync(requirementsPath) || fs5.existsSync(pyprojectPath)) {
+  if (fs7.existsSync(requirementsPath) || fs7.existsSync(pyprojectPath)) {
     stacks.push("python");
   }
   return stacks;
@@ -6294,7 +7947,7 @@ var SecurityScanner = class {
   }
   async scanFile(filePath) {
     if (!this.config.enabled) return [];
-    const content = await fs6.readFile(filePath, "utf-8");
+    const content = await fs8.readFile(filePath, "utf-8");
     return this.scanContent(content, filePath, 1);
   }
   async scanFiles(filePaths) {
@@ -6327,7 +7980,8 @@ var ALL_CHECKS = [
   "entropy",
   "security",
   "perf",
-  "phase-gate"
+  "phase-gate",
+  "arch"
 ];
 async function runSingleCheck(name, projectRoot, config) {
   const start = Date.now();
@@ -6391,7 +8045,17 @@ async function runSingleCheck(name, projectRoot, config) {
       }
       case "docs": {
         const docsDir = path5.join(projectRoot, config.docsDir ?? "docs");
-        const result = await checkDocCoverage("project", { docsDir });
+        const entropyConfig = config.entropy || {};
+        const result = await checkDocCoverage("project", {
+          docsDir,
+          sourceDir: projectRoot,
+          excludePatterns: entropyConfig.excludePatterns || [
+            "**/node_modules/**",
+            "**/dist/**",
+            "**/*.test.ts",
+            "**/fixtures/**"
+          ]
+        });
         if (!result.ok) {
           issues.push({ severity: "warning", message: result.error.message });
         } else if (result.value.gaps.length > 0) {
@@ -6466,11 +8130,13 @@ async function runSingleCheck(name, projectRoot, config) {
         break;
       }
       case "perf": {
+        const perfConfig = config.performance || {};
         const perfAnalyzer = new EntropyAnalyzer({
           rootDir: projectRoot,
           analyze: {
-            complexity: true,
-            coupling: true
+            complexity: perfConfig.complexity || true,
+            coupling: perfConfig.coupling || true,
+            sizeBudget: perfConfig.sizeBudget || false
           }
         });
         const perfResult = await perfAnalyzer.analyze();
@@ -6511,6 +8177,43 @@ async function runSingleCheck(name, projectRoot, config) {
         });
         break;
       }
+      case "arch": {
+        const rawArchConfig = config.architecture;
+        const archConfig = ArchConfigSchema.parse(rawArchConfig ?? {});
+        if (!archConfig.enabled) break;
+        const results = await runAll(archConfig, projectRoot);
+        const baselineManager = new ArchBaselineManager(projectRoot, archConfig.baselinePath);
+        const baseline = baselineManager.load();
+        if (baseline) {
+          const diffResult = diff(results, baseline);
+          if (!diffResult.passed) {
+            for (const v of diffResult.newViolations) {
+              issues.push({
+                severity: v.severity,
+                message: `[${v.category || "arch"}] NEW: ${v.detail}`,
+                file: v.file
+              });
+            }
+            for (const r of diffResult.regressions) {
+              issues.push({
+                severity: "error",
+                message: `[${r.category}] REGRESSION: ${r.currentValue} > ${r.baselineValue} (delta: ${r.delta})`
+              });
+            }
+          }
+        } else {
+          for (const result of results) {
+            for (const v of result.violations) {
+              issues.push({
+                severity: v.severity,
+                message: `[${result.category}] ${v.detail}`,
+                file: v.file
+              });
+            }
+          }
+        }
+        break;
+      }
     }
   } catch (error) {
     issues.push({
@@ -6845,22 +8548,22 @@ var PREFIX_PATTERNS = [
 ];
 var TEST_FILE_PATTERN = /\.(test|spec)\.(ts|tsx|js|jsx|mts|cts)$/;
 var MD_FILE_PATTERN = /\.md$/;
-function detectChangeType(commitMessage, diff) {
+function detectChangeType(commitMessage, diff2) {
   const trimmed = commitMessage.trim();
   for (const { pattern, type } of PREFIX_PATTERNS) {
     if (pattern.test(trimmed)) {
       return type;
     }
   }
-  if (diff.changedFiles.length > 0 && diff.changedFiles.every((f) => MD_FILE_PATTERN.test(f))) {
+  if (diff2.changedFiles.length > 0 && diff2.changedFiles.every((f) => MD_FILE_PATTERN.test(f))) {
     return "docs";
   }
-  const newNonTestFiles = diff.newFiles.filter((f) => !TEST_FILE_PATTERN.test(f));
+  const newNonTestFiles = diff2.newFiles.filter((f) => !TEST_FILE_PATTERN.test(f));
   if (newNonTestFiles.length > 0) {
     return "feature";
   }
-  const hasNewTestFile = diff.newFiles.some((f) => TEST_FILE_PATTERN.test(f));
-  if (diff.totalDiffLines < 20 && hasNewTestFile) {
+  const hasNewTestFile = diff2.newFiles.some((f) => TEST_FILE_PATTERN.test(f));
+  if (diff2.totalDiffLines < 20 && hasNewTestFile) {
     return "bugfix";
   }
   return "feature";
@@ -6889,7 +8592,7 @@ async function readContextFile(projectRoot, filePath, reason) {
   const relPath = path7.isAbsolute(filePath) ? path7.relative(projectRoot, filePath) : filePath;
   return { path: relPath, content, reason, lines };
 }
-function extractImportSources(content) {
+function extractImportSources2(content) {
   const sources = [];
   const importRegex = /(?:import\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"]|require\(\s*['"]([^'"]+)['"]\s*\))/g;
   let match;
@@ -6931,7 +8634,7 @@ async function gatherImportContext(projectRoot, changedFiles, budget) {
   const seen = new Set(changedFiles.map((f) => f.path));
   for (const cf of changedFiles) {
     if (linesGathered >= budget) break;
-    const sources = extractImportSources(cf.content);
+    const sources = extractImportSources2(cf.content);
     for (const source of sources) {
       if (linesGathered >= budget) break;
       const resolved = await resolveImportPath2(projectRoot, cf.path, source);
@@ -7098,11 +8801,11 @@ async function scopeArchitectureContext(projectRoot, changedFiles, budget, optio
   return contextFiles;
 }
 async function scopeContext(options) {
-  const { projectRoot, diff, commitMessage } = options;
-  const changeType = detectChangeType(commitMessage, diff);
-  const budget = computeContextBudget(diff.totalDiffLines);
+  const { projectRoot, diff: diff2, commitMessage } = options;
+  const changeType = detectChangeType(commitMessage, diff2);
+  const budget = computeContextBudget(diff2.totalDiffLines);
   const changedFiles = [];
-  for (const filePath of diff.changedFiles) {
+  for (const filePath of diff2.changedFiles) {
     const cf = await readContextFile(projectRoot, filePath, "changed");
     if (cf) changedFiles.push(cf);
   }
@@ -7122,7 +8825,7 @@ async function scopeContext(options) {
       changedFiles: [...changedFiles],
       contextFiles,
       commitHistory: options.commitHistory ?? [],
-      diffLines: diff.totalDiffLines,
+      diffLines: diff2.totalDiffLines,
       contextLines
     });
   }
@@ -8132,7 +9835,7 @@ function formatGitHubSummary(options) {
 async function runReviewPipeline(options) {
   const {
     projectRoot,
-    diff,
+    diff: diff2,
     commitMessage,
     flags,
     graph,
@@ -8166,7 +9869,7 @@ async function runReviewPipeline(options) {
       const mechResult = await runMechanicalChecks({
         projectRoot,
         config,
-        changedFiles: diff.changedFiles
+        changedFiles: diff2.changedFiles
       });
       if (mechResult.ok) {
         mechanicalResult = mechResult.value;
@@ -8205,7 +9908,7 @@ async function runReviewPipeline(options) {
   try {
     contextBundles = await scopeContext({
       projectRoot,
-      diff,
+      diff: diff2,
       commitMessage,
       ...graph != null ? { graph } : {},
       ...conventionFiles != null ? { conventionFiles } : {},
@@ -8219,14 +9922,14 @@ async function runReviewPipeline(options) {
       changedFiles: [],
       contextFiles: [],
       commitHistory: [],
-      diffLines: diff.totalDiffLines,
+      diffLines: diff2.totalDiffLines,
       contextLines: 0
     }));
   }
   const agentResults = await fanOutReview({ bundles: contextBundles });
   const rawFindings = agentResults.flatMap((r) => r.findings);
   const fileContents = /* @__PURE__ */ new Map();
-  for (const [file, content] of diff.fileDiffs) {
+  for (const [file, content] of diff2.fileDiffs) {
     fileContents.set(file, content);
   }
   const validatedFindings = await validateFindings({
@@ -8262,7 +9965,7 @@ async function runReviewPipeline(options) {
 }
 
 // src/roadmap/parse.ts
-var import_types9 = require("@harness-engineering/types");
+var import_types16 = require("@harness-engineering/types");
 var VALID_STATUSES = /* @__PURE__ */ new Set([
   "backlog",
   "planned",
@@ -8274,14 +9977,14 @@ var EM_DASH = "\u2014";
 function parseRoadmap(markdown) {
   const fmMatch = markdown.match(/^---\n([\s\S]*?)\n---/);
   if (!fmMatch) {
-    return (0, import_types9.Err)(new Error("Missing or malformed YAML frontmatter"));
+    return (0, import_types16.Err)(new Error("Missing or malformed YAML frontmatter"));
   }
   const fmResult = parseFrontmatter(fmMatch[1]);
   if (!fmResult.ok) return fmResult;
   const body = markdown.slice(fmMatch[0].length);
   const milestonesResult = parseMilestones(body);
   if (!milestonesResult.ok) return milestonesResult;
-  return (0, import_types9.Ok)({
+  return (0, import_types16.Ok)({
     frontmatter: fmResult.value,
     milestones: milestonesResult.value
   });
@@ -8301,7 +10004,7 @@ function parseFrontmatter(raw) {
   const lastSynced = map.get("last_synced");
   const lastManualEdit = map.get("last_manual_edit");
   if (!project || !versionStr || !lastSynced || !lastManualEdit) {
-    return (0, import_types9.Err)(
+    return (0, import_types16.Err)(
       new Error(
         "Frontmatter missing required fields: project, version, last_synced, last_manual_edit"
       )
@@ -8309,9 +10012,9 @@ function parseFrontmatter(raw) {
   }
   const version = parseInt(versionStr, 10);
   if (isNaN(version)) {
-    return (0, import_types9.Err)(new Error("Frontmatter version must be a number"));
+    return (0, import_types16.Err)(new Error("Frontmatter version must be a number"));
   }
-  return (0, import_types9.Ok)({ project, version, lastSynced, lastManualEdit });
+  return (0, import_types16.Ok)({ project, version, lastSynced, lastManualEdit });
 }
 function parseMilestones(body) {
   const milestones = [];
@@ -8335,7 +10038,7 @@ function parseMilestones(body) {
       features: featuresResult.value
     });
   }
-  return (0, import_types9.Ok)(milestones);
+  return (0, import_types16.Ok)(milestones);
 }
 function parseFeatures(sectionBody) {
   const features = [];
@@ -8356,7 +10059,7 @@ function parseFeatures(sectionBody) {
     if (!featureResult.ok) return featureResult;
     features.push(featureResult.value);
   }
-  return (0, import_types9.Ok)(features);
+  return (0, import_types16.Ok)(features);
 }
 function parseFeatureFields(name, body) {
   const fieldMap = /* @__PURE__ */ new Map();
@@ -8367,7 +10070,7 @@ function parseFeatureFields(name, body) {
   }
   const statusRaw = fieldMap.get("Status");
   if (!statusRaw || !VALID_STATUSES.has(statusRaw)) {
-    return (0, import_types9.Err)(
+    return (0, import_types16.Err)(
       new Error(
         `Feature "${name}" has invalid status: "${statusRaw ?? "(missing)"}". Valid statuses: ${[...VALID_STATUSES].join(", ")}`
       )
@@ -8381,7 +10084,7 @@ function parseFeatureFields(name, body) {
   const blockedByRaw = fieldMap.get("Blocked by") ?? EM_DASH;
   const blockedBy = blockedByRaw === EM_DASH ? [] : blockedByRaw.split(",").map((b) => b.trim());
   const summary = fieldMap.get("Summary") ?? "";
-  return (0, import_types9.Ok)({ name, status, spec, plans, blockedBy, summary });
+  return (0, import_types16.Ok)({ name, status, spec, plans, blockedBy, summary });
 }
 
 // src/roadmap/serialize.ts
@@ -8425,9 +10128,9 @@ function serializeFeature(feature) {
 }
 
 // src/roadmap/sync.ts
-var fs7 = __toESM(require("fs"));
+var fs9 = __toESM(require("fs"));
 var path9 = __toESM(require("path"));
-var import_types10 = require("@harness-engineering/types");
+var import_types17 = require("@harness-engineering/types");
 function inferStatus(feature, projectPath, allFeatures) {
   if (feature.blockedBy.length > 0) {
     const blockerNotDone = feature.blockedBy.some((blockerName) => {
@@ -8442,9 +10145,9 @@ function inferStatus(feature, projectPath, allFeatures) {
   const useRootState = featuresWithPlans.length <= 1;
   if (useRootState) {
     const rootStatePath = path9.join(projectPath, ".harness", "state.json");
-    if (fs7.existsSync(rootStatePath)) {
+    if (fs9.existsSync(rootStatePath)) {
       try {
-        const raw = fs7.readFileSync(rootStatePath, "utf-8");
+        const raw = fs9.readFileSync(rootStatePath, "utf-8");
         const state = JSON.parse(raw);
         if (state.progress) {
           for (const status of Object.values(state.progress)) {
@@ -8456,15 +10159,15 @@ function inferStatus(feature, projectPath, allFeatures) {
     }
   }
   const sessionsDir = path9.join(projectPath, ".harness", "sessions");
-  if (fs7.existsSync(sessionsDir)) {
+  if (fs9.existsSync(sessionsDir)) {
     try {
-      const sessionDirs = fs7.readdirSync(sessionsDir, { withFileTypes: true });
+      const sessionDirs = fs9.readdirSync(sessionsDir, { withFileTypes: true });
       for (const entry of sessionDirs) {
         if (!entry.isDirectory()) continue;
         const autopilotPath = path9.join(sessionsDir, entry.name, "autopilot-state.json");
-        if (!fs7.existsSync(autopilotPath)) continue;
+        if (!fs9.existsSync(autopilotPath)) continue;
         try {
-          const raw = fs7.readFileSync(autopilotPath, "utf-8");
+          const raw = fs9.readFileSync(autopilotPath, "utf-8");
           const autopilot = JSON.parse(raw);
           if (!autopilot.phases) continue;
           const linkedPhases = autopilot.phases.filter(
@@ -8511,46 +10214,214 @@ function syncRoadmap(options) {
       to: inferred
     });
   }
-  return (0, import_types10.Ok)(changes);
+  return (0, import_types17.Ok)(changes);
 }
 
 // src/interaction/types.ts
-var import_zod5 = require("zod");
-var InteractionTypeSchema = import_zod5.z.enum(["question", "confirmation", "transition"]);
-var QuestionSchema = import_zod5.z.object({
-  text: import_zod5.z.string(),
-  options: import_zod5.z.array(import_zod5.z.string()).optional(),
-  default: import_zod5.z.string().optional()
+var import_zod7 = require("zod");
+var InteractionTypeSchema = import_zod7.z.enum(["question", "confirmation", "transition"]);
+var QuestionSchema = import_zod7.z.object({
+  text: import_zod7.z.string(),
+  options: import_zod7.z.array(import_zod7.z.string()).optional(),
+  default: import_zod7.z.string().optional()
 });
-var ConfirmationSchema = import_zod5.z.object({
-  text: import_zod5.z.string(),
-  context: import_zod5.z.string()
+var ConfirmationSchema = import_zod7.z.object({
+  text: import_zod7.z.string(),
+  context: import_zod7.z.string()
 });
-var TransitionSchema = import_zod5.z.object({
-  completedPhase: import_zod5.z.string(),
-  suggestedNext: import_zod5.z.string(),
-  reason: import_zod5.z.string(),
-  artifacts: import_zod5.z.array(import_zod5.z.string()),
-  requiresConfirmation: import_zod5.z.boolean(),
-  summary: import_zod5.z.string()
+var TransitionSchema = import_zod7.z.object({
+  completedPhase: import_zod7.z.string(),
+  suggestedNext: import_zod7.z.string(),
+  reason: import_zod7.z.string(),
+  artifacts: import_zod7.z.array(import_zod7.z.string()),
+  requiresConfirmation: import_zod7.z.boolean(),
+  summary: import_zod7.z.string()
 });
-var EmitInteractionInputSchema = import_zod5.z.object({
-  path: import_zod5.z.string(),
+var EmitInteractionInputSchema = import_zod7.z.object({
+  path: import_zod7.z.string(),
   type: InteractionTypeSchema,
-  stream: import_zod5.z.string().optional(),
+  stream: import_zod7.z.string().optional(),
   question: QuestionSchema.optional(),
   confirmation: ConfirmationSchema.optional(),
   transition: TransitionSchema.optional()
 });
 
-// src/update-checker.ts
-var fs8 = __toESM(require("fs"));
+// src/blueprint/scanner.ts
+var fs10 = __toESM(require("fs/promises"));
 var path10 = __toESM(require("path"));
+var ProjectScanner = class {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  async scan() {
+    let projectName = path10.basename(this.rootDir);
+    try {
+      const pkgPath = path10.join(this.rootDir, "package.json");
+      const pkgRaw = await fs10.readFile(pkgPath, "utf-8");
+      const pkg = JSON.parse(pkgRaw);
+      if (pkg.name) projectName = pkg.name;
+    } catch {
+    }
+    return {
+      projectName,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      modules: [
+        {
+          id: "foundations",
+          title: "Foundations",
+          description: "Utility files and basic types.",
+          files: []
+        },
+        {
+          id: "core-logic",
+          title: "Core Logic",
+          description: "Mid-level services and domain logic.",
+          files: []
+        },
+        {
+          id: "interaction-surface",
+          title: "Interaction Surface",
+          description: "APIs, CLIs, and Entry Points.",
+          files: []
+        },
+        {
+          id: "cross-cutting",
+          title: "Cross-Cutting Concerns",
+          description: "Security, Logging, and Observability.",
+          files: []
+        }
+      ],
+      hotspots: [],
+      dependencies: []
+    };
+  }
+};
+
+// src/blueprint/generator.ts
+var fs11 = __toESM(require("fs/promises"));
+var path11 = __toESM(require("path"));
+var ejs = __toESM(require("ejs"));
+
+// src/blueprint/templates.ts
+var SHELL_TEMPLATE = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Blueprint: <%= projectName %></title>
+    <style><%- styles %></style>
+</head>
+<body>
+    <div id="app">
+        <header>
+            <h1>Blueprint: <%= projectName %></h1>
+            <p>Generated at: <%= generatedAt %></p>
+        </header>
+        <main>
+            <section class="modules">
+                <% modules.forEach(module => { %>
+                    <article class="module" id="<%= module.id %>">
+                    <h2><%= module.title %></h2>
+                    <p><%= module.description %></p>
+                    <div class="content">
+                        <h3>Code Translation</h3>
+                        <div class="translation"><%- module.content.codeTranslation %></div>
+                        <h3>Knowledge Check</h3>
+                        <div class="quiz">
+                            <% module.content.quiz.questions.forEach((q, i) => { %>
+                                <div class="question">
+                                    <p><%= q.question %></p>
+                                    <button onclick="reveal(this)">Reveal Answer</button>
+                                    <p class="answer" style="display:none;"><%= q.answer %></p>
+                                </div>
+                            <% }) %>
+                        </div>
+                    </div>
+                    </article>
+
+                <% }) %>
+            </section>
+        </main>
+    </div>
+    <script><%- scripts %></script>
+</body>
+</html>
+`;
+var STYLES = `
+body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; line-height: 1.6; margin: 0; padding: 20px; color: #333; }
+header { border-bottom: 2px solid #eee; margin-bottom: 20px; padding-bottom: 10px; }
+.module { background: #f9f9f9; border: 1px solid #ddd; padding: 15px; margin-bottom: 15px; border-radius: 4px; }
+.module h2 { margin-top: 0; color: #0066cc; }
+`;
+var SCRIPTS = `
+function reveal(btn) {
+    btn.nextElementSibling.style.display = 'block';
+    btn.style.display = 'none';
+}
+console.log('Blueprint player initialized.');
+`;
+
+// src/shared/llm.ts
+var MockLLMService = class {
+  async generate(prompt) {
+    return "This is a mock LLM response for: " + prompt;
+  }
+};
+var llmService = new MockLLMService();
+
+// src/blueprint/content-pipeline.ts
+var ContentPipeline = class {
+  async generateModuleContent(module2) {
+    const codeContext = module2.files.join("\n");
+    const translation = await llmService.generate(
+      `You are a technical educator. Explain the following code clearly and concisely: ${codeContext}`
+    );
+    const quizJson = await llmService.generate(
+      `Create 3 technical quiz questions for this code. Return ONLY valid JSON in this format: { "questions": [{ "question": "...", "answer": "..." }] }. Code: ${codeContext}`
+    );
+    let quiz;
+    try {
+      const cleanJson = quizJson.replace(/```json/g, "").replace(/```/g, "").trim();
+      quiz = JSON.parse(cleanJson);
+    } catch (e) {
+      console.error("Failed to parse quiz JSON", e);
+      quiz = { questions: [{ question: "Failed to generate quiz", answer: "N/A" }] };
+    }
+    return {
+      codeTranslation: translation,
+      quiz
+    };
+  }
+};
+
+// src/blueprint/generator.ts
+var BlueprintGenerator = class {
+  contentPipeline = new ContentPipeline();
+  async generate(data, options) {
+    await Promise.all(
+      data.modules.map(async (module2) => {
+        module2.content = await this.contentPipeline.generateModuleContent(module2);
+      })
+    );
+    const html = ejs.render(SHELL_TEMPLATE, {
+      ...data,
+      styles: STYLES,
+      scripts: SCRIPTS
+    });
+    await fs11.mkdir(options.outputDir, { recursive: true });
+    await fs11.writeFile(path11.join(options.outputDir, "index.html"), html);
+  }
+};
+
+// src/update-checker.ts
+var fs12 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 var os = __toESM(require("os"));
 var import_child_process3 = require("child_process");
 function getStatePath() {
   const home = process.env["HOME"] || os.homedir();
-  return path10.join(home, ".harness", "update-check.json");
+  return path12.join(home, ".harness", "update-check.json");
 }
 function isUpdateCheckEnabled(configInterval) {
   if (process.env["HARNESS_NO_UPDATE_CHECK"] === "1") return false;
@@ -8563,7 +10434,7 @@ function shouldRunCheck(state, intervalMs) {
 }
 function readCheckState() {
   try {
-    const raw = fs8.readFileSync(getStatePath(), "utf-8");
+    const raw = fs12.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;
@@ -8580,7 +10451,7 @@ function readCheckState() {
 }
 function spawnBackgroundCheck(currentVersion) {
   const statePath = getStatePath();
-  const stateDir = path10.dirname(statePath);
+  const stateDir = path12.dirname(statePath);
   const script = `
 const { execSync } = require('child_process');
 const fs = require('fs');
@@ -8634,39 +10505,64 @@ Run "harness update" to upgrade.`;
 }
 
 // src/index.ts
-var VERSION = "1.8.2";
+var VERSION = "0.11.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_DESCRIPTORS,
   ARCHITECTURE_DESCRIPTOR,
   AgentActionEmitter,
+  ArchBaselineManager,
+  ArchBaselineSchema,
+  ArchConfigSchema,
+  ArchDiffResultSchema,
+  ArchMetricCategorySchema,
   BUG_DETECTION_DESCRIPTOR,
   BaselineManager,
   BenchmarkRunner,
+  BlueprintGenerator,
+  BundleConstraintsSchema,
+  BundleSchema,
   COMPLIANCE_DESCRIPTOR,
+  CategoryBaselineSchema,
+  CategoryRegressionSchema,
   ChecklistBuilder,
+  CircularDepsCollector,
+  ComplexityCollector,
   ConfirmationSchema,
   ConsoleSink,
+  ConstraintRuleSchema,
+  ContentPipeline,
+  ContributionsSchema,
+  CouplingCollector,
   CriticalPathResolver,
   DEFAULT_PROVIDER_TIERS,
   DEFAULT_SECURITY_CONFIG,
   DEFAULT_STATE,
   DEFAULT_STREAM_INDEX,
+  DepDepthCollector,
   EmitInteractionInputSchema,
   EntropyAnalyzer,
   EntropyConfigSchema,
   ExclusionSet,
   FailureEntrySchema,
   FileSink,
+  ForbiddenImportCollector,
   GateConfigSchema,
   GateResultSchema,
   HandoffSchema,
   HarnessStateSchema,
   InteractionTypeSchema,
+  LayerViolationCollector,
+  LockfilePackageSchema,
+  LockfileSchema,
+  ManifestSchema,
+  MetricResultSchema,
+  ModuleSizeCollector,
   NoOpExecutor,
   NoOpSink,
   NoOpTelemetryAdapter,
   PatternConfigSchema,
+  ProjectScanner,
   QuestionSchema,
   REQUIRED_SECTIONS,
   RegressionDetector,
@@ -8674,16 +10570,26 @@ var VERSION = "1.8.2";
   SECURITY_DESCRIPTOR,
   SecurityConfigSchema,
   SecurityScanner,
+  SharableBoundaryConfigSchema,
+  SharableForbiddenImportSchema,
+  SharableLayerSchema,
+  SharableSecurityRulesSchema,
   StreamIndexSchema,
   StreamInfoSchema,
+  ThresholdConfigSchema,
   TransitionSchema,
   TypeScriptParser,
   VERSION,
+  ViolationSchema,
+  addProvenance,
   analyzeDiff,
   appendFailure,
   appendLearning,
   applyFixes,
   applyHotspotDowngrade,
+  archMatchers,
+  archModule,
+  architecture,
   archiveFailures,
   archiveStream,
   buildDependencyGraph,
@@ -8693,6 +10599,7 @@ var VERSION = "1.8.2";
   checkEligibility,
   classifyFinding,
   configureFeedback,
+  constraintRuleId,
   contextBudget,
   contextFilter,
   createBoundaryValidator,
@@ -8707,6 +10614,8 @@ var VERSION = "1.8.2";
   cryptoRules,
   deduplicateCleanupFindings,
   deduplicateFindings,
+  deepMergeConstraints,
+  defaultCollectors,
   defineLayer,
   deserializationRules,
   detectChangeType,
@@ -8719,9 +10628,12 @@ var VERSION = "1.8.2";
   detectPatternViolations,
   detectSizeBudgetViolations,
   detectStack,
+  detectStaleConstraints,
   determineAssessment,
+  diff,
   executeWorkflow,
   expressRules,
+  extractBundle,
   extractMarkdownLinks,
   extractSections,
   fanOutReview,
@@ -8752,6 +10664,7 @@ var VERSION = "1.8.2";
   networkRules,
   nodeRules,
   parseDiff,
+  parseManifest,
   parseRoadmap,
   parseSecurityConfig,
   parseSize,
@@ -8759,6 +10672,8 @@ var VERSION = "1.8.2";
   previewFix,
   reactRules,
   readCheckState,
+  readLockfile,
+  removeProvenance,
   requestMultiplePeerReviews,
   requestPeerReview,
   resetFeedbackConfig,
@@ -8766,6 +10681,8 @@ var VERSION = "1.8.2";
   resolveModelTier,
   resolveRuleSeverity,
   resolveStreamPath,
+  resolveThresholds,
+  runAll,
   runArchitectureAgent,
   runBugDetectionAgent,
   runCIChecks,
@@ -8785,6 +10702,7 @@ var VERSION = "1.8.2";
   setActiveStream,
   shouldRunCheck,
   spawnBackgroundCheck,
+  syncConstraintNodes,
   syncRoadmap,
   touchStream,
   trackAction,
@@ -8797,6 +10715,9 @@ var VERSION = "1.8.2";
   validateFindings,
   validateKnowledgeMap,
   validatePatternConfig,
+  violationId,
+  writeConfig,
+  writeLockfile,
   xssRules,
   ...require("@harness-engineering/types")
 });