arkgate 4.8.22 → 4.8.24

package/dist/index.d.ts

@@ -1,26 +1,4 @@
-import { A as AdapterViolationInput, a as ArkRulesFile, E as EffectiveArkRules, R as ResolvedArkRunKernelCallKind, b as ResolvedArkRunDeclarationFact, c as ResolvedArkRunKernelCallFact, d as ResolvedArkRunManagedNewFact, e as ResolvedDependencyFact, f as ResolvedArkRunCompositionRootHitFact, g as ResolvedFactsReason, h as ResolvedArkOrderPlaneCallFact, i as ResolvedArkOrderGenericUpdateFact, j as ResolvedArkOrderRootHitFact, k as ResolvedArkOrderXiFieldWriteFact, l as ResolvedArkOrderIngestWriteFact } from './diagnosticCatalog-WD2TPSwZ.js';
-export { m as ADAPTER_DIAGNOSTIC_DOCS_RELATIVE_PATH, n as AICodeGate, o as AICodeGateContext, p as AICodeGateOptions, q as AICodeGateResult, r as AICodeGateViolation, s as AIGateExtension, t as ANALYSIS_IR_SCHEMA_VERSION, u as ARK_ANALYSIS_RESULT_SCHEMA, v as ARK_ANALYSIS_RESULT_SCHEMA_VERSION, w as ARK_DESIGN_DELTA_SCHEMA_VERSION, x as ARK_ENFORCEMENT_STATE_SCHEMA_VERSION, y as AdapterCompletenessReason, z as AdapterDiagnostic, B as AdapterResult, C as AdapterSeverity, D as AnalysisCapabilityUse, F as AnalysisCompilerOptions, G as AnalysisCompleteness, H as AnalysisContract, I as AnalysisEvidence, J as AnalysisFile, K as AnalysisFileChange, L as AnalysisFileInput, M as AnalysisImportEdge, N as AnalysisIr, O as AnalysisMode, P as AnalysisResult, Q as AnalysisViolation, S as AnalyzeArchitectureConvergenceInput, T as AnalyzeChangeInput, U as AnalyzePolicyDeltaInput, V as AnalyzeProjectInput, W as AnalyzeResolvedProjectInput, X as ArchitectureActualChange, Y as ArchitectureChangeMap, Z as ArchitectureChangeMapContract, _ as ArchitectureChangeMapDependency, $ as ArchitectureChangeMapFile, a0 as ArchitectureChangeOperation, a1 as ArchitectureConvergenceClassification, a2 as ArchitectureConvergenceFinding, a3 as ArchitectureConvergenceResult, a4 as ArchitectureDependency, a5 as ArchitectureEngineEdge, a6 as ArchitectureEngineResult, a7 as ArchitectureEngineViolation, a8 as ArkDesignDeltaResult, a9 as ArkEnforcementHost, aa as ArkEnforcementState, ab as ArkRuleSensorViolation, ac as ChangePreflightResult, ad as ClassShapeFact, ae as CollectAnalysisConfigWarningsInput, af as CoverageEvidence, ag as CoverageFiles, ah as CoverageInvariant, ai as DIAGNOSTIC_CATALOG, aj as DIAGNOSTIC_CATALOG_SCHEMA_VERSION, ak as DIAGNOSTIC_DOCS_RELATIVE_PATH, al as DIAGNOSTIC_RULE_IDS, am as DeclarationShape, an as DesignDeltaChange, ao as DesignDeltaEnforcementScope, ap as DesignDeltaIdentity, aq as DesignSmellEvidence, ar as DesignSmellFinding, as as DesignSmellId, at as DiagnosticCatalogEntry, au as DiagnosticCategory, av as EnforcementBoundaryState, aw as EnforcementEvidence, ax as EnforcementEvidenceField, ay as EnforcementVerification, az as EvaluateArchitectureGraphInput, aA as ForbiddenCapabilityUse, aB as InvariantCoverageEvidence, aC as MentionContext, aD as POLICY_DELTA_SCHEMA_VERSION, aE as PolicyDelta, aF as PolicyDeltaAcknowledgement, aG as PolicyDeltaAnalysis, aH as PolicyDeltaClassification, aI as PolicyDeltaFinding, aJ as PreflightResolvedChangeInput, aK as PreparedChangeFile, aL as RESOLVED_CANDIDATE_FACTS_SCHEMA, aM as RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION, aN as ResolvedAmbientFact, aO as ResolvedAnalysisFile, aP as ResolvedAnalysisIr, aQ as ResolvedAnalysisResult, aR as ResolvedCandidateFacts, aS as ResolvedCandidateFactsInput, aT as ResolvedCapability, aU as ResolvedCapabilityFact, aV as ResolvedChangePreflightResult, aW as ResolvedDependencyKind, aX as ResolvedDependencyState, aY as ResolvedFactsCompleteness, aZ as ResolvedFileFact, a_ as ResolvedIntentReferenceFact, a$ as ResolvedPublishFact, b0 as ResolvedSafetyFact, b1 as ResolvedSafetyKind, b2 as ResolvedSafetyReport, b3 as SemanticDependency, b4 as SemanticDependencyKind, b5 as analyzeArchitectureConvergence, b6 as analyzeChange, b7 as analyzePolicyDelta, b8 as analyzeProject, b9 as analyzeResolvedProject, ba as buildArkRuleFileHints, bb as canPromoteInvariant, bc as catalogFixForRuleId, bd as catalogWhyForRuleId, be as classifyArkPolicyDelta, bf as classifyCoverage, bg as collectAnalysisConfigWarnings, bh as collectEmptyAppliesToFindings, bi as collectForbiddenCapabilityUses, bj as countsAsCoverage, bk as createAICodeGate, bl as createAdapterResult, bm as createArchitectureProfile, bn as createArchitectureProfileFromArkConfig, bo as createElevenLayerArkConfig, bp as createResolvedCandidateFacts, bq as deriveArkRuleFileHints, br as describeCoverage, bs as detectArchitectureCycles, bt as deterministicHash, bu as diagnosticDocsFragment, bv as diagnosticDocsPath, bw as elevenLayerProfile, bx as evaluateArchitectureGraph, by as evaluateArkRuleSensors, bz as evaluateInvariantCoverage, bA as explainViolation, bB as extractClassShapesFromSource, bC as extractSemanticDependencies, bD as getDiagnosticCatalogEntry, bE as isCataloguedOrArkRuleFamily, bF as isKnownDiagnosticCode, bG as loadContract, bH as loadResolvedCandidateFacts, bI as policyDeltaAcknowledgementMatches, bJ as preflightChange, bK as preflightResolvedChange, bL as resolvedFactsEvidenceRequirementsHash, bM as serializeDiagnosticCatalog, bN as stableSerialize, bO as toAdapterDiagnostic, bP as version } from './diagnosticCatalog-WD2TPSwZ.js';
-export { A as ArchitectureLayer, a as ArchitectureLayerConfig, b as ArchitectureProfile, c as ArchitectureRule, d as ArkCheckConfig, C as CreateArchitectureProfileFromArkConfigOptions, e as CreateArchitectureProfileOptions, f as CreateElevenLayerArkConfigOptions } from './types-fQ9-KrBj.js';
-import { a as ArkConfigRule, b as ArkConfigSchemaVersion, c as ArkConfigLoadResult, A as ArkConfig, d as ArkConfigIssue, e as ArkConfigArkRun, f as ArkConfigLayer, g as ArkConfigArkOrder } from './configTypes-CTELo87-.js';
-
-/**
- * Baseline-compatible target key for a violation input.
- * Field order and empty-string fallbacks **must** match `baselineKey` in
- * `baselineKey.ts` — parity tests guard this so finding refs never orphan freezes.
- *
- * Note: uses raw ruleId/file strings (including empty) the same way baseline does;
- * display `ruleId` / `location.file` may still normalize to ARK_UNKNOWN / `<unknown>`.
- */
-declare function adapterFindingTargetKey(violation: AdapterViolationInput): string;
-/**
- * Occurrence-aware target keys for a violation list (parity with baselineOccurrenceKeys).
- * First occurrence keeps the historical base key; duplicates get `#N`.
- */
-declare function adapterFindingOccurrenceTargetKeys(violations: readonly AdapterViolationInput[]): string[];
-/** FNV-1a finding ref from a baseline-compatible targetKey (not a security hash). */
-declare function adapterFindingRefFromTargetKey(targetKey: string): string;
-/** Package-relative docs path with fragment for a public ruleId. */
-declare function adapterDocsCodePath(ruleId: string): string;
+import { a as ArkConfigRule, b as ArkConfigSchemaVersion, c as ArkConfigLoadResult, d as ArkConfigLayer, A as ArkConfig, e as ArkConfigIssue, f as ArkConfigArkRun, g as ArkConfigArkOrder } from './configTypes-BJbaeoj4.js';
 
 /**
  * Canonical, pure contract for ark.config.json.
@@ -287,7 +265,7 @@ declare const ARK_CONFIG_SCHEMA: {
                 readonly sliceIdentity: {
                     readonly type: "string";
                     readonly enum: readonly ["path", "stars"];
-                    readonly description: "How a starred sliceFolders prefix is named. Absent and path keep today's ids (every literal and star binding). stars keeps the last literal plus the star bindings, so parallel trees share one feature id. Bare names are unchanged.";
+                    readonly description: "How a starred sliceFolders prefix is named. Absent and path keep today's ids (every literal and star binding). stars keeps the last literal plus every star binding (a star before the last literal is kept too), so parallel trees share one feature id. Bare names are unchanged.";
                 };
                 readonly sharedRoots: {
                     readonly minItems: 1;
@@ -318,8 +296,136 @@ declare const ARK_CONFIG_SCHEMA: {
                     };
                 };
                 readonly sharedImportsSlice: {
-                    readonly type: "string";
-                    readonly enum: readonly ["deny"];
+                    readonly description: "deny blocks every shared-root import of a slice. deny-cross-parent leaves that hop as a warning and, in ark-check and CI only, reports a slice that reaches another universe through a shared root. The write hook and ESLint see one edge and do not block it. The object form { mode: \"deny-cross-parent\", stopAt } names composition roots (bootstrap, DI registrations) the whole-graph walk never starts at or passes through; a stop file must still sit under sharedRoots, and stopAt does not silence the direct SHARED_IMPORTS_SLICE warning. arkgate 4.8.22 and older reject deny-cross-parent. arkgate 4.8.23 and older reject the object form (must be one of deny, deny-cross-parent).";
+                    readonly oneOf: readonly [{
+                        readonly type: "string";
+                        readonly enum: readonly ["deny", "deny-cross-parent"];
+                    }, {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["mode", "stopAt"];
+                        readonly properties: {
+                            readonly mode: {
+                                readonly type: "string";
+                                readonly enum: readonly ["deny-cross-parent"];
+                            };
+                            readonly stopAt: {
+                                readonly minItems: 1;
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly uniqueItems: true;
+                            };
+                        };
+                    }];
+                };
+                readonly childSlices: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["sliceFolders"];
+                    readonly description: "Optional inner wall under this rule. Runs only on a rule with peerIsolation: true and allowed: false; elsewhere it is inert and ark-check warns CONFIG_CHILD_SLICES_INERT (config load still accepts it, as 4.8.23 did). Absent keeps today's universe wall. sliceFolders names children. Flat files are universe common, and so is a commonFolders directory directly under the universe (a folder of that name inside a child belongs to that child). siblings is \"deny\" (default), \"advisory\", or { default, enforce, ratchet }. parentMayImportChild defaults to false. message is the text for inner-wall findings. allowedCrossSlice may use a whole-segment *. It clears only a sibling crossing. Cross-parent has no advisory knob. arkgate 4.8.22 and older reject this key. A build that still rejects unknown childSlices fields rejects allowedCrossSlice at config load. A build that still types siblings as a string enum rejects the object at config load.";
+                    readonly properties: {
+                        readonly sliceFolders: {
+                            readonly minItems: 1;
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly uniqueItems: true;
+                        };
+                        readonly sliceIdentity: {
+                            readonly type: "string";
+                            readonly enum: readonly ["path", "stars"];
+                        };
+                        readonly commonFolders: {
+                            readonly minItems: 1;
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly uniqueItems: true;
+                        };
+                        readonly siblings: {
+                            readonly description: "\"deny\" or \"advisory\", or { default, enforce, ratchet } so listed subtrees are errors while the default stays advisory. ratchet absent: a new advisory crossing fails only when the baseline in use already records an advisory crossing of this rule. ratchet true: any unrecorded advisory crossing fails when a baseline is in use. ratchet false: measure only, never fails. A string-enum build rejects the object at config load (must be one of deny, advisory). arkgate 4.8.23 and older reject ratchet (unknown field).";
+                            readonly oneOf: readonly [{
+                                readonly type: "string";
+                                readonly enum: readonly ["deny", "advisory"];
+                            }, {
+                                readonly type: "object";
+                                readonly additionalProperties: false;
+                                readonly required: readonly ["default"];
+                                readonly properties: {
+                                    readonly default: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["deny", "advisory"];
+                                    };
+                                    readonly enforce: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                            readonly minLength: 1;
+                                        };
+                                        readonly uniqueItems: true;
+                                    };
+                                    readonly ratchet: {
+                                        readonly type: "boolean";
+                                    };
+                                };
+                            }];
+                        };
+                        readonly parentMayImportChild: {
+                            readonly type: "boolean";
+                        };
+                        readonly message: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly description: "Text for inner-wall findings (CROSS_SIBLING_SLICE and universe common importing a child). The rule message stays the universe-wall text (CROSS_PARENT_SLICE and fail-closed denies). Absent: ArkGate default text, never the rule message. arkgate 4.8.23 and older reject this field (unknown field).";
+                        };
+                        readonly sliceAliases: {
+                            readonly type: "array";
+                            readonly minItems: 1;
+                            readonly description: "Maps a source path glob onto a child slice id (universe id plus one child segment) so files outside the slice trees take that universe and child for both walls. A path without a wildcard also covers everything under it, as sharedRoots does. A bare name, a universe id alone, a target outside every universe shape, and a wildcard in to are rejected. Under stars identity a target written against the 4.8.23 stars id (star bindings before the last literal dropped, e.g. api/v1/x for modules/*/api/*) still loads when it maps to one universe shape, and ark-check warns CONFIG_SLICE_LEGACY_STARS_ID with the new id; it is rejected only when it maps to more than one shape. Config load checks only the shape; doctor reports a target universe no file belongs to. The glob may not overlap a slice folder, and two aliases may not match the same file. Doctor lists each alias as an owed move. A build that rejects unknown childSlices fields fails at config load (unknown field). arkgate 4.8.22 and older reject childSlices.";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly additionalProperties: false;
+                                readonly required: readonly ["from", "to"];
+                                readonly properties: {
+                                    readonly from: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly to: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                };
+                            };
+                        };
+                        readonly allowedCrossSlice: {
+                            readonly type: "array";
+                            readonly minItems: 1;
+                            readonly description: "Directed child-slice allowances. * matches one whole path segment (features/projects/*). ** and a partial segment are rejected. A bare name is rejected. This list clears only CROSS_SIBLING_SLICE. It cannot clear CROSS_PARENT_SLICE or CROSS_PARENT_VIA_SHARED. The universe allowedCrossSlice still treats * as a literal. A build that rejects unknown childSlices fields fails at config load (unknown field).";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly additionalProperties: false;
+                                readonly required: readonly ["from", "to"];
+                                readonly properties: {
+                                    readonly from: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly to: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                };
+                            };
+                        };
+                    };
                 };
             };
         };
@@ -480,325 +586,3092 @@ declare function loadArkConfigContract(input: unknown, source?: string): ArkConf
 declare function parseArkConfigJson(json: string, source?: string): ArkConfigLoadResult;
 
 /**
- * Canonical, pure contract for ArkGate MCP project identity.
+ * Type vocabulary for ArkRules files (ADR 0012).
  *
- * Filesystem canonicalization, hashing, clocks, and runtime ids belong to the
- * Tooling adapter. This module owns the stable payload and published schemas so
- * every MCP surface speaks the same identity/binding language.
+ * Pure declarations only — runtime validation and the published JSON Schema live in
+ * ./arkRulesContract.ts so generate:cli-pure can emit a self-contained artifact.
  */
-declare const ARK_PROJECT_IDENTITY_SCHEMA_VERSION: "1.0";
-declare const ARK_PROJECT_IDENTITY_SCHEMA_URL = "https://unpkg.com/arkgate@4/schemas/ark.project-identity.schema.json";
-type ProjectIdentity = {
-    schemaVersion: typeof ARK_PROJECT_IDENTITY_SCHEMA_VERSION;
-    projectId: string;
-    resolvedRoot: string;
-    resolvedConfigPath: string;
-    arkgateVersion: string;
-    contractHash: string;
-    contractSource: 'project' | 'default-profile' | 'manifest';
-    runtimeId: string;
-    processStartedAt: string;
+/** Closed sensor vocabulary (ADR 0013). Unknown sensors fail closed at load time. */
+declare const ARK_RULE_SENSOR_IDS: readonly ["aggregate-private-state", "always-valid-factory", "domain-event-on-mutation", "orchestration-only", "thin-adapter", "writes-via-aggregate", "no-anemic-model", "invariant-coverage"];
+type ArkRuleSensorId = (typeof ARK_RULE_SENSOR_IDS)[number];
+type ArkRuleMode = 'advisory' | 'enforced';
+type ArkRuleStructureEntry = {
+    id: string;
+    sensor: ArkRuleSensorId;
+    mode?: ArkRuleMode;
+    appliesTo?: string[];
+    description?: string;
 };
-type ProjectExpectation = {
-    expectedRoot?: string;
-    expectedProjectId?: string;
+type ArkRuleInvariantCoverage = {
+    test?: boolean;
+    symbol?: string;
 };
-type ProjectBinding = {
-    status: 'matched' | 'unverified' | 'mismatch';
-    authoritative: boolean;
-    expectedRoot?: string;
-    expectedProjectId?: string;
-    code?: 'PROJECT_ROOT_MISMATCH' | 'PROJECT_ID_MISMATCH' | 'INVALID_PROJECT_EXPECTATION';
-    message?: string;
+type ArkRuleInvariantEntry = {
+    id: string;
+    description: string;
+    aggregate?: string;
+    coverage?: ArkRuleInvariantCoverage;
+    mode?: ArkRuleMode;
+    appliesTo?: string[];
 };
-declare const PROJECT_EXPECTATION_SCHEMA: {
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly properties: {
-        readonly expectedRoot: {
-            readonly type: "string";
-            readonly minLength: 1;
-            readonly description: string;
-        };
-        readonly expectedProjectId: {
-            readonly type: "string";
-            readonly pattern: "^sha256:[a-f0-9]{64}$";
-            readonly description: "Project id previously returned by ark_identity or ark_manifest.";
-        };
-    };
+type ArkRulesFile = {
+    $schema?: string;
+    schemaVersion: '1.0';
+    layer: string;
+    structure?: ArkRuleStructureEntry[];
+    invariants?: ArkRuleInvariantEntry[];
 };
-declare const PROJECT_BINDING_SCHEMA: {
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly required: readonly ["status", "authoritative"];
-    readonly properties: {
-        readonly status: {
-            readonly enum: readonly ["matched", "unverified", "mismatch"];
-        };
-        readonly authoritative: {
-            readonly type: "boolean";
-        };
-        readonly expectedRoot: {
-            readonly type: "string";
-            readonly minLength: 1;
-        };
-        readonly expectedProjectId: {
-            readonly type: "string";
-            readonly pattern: "^sha256:[a-f0-9]{64}$";
-        };
-        readonly code: {
-            readonly enum: readonly ["PROJECT_ROOT_MISMATCH", "PROJECT_ID_MISMATCH", "INVALID_PROJECT_EXPECTATION"];
-        };
-        readonly message: {
-            readonly type: "string";
-            readonly minLength: 1;
-        };
-    };
+type ArkRuleProvenance = {
+    sourceFile: string;
+    ruleId: string;
+    layer: string;
 };
-declare const ARK_PROJECT_IDENTITY_SCHEMA: {
+type EffectiveStructureRule = ArkRuleStructureEntry & {
+    mode: ArkRuleMode;
+    provenance: ArkRuleProvenance;
+};
+type EffectiveInvariantRule = ArkRuleInvariantEntry & {
+    mode: ArkRuleMode;
+    provenance: ArkRuleProvenance;
+};
+type EffectiveArkRules = {
+    schemaVersion: '1.0';
+    byLayer: Record<string, {
+        sourceFile: string;
+        structure: EffectiveStructureRule[];
+        invariants: EffectiveInvariantRule[];
+    }>;
+    structure: EffectiveStructureRule[];
+    invariants: EffectiveInvariantRule[];
+};
+type ArkRulesIssue = {
+    path: string;
+    message: string;
+};
+
+/**
+ * Canonical, pure contract for arkrules/<Layer>.json (ADR 0012).
+ *
+ * Tooling adapters own filesystem I/O; this module owns JSON parsing, validation,
+ * diagnostics, and the published JSON Schema. The standalone CLI artifact is generated
+ * into bin/lib/arkrules-contract.mjs + schemas/ark.arkrules.schema.json.
+ */
+
+declare const ARK_RULES_SCHEMA_VERSION: "1.0";
+/** Closed sensor vocabulary — keep in lockstep with arkRulesTypes.ARK_RULE_SENSOR_IDS. */
+declare const ARK_RULE_SENSORS: readonly ["aggregate-private-state", "always-valid-factory", "domain-event-on-mutation", "orchestration-only", "thin-adapter", "writes-via-aggregate", "no-anemic-model", "invariant-coverage"];
+declare const ARK_RULES_SCHEMA: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
-    readonly $id: "https://unpkg.com/arkgate@4/schemas/ark.project-identity.schema.json";
-    readonly title: "ArkGate MCP project identity";
-    readonly description: "Stable project binding plus separate runtime and architecture-contract evidence.";
+    readonly $id: "https://unpkg.com/arkgate/schemas/ark.arkrules.schema.json";
+    readonly title: "ArkGate ArkRules (intra-layer contract)";
+    readonly description: "Per-layer structure sensors and invariant catalog consumed by the ArkGate Effective Contract.";
     readonly type: "object";
     readonly additionalProperties: false;
-    readonly required: readonly ["schemaVersion", "projectId", "resolvedRoot", "resolvedConfigPath", "arkgateVersion", "contractHash", "contractSource", "runtimeId", "processStartedAt"];
+    readonly required: readonly ["schemaVersion", "layer"];
     readonly properties: {
-        readonly schemaVersion: {
-            readonly const: "1.0";
-        };
-        readonly projectId: {
-            readonly type: "string";
-            readonly pattern: "^sha256:[a-f0-9]{64}$";
-        };
-        readonly resolvedRoot: {
+        readonly $schema: {
             readonly type: "string";
             readonly minLength: 1;
+            readonly default: "https://unpkg.com/arkgate/schemas/ark.arkrules.schema.json";
         };
-        readonly resolvedConfigPath: {
+        readonly schemaVersion: {
             readonly type: "string";
-            readonly minLength: 1;
+            readonly const: "1.0";
+            readonly default: "1.0";
         };
-        readonly arkgateVersion: {
+        readonly layer: {
             readonly type: "string";
             readonly minLength: 1;
         };
-        readonly contractHash: {
-            readonly type: "string";
-            readonly pattern: "^sha256:[a-f0-9]{64}$";
-        };
-        readonly contractSource: {
-            readonly enum: readonly ["project", "default-profile", "manifest"];
-        };
-        readonly runtimeId: {
-            readonly type: "string";
-            readonly minLength: 1;
+        readonly structure: {
+            readonly type: "array";
+            readonly default: readonly [];
+            readonly items: {
+                readonly $ref: "#/$defs/structureEntry";
+            };
         };
-        readonly processStartedAt: {
-            readonly type: "string";
-            readonly format: "date-time";
+        readonly invariants: {
+            readonly type: "array";
+            readonly default: readonly [];
+            readonly items: {
+                readonly $ref: "#/$defs/invariantEntry";
+            };
         };
     };
     readonly $defs: {
-        readonly expectation: {
+        readonly structureEntry: {
             readonly type: "object";
             readonly additionalProperties: false;
+            readonly required: readonly ["id", "sensor"];
             readonly properties: {
-                readonly expectedRoot: {
+                readonly id: {
                     readonly type: "string";
                     readonly minLength: 1;
-                    readonly description: string;
                 };
-                readonly expectedProjectId: {
+                readonly sensor: {
                     readonly type: "string";
-                    readonly pattern: "^sha256:[a-f0-9]{64}$";
-                    readonly description: "Project id previously returned by ark_identity or ark_manifest.";
+                    readonly enum: readonly ["aggregate-private-state", "always-valid-factory", "domain-event-on-mutation", "orchestration-only", "thin-adapter", "writes-via-aggregate", "no-anemic-model", "invariant-coverage"];
+                };
+                readonly mode: {
+                    readonly type: "string";
+                    readonly enum: readonly ["advisory", "enforced"];
+                    readonly default: "advisory";
+                };
+                readonly appliesTo: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly uniqueItems: true;
+                };
+                readonly description: {
+                    readonly type: "string";
+                    readonly minLength: 1;
                 };
             };
         };
-        readonly binding: {
+        readonly invariantEntry: {
             readonly type: "object";
             readonly additionalProperties: false;
-            readonly required: readonly ["status", "authoritative"];
+            readonly required: readonly ["id", "description"];
             readonly properties: {
-                readonly status: {
-                    readonly enum: readonly ["matched", "unverified", "mismatch"];
-                };
-                readonly authoritative: {
-                    readonly type: "boolean";
-                };
-                readonly expectedRoot: {
+                readonly id: {
                     readonly type: "string";
                     readonly minLength: 1;
                 };
-                readonly expectedProjectId: {
+                readonly description: {
                     readonly type: "string";
-                    readonly pattern: "^sha256:[a-f0-9]{64}$";
+                    readonly minLength: 1;
                 };
-                readonly code: {
-                    readonly enum: readonly ["PROJECT_ROOT_MISMATCH", "PROJECT_ID_MISMATCH", "INVALID_PROJECT_EXPECTATION"];
-                };
-                readonly message: {
+                readonly aggregate: {
                     readonly type: "string";
                     readonly minLength: 1;
                 };
+                readonly coverage: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly test: {
+                            readonly type: "boolean";
+                        };
+                        readonly symbol: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly mode: {
+                    readonly type: "string";
+                    readonly enum: readonly ["advisory", "enforced"];
+                    readonly default: "advisory";
+                };
+                readonly appliesTo: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly uniqueItems: true;
+                };
+            };
+        };
+    };
+};
+declare class ArkRulesValidationError extends Error {
+    readonly issues: ArkRulesIssue[];
+    readonly source: string;
+    constructor(source: string, issues: ArkRulesIssue[]);
+}
+declare function loadArkRulesContract(input: unknown, source?: string, expectedLayer?: string): {
+    config: ArkRulesFile;
+};
+declare function parseArkRulesJson(json: string, source?: string, expectedLayer?: string): {
+    config: ArkRulesFile;
+};
+/**
+ * Build the Effective Contract from already-validated ArkRules files.
+ * Callers supply `{ layer → { sourceFile, file } }` after resolving references.
+ */
+declare function buildEffectiveArkRules(parts: ReadonlyArray<{
+    layer: string;
+    sourceFile: string;
+    file: ArkRulesFile;
+}>): EffectiveArkRules;
+/** Empty Effective Contract used when `arkRules` is absent (byte-for-byte verdict parity). */
+declare function emptyEffectiveArkRules(): EffectiveArkRules;
+
+/** Versioned public result contract types + JSON Schema (adapter envelope). */
+/**
+ * 1.5 adds stable finding refs on every factory-emitted diagnostic (ACS06):
+ * `findingRef`, `targetKey` (baseline-compatible), `docsCodePath`.
+ * 1.4 added optional evidence.arkruleId + evidence.arkruleSource (ADR 0012 / AR03).
+ */
+declare const ARK_ANALYSIS_RESULT_SCHEMA_VERSION: "1.5";
+/** Repo-relative diagnostics docs path (parity with ACS02 diagnostic catalog). */
+declare const ADAPTER_DIAGNOSTIC_DOCS_RELATIVE_PATH: "docs/diagnostics.md";
+type AdapterSeverity = 'error' | 'warning';
+type AnalysisCompleteness = 'complete' | 'partial' | 'unavailable';
+type AnalysisMode = 'lexical-compatibility' | 'resolved-candidate-facts';
+type AdapterCompletenessReason = {
+    code: string;
+    message: string;
+    file?: string;
+};
+type AdapterViolationInput = {
+    ruleId?: unknown;
+    code?: unknown;
+    message?: unknown;
+    file?: unknown;
+    line?: unknown;
+    column?: unknown;
+    target?: unknown;
+    fromLayer?: unknown;
+    toLayer?: unknown;
+    typeOnly?: unknown;
+    targetTypeOnlyExports?: unknown;
+    sourcePureTypeModule?: unknown;
+    namedBindingsTypeOnly?: unknown;
+    portProofEligible?: unknown;
+    peerIsolation?: unknown;
+    edgeKind?: unknown;
+    severity?: unknown;
+    /** When false, finding is non-blocking (e.g. type-only placement debt). */
+    failsStrict?: unknown;
+    /** Nested-wall reason. The ruleId stays LAYER_IMPORT_VIOLATION. Not part of the baseline key. */
+    reasonId?: unknown;
+    /** Last segment of the importer universe id, when the finding has a reasonId. */
+    universeFrom?: unknown;
+    /** Last segment of the importee universe id, when the finding has a reasonId. */
+    universeTo?: unknown;
+    nextAction?: unknown;
+    /** U04: the denied capability id on CAPABILITY_VIOLATION. */
+    capability?: unknown;
+    /** AR03: ArkRule identity for structure/invariant diagnostics. */
+    arkruleId?: unknown;
+    /** AR03: project-relative ArkRules source file that declared the rule. */
+    arkruleSource?: unknown;
+};
+type AdapterDiagnostic = {
+    ruleId: string;
+    severity: AdapterSeverity;
+    message: string;
+    location: {
+        file: string;
+        line: number;
+        column: number;
+    };
+    evidence: {
+        target?: string;
+        fromLayer?: string;
+        toLayer?: string;
+        typeOnly?: boolean;
+        targetTypeOnlyExports?: boolean;
+        sourcePureTypeModule?: boolean;
+        namedBindingsTypeOnly?: boolean;
+        portProofEligible?: boolean;
+        peerIsolation?: boolean;
+        capability?: string;
+        edgeKind?: string;
+        /** AR03 — ArkRule id (structure or invariant). */
+        arkruleId?: string;
+        /** AR03 — ArkRules source file path. */
+        arkruleSource?: string;
+        /** Nested-wall reason. Not part of the baseline key. */
+        reasonId?: 'CROSS_PARENT_SLICE' | 'CROSS_SIBLING_SLICE' | 'CROSS_PARENT_VIA_SHARED';
+        /** Last segment of the importer universe id, with a reasonId. */
+        universeFrom?: string;
+        /** Last segment of the importee universe id, with a reasonId. */
+        universeTo?: string;
+    };
+    /** Added in schema 1.1; optional in TypeScript so 1.0 consumer-owned values remain valid. */
+    nextAction?: string;
+    /**
+     * ACS06 / schema 1.5 — compact stable id for multi-turn re-address
+     * (`fnv1a-` + hex). Always derived from `targetKey`. Optional so 1.0–1.4
+     * consumer-owned diagnostics remain assignable.
+     */
+    findingRef?: string;
+    /**
+     * ACS06 / schema 1.5 — baseline-compatible freeze identity
+     * (`ruleId|file|fromLayer|toLayer|target`, with occurrence `#N` suffixes in lists).
+     * Must match `baselineKey` / `baselineOccurrenceKeys` so refs never orphan baselines.
+     */
+    targetKey?: string;
+    /**
+     * ACS06 / schema 1.5 — package-relative docs path with rule anchor
+     * (`docs/diagnostics.md#RULE_ID`). Optional for legacy consumer-owned values.
+     */
+    docsCodePath?: string;
+};
+type LegacyAdapterResult = {
+    schemaVersion: '1.0' | '1.1';
+    valid: boolean;
+    diagnostics: AdapterDiagnostic[];
+    completeness?: never;
+    mode?: never;
+};
+type Version12AdapterResultBase = {
+    schemaVersion: '1.2';
+    diagnostics: AdapterDiagnostic[];
+    mode?: never;
+};
+type Version12AdapterResult = (Version12AdapterResultBase & {
+    completeness: 'complete';
+    valid: boolean;
+}) | (Version12AdapterResultBase & {
+    completeness: 'partial' | 'unavailable';
+    valid: false;
+});
+type CurrentAdapterResultBase = {
+    schemaVersion: typeof ARK_ANALYSIS_RESULT_SCHEMA_VERSION;
+    completenessReasons: AdapterCompletenessReason[];
+    diagnostics: AdapterDiagnostic[];
+};
+type ResolvedAdapterEvidence = {
+    policyHash: string;
+    resolverIdentity: string;
+    factsHash: string;
+    candidateTreeHash: string;
+};
+type CurrentAdapterResult = (CurrentAdapterResultBase & Partial<ResolvedAdapterEvidence> & {
+    mode: 'lexical-compatibility';
+    valid: boolean;
+    completeness: 'complete';
+}) | (CurrentAdapterResultBase & Partial<ResolvedAdapterEvidence> & {
+    mode: 'lexical-compatibility';
+    valid: false;
+    completeness: 'partial' | 'unavailable';
+}) | (CurrentAdapterResultBase & ResolvedAdapterEvidence & {
+    mode: 'resolved-candidate-facts';
+    valid: boolean;
+    completeness: 'complete';
+}) | (CurrentAdapterResultBase & ResolvedAdapterEvidence & {
+    mode: 'resolved-candidate-facts';
+    valid: false;
+    completeness: 'partial';
+}) | (CurrentAdapterResultBase & Partial<ResolvedAdapterEvidence> & {
+    mode: 'resolved-candidate-facts';
+    valid: false;
+    completeness: 'unavailable';
+});
+type AdapterResult = LegacyAdapterResult | Version12AdapterResult | CurrentAdapterResult;
+declare const ARK_ANALYSIS_RESULT_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://unpkg.com/arkgate@3/schemas/ark.analysis-result.schema.json";
+    readonly title: "ArkGate analysis result";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["schemaVersion", "mode", "valid", "completeness", "completenessReasons", "diagnostics"];
+    readonly allOf: readonly [{
+        readonly if: {
+            readonly properties: {
+                readonly completeness: {
+                    readonly enum: readonly ["partial", "unavailable"];
+                };
+            };
+            readonly required: readonly ["completeness"];
+        };
+        readonly then: {
+            readonly properties: {
+                readonly valid: {
+                    readonly const: false;
+                };
+            };
+        };
+    }, {
+        readonly if: {
+            readonly properties: {
+                readonly mode: {
+                    readonly const: "resolved-candidate-facts";
+                };
+                readonly completeness: {
+                    readonly enum: readonly ["complete", "partial"];
+                };
+            };
+            readonly required: readonly ["mode", "completeness"];
+        };
+        readonly then: {
+            readonly required: readonly ["policyHash", "resolverIdentity", "factsHash", "candidateTreeHash"];
+        };
+    }, {
+        readonly if: {
+            readonly properties: {
+                readonly completeness: {
+                    readonly const: "complete";
+                };
+            };
+            readonly required: readonly ["completeness"];
+        };
+        readonly then: {
+            readonly properties: {
+                readonly completenessReasons: {
+                    readonly maxItems: 0;
+                };
+            };
+        };
+        readonly else: {
+            readonly properties: {
+                readonly completenessReasons: {
+                    readonly minItems: 1;
+                };
+            };
+        };
+    }];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly const: "1.5";
+        };
+        readonly mode: {
+            readonly enum: readonly ["lexical-compatibility", "resolved-candidate-facts"];
+        };
+        readonly valid: {
+            readonly type: "boolean";
+        };
+        readonly completeness: {
+            readonly enum: readonly ["complete", "partial", "unavailable"];
+        };
+        readonly completenessReasons: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["code", "message"];
+                readonly properties: {
+                    readonly code: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly message: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly policyHash: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly resolverIdentity: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly factsHash: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly candidateTreeHash: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly diagnostics: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["ruleId", "severity", "message", "location", "evidence"];
+                readonly properties: {
+                    readonly ruleId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly severity: {
+                        readonly enum: readonly ["error", "warning"];
+                    };
+                    readonly message: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly location: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["file", "line", "column"];
+                        readonly properties: {
+                            readonly file: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly line: {
+                                readonly type: "integer";
+                                readonly minimum: 1;
+                            };
+                            readonly column: {
+                                readonly type: "integer";
+                                readonly minimum: 1;
+                            };
+                        };
+                    };
+                    readonly evidence: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly target: {
+                                readonly type: "string";
+                            };
+                            readonly fromLayer: {
+                                readonly type: "string";
+                            };
+                            readonly toLayer: {
+                                readonly type: "string";
+                            };
+                            readonly typeOnly: {
+                                readonly type: "boolean";
+                            };
+                            readonly targetTypeOnlyExports: {
+                                readonly type: "boolean";
+                            };
+                            readonly sourcePureTypeModule: {
+                                readonly type: "boolean";
+                            };
+                            readonly namedBindingsTypeOnly: {
+                                readonly type: "boolean";
+                            };
+                            readonly portProofEligible: {
+                                readonly type: "boolean";
+                            };
+                            readonly peerIsolation: {
+                                readonly type: "boolean";
+                            };
+                            readonly capability: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly edgeKind: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly arkruleId: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly arkruleSource: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly reasonId: {
+                                readonly enum: readonly ["CROSS_PARENT_SLICE", "CROSS_SIBLING_SLICE", "CROSS_PARENT_VIA_SHARED"];
+                            };
+                            readonly universeFrom: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly universeTo: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                        };
+                    };
+                    readonly nextAction: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    /** ACS06 — compact multi-turn id; always derived from targetKey when emitted. */
+                    readonly findingRef: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^fnv1a-[0-9a-f]{8}$";
+                    };
+                    /**
+                     * ACS06 — baseline-compatible freeze identity
+                     * (`ruleId|file|from|to|target` with optional `#N` occurrence suffix).
+                     */
+                    readonly targetKey: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    /** ACS06 — package-relative diagnostics anchor path. */
+                    readonly docsCodePath: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
             };
         };
     };
 };
+
+/**
+ * Baseline-compatible target key for a violation input.
+ * Field order and empty-string fallbacks **must** match `baselineKey` in
+ * `baselineKey.ts` — parity tests guard this so finding refs never orphan freezes.
+ *
+ * Note: uses raw ruleId/file strings (including empty) the same way baseline does;
+ * display `ruleId` / `location.file` may still normalize to ARK_UNKNOWN / `<unknown>`.
+ */
+declare function adapterFindingTargetKey(violation: AdapterViolationInput): string;
+/**
+ * Occurrence-aware target keys for a violation list (parity with baselineOccurrenceKeys).
+ * First occurrence keeps the historical base key; duplicates get `#N`.
+ */
+declare function adapterFindingOccurrenceTargetKeys(violations: readonly AdapterViolationInput[]): string[];
+/** FNV-1a finding ref from a baseline-compatible targetKey (not a security hash). */
+declare function adapterFindingRefFromTargetKey(targetKey: string): string;
+/** Package-relative docs path with fragment for a public ruleId. */
+declare function adapterDocsCodePath(ruleId: string): string;
+
+declare function toAdapterDiagnostic(violation: AdapterViolationInput, fallbackSeverity?: AdapterSeverity, 
+/**
+ * Optional precomputed baseline-compatible targetKey (e.g. occurrence-aware from
+ * `adapterFindingOccurrenceTargetKeys`). When omitted, uses the first-occurrence key.
+ */
+targetKeyOverride?: string): AdapterDiagnostic;
+declare function createAdapterResult(input: {
+    valid: boolean;
+    completeness?: AnalysisCompleteness;
+    mode?: AnalysisMode;
+    policyHash?: unknown;
+    resolverIdentity?: unknown;
+    factsHash?: unknown;
+    candidateTreeHash?: unknown;
+    completenessReasons?: readonly AdapterCompletenessReason[];
+    violations?: readonly AdapterViolationInput[];
+    warnings?: readonly AdapterViolationInput[];
+}): CurrentAdapterResult;
+
+/** ArkGate library version — single source of truth. */
+declare const version = "4.8.24";
+
+/**
+ * Canonical, pure contract for ArkGate MCP project identity.
+ *
+ * Filesystem canonicalization, hashing, clocks, and runtime ids belong to the
+ * Tooling adapter. This module owns the stable payload and published schemas so
+ * every MCP surface speaks the same identity/binding language.
+ */
+declare const ARK_PROJECT_IDENTITY_SCHEMA_VERSION: "1.0";
+declare const ARK_PROJECT_IDENTITY_SCHEMA_URL = "https://unpkg.com/arkgate@4/schemas/ark.project-identity.schema.json";
+type ProjectIdentity = {
+    schemaVersion: typeof ARK_PROJECT_IDENTITY_SCHEMA_VERSION;
+    projectId: string;
+    resolvedRoot: string;
+    resolvedConfigPath: string;
+    arkgateVersion: string;
+    contractHash: string;
+    contractSource: 'project' | 'default-profile' | 'manifest';
+    runtimeId: string;
+    processStartedAt: string;
+};
+type ProjectExpectation = {
+    expectedRoot?: string;
+    expectedProjectId?: string;
+};
+type ProjectBinding = {
+    status: 'matched' | 'unverified' | 'mismatch';
+    authoritative: boolean;
+    expectedRoot?: string;
+    expectedProjectId?: string;
+    code?: 'PROJECT_ROOT_MISMATCH' | 'PROJECT_ID_MISMATCH' | 'INVALID_PROJECT_EXPECTATION';
+    message?: string;
+};
+declare const PROJECT_EXPECTATION_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly expectedRoot: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: string;
+        };
+        readonly expectedProjectId: {
+            readonly type: "string";
+            readonly pattern: "^sha256:[a-f0-9]{64}$";
+            readonly description: "Project id previously returned by ark_identity or ark_manifest.";
+        };
+    };
+};
+declare const PROJECT_BINDING_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["status", "authoritative"];
+    readonly properties: {
+        readonly status: {
+            readonly enum: readonly ["matched", "unverified", "mismatch"];
+        };
+        readonly authoritative: {
+            readonly type: "boolean";
+        };
+        readonly expectedRoot: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly expectedProjectId: {
+            readonly type: "string";
+            readonly pattern: "^sha256:[a-f0-9]{64}$";
+        };
+        readonly code: {
+            readonly enum: readonly ["PROJECT_ROOT_MISMATCH", "PROJECT_ID_MISMATCH", "INVALID_PROJECT_EXPECTATION"];
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+    };
+};
+declare const ARK_PROJECT_IDENTITY_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://unpkg.com/arkgate@4/schemas/ark.project-identity.schema.json";
+    readonly title: "ArkGate MCP project identity";
+    readonly description: "Stable project binding plus separate runtime and architecture-contract evidence.";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["schemaVersion", "projectId", "resolvedRoot", "resolvedConfigPath", "arkgateVersion", "contractHash", "contractSource", "runtimeId", "processStartedAt"];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly const: "1.0";
+        };
+        readonly projectId: {
+            readonly type: "string";
+            readonly pattern: "^sha256:[a-f0-9]{64}$";
+        };
+        readonly resolvedRoot: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly resolvedConfigPath: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly arkgateVersion: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly contractHash: {
+            readonly type: "string";
+            readonly pattern: "^sha256:[a-f0-9]{64}$";
+        };
+        readonly contractSource: {
+            readonly enum: readonly ["project", "default-profile", "manifest"];
+        };
+        readonly runtimeId: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly processStartedAt: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+    };
+    readonly $defs: {
+        readonly expectation: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly expectedRoot: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: string;
+                };
+                readonly expectedProjectId: {
+                    readonly type: "string";
+                    readonly pattern: "^sha256:[a-f0-9]{64}$";
+                    readonly description: "Project id previously returned by ark_identity or ark_manifest.";
+                };
+            };
+        };
+        readonly binding: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["status", "authoritative"];
+            readonly properties: {
+                readonly status: {
+                    readonly enum: readonly ["matched", "unverified", "mismatch"];
+                };
+                readonly authoritative: {
+                    readonly type: "boolean";
+                };
+                readonly expectedRoot: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly expectedProjectId: {
+                    readonly type: "string";
+                    readonly pattern: "^sha256:[a-f0-9]{64}$";
+                };
+                readonly code: {
+                    readonly enum: readonly ["PROJECT_ROOT_MISMATCH", "PROJECT_ID_MISMATCH", "INVALID_PROJECT_EXPECTATION"];
+                };
+                readonly message: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+        };
+    };
+};
+/**
+ * Stable identity: contract edits and MCP restarts must not change which project
+ * this is. Callers must pass canonical real paths and a SHA-256 hex function.
+ */
+declare function createProjectId(resolvedRoot: string, resolvedConfigPath: string, sha256Hex: (value: string) => string): string;
+declare function createProjectIdentity(input: Omit<ProjectIdentity, 'schemaVersion'>): ProjectIdentity;
+
+/**
+ * AI Code Gate (basic).
+ *
+ * Allows validation of generated source code against the defined architecture.
+ */
+interface AICodeGateViolation {
+    /** Stable rule identifier for agents and CI pipelines. */
+    ruleId: string;
+    /** @deprecated Use ruleId — kept for backward compatibility. */
+    code: string;
+    message: string;
+    line?: number;
+    suggestion?: string;
+    source?: string;
+    filePath?: string;
+    target?: string;
+    fromLayer?: string;
+    toLayer?: string;
+    /** Nested-wall reason. Absent on a classic layer deny and on a child-only parent import. */
+    reasonId?: string;
+    /** Last segment of the importer universe id, with a reasonId. */
+    universeFrom?: string;
+    /** Last segment of the importee universe id, with a reasonId. */
+    universeTo?: string;
+    /** True when a peerIsolation rule produced this finding (also mirrored in details). */
+    peerIsolation?: boolean;
+    /** False for an advisory sibling crossing. Omitted findings still block the snippet. */
+    failsStrict?: boolean;
+    details?: unknown;
+}
+/** Extension point for external analyzers (AST, semantic, etc.). */
+interface AIGateExtension<Context = unknown> {
+    readonly name: string;
+    analyze(source: string, context?: Context): AICodeGateViolation[];
+}
+interface AICodeGateContext {
+    filePath?: string;
+    agentId?: string;
+    layer?: string;
+    [key: string]: unknown;
+}
+interface AICodeGateResult {
+    /** Single-source snippets do not carry project-wide resolver evidence. */
+    mode: 'lexical-compatibility';
+    /** A snippet result is intentionally never an authoritative complete verdict. */
+    completeness: 'partial';
+    completenessReasons: string[];
+    /** Authoritative verdict. Always false until the complete candidate is resolved. */
+    valid: boolean;
+    /** Compatibility signal for the bounded lexical checks performed here. */
+    lexicalValid: boolean;
+    violations: AICodeGateViolation[];
+}
+interface AICodeGate<Context = AICodeGateContext> {
+    validate(source: string, context?: Context): AICodeGateResult;
+}
+
+/**
+ * Policy types for the Ark kernel.
+ *
+ * Policies allow declaring architectural rules that can be checked at runtime.
+ * Supports both hard policies (must never be violated) and soft policies (warnings).
+ */
+type PolicySeverity = 'hard' | 'soft';
+type PolicyEnforcementMode = 'runtime' | 'static' | 'runtime-and-static' | 'advisory';
+/**
+ * Represents a single violation of a policy.
+ */
+interface PolicyViolation {
+    /** Name of the policy that was violated */
+    policyName: string;
+    /** Severity level of the policy */
+    severity: PolicySeverity;
+    /** Human-readable explanation of the violation */
+    message: string;
+    /** Optional additional structured details */
+    details?: unknown;
+}
+/**
+ * A Policy defines a rule that can be evaluated against a context.
+ *
+ * @template Context - The shape of data the policy evaluates (e.g. { registry, events })
+ */
+interface Policy<Context = unknown> {
+    /** Unique name of the policy (used in violations and reporting) */
+    readonly name: string;
+    /** Whether this is a hard rule (enforced strictly) or soft (advisory) */
+    readonly severity: PolicySeverity;
+    /** Optional tags for policy classification (e.g. 'layer', 'naming') */
+    readonly tags?: readonly string[];
+    readonly owner?: string;
+    readonly version?: string;
+    readonly rationale?: string;
+    readonly enforcementMode?: PolicyEnforcementMode;
+    readonly deprecated?: boolean | string;
+    readonly replacedBy?: string;
+    /**
+     * Evaluates the policy against the given context.
+     * Return true / [] for pass, false / single violation / array for failure.
+     */
+    check(context: Context): boolean | PolicyViolation | PolicyViolation[];
+}
+
+/**
+ * Core domain primitives for Ark.
+ * These types are the foundation for all governance concepts.
+ */
+/**
+ * Semantic intent names follow a convention:
+ * - Domain.* for domain events and entities
+ * - Application.* for use-cases / orchestration
+ * - Adapter.* for integration points
+ * - Workflow.* for sagas and processes
+ * - Job.* for background jobs and scheduling
+ * - Presentation.* for UI/API adapters
+ * - Reporting.* for read models and projections
+ * - Metadata.* for extensibility contracts
+ * - Security.* / Audit.* / Observability.* for cross-cutting kernel concerns
+ * - Kernel.* for Ark-owned governance signals
+ */
+type IntentName = `Domain.${string}` | `Application.${string}` | `Adapter.${string}` | `Workflow.${string}` | `Job.${string}` | `Presentation.${string}` | `Reporting.${string}` | `Metadata.${string}` | `Security.${string}` | `Audit.${string}` | `Observability.${string}` | `Kernel.${string}`;
+type CorrelationId = string;
+interface EventMetadata {
+    occurredAt: string;
+    source: string;
+    kernelInstanceId?: string;
+    eventVersion?: string;
+    schemaVersion?: string;
+    allowInterception?: boolean;
+    interceptions?: Array<{
+        interceptorId: string;
+        timestamp: string;
+    }>;
+    correlationId?: CorrelationId;
+    causationId?: string;
+    traceId?: string;
+    spanId?: string;
+    parentSpanId?: string;
+    [key: string]: unknown;
+}
+interface DomainEvent<Name extends IntentName = IntentName, Payload = unknown> {
+    intent: Name;
+    payload: Payload;
+    metadata: EventMetadata;
+}
+
+/**
+ * Intent-specific types for the Ark kernel.
+ *
+ * Intents provide semantic naming for every important concept in the system
+ * (domain events, application operations, adapters, workflows).
+ */
+
+/**
+ * An IntentCreator is a callable that creates a strongly-typed DomainEvent
+ * when invoked with a payload.
+ *
+ * It also carries the semantic `name`.
+ *
+ * @example
+ * const OrderPlaced = defineIntent<'Domain.Order.OrderPlaced', { orderId: string }>('Domain.Order.OrderPlaced');
+ * const event = OrderPlaced({ orderId: 'o-1' });
+ */
+interface IntentCreator<Name extends IntentName, Payload = unknown> {
+    /**
+     * Creates a DomainEvent for this intent.
+     */
+    (payload: Payload): DomainEvent<Name, Payload>;
+    /**
+     * The fully-qualified semantic name of the intent (e.g. "Domain.Order.OrderPlaced").
+     */
+    readonly name: Name;
+}
+
+/**
+ * Architecture layer profiles.
+ *
+ * A profile turns semantic names such as `Domain.Order.Placed` into governed
+ * layer names and dependency rules.
+ */
+
+interface ArchitectureLayer {
+    name: string;
+    prefixes: string[];
+    /**
+     * Custom matcher for teams whose intent names don't follow prefix conventions.
+     * Checked before any prefix matching, in layer declaration order. A layer may
+     * use `match` alone (with `prefixes: []`), prefixes alone, or both.
+     */
+    match?: (name: string) => boolean;
+    description?: string;
+    trustBoundary?: 'public' | 'auth' | 'admin' | 'internal';
+    owners?: string[];
+    order?: number;
+}
+type ArchitectureRule = ArkConfigRule;
+interface ArchitectureProfile {
+    name: string;
+    layers: ArchitectureLayer[];
+    rules: ArchitectureRule[];
+    resolveLayer(name: string): string | undefined;
+}
+interface CreateArchitectureProfileOptions {
+    name: string;
+    layers: ArchitectureLayer[];
+    rules?: ArchitectureRule[];
+}
+interface CreateArchitectureProfileFromArkConfigOptions {
+    /** Runtime profile name. Default: config.name or "ark.config.json". */
+    name?: string;
+}
+type ArchitectureLayerConfig = ArkConfigLayer;
+type ArkCheckConfig = Omit<ArkConfig, '$schema' | 'schemaVersion' | 'rules'> & {
+    $schema?: string;
+    schemaVersion?: ArkConfig['schemaVersion'];
+    rules?: ArchitectureRule[];
+};
+interface CreateElevenLayerArkConfigOptions {
+    /** Source root used in generated file patterns. Default: "src". */
+    rootDir?: string;
+    /** Include entries for ark-check. Default: [rootDir]. */
+    include?: string[];
+    /** Mark generated layers optional. Default: true. */
+    optionalLayers?: boolean;
+}
+
+declare function createArchitectureProfile(options: CreateArchitectureProfileOptions): ArchitectureProfile;
+declare function createArchitectureProfileFromArkConfig(config: ArkCheckConfig, options?: CreateArchitectureProfileFromArkConfigOptions): ArchitectureProfile;
+declare const elevenLayerProfile: ArchitectureProfile;
+declare function createElevenLayerArkConfig(options?: CreateElevenLayerArkConfigOptions): ArkCheckConfig;
+
+/**
+ * Basic AI Code Gate implementation.
+ *
+ * Uses simple string heuristics + registered intent names to detect obvious
+ * architectural violations in generated code (e.g. direct infra imports from domain).
+ * Not a full static analyzer — documented limitation.
+ */
+
+interface AICodeGatePolicyContext<Context = AICodeGateContext> {
+    source: string;
+    context?: Context;
+}
+interface AICodeGateOptions<Context = AICodeGateContext> {
+    policies?: Policy<AICodeGatePolicyContext<Context>>[];
+    intents?: Array<string | Pick<IntentCreator<IntentName, unknown>, 'name'>>;
+    /**
+     * Additional forbidden patterns (regex or strings).
+     */
+    forbiddenPatterns?: Array<string | RegExp>;
+    /**
+     * External analyzer extensions (type-only contract; plug in AST tools later).
+     */
+    extensions?: AIGateExtension<Context>[];
+    /**
+     * Optional architecture profile for layer-aware generated-code checks.
+     * When context.layer is provided, intent references are checked against it.
+     */
+    architectureProfile?: ArchitectureProfile;
+    /**
+     * When true, flag string literals that look like intent names but are not registered.
+     */
+    enforceIntentAllowlist?: boolean;
+    /**
+     * Optional TypeScript module object. When provided, AICodeGate adds AST-backed checks
+     * for publish misuse without taking a runtime dependency on TypeScript.
+     */
+    typescript?: unknown;
+    /**
+     * Ambient globals forbidden per layer (layer name → entries such as "fetch" or
+     * "Date.now"). Checked only when `typescript` is provided and context.layer resolves
+     * to a listed layer — mirrors ark-check's FORBIDDEN_GLOBAL rule.
+     */
+    forbiddenGlobals?: Record<string, string[]>;
+    /**
+     * Layer → effective capability deny set (U04 walls; ADR 0009). Enforced like
+     * forbiddenGlobals when the target file's layer is known. An ambient use
+     * already covered by the layer's forbiddenGlobals reports only
+     * FORBIDDEN_GLOBAL (D7 — one violation, one voice).
+     */
+    capabilityWalls?: Record<string, string[]>;
+    /**
+     * Layer names whose role is infrastructure and may therefore import infrastructure
+     * (a persistence adapter importing the DB is correct, not a violation). The built-in
+     * infra-import heuristics are suppressed for these layers and for any layer whose
+     * name matches the conventional infra tokens. Populate from ark.config.json layers
+     * flagged `mayImportInfrastructure: true`, so unconventionally-named infra layers
+     * opt in explicitly. User-supplied `forbiddenPatterns` still apply everywhere.
+     */
+    infrastructureLayers?: string[];
+    /**
+     * Preferred single resolve step: import specifier or absolute source file →
+     * `{ layer, relPath }` for contract + peerIsolation. Prefer this over the
+     * legacy layer-only callback.
+     */
+    resolveImportTarget?: (specifierOrFilePath: string, fromFilePath?: string) => {
+        layer?: string;
+        relPath?: string;
+    } | undefined;
+    /**
+     * @deprecated Prefer resolveImportTarget. Layer-only resolve for governed imports.
+     */
+    resolveImportLayer?: (specifier: string, fromFilePath?: string) => string | undefined;
+    /**
+     * Layer configs (patterns) used to infer sliceFolders when a peerIsolation rule
+     * omits an explicit list.
+     */
+    architectureLayers?: Array<{
+        name: string;
+        patterns?: string[];
+    }>;
+    /** Explicit file-level escape hatch for reviewed non-literal import()/require() calls. */
+    allowNonLiteralDynamicImport?: (filePath?: string) => boolean;
+}
+declare function createAICodeGate<Context = AICodeGateContext>(options?: AICodeGateOptions<Context>): AICodeGate<Context>;
+
+/**
+ * Portable identity/fingerprint primitives for pure Domain contracts.
+ *
+ * FNV-1a is intentional: no Node crypto dependency for CLI/MCP/browserless consumers.
+ */
+/** Stable FNV-1a hash. Identity/fingerprint only — not a security primitive. */
+declare function deterministicHash(value: string): string;
+/** Serialize JSON-like values with sorted object keys for reproducible hashes. */
+declare function stableSerialize(value: unknown): string;
+
+/**
+ * ArkOrder resolver-fact extraction (ADR 0029). Syntax only — no verdicts.
+ */
+
+type ResolvedArkOrderPlaneCallFact = {
+    file: string;
+    line: number;
+    callee: string;
+};
+type ResolvedArkOrderGenericUpdateFact = {
+    file: string;
+    line: number;
+    method: string;
+};
+type ResolvedArkOrderRootHitFact = {
+    file: string;
+    matchedRoot: string;
+    hasPlaneFactory: boolean;
+};
+type ResolvedArkOrderXiFieldWriteFact = {
+    file: string;
+    line: number;
+    key: string;
+};
+type ResolvedArkOrderIngestWriteFact = {
+    file: string;
+    line: number;
+};
+type ResolvedArkOrderReleaseKeyCountFact = {
+    file: string;
+    line: number;
+    keyCount: number;
+};
+/** A freshness key (ttl/freshUntil/maxAge) inside the ξ literal of plane.release / proposeRelease. */
+type ResolvedArkOrderXiTtlFact = {
+    file: string;
+    line: number;
+    key: string;
+};
+/** A literal `allowedKinds` entry that a literal `informationBudget.cannotObserve` denies. */
+type ResolvedArkOrderBudgetLeakFact = {
+    file: string;
+    line: number;
+    kind: string;
+};
+
+/**
+ * Versioned type vocabulary for resolved candidate facts (schema 1.0).
+ *
+ * Pure declarations + schema version identity. Create/load live in
+ * resolvedCandidateFacts.ts; JSON Schema lives in resolvedCandidateFactsSchema.ts.
+ */
+
+/** 1.1 adds optional classShapes[] (ADR 0013). 1.2 adds optional ArkRun facts (ADR 0022). 1.0/1.1 remain loadable. */
+declare const RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION: "1.2";
+type ResolvedFactsCompleteness = 'complete' | 'partial' | 'unavailable';
+type ResolvedDependencyKind = 'import' | 'export' | 'dynamic-import' | 'require';
+type ResolvedDependencyState = 'resolved-project' | 'resolved-external' | 'unresolved' | 'dynamic';
+type ResolvedCapability = 'network' | 'filesystem' | 'clock' | 'randomness' | 'environment' | 'process' | 'persistence';
+type ResolvedFactsReason = {
+    code: string;
+    message: string;
+    file?: string;
+};
+type ResolvedFileFact = {
+    path: string;
+    contentHash: string;
+    parseStatus: 'parsed' | 'invalid';
+    parseDiagnosticCount: number;
+    exportsOnlyTypes: boolean;
+    typeOnlyExportNames: string[];
+    hasTopLevelSideEffects: boolean;
+};
+/** ADR 0022 kernel API call-site evidence. Sensors consume this in RN04. */
+type ResolvedArkRunKernelCallKind = 'factory' | 'publisher' | 'publish' | 'raise' | 'send' | 'subscribe' | 'register-handler' | 'resolve' | 'resolve-singleton';
+type ResolvedArkRunKernelCallFact = {
+    file: string;
+    line: number;
+    kind: ResolvedArkRunKernelCallKind;
+    callee: string;
+    viaImport: boolean;
+    receiver?: string;
+    nameLiteral?: string;
+};
+/** `new` of a class admitted for kernel creation (classShapes name or kernel import). */
+type ResolvedArkRunManagedNewFact = {
+    file: string;
+    line: number;
+    typeName: string;
+    importedFrom?: string;
+};
+/** Governed file that matched an `arkRun.compositionRoots` glob. */
+type ResolvedArkRunCompositionRootHitFact = {
+    file: string;
+    matchedRoot: string;
+    hasKernelFactory: boolean;
+};
+/** File-scoped interaction declaration lists (ADR 0023). Sensors consume this in RN04. */
+type ResolvedArkRunDeclarationFact = {
+    file: string;
+    line: number;
+    uses: string[];
+    reactsTo: string[];
+    raises: string[];
+    sends: string[];
+};
+/** ADR 0013 class-shape evidence for ArkRules structure sensors. */
+type ResolvedClassShapeFact = {
+    file: string;
+    className: string;
+    exported: boolean;
+    hasPublicMutableFields: boolean;
+    hasPublicSetters: boolean;
+    hasPublicConstructor: boolean;
+    hasStaticFactory: boolean;
+    mutatingMethods: readonly {
+        name: string;
+        referencesGuardOrPublish: boolean;
+    }[];
+    dataOnly?: boolean;
+    /** Source offset where the class-shape scan stopped (unwalkable body/header). */
+    truncatedUntil?: number;
+};
+type ResolvedDependencyFact = {
+    from: string;
+    specifier?: string;
+    kind: ResolvedDependencyKind;
+    typeOnly: boolean;
+    line: number;
+    resolution: ResolvedDependencyState;
+    target?: string;
+    namedBindings?: string[];
+    targetTypeOnlyExports?: boolean;
+    sourcePureTypeModule?: boolean;
+    namedBindingsTypeOnly?: boolean;
+    portProofEligible?: boolean;
+};
+type ResolvedCapabilityFact = {
+    file: string;
+    line: number;
+    symbol: string;
+    capability: ResolvedCapability;
+    source: 'ambient-global' | 'import-based';
+};
+type ResolvedAmbientFact = {
+    file: string;
+    line: number;
+    symbol: string;
+};
+type ResolvedPublishFact = {
+    file: string;
+    line: number;
+    rawIntentName?: string;
+    objectHasIntent: boolean;
+    arkPublishCandidate: boolean;
+    hasSource: boolean;
+    sourceIntent?: string;
+};
+type ResolvedIntentReferenceFact = {
+    file: string;
+    line: number;
+    intent: string;
+};
+type ResolvedSafetyKind = 'ts-suppression' | 'any-cast' | 'dynamic-import' | 'dynamic-require' | 'in-memory-store';
+/** Neutral syntax evidence for policy-controlled safety diagnostics. */
+type ResolvedSafetyFact = {
+    file: string;
+    line: number;
+    kind: ResolvedSafetyKind;
+    symbol?: string;
+};
+type ResolvedCandidateFactsInput = {
+    schemaVersion: '1.0' | '1.1' | typeof RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION;
+    completeness: ResolvedFactsCompleteness;
+    completenessReasons: readonly ResolvedFactsReason[];
+    resolverIdentity: string;
+    compilerIdentity: string;
+    compilerOptionsHash: string;
+    tsconfigHash: string;
+    evidenceRequirementsHash: string;
+    projectPackageName?: string;
+    files: readonly ResolvedFileFact[];
+    dependencies: readonly ResolvedDependencyFact[];
+    capabilityUses: readonly ResolvedCapabilityFact[];
+    ambientUses: readonly ResolvedAmbientFact[];
+    publishCalls: readonly ResolvedPublishFact[];
+    intentReferences: readonly ResolvedIntentReferenceFact[];
+    safetyUses: readonly ResolvedSafetyFact[];
+    /** ADR 0013 — optional on 1.0; default [] on load. */
+    classShapes?: readonly ResolvedClassShapeFact[];
+    /** ADR 0022 / RN03 — optional on 1.0/1.1; default [] on load. */
+    arkRunKernelCalls?: readonly ResolvedArkRunKernelCallFact[];
+    arkRunManagedNews?: readonly ResolvedArkRunManagedNewFact[];
+    arkRunCompositionRootHits?: readonly ResolvedArkRunCompositionRootHitFact[];
+    arkRunDeclarations?: readonly ResolvedArkRunDeclarationFact[];
+    arkOrderPlaneCalls?: readonly ResolvedArkOrderPlaneCallFact[];
+    arkOrderGenericUpdates?: readonly ResolvedArkOrderGenericUpdateFact[];
+    arkOrderRootHits?: readonly ResolvedArkOrderRootHitFact[];
+    arkOrderXiFieldWrites?: readonly ResolvedArkOrderXiFieldWriteFact[];
+    arkOrderIngestWritesXi?: readonly ResolvedArkOrderIngestWriteFact[];
+    arkOrderReleaseKeyCounts?: readonly ResolvedArkOrderReleaseKeyCountFact[];
+    arkOrderXiTtlKeys?: readonly ResolvedArkOrderXiTtlFact[];
+    arkOrderBudgetLeaks?: readonly ResolvedArkOrderBudgetLeakFact[];
+};
+type ResolvedCandidateFacts = Omit<ResolvedCandidateFactsInput, 'candidateTreeHash' | 'classShapes' | 'arkRunKernelCalls' | 'arkOrderPlaneCalls' | 'arkOrderGenericUpdates' | 'arkOrderXiFieldWrites' | 'arkOrderIngestWritesXi' | 'arkOrderReleaseKeyCounts' | 'arkOrderXiTtlKeys' | 'arkOrderBudgetLeaks' | 'arkOrderRootHits' | 'arkRunManagedNews' | 'arkRunCompositionRootHits' | 'arkRunDeclarations'> & {
+    schemaVersion: typeof RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION;
+    completenessReasons: ResolvedFactsReason[];
+    candidateTreeHash: string;
+    files: ResolvedFileFact[];
+    dependencies: ResolvedDependencyFact[];
+    capabilityUses: ResolvedCapabilityFact[];
+    ambientUses: ResolvedAmbientFact[];
+    publishCalls: ResolvedPublishFact[];
+    intentReferences: ResolvedIntentReferenceFact[];
+    safetyUses: ResolvedSafetyFact[];
+    classShapes: ResolvedClassShapeFact[];
+    arkRunKernelCalls: ResolvedArkRunKernelCallFact[];
+    arkRunManagedNews: ResolvedArkRunManagedNewFact[];
+    arkRunCompositionRootHits: ResolvedArkRunCompositionRootHitFact[];
+    arkRunDeclarations: ResolvedArkRunDeclarationFact[];
+    arkOrderPlaneCalls: ResolvedArkOrderPlaneCallFact[];
+    arkOrderGenericUpdates: ResolvedArkOrderGenericUpdateFact[];
+    arkOrderRootHits: ResolvedArkOrderRootHitFact[];
+    arkOrderXiFieldWrites: ResolvedArkOrderXiFieldWriteFact[];
+    arkOrderIngestWritesXi: ResolvedArkOrderIngestWriteFact[];
+    arkOrderReleaseKeyCounts: ResolvedArkOrderReleaseKeyCountFact[];
+    arkOrderXiTtlKeys: ResolvedArkOrderXiTtlFact[];
+    arkOrderBudgetLeaks: ResolvedArkOrderBudgetLeakFact[];
+    factsHash: string;
+};
+
+/**
+ * Canonical create/load for versioned resolved candidate facts.
+ *
+ * Types: resolvedCandidateFactsTypes.ts · Schema: resolvedCandidateFactsSchema.ts ·
+ * Hash: stableHash.ts. Plan-B god-module pilot cluster (pattern-b:god-module).
+ */
+
+/** Identity of the policy-controlled evidence a resolver must attempt to collect. */
+declare function resolvedFactsEvidenceRequirementsHash(config: ArkConfig): string;
+declare function createResolvedCandidateFacts(input: ResolvedCandidateFactsInput): ResolvedCandidateFacts;
+declare function loadResolvedCandidateFacts(input: unknown): ResolvedCandidateFacts;
+
+declare const RESOLVED_CANDIDATE_FACTS_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://unpkg.com/arkgate@3/schemas/ark.resolved-candidate-facts.schema.json";
+    readonly title: "ArkGate resolved candidate facts";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["schemaVersion", "completeness", "completenessReasons", "resolverIdentity", "compilerIdentity", "compilerOptionsHash", "tsconfigHash", "candidateTreeHash", "evidenceRequirementsHash", "files", "dependencies", "capabilityUses", "ambientUses", "publishCalls", "intentReferences", "safetyUses", "factsHash"];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly enum: readonly ["1.0", "1.1", "1.2"];
+        };
+        readonly completeness: {
+            readonly enum: readonly ["complete", "partial", "unavailable"];
+        };
+        readonly completenessReasons: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["code", "message"];
+                readonly properties: {
+                    readonly code: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly message: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                };
+            };
+        };
+        readonly resolverIdentity: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly compilerIdentity: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly compilerOptionsHash: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly tsconfigHash: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly candidateTreeHash: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly evidenceRequirementsHash: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly projectPackageName: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly files: {
+            readonly type: "array";
+            readonly uniqueItems: true;
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["path", "contentHash", "parseStatus", "parseDiagnosticCount", "exportsOnlyTypes", "typeOnlyExportNames", "hasTopLevelSideEffects"];
+                readonly properties: {
+                    readonly path: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly contentHash: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly parseStatus: {
+                        readonly enum: readonly ["parsed", "invalid"];
+                    };
+                    readonly parseDiagnosticCount: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
+                    readonly exportsOnlyTypes: {
+                        readonly type: "boolean";
+                    };
+                    readonly typeOnlyExportNames: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                    readonly hasTopLevelSideEffects: {
+                        readonly type: "boolean";
+                    };
+                };
+                readonly allOf: readonly [{
+                    readonly if: {
+                        readonly properties: {
+                            readonly parseStatus: {
+                                readonly const: "parsed";
+                            };
+                        };
+                    };
+                    readonly then: {
+                        readonly properties: {
+                            readonly parseDiagnosticCount: {
+                                readonly const: 0;
+                            };
+                        };
+                    };
+                }, {
+                    readonly if: {
+                        readonly properties: {
+                            readonly parseStatus: {
+                                readonly const: "invalid";
+                            };
+                        };
+                    };
+                    readonly then: {
+                        readonly properties: {
+                            readonly parseDiagnosticCount: {
+                                readonly minimum: 1;
+                            };
+                        };
+                    };
+                }];
+            };
+        };
+        readonly dependencies: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["from", "kind", "typeOnly", "line", "resolution"];
+                readonly properties: {
+                    readonly from: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly specifier: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly kind: {
+                        readonly enum: readonly ["import", "export", "dynamic-import", "require"];
+                    };
+                    readonly typeOnly: {
+                        readonly type: "boolean";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly resolution: {
+                        readonly enum: readonly ["resolved-project", "resolved-external", "unresolved", "dynamic"];
+                    };
+                    readonly target: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly namedBindings: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                    readonly targetTypeOnlyExports: {
+                        readonly type: "boolean";
+                    };
+                    readonly sourcePureTypeModule: {
+                        readonly type: "boolean";
+                    };
+                    readonly namedBindingsTypeOnly: {
+                        readonly type: "boolean";
+                    };
+                    readonly portProofEligible: {
+                        readonly type: "boolean";
+                    };
+                };
+                readonly allOf: readonly [{
+                    readonly if: {
+                        readonly properties: {
+                            readonly resolution: {
+                                readonly const: "resolved-project";
+                            };
+                        };
+                    };
+                    readonly then: {
+                        readonly required: readonly ["target"];
+                    };
+                    readonly else: {
+                        readonly not: {
+                            readonly required: readonly ["target"];
+                        };
+                    };
+                }, {
+                    readonly if: {
+                        readonly properties: {
+                            readonly resolution: {
+                                readonly const: "dynamic";
+                            };
+                        };
+                    };
+                    readonly else: {
+                        readonly required: readonly ["specifier"];
+                    };
+                }];
+            };
+        };
+        readonly capabilityUses: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "symbol", "capability", "source"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly symbol: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly capability: {
+                        readonly enum: readonly ["network", "filesystem", "clock", "randomness", "environment", "process", "persistence"];
+                    };
+                    readonly source: {
+                        readonly enum: readonly ["ambient-global", "import-based"];
+                    };
+                };
+            };
+        };
+        readonly ambientUses: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "symbol"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly symbol: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly publishCalls: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "objectHasIntent", "arkPublishCandidate", "hasSource"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly rawIntentName: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly objectHasIntent: {
+                        readonly type: "boolean";
+                    };
+                    readonly arkPublishCandidate: {
+                        readonly type: "boolean";
+                    };
+                    readonly hasSource: {
+                        readonly type: "boolean";
+                    };
+                    readonly sourceIntent: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly intentReferences: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "intent"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly intent: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly safetyUses: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "kind"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly kind: {
+                        readonly enum: readonly ["ts-suppression", "any-cast", "dynamic-import", "dynamic-require", "in-memory-store"];
+                    };
+                    readonly symbol: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+                readonly allOf: readonly [{
+                    readonly if: {
+                        readonly properties: {
+                            readonly kind: {
+                                readonly const: "in-memory-store";
+                            };
+                        };
+                    };
+                    readonly then: {
+                        readonly required: readonly ["symbol"];
+                    };
+                    readonly else: {
+                        readonly not: {
+                            readonly required: readonly ["symbol"];
+                        };
+                    };
+                }];
+            };
+        };
+        readonly classShapes: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "className", "exported", "hasPublicMutableFields", "hasPublicSetters", "hasPublicConstructor", "hasStaticFactory", "mutatingMethods"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly className: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly exported: {
+                        readonly type: "boolean";
+                    };
+                    readonly hasPublicMutableFields: {
+                        readonly type: "boolean";
+                    };
+                    readonly hasPublicSetters: {
+                        readonly type: "boolean";
+                    };
+                    readonly hasPublicConstructor: {
+                        readonly type: "boolean";
+                    };
+                    readonly hasStaticFactory: {
+                        readonly type: "boolean";
+                    };
+                    readonly dataOnly: {
+                        readonly type: "boolean";
+                    };
+                    readonly truncatedUntil: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
+                    readonly mutatingMethods: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["name", "referencesGuardOrPublish"];
+                            readonly properties: {
+                                readonly name: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly referencesGuardOrPublish: {
+                                    readonly type: "boolean";
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        readonly arkRunKernelCalls: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "kind", "callee", "viaImport"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly kind: {
+                        readonly enum: readonly ["factory", "publisher", "publish", "raise", "send", "subscribe", "register-handler", "resolve", "resolve-singleton"];
+                    };
+                    readonly callee: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly viaImport: {
+                        readonly type: "boolean";
+                    };
+                    readonly receiver: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly nameLiteral: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly arkRunManagedNews: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "typeName"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly typeName: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly importedFrom: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly arkRunCompositionRootHits: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "matchedRoot", "hasKernelFactory"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly matchedRoot: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly hasKernelFactory: {
+                        readonly type: "boolean";
+                    };
+                };
+            };
+        };
+        readonly arkRunDeclarations: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "uses", "reactsTo", "raises", "sends"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly uses: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                    readonly reactsTo: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                    readonly raises: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                    readonly sends: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+            };
+        };
+        readonly arkOrderPlaneCalls: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "callee"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly callee: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly arkOrderGenericUpdates: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "method"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly method: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly arkOrderRootHits: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "matchedRoot", "hasPlaneFactory"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly matchedRoot: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly hasPlaneFactory: {
+                        readonly type: "boolean";
+                    };
+                };
+            };
+        };
+        readonly arkOrderXiFieldWrites: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "key"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly key: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly arkOrderIngestWritesXi: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                };
+            };
+        };
+        readonly arkOrderReleaseKeyCounts: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "keyCount"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly keyCount: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                };
+            };
+        };
+        readonly arkOrderXiTtlKeys: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "key"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly key: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly arkOrderBudgetLeaks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "kind"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly kind: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly factsHash: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+    };
+    readonly allOf: readonly [{
+        readonly if: {
+            readonly properties: {
+                readonly completeness: {
+                    readonly const: "complete";
+                };
+            };
+        };
+        readonly then: {
+            readonly properties: {
+                readonly completenessReasons: {
+                    readonly maxItems: 0;
+                };
+                readonly files: {
+                    readonly items: {
+                        readonly properties: {
+                            readonly parseStatus: {
+                                readonly const: "parsed";
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    }, {
+        readonly if: {
+            readonly properties: {
+                readonly completeness: {
+                    readonly enum: readonly ["partial", "unavailable"];
+                };
+            };
+        };
+        readonly then: {
+            readonly properties: {
+                readonly completenessReasons: {
+                    readonly minItems: 1;
+                };
+            };
+        };
+    }];
+};
+
+/**
+ * Stable, pure vocabulary for ArkGate's importable analysis engine.
+ *
+ * This module owns the Analysis IR types and re-exports the resolved-candidate-facts
+ * pilot cluster (plan-B / pattern-b:god-module). Parsing and filesystem discovery
+ * belong to adapters.
+ *
+ * Cluster:
+ * - `stableHash` — identity/fingerprint primitives
+ * - `resolvedCandidateFactsTypes` — versioned fact types
+ * - `resolvedCandidateFacts` — create/load/canonicalize
+ * - `resolvedCandidateFactsSchema` — published JSON Schema
+ *
+ * Consumer import paths through this facade remain stable (same pattern as Kernel
+ * `analysis.ts` after U02).
+ */
+
+declare const ANALYSIS_IR_SCHEMA_VERSION: "1.0";
+type AnalysisFileInput = {
+    path: string;
+    content: string;
+};
+type AnalysisFileChange = {
+    path: string;
+    content: string;
+} | {
+    path: string;
+    delete: true;
+};
+type AnalysisCompilerOptions = Readonly<Record<string, unknown>>;
+type AnalysisFile = AnalysisFileInput & {
+    contentHash: string;
+    layer: string | null;
+};
+type AnalysisImportEdge = {
+    from: string;
+    specifier: string;
+    to: string | null;
+    resolution: 'resolved' | 'unresolved';
+    fromLayer: string | null;
+    toLayer: string | null;
+    evidence: AnalysisEvidence;
+};
+/** A capability use is reserved for C04's symbol-aware implementation. */
+type AnalysisCapabilityUse = {
+    file: string;
+    symbol: string;
+    capability: string;
+    evidence: AnalysisEvidence;
+};
+type AnalysisEvidence = {
+    kind: 'import' | 'policy';
+    file: string;
+    line: number;
+    excerpt: string;
+};
+type AnalysisViolation = {
+    ruleId: string;
+    message: string;
+    edge?: AnalysisImportEdge;
+    /** U04 (additive): present on CAPABILITY_VIOLATION — the denied capability id. */
+    capability?: string;
+    /** U04 (additive): the matched module specifier or ambient path. */
+    symbol?: string;
+    evidence: AnalysisEvidence;
+};
+type AnalysisIr = {
+    schemaVersion: typeof ANALYSIS_IR_SCHEMA_VERSION;
+    policyHash: string;
+    compilerOptionsHash: string;
+    files: AnalysisFile[];
+    layers: string[];
+    edges: AnalysisImportEdge[];
+    capabilityUses: AnalysisCapabilityUse[];
+    violations: AnalysisViolation[];
+};
+
+declare const ARK_CHANGE_MAP_SCHEMA_VERSION: "1.0";
+type ArchitectureChangeOperation = 'create' | 'update' | 'delete';
+type ArchitectureChangeMapFile = {
+    path: string;
+    operation: ArchitectureChangeOperation;
+    layer: string;
+};
+type ArchitectureChangeMapDependency = {
+    from: string;
+    to: string;
+};
+type ArchitectureChangeMap = {
+    $schema: string;
+    schemaVersion: typeof ARK_CHANGE_MAP_SCHEMA_VERSION;
+    files: ArchitectureChangeMapFile[];
+    dependencies: ArchitectureChangeMapDependency[];
+};
+type ArchitectureChangeMapContract = {
+    map: ArchitectureChangeMap;
+    hash: string;
+};
+
+type ArchitectureDependency = {
+    from: string;
+    to: string;
+};
+type ArchitectureActualChange = {
+    path: string;
+    operation: ArchitectureChangeOperation;
+};
+type ArchitectureConvergenceClassification = 'satisfied' | 'missing' | 'contradictory' | 'unplanned';
+type ArchitectureConvergenceFinding = {
+    id: string;
+    classification: ArchitectureConvergenceClassification;
+    subject: 'file' | 'dependency';
+    message: string;
+    nextAction?: string;
+    path?: string;
+    from?: string;
+    to?: string;
+    expectedOperation?: ArchitectureChangeOperation;
+    actualOperation?: ArchitectureChangeOperation | 'added' | 'removed';
+};
+type ArchitectureConvergenceResult = {
+    schemaVersion: '1.0';
+    readOnly: true;
+    changeMapHash: string;
+    structurallyConverged: boolean;
+    behavioralCompletion: 'not-evaluated';
+    summary: Record<ArchitectureConvergenceClassification, number>;
+    findings: ArchitectureConvergenceFinding[];
+};
+type AnalyzeArchitectureConvergenceInput = {
+    changeMap: ArchitectureChangeMapContract;
+    changes: readonly ArchitectureActualChange[];
+    baseDependencies: readonly ArchitectureDependency[];
+    candidateDependencies: readonly ArchitectureDependency[];
+};
+declare function analyzeArchitectureConvergence(input: AnalyzeArchitectureConvergenceInput): ArchitectureConvergenceResult;
+
+type SemanticDependencyKind = 'import' | 'export' | 'dynamic-import' | 'require';
+type SemanticDependency = {
+    specifier?: string;
+    kind: SemanticDependencyKind;
+    line: number;
+    typeOnly: boolean;
+    unresolved: boolean;
+    node: unknown;
+};
+type ForbiddenCapabilityUse = {
+    name: string;
+    line: number;
+    node: unknown;
+};
+/** Extract every dependency form whose specifier is statically knowable, plus unresolved calls. */
+declare function extractSemanticDependencies(ts: any, sourceFile: any): SemanticDependency[];
+/** Resolve forbidden ambient capabilities through symbols, aliases, globalThis, and static keys. */
+declare function collectForbiddenCapabilityUses(ts: any, sourceFile: any, forbidden: readonly string[]): ForbiddenCapabilityUse[];
+
+type LayerFlowConfigShape = {
+    layers: readonly {
+        name: string;
+        intentPrefixes?: readonly string[];
+    }[];
+    rules?: readonly {
+        from: string;
+        to: string;
+        allowed?: boolean;
+        peerIsolation?: boolean;
+    }[];
+};
+
+/**
+ * Pure invariant coverage evidence (ADR 0014 / AR09–AR10).
+ *
+ * Mines test titles and symbol declarations against the Effective ArkRules catalog.
+ * `classifyCoverage` returns one verdict; `countsAsCoverage` is the policy;
+ * `describeCoverage` is the sentence. A bare mention is never coverage.
+ * No filesystem — Tooling supplies file contents and test globs.
+ */
+
+/**
+ * How a `coverage.symbol` identifier is declared. `type`, `interface`, and
+ * `enum` are declarations — the same witness as function, class, const, and
+ * method.
+ */
+type DeclarationShape = 'function' | 'class' | 'const' | 'method' | 'type' | 'interface' | 'enum';
+/** Where a bare mention of an id or symbol sat. Never coverage. */
+type MentionContext = 'test-body' | 'comment' | 'string' | 'import';
+/**
+ * One coverage verdict. Best evidence wins: test-title, then declaration,
+ * then mention-only, then none. A comment in another file, when the symbol
+ * still occurs in code, is `declaration-miss` and does not count.
+ * Regexes, the test-file vs source split, and `Aggregate.method` lookup stay
+ * behind this value.
+ */
+type CoverageEvidence = {
+    kind: 'test-title';
+    file: string;
+    title: string;
+} | {
+    kind: 'declaration';
+    file: string;
+    shape: DeclarationShape;
+} | {
+    kind: 'mention-only';
+    file: string;
+    context: MentionContext;
+} | {
+    kind: 'declaration-miss';
+    symbol: string;
+} | {
+    kind: 'none';
+};
+/** Invariant fields the classifier reads. A full catalog entry is assignable. */
+type CoverageInvariant = {
+    id: string;
+    coverage?: {
+        test?: boolean;
+        symbol?: string;
+    } | null;
+};
+/** File set the classifier reads. Tooling has already loaded the contents. */
+type CoverageFiles = {
+    /** Project-relative path → file contents (tests and sources). */
+    fileContents: Readonly<Record<string, string>>;
+    /** Paths already classified as tests. */
+    testFiles?: readonly string[];
+    /**
+     * Declared runner roots. A test title inside a root beats one outside it.
+     * The outside-roots finding stays a separate verdict.
+     */
+    coverageRoots?: readonly string[];
+};
+type InvariantCoverageEvidence = {
+    invariantId: string;
+    layer: string;
+    sourceFile: string;
+    mode: 'advisory' | 'enforced';
+    covered: boolean;
+    evidence: Array<'test-title' | 'symbol'>;
+    /** When no test globs were supplied, coverage cannot be proven. */
+    partial: boolean;
+    description: string;
+    /** Test file that supplied the `test-title` evidence, when there was one. */
+    testEvidenceFile?: string;
+    /**
+     * Non-test file that declares `coverage.symbol`. Absent when the name only
+     * appears in an import or a call. ArkGate never runs tests; this path is the
+     * declaration text, not a passing suite.
+     */
+    symbolEvidenceFile?: string;
+    /**
+     * Declaration shape when `evidence` includes `symbol`. Additive: readers that
+     * only know `test-title` | `symbol` ignore it.
+     */
+    shape?: DeclarationShape;
+    /**
+     * The only covering test found sits outside `coverage.coverageRoots` — the
+     * places the project declares its runner executes. ArkGate never runs tests,
+     * so a title match outside those roots is a test that exists, not a test that
+     * runs. Absent (undefined) when no roots were declared: without a declaration
+     * there is nothing to compare against, and silence is honest.
+     */
+    outsideDeclaredRoots?: boolean;
+    /**
+     * True when `coverage.coverageRoots` was non-empty for this evaluation.
+     * `false` when the project declared nothing. Omitted on hand-built evidence
+     * so existing promote fixtures stay valid; the evaluator always sets it.
+     */
+    coverageRootsDeclared?: boolean;
+};
+type InvariantUncoveredKind = 'never-had-tests' | 'tests-disappeared';
+type InvariantCoverageRuleId = 'INVARIANT_UNCOVERED' | 'INVARIANT_COVERAGE_OUTSIDE_ROOTS';
+type InvariantCoverageViolation = {
+    ruleId: InvariantCoverageRuleId;
+    message: string;
+    file: string;
+    line: number;
+    arkruleId: string;
+    arkruleSource: string;
+    fromLayer: string;
+    severity: 'error' | 'warning';
+    failsStrict: boolean;
+    /**
+     * Adopt residual (no test suite) vs regression (suite exists, coverage gone).
+     * Only INVARIANT_UNCOVERED carries it: an outside-roots finding is about
+     * WHERE the covering test lives, not about whether one exists.
+     */
+    kind?: InvariantUncoveredKind;
+};
+type EvaluateInvariantCoverageInput = {
+    arkRules: EffectiveArkRules;
+    /** Project-relative path → file contents (tests + domain sources). */
+    fileContents: Readonly<Record<string, string>>;
+    /** Paths considered tests (already filtered by Tooling via globs). */
+    testFiles?: readonly string[];
+    /** When true, missing test files make coverage partial (never green covered). */
+    testGlobsMissing?: boolean;
+    /**
+     * Tooling hit MAX_COVERAGE_FILES. Partial must not claim the repo never had tests —
+     * the suite may exist outside the scan budget.
+     */
+    coverageBudgetExhausted?: boolean;
+    /** Numbers behind the scan: what was loaded, what was discarded and why. */
+    coverageStats?: InvariantCoverageStats;
+    /**
+     * Declared (`coverage.coverageRoots`) path prefixes where the project says its
+     * runner actually executes tests. ArkGate never executes anything: this is a
+     * second DECLARATION to compare the first against. Absent or empty means no
+     * declaration was made, so no outside-roots claim is possible.
+     */
+    coverageRoots?: readonly string[];
+};
+/**
+ * What the Tooling scan actually saw. Every discard has a counted reason —
+ * a silent drop would make an uncovered verdict unexplainable.
+ */
+type InvariantCoverageStats = {
+    /**
+     * Files actually opened and read. Always >= filesLoaded: a test is read
+     * before it can be judged for naming an invariant, so the file budget bounds
+     * RETENTION, not I/O. Reporting only the retained count made
+     * `coverage.maxFiles` read as a knob on how much the scan opens.
+     */
+    filesRead?: number;
+    /** Files retained as coverage evidence (tests + production). */
+    filesLoaded: number;
+    /** Test files retained (subset of filesLoaded). */
+    testFilesRetained: number;
+    /** The file budget in force for this scan (config `coverage.maxFiles` or the default). */
+    maxFiles: number;
+    discarded: {
+        /** Reached the file budget. */
+        budget: number;
+        /** Test file naming no catalogued invariant (scanned, then dropped). */
+        noInvariantMention: number;
+        /** Larger than the per-file byte cap. */
+        oversize: number;
+        /**
+         * stat/read failed on a file or a directory: permissions, a broken symlink,
+         * or something that moved mid-scan. Files and directories share one counter.
+         */
+        unreadable: number;
+        /** Directory deeper than the walk depth limit — its files were never seen. */
+        depthLimited: number;
+        /**
+         * Symlink inside the tree whose target resolves outside the project root.
+         * Refused as evidence: a file that is not in this repo must not prove an
+         * invariant covered.
+         */
+        outOfRoot: number;
+    };
+};
+/**
+ * Best coverage evidence for `invariant` in `files`.
+ * test-title beats a declaration; a declaration beats a bare mention; a bare
+ * mention beats silence. Callers do not re-scan to explain the verdict.
+ */
+declare function classifyCoverage(invariant: CoverageInvariant, files: CoverageFiles): CoverageEvidence;
+/**
+ * Policy: a test title or any declaration counts, including type, interface,
+ * and enum. A mention-only verdict never counts. `none` does not count.
+ */
+declare function countsAsCoverage(ev: CoverageEvidence): boolean;
+/** Sentence for the verdict. `INVARIANT_UNCOVERED` prints this; it does not re-derive it. */
+declare function describeCoverage(invariant: CoverageInvariant, ev: CoverageEvidence): string;
+declare function evaluateInvariantCoverage(input: EvaluateInvariantCoverageInput): {
+    coverage: InvariantCoverageEvidence[];
+    violations: InvariantCoverageViolation[];
+    partial: boolean;
+};
+/**
+ * Deterministic promotion gate: refuse advisory→enforced when invariant is uncovered.
+ */
+declare function canPromoteInvariant(coverage: InvariantCoverageEvidence | undefined): {
+    ok: boolean;
+    reason: string;
+};
+
+/**
+ * Pure ArkRules structure sensor evaluation (ADR 0013).
+ *
+ * Consumes closed class-shape / file facts + Effective ArkRules. Emits violations with
+ * arkrule provenance. No filesystem, no TypeScript compiler.
+ */
+
+type ClassShapeFact = {
+    file: string;
+    className: string;
+    exported: boolean;
+    hasPublicMutableFields: boolean;
+    hasPublicSetters: boolean;
+    hasPublicConstructor: boolean;
+    hasStaticFactory: boolean;
+    mutatingMethods: readonly {
+        name: string;
+        referencesGuardOrPublish: boolean;
+    }[];
+    /** Heuristic: data-only class (fields, no methods beyond accessors). */
+    dataOnly?: boolean;
+    /**
+     * Set when the scanner could not walk the class to its end: the character
+     * offset (in the source file) where analysis stopped. Enumerable on purpose so
+     * it survives fact canonicalisation and serialisation; enforced structure
+     * sensors report it instead of passing in silence.
+     */
+    truncatedUntil?: number;
+};
+type ArkRuleSensorViolation = {
+    ruleId: string;
+    code: string;
+    message: string;
+    file: string;
+    line: number;
+    fromLayer?: string;
+    arkruleId: string;
+    arkruleSource: string;
+    severity: 'error' | 'warning';
+    sensor: ArkRuleSensorId;
+    /** When true, advisory surfaces only (does not fail strict). */
+    failsStrict: boolean;
+};
+type EvaluateArkRuleSensorsInput = {
+    arkRules: EffectiveArkRules;
+    classShapes: readonly ClassShapeFact[];
+    /** Project-relative paths in scope for the analysis. */
+    files: readonly string[];
+    /**
+     * Optional layer membership: path → layer name. When omitted, structure rules
+     * apply by appliesTo globs only (or all files when appliesTo is absent).
+     */
+    layerForFile?: (path: string) => string | null | undefined;
+    /**
+     * Optional thin/orchestration heuristic flags per file (Tooling-supplied).
+     */
+    fileHints?: Readonly<Record<string, {
+        orchestrationHeavy?: boolean;
+        adapterThick?: boolean;
+        persistenceWrite?: boolean;
+    }>>;
+};
+/**
+ * Evaluate all structure sensors. Empty Effective Contract → no findings (byte-for-byte parity).
+ */
+declare function evaluateArkRuleSensors(input: EvaluateArkRuleSensorsInput): ArkRuleSensorViolation[];
+/**
+ * ADR 0012 D3 — a structure rule whose appliesTo matches zero governed files is
+ * never silent green. Advisory → warning; enforced → failsStrict.
+ * Rules without appliesTo (whole-layer) never emit this signal.
+ */
+declare function collectEmptyAppliesToFindings(arkRules: EffectiveArkRules, files: readonly string[]): ArkRuleSensorViolation[];
+/**
+ * IO / ORM import evidence and receiver-bound write tokens live in
+ * persistenceWriteHint (shared with ArkOrder — one definition, not lockstep copies).
+ * Callee must be a persistence client (db|tx|client|prisma|drizzle, `new PrismaClient()`,
+ * or a name bound to a driver constructor); not repo.update(.
+ */
+/** Optional resolved-import facts when the collector already classified the specifier. */
+type ResolvedPersistenceImportFact = {
+    specifier?: string;
+    resolvedFile?: string;
+    layer?: string | null;
+};
+/**
+ * Pure Tooling/Domain heuristic for orchestration-only / thin-adapter fileHints.
+ * Prefers false negatives over false positives (ADR 0013 discipline).
+ * Returns null when neither flag is set (callers may omit the path).
+ */
+declare function deriveArkRuleFileHints(_file: string, content: string, resolvedImports?: readonly ResolvedPersistenceImportFact[]): {
+    orchestrationHeavy?: boolean;
+    adapterThick?: boolean;
+    persistenceWrite?: boolean;
+} | null;
+/**
+ * Build fileHints map from path→content. Omits paths with no flags (sparse map).
+ */
+declare function buildArkRuleFileHints(fileContents: Readonly<Record<string, string>>, resolvedImportsByFile?: Readonly<Record<string, readonly ResolvedPersistenceImportFact[]>>): Record<string, {
+    orchestrationHeavy?: boolean;
+    adapterThick?: boolean;
+    persistenceWrite?: boolean;
+}>;
+/**
+ * Lightweight class-shape extraction from TypeScript source text (no compiler).
+ * Conservative: prefers false negatives over false positives for mutability.
+ * Tooling may replace with TypeScript-API facts; sensors consume the same shape.
+ *
+ * The header and body are walked by the shared tokenizer (classSourceScan):
+ * type parameters (`class Box<T>`), generic `extends` / `implements` clauses, and
+ * braces inside strings, comments, or template literals are handled. A class whose
+ * header or body cannot be walked is still reported, with a truncation mark, so
+ * enforced sensors say so instead of passing in silence.
+ *
+ * Limitation (AR05/AR06): only `export class` / `export abstract class` forms.
+ * `export default class`, re-exported classes, and non-exported aggregates are
+ * invisible — enforced structure sensors stay silent (false negative). Silence
+ * is never proof of compliance.
+ */
+declare function extractClassShapesFromSource(file: string, content: string): ClassShapeFact[];
+
+/**
+ * Config-key version floors plus pin evidence (#338).
+ *
+ * A slice key such as `childSlices` is rejected at config load by an older
+ * arkgate (the rule schema sets `additionalProperties: false`). ArkGate warns
+ * about that only with evidence that this repo pins such an older arkgate: an
+ * exact package.json dependency, the installed copy, the lockfile, a hook
+ * script, or a CI workflow. Without evidence it stays silent.
+ *
+ * Pure: Tooling reads the files and passes their text here.
+ */
+/** Where a pin was found. */
+type ArkgatePinSource = 'package-json' | 'package-lock' | 'installed' | 'hook' | 'ci';
+type ArkgatePinEvidence = {
+    /** Repo-relative file that pins arkgate. */
+    file: string;
+    /** 1-based line of the pin. */
+    line: number;
+    /** Pinned version, without a leading `v`. */
+    version: string;
+    source: ArkgatePinSource;
+};
+
+declare const POLICY_DELTA_SCHEMA_VERSION: "1.0";
+type PolicyDeltaClassification = 'strengthening' | 'neutral' | 'judgment-required' | 'weakening';
+type PolicyDeltaFinding = {
+    id: string;
+    path: string;
+    classification: Exclude<PolicyDeltaClassification, 'neutral'>;
+    message: string;
+    nextAction?: string;
+    before?: unknown;
+    after?: unknown;
+};
+type PolicyDelta = {
+    schemaVersion: typeof POLICY_DELTA_SCHEMA_VERSION;
+    classification: PolicyDeltaClassification;
+    findings: PolicyDeltaFinding[];
+};
+type PolicyDeltaAcknowledgement = {
+    schemaVersion: typeof POLICY_DELTA_SCHEMA_VERSION;
+    basePolicyHash: string;
+    candidatePolicyHash: string;
+    findingIds: readonly string[];
+    reason: string;
+    /**
+     * Relative decision-note path under a conventional home (`docs/adr/`,
+     * `docs/decisions/`, or the AP01 single-file homes). Tooling checks the file.
+     * Hash matching does not require it.
+     */
+    adrPath?: string;
+};
+type ClassifyArkPolicyDeltaOptions = {
+    baseArkRules?: EffectiveArkRules;
+    candidateArkRules?: EffectiveArkRules;
+    /**
+     * AR11 — coverage evidence for candidate invariants. Required to auto-allow
+     * advisory→enforced promotion; without it (or when uncovered), promotion is
+     * judgment-required / refused.
+     */
+    candidateInvariantCoverage?: readonly InvariantCoverageEvidence[];
+};
+declare function classifyArkPolicyDelta(base: ArkConfig, candidate: ArkConfig, options?: ClassifyArkPolicyDeltaOptions): PolicyDelta;
+declare function policyDeltaAcknowledgementMatches(acknowledgement: PolicyDeltaAcknowledgement | undefined, expected: {
+    basePolicyHash: string;
+    candidatePolicyHash: string;
+    findingIds: readonly string[];
+}): boolean;
+
+type AnalysisContract = ArkConfigLoadResult & {
+    policyHash: string;
+    /**
+     * ADR 0012 Effective ArkRules (empty when arkRules is absent).
+     * Included in policyHash when non-empty so arkrules edits invalidate identity.
+     */
+    arkRules?: EffectiveArkRules;
+    /**
+     * ADR 0013 class-shape facts for ArkRules sensors (Tooling-supplied).
+     * Empty / absent when ArkRules are not active.
+     */
+    classShapes?: ClassShapeFact[];
+};
+type AnalyzeProjectInput = {
+    contract: AnalysisContract;
+    files: readonly AnalysisFileInput[];
+    compilerOptions?: AnalysisCompilerOptions;
+};
+type AnalyzeChangeInput = AnalyzeProjectInput & {
+    changes: readonly AnalysisFileChange[];
+    changeMap?: ArchitectureChangeMapContract;
+};
+type AnalysisResult = {
+    mode: 'lexical-compatibility';
+    completeness: ResolvedFactsCompleteness;
+    completenessReasons: ResolvedFactsReason[];
+    valid: boolean;
+    ir: AnalysisIr;
+};
+type AnalyzeResolvedProjectInput = {
+    contract: AnalysisContract;
+    facts: unknown;
+    /** Tooling FS evidence of arkgate pins. Omitted: version-floor warnings stay silent. */
+    arkgatePins?: readonly ArkgatePinEvidence[];
+    /** The running arkgate version, for the version-floor nextAction. */
+    runningArkgateVersion?: string;
+    /**
+     * D0 adopted or --require-gates / --strict-merge. When true, a missing
+     * domain-invariant tests path fails closed. Omitted stays silent.
+     */
+    adopted?: boolean;
+    /**
+     * Tooling FS check for the declared tests path. `false` means empty on disk.
+     * Omitted: a non-empty config declaration is enough.
+     */
+    invariantTestsPathPresent?: boolean;
+    /**
+     * Tooling FS check for declared `coverage.coverageRoots`. `false` means
+     * missing or empty on disk. Omitted: a non-empty config declaration is enough.
+     */
+    coverageRootsPresent?: boolean;
+    /**
+     * AR10 — Tooling-supplied contents for invariant coverage evidence.
+     * When omitted and the Effective Contract has invariants, coverage is partial
+     * (never false green covered).
+     */
+    coverageInputs?: {
+        fileContents: Readonly<Record<string, string>>;
+        testFiles?: readonly string[];
+        testGlobsMissing?: boolean;
+        coverageBudgetExhausted?: boolean;
+        /** Declared `coverage.coverageRoots`: where the project says its runner runs. */
+        coverageRoots?: readonly string[];
+        /** Counted scan facts: files loaded, tests retained, discards by reason. */
+        stats?: InvariantCoverageStats;
+    };
+    /**
+     * AR07 — Tooling-supplied orchestration/thin-adapter heuristics per file.
+     * Prefer deriveArkRuleFileHints / buildArkRuleFileHints (Domain pure).
+     * When omitted, orchestration-only, thin-adapter, and writes-via-aggregate
+     * sensors stay silent.
+     */
+    fileHints?: Readonly<Record<string, {
+        orchestrationHeavy?: boolean;
+        adapterThick?: boolean;
+        persistenceWrite?: boolean;
+    }>>;
+};
+/** Tooling-supplied analysis evidence for one side (base or candidate) of a preflight. */
+type ResolvedAnalysisSideInputs = Pick<AnalyzeResolvedProjectInput, 'adopted' | 'invariantTestsPathPresent' | 'coverageRootsPresent' | 'coverageInputs' | 'fileHints'>;
+type PreflightResolvedChangeInput = {
+    contract: AnalysisContract;
+    baseFacts: unknown;
+    candidateFacts: unknown;
+    changes: readonly AnalysisFileChange[];
+    changeMap?: ArchitectureChangeMapContract;
+    /**
+     * ArkRules evidence (coverage contents, structural hints) for the on-disk base and
+     * the in-memory candidate, so preflight runs the same engine inputs as ark-check.
+     */
+    baseAnalysisInputs?: ResolvedAnalysisSideInputs;
+    candidateAnalysisInputs?: ResolvedAnalysisSideInputs;
+};
+type ResolvedAnalysisFile = ResolvedFileFact & {
+    layer: string | null;
+};
+type ResolvedAnalysisIr = {
+    schemaVersion: '1.0';
+    policyHash: string;
+    compilerOptionsHash: string;
+    files: ResolvedAnalysisFile[];
+    layers: string[];
+    edges: ArchitectureEngineEdge[];
+    capabilityUses: ResolvedCapabilityFact[];
+    violations: ArchitectureEngineViolation[];
+    warnings: ArchitectureEngineViolation[];
+};
+type ResolvedSafetyReport = {
+    tsSuppressions: {
+        file: string;
+        line: number;
+    }[];
+    anyCasts: {
+        file: string;
+        line: number;
+    }[];
+    nonLiteralDynamicImports: {
+        file: string;
+        line: number;
+        kind: 'import' | 'require';
+    }[];
+    inMemoryProductionStores: {
+        file: string;
+        line: number;
+        store: string;
+    }[];
+    disabledPeerIsolationRules: {
+        from: string;
+        to: string;
+    }[];
+    thresholds: {
+        maxTsSuppressions: number;
+        maxAnyCasts: number;
+    };
+};
+type ResolvedAnalysisResult = {
+    mode: 'resolved-candidate-facts';
+    completeness: ResolvedFactsCompleteness;
+    completenessReasons: ResolvedFactsReason[];
+    valid: boolean;
+    strictValid: boolean;
+    policyHash: string;
+    factsHash: ResolvedCandidateFacts['factsHash'];
+    resolverIdentity: ResolvedCandidateFacts['resolverIdentity'];
+    candidateTreeHash: ResolvedCandidateFacts['candidateTreeHash'];
+    safety: ResolvedSafetyReport;
+    ir: ResolvedAnalysisIr;
+};
+type ResolvedChangePreflightResult = {
+    schemaVersion: '1.0';
+    mode: 'resolved-candidate-facts';
+    valid: boolean;
+    readOnly: true;
+    policyHash: string;
+    resolverIdentity: string;
+    compilerIdentity: string;
+    compilerOptionsHash: string;
+    tsconfigHash: string;
+    baseCompilerOptionsHash: string;
+    candidateCompilerOptionsHash: string;
+    baseTsconfigHash: string;
+    candidateTsconfigHash: string;
+    evidenceRequirementsHash: string;
+    baseFactsHash: string;
+    candidateFactsHash: string;
+    baseTreeHash: string;
+    candidateTreeHash: string;
+    baseCompleteness: ResolvedFactsCompleteness;
+    candidateCompleteness: ResolvedFactsCompleteness;
+    baseCompletenessReasons: ResolvedFactsReason[];
+    candidateCompletenessReasons: ResolvedFactsReason[];
+    changeMapHash?: string;
+    convergence?: ArchitectureConvergenceResult;
+    changes: PreparedChangeFile[];
+    violations: ArchitectureEngineViolation[];
+    warnings: ArchitectureEngineViolation[];
+};
+type AnalyzePolicyDeltaInput = {
+    baseConfig: unknown;
+    candidateConfig: unknown;
+    acknowledgement?: PolicyDeltaAcknowledgement;
+    baseSource?: string;
+    candidateSource?: string;
+    /** Optional pre-resolved Effective ArkRules for each side (ADR 0012 / AR02). */
+    baseArkRules?: EffectiveArkRules;
+    candidateArkRules?: EffectiveArkRules;
+    /**
+     * AR11 — optional coverage evidence for candidate invariants.
+     * When omitted, advisory→enforced promotion is judgment-required (refuse auto-allow).
+     */
+    candidateInvariantCoverage?: readonly InvariantCoverageEvidence[];
+};
+type PolicyDeltaAnalysis = {
+    schemaVersion: '1.0';
+    basePolicyHash: string;
+    candidatePolicyHash: string;
+    classification: PolicyDeltaClassification;
+    findings: PolicyDeltaFinding[];
+    blockingFindingIds: string[];
+    requiresAcknowledgement: boolean;
+    acknowledged: boolean;
+    valid: boolean;
+};
+type ArchitectureEngineViolation = {
+    ruleId: string;
+    message: string;
+    file?: string;
+    line?: number;
+    target?: string;
+    fromLayer?: string;
+    toLayer?: string;
+    nextAction?: string;
+    [key: string]: unknown;
+};
+type ArchitectureEngineEdge = {
+    from: string;
+    fromLayer: string | null;
+    to?: string;
+    toLayer?: string;
+    line: number;
+    kind: string;
+    typeOnly?: boolean;
+    targetTypeOnlyExports?: boolean;
+    sourcePureTypeModule?: boolean;
+    namedBindingsTypeOnly?: boolean;
+    portProofEligible?: boolean;
+};
+type EvaluateArchitectureGraphInput = {
+    config: ArkConfig;
+    rules: ArkConfig['rules'];
+    files: readonly string[];
+    contentViolations: readonly ArchitectureEngineViolation[];
+    edges: readonly ArchitectureEngineEdge[];
+    warnings?: readonly ArchitectureEngineViolation[];
+    safety?: unknown;
+};
+type ArchitectureEngineResult = {
+    violations: ArchitectureEngineViolation[];
+    warnings: ArchitectureEngineViolation[];
+    safety?: unknown;
+};
+type PreparedChangeFile = {
+    path: string;
+    operation: 'create' | 'update' | 'delete';
+    beforeContentHash?: string;
+    candidateContentHash?: string;
+};
+type ChangePreflightResult = {
+    schemaVersion: '1.0';
+    mode: 'lexical-compatibility';
+    valid: boolean;
+    readOnly: true;
+    policyHash: string;
+    compilerOptionsHash: string;
+    baseTreeHash: string;
+    candidateTreeHash: string;
+    baseCompleteness: ResolvedFactsCompleteness;
+    candidateCompleteness: ResolvedFactsCompleteness;
+    baseCompletenessReasons: ResolvedFactsReason[];
+    candidateCompletenessReasons: ResolvedFactsReason[];
+    changeMapHash?: string;
+    convergence?: ArchitectureConvergenceResult;
+    changes: PreparedChangeFile[];
+    violations: ArchitectureEngineViolation[];
+    warnings: ArchitectureEngineViolation[];
+};
+type CollectAnalysisConfigWarningsInput = {
+    config: ArkConfig;
+    rules: ArkConfig['rules'];
+    files: readonly string[];
+    /**
+     * Tooling FS evidence of arkgate pins in this repo (package.json, lockfile,
+     * installed copy, hook scripts, CI). Omitted: version-floor warnings stay silent.
+     */
+    arkgatePins?: readonly ArkgatePinEvidence[];
+    /** The running arkgate version. The version-floor nextAction targets it when newer. */
+    runningArkgateVersion?: string;
+    manifest?: {
+        architecture?: {
+            layers?: readonly {
+                name?: string;
+                prefixes?: readonly string[];
+            }[];
+        };
+    };
+};
+
 /**
- * Stable identity: contract edits and MCP restarts must not change which project
- * this is. Callers must pass canonical real paths and a SHA-256 hex function.
+ * Contract loading, project/change analysis, and policy-delta analysis
+ * (U02 pilot 2). Reached through the src/kernel/analysis.ts facade; consumer
+ * import paths never change.
  */
-declare function createProjectId(resolvedRoot: string, resolvedConfigPath: string, sha256Hex: (value: string) => string): string;
-declare function createProjectIdentity(input: Omit<ProjectIdentity, 'schemaVersion'>): ProjectIdentity;
+
+type LoadContractOptions = {
+    /** Pre-resolved Effective ArkRules (from resolveEffectiveContract). */
+    arkRules?: EffectiveArkRules;
+};
+declare function loadContract(input: unknown, source?: string, options?: LoadContractOptions): AnalysisContract;
+declare function analyzePolicyDelta(input: AnalyzePolicyDeltaInput): PolicyDeltaAnalysis;
+declare function analyzeProject(input: AnalyzeProjectInput): AnalysisResult;
+declare function analyzeChange(input: AnalyzeChangeInput): AnalysisResult;
+declare function explainViolation(violation: AnalysisViolation): string;
+
+declare function detectArchitectureCycles(graph: ReadonlyMap<string, ReadonlySet<string>>): ArchitectureEngineViolation[];
+/** Canonical graph and layer-policy evaluator shared by library, CLI, and MCP adapters. */
+declare function evaluateArchitectureGraph(input: EvaluateArchitectureGraphInput): ArchitectureEngineResult;
 
 /**
- * Canonical, pure contract for arkrules/<Layer>.json (ADR 0012).
+ * Pure evaluation of validated, resolver-supplied candidate facts (ADR 0011).
  *
- * Tooling adapters own filesystem I/O; this module owns JSON parsing, validation,
- * diagnostics, and the published JSON Schema. The standalone CLI artifact is generated
- * into bin/lib/arkrules-contract.mjs + schemas/ark.arkrules.schema.json.
+ * Filesystem discovery and TypeScript resolution remain Tooling concerns. This
+ * module only classifies canonical paths against the supplied contract and
+ * produces the one architecture verdict consumed by every resolved adapter.
  */
 
-declare const ARK_RULES_SCHEMA_VERSION: "1.0";
-/** Closed sensor vocabulary — keep in lockstep with arkRulesTypes.ARK_RULE_SENSOR_IDS. */
-declare const ARK_RULE_SENSORS: readonly ["aggregate-private-state", "always-valid-factory", "domain-event-on-mutation", "orchestration-only", "thin-adapter", "writes-via-aggregate", "no-anemic-model", "invariant-coverage"];
-declare const ARK_RULES_SCHEMA: {
-    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
-    readonly $id: "https://unpkg.com/arkgate/schemas/ark.arkrules.schema.json";
-    readonly title: "ArkGate ArkRules (intra-layer contract)";
-    readonly description: "Per-layer structure sensors and invariant catalog consumed by the ArkGate Effective Contract.";
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly required: readonly ["schemaVersion", "layer"];
-    readonly properties: {
-        readonly $schema: {
-            readonly type: "string";
-            readonly minLength: 1;
-            readonly default: "https://unpkg.com/arkgate/schemas/ark.arkrules.schema.json";
-        };
-        readonly schemaVersion: {
-            readonly type: "string";
-            readonly const: "1.0";
-            readonly default: "1.0";
-        };
-        readonly layer: {
-            readonly type: "string";
-            readonly minLength: 1;
-        };
-        readonly structure: {
-            readonly type: "array";
-            readonly default: readonly [];
-            readonly items: {
-                readonly $ref: "#/$defs/structureEntry";
-            };
-        };
-        readonly invariants: {
-            readonly type: "array";
-            readonly default: readonly [];
-            readonly items: {
-                readonly $ref: "#/$defs/invariantEntry";
-            };
-        };
-    };
-    readonly $defs: {
-        readonly structureEntry: {
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly required: readonly ["id", "sensor"];
-            readonly properties: {
-                readonly id: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-                readonly sensor: {
-                    readonly type: "string";
-                    readonly enum: readonly ["aggregate-private-state", "always-valid-factory", "domain-event-on-mutation", "orchestration-only", "thin-adapter", "writes-via-aggregate", "no-anemic-model", "invariant-coverage"];
-                };
-                readonly mode: {
-                    readonly type: "string";
-                    readonly enum: readonly ["advisory", "enforced"];
-                    readonly default: "advisory";
-                };
-                readonly appliesTo: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly uniqueItems: true;
-                };
-                readonly description: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-            };
-        };
-        readonly invariantEntry: {
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly required: readonly ["id", "description"];
-            readonly properties: {
-                readonly id: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-                readonly description: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-                readonly aggregate: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-                readonly coverage: {
-                    readonly type: "object";
-                    readonly additionalProperties: false;
-                    readonly properties: {
-                        readonly test: {
-                            readonly type: "boolean";
-                        };
-                        readonly symbol: {
-                            readonly type: "string";
-                            readonly minLength: 1;
-                        };
-                    };
-                };
-                readonly mode: {
-                    readonly type: "string";
-                    readonly enum: readonly ["advisory", "enforced"];
-                    readonly default: "advisory";
-                };
-                readonly appliesTo: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly uniqueItems: true;
-                };
-            };
-        };
-    };
-};
-declare function loadArkRulesContract(input: unknown, source?: string, expectedLayer?: string): {
-    config: ArkRulesFile;
-};
-declare function parseArkRulesJson(json: string, source?: string, expectedLayer?: string): {
-    config: ArkRulesFile;
-};
+/** Validate supplied facts and evaluate their graph without host effects. */
+declare function analyzeResolvedProject(input: AnalyzeResolvedProjectInput): ResolvedAnalysisResult;
+
 /**
- * Build the Effective Contract from already-validated ArkRules files.
- * Callers supply `{ layer → { sourceFile, file } }` after resolving references.
+ * Evaluate one create/update/delete set as a single in-memory candidate.
+ * The function never writes and returns hashes that bind a later host commit to
+ * the exact base, policy, compiler options, and candidate contents it checked.
  */
-declare function buildEffectiveArkRules(parts: ReadonlyArray<{
-    layer: string;
-    sourceFile: string;
-    file: ArkRulesFile;
-}>): EffectiveArkRules;
-/** Empty Effective Contract used when `arkRules` is absent (byte-for-byte verdict parity). */
-declare function emptyEffectiveArkRules(): EffectiveArkRules;
+declare function preflightChange(input: AnalyzeChangeInput): ChangePreflightResult;
+
+/** Atomic preflight over one validated base/candidate facts pair (ADR 0011). */
+
+/**
+ * Validate that the supplied candidate is exactly the declared in-memory
+ * overlay, then return its canonical resolved verdict. No project file is read
+ * or written here.
+ */
+declare function preflightResolvedChange(input: PreflightResolvedChangeInput): ResolvedChangePreflightResult;
+
+/** Canonical config diagnostics over repo-relative file paths. */
+declare function collectAnalysisConfigWarnings(input: CollectAnalysisConfigWarningsInput): ArchitectureEngineViolation[];
 
 /**
  * Pure Effective Contract composition (ADR 0012).
@@ -859,7 +3732,7 @@ declare function effectiveContractPolicyPayload(contract: EffectiveContract): un
  */
 
 /** Closed factory names from ADR 0022 `arkrun-missing-root`. */
-declare const ARKRUN_KERNEL_FACTORY_CALLEES: readonly ["createArkKernel", "createStrictArkKernel", "createArkKernelFromConfig", "createStrictArkKernelFromConfig"];
+declare const ARKRUN_KERNEL_FACTORY_CALLEES: readonly ["createArkKernel", "createStrictArkKernel", "createLenientArkKernel", "createArkKernelFromConfig", "createStrictArkKernelFromConfig", "createLenientArkKernelFromConfig"];
 /** Closed interaction callees from ADR 0022 undeclared-emit/handle/depend. */
 declare const ARKRUN_KERNEL_INTERACTION_CALLEES: readonly ["publisher", "publish", "raise", "raiseAsync", "send", "sendTo", "subscribe", "registerHandler", "resolve", "resolveSingleton"];
 declare function isArkRunKernelModuleSpecifier(specifier: string): boolean;
@@ -878,7 +3751,22 @@ declare function arkRunKernelCallKind(callee: string): ResolvedArkRunKernelCallK
 declare function extractArkRunValueImportDependenciesFromSource(file: string, content: string): ResolvedDependencyFact[];
 /** PascalCase named bindings from value import clauses (snippet admitted constructors). */
 declare function extractArkRunImportedConstructorNamesFromSource(content: string): string[];
-declare function extractArkRunKernelCallsFromSource(file: string, content: string): ResolvedArkRunKernelCallFact[];
+type ExtractArkRunKernelCallsOptions = {
+    /**
+     * Relative specifiers that resolve to a kernel/composition root module
+     * (see {@link createArkRunKernelRootSpecifierMatcher}); identifiers imported
+     * from them are traced as kernel receivers.
+     */
+    isKernelRootSpecifier?: (specifier: string) => boolean;
+    /**
+     * The project's effective intent prefixes (configured `layers[].intentPrefixes`
+     * plus the canonical defaults — {@link arkRunEffectiveIntentPrefixes}). An
+     * untraced receiver counts as a kernel call when its name literal carries one.
+     * Omitted: only the canonical prefixes count.
+     */
+    intentPrefixes?: readonly string[];
+};
+declare function extractArkRunKernelCallsFromSource(file: string, content: string, options?: ExtractArkRunKernelCallsOptions): ResolvedArkRunKernelCallFact[];
 declare function extractArkRunManagedNewsFromSource(file: string, content: string, admittedTypeNames: ReadonlySet<string>): ResolvedArkRunManagedNewFact[];
 /** File-scoped `uses` / `reactsTo` / `raises` / `sends` string-literal lists (ADR 0023). */
 declare function extractArkRunDeclarationsFromSource(file: string, content: string): ResolvedArkRunDeclarationFact[];
@@ -1023,6 +3911,11 @@ type ArkRunDoctorSection = {
     failMergeWhen: string;
     note: string;
     mergePlanes: MergePlanesHonesty;
+    /**
+     * Deny-rule layers a kernel built from this config cannot map an intent to
+     * (no `intentPrefixes`, not a canonical name). Empty when the extra is off.
+     */
+    layerFlowUnresolvable: string[];
 };
 type ArkRunStatusSlice = {
     notAScore: true;
@@ -1057,6 +3950,8 @@ declare function summarizeArkRunSection(input?: {
         covered?: number;
         uncovered?: number;
     } | null;
+    /** Config layers + rules, for the runtime layer-flow resolvability advisory. */
+    layerFlow?: LayerFlowConfigShape | null;
 }): ArkRunDoctorSection;
 /** Thin status slice — counts only; residual null means unknown, not green. */
 declare function projectStatusArkRun(input?: {
@@ -1172,6 +4067,8 @@ type EvaluateArkOrderSensorsInput = {
         line: number;
         keyCount: number;
     }[];
+    xiTtlKeys?: readonly ResolvedArkOrderXiTtlFact[];
+    budgetLeaks?: readonly ResolvedArkOrderBudgetLeakFact[];
     dependencies: readonly ResolvedDependencyFact[];
     layerForFile: (path: string) => string | null | undefined;
     classification?: ExtraMergeTeethClassification;
@@ -1234,7 +4131,19 @@ type BuildRulesInventoryInput = {
     layerContexts?: readonly RulesInventoryLayerContext[];
     /** Invariant / structure ids already under contract (to compute underContract count). */
     contractedRuleIds?: readonly string[];
-    /** Baseline keys currently frozen for arkrule residual. */
+    /**
+     * Declared structure rules as (layer, sensor). A structure suggestion is under
+     * contract when its layer declares a rule on the same sensor, whatever the
+     * author called the rule id.
+     */
+    contractedStructure?: readonly {
+        layer: string;
+        sensor: string;
+    }[];
+    /**
+     * Raw baseline keys (`ruleId|file|…`). Only ArkRules-plane keys (ruleId
+     * `ARKRULE_*` / `INVARIANT_*`) count as frozen residual; others are ignored.
+     */
     frozenKeys?: readonly string[];
 };
 declare function buildRulesInventory(input: BuildRulesInventoryInput): RulesInventoryResult;
@@ -1252,6 +4161,179 @@ declare function inventoryToExtractionCard(candidate: RulesInventoryCandidate):
     next: string;
 };
 
+/** Public, evidence-backed enforcement state shared by doctor adapters. */
+declare const ARK_ENFORCEMENT_STATE_SCHEMA_VERSION: "1.1";
+type EnforcementVerification = boolean | 'unverified';
+type EnforcementEvidenceField = 'configured' | 'installed' | 'active' | 'runtimeObserved' | 'operationCoverage' | 'bypassable' | 'required' | 'hard';
+type EnforcementEvidence = {
+    field: 'configured' | 'installed' | 'runtimeObserved' | 'hard';
+    source: string;
+    value: boolean;
+} | {
+    field: 'active' | 'operationCoverage' | 'bypassable' | 'required';
+    source: string;
+    value: EnforcementVerification;
+};
+/**
+ * State for one enforcement boundary.
+ *
+ * `configured` records valid wiring, while `installed` requires the referenced
+ * package or executable to resolve. Runtime/provider facts remain
+ * `unverified` until observed; local files never prove `required: true`.
+ */
+type EnforcementBoundaryState = {
+    supported: boolean;
+    analyzed: boolean;
+    configured: boolean;
+    installed: boolean;
+    active: EnforcementVerification;
+    runtimeObserved: boolean;
+    operation: string | null;
+    operationCoverage: EnforcementVerification;
+    bypassable: EnforcementVerification;
+    required: EnforcementVerification;
+    hard: boolean;
+    evidence: readonly EnforcementEvidence[];
+};
+type ArkEnforcementHost = 'claude' | 'grok' | 'cursor' | 'codex' | 'unknown';
+type ArkEnforcementState = {
+    schemaVersion: typeof ARK_ENFORCEMENT_STATE_SCHEMA_VERSION;
+    activeHost: ArkEnforcementHost;
+    localWrite: EnforcementBoundaryState;
+    advisoryMcp: EnforcementBoundaryState;
+    ciMerge: EnforcementBoundaryState;
+};
+
+/** Public neutral contract for the opt-in new-code design-fitness ratchet. */
+declare const ARK_DESIGN_DELTA_SCHEMA_VERSION: "1.0";
+type DesignSmellId = 'io-under-application' | 'handler-in-persistence' | 'god-module' | 'domain-logic-in-ui' | 'facade-sql-in-routes' | 'mixed-pattern-cluster' | 'soft-contract';
+type DesignDeltaIdentity = {
+    kind: 'git-tree' | 'candidate-tree';
+    value: string;
+    commit?: string;
+};
+type DesignSmellEvidence = {
+    kind: string;
+    path: string;
+    line?: number;
+    symbol?: string;
+    detail?: string;
+    magnitude: number;
+};
+type DesignSmellFinding = {
+    smellId: DesignSmellId;
+    fingerprint: string;
+    identity: string;
+    evidence: DesignSmellEvidence;
+    repairHint: string;
+};
+type DesignDeltaChange = DesignSmellFinding & {
+    classification: 'new' | 'worsened';
+    baseMagnitude: number;
+    candidateMagnitude: number;
+};
+/** Created-path merge vs full new+worsened ratchet (Z10). Omitted on older producers. */
+type DesignDeltaEnforcementScope = 'created-paths' | 'touched-new-or-worsened';
+type ArkDesignDeltaResult = {
+    schemaVersion: typeof ARK_DESIGN_DELTA_SCHEMA_VERSION;
+    mode: 'git-base' | 'write-candidate';
+    complete: boolean;
+    valid: boolean;
+    base: DesignDeltaIdentity;
+    candidate: DesignDeltaIdentity;
+    supportedSmellIds: readonly DesignSmellId[];
+    touchedPaths: readonly string[];
+    changes: readonly DesignDeltaChange[];
+    baseFindingCount: number;
+    candidateFindingCount: number;
+    historicalResidualCount: number;
+    enforcementScope?: DesignDeltaEnforcementScope;
+    error?: string;
+};
+
+/**
+ * Public diagnostic code catalog (ACS02).
+ *
+ * Closed vocabulary of stable `ruleId` values emitted by ArkGate adapters with
+ * human/agent `why` / `fix` anchors and docs fragment ids. Cataloguing only —
+ * no new rule semantics, no LLM verdict, no enforcement from prose.
+ *
+ * **Canonical** for docs, agent projection (ACS04), and finding refs (ACS06).
+ * Runtime remediation remains in `remediation.ts`; parity tests bind the two.
+ *
+ * Zero Node I/O. Optional CLI surface: generated `bin/lib/diagnostic-catalog.mjs`.
+ *
+ * @see docs/diagnostics.md
+ * @see docs/plans/agent-contract-surface-4.3/README.md
+ */
+/** Product-relative docs path (shipped in the npm tarball when listed in package files). */
+declare const DIAGNOSTIC_DOCS_RELATIVE_PATH: "docs/diagnostics.md";
+/** Schema id for serializing the catalog snapshot (agents / install projection). */
+declare const DIAGNOSTIC_CATALOG_SCHEMA_VERSION: "1.0";
+type DiagnosticCategory = 'layer' | 'capability' | 'publish' | 'safety' | 'arkrules' | 'arkrun' | 'arkorder' | 'preflight' | 'analysis' | 'drift' | 'snippet-policy' | 'config' | 'adapter' | 'meta';
+type DiagnosticCatalogEntry = {
+    /** Stable public violation / diagnostic id. */
+    ruleId: string;
+    /** Short title for indexes and agent projection. */
+    title: string;
+    /** Why this finding exists (contract intent). */
+    why: string;
+    /**
+     * Canonical fix guidance (agent + human). Contextual nextAction on live
+     * findings may specialize this (e.g. type-only vs value layer import).
+     */
+    fix: string;
+    /** Markdown fragment id for docs/diagnostics.md (without leading #). */
+    docsAnchor: string;
+    category: DiagnosticCategory;
+    /**
+     * When true, finding is commonly advisory / non-blocking in default profiles
+     * (doctor/config warnings, type-only placement debt, empty ArkRule scope).
+     * Not a severity bit for the engine — documentation only.
+     */
+    oftenAdvisory?: boolean;
+};
+/**
+ * Closed public catalog. Order is stable (category groups, then ruleId) for
+ * deterministic serialization and docs generation.
+ *
+ * Every production-emitted `ruleId` must appear here. Remediation switch cases
+ * and adapter nextAction branches are parity-tested against this list.
+ */
+declare const DIAGNOSTIC_CATALOG: readonly DiagnosticCatalogEntry[];
+/** All public ruleIds in catalog order. */
+declare const DIAGNOSTIC_RULE_IDS: readonly string[];
+declare function isKnownDiagnosticCode(ruleId: string | null | undefined): boolean;
+/**
+ * True when the code is catalogued or is an ArkRule-family id handled by the
+ * ARKRULE_* prefix fallback in remediation (structure sensors may add members later
+ * only via catalog + ROADMAP — prefix alone is not a license for free-form ids).
+ */
+declare function isCataloguedOrArkRuleFamily(ruleId: string | null | undefined): boolean;
+declare function getDiagnosticCatalogEntry(ruleId: string | null | undefined): DiagnosticCatalogEntry | undefined;
+/** Fragment for docs links, e.g. `#LAYER_IMPORT_VIOLATION`. */
+declare function diagnosticDocsFragment(ruleId: string): string;
+/**
+ * Repo-relative docs path with fragment (for agents and JSON).
+ * Package consumers resolve against the installed package root or GitHub tree.
+ */
+declare function diagnosticDocsPath(ruleId: string): string;
+/** Catalog snapshot for JSON export / agent projection (stable field order). */
+declare function serializeDiagnosticCatalog(): {
+    schemaVersion: typeof DIAGNOSTIC_CATALOG_SCHEMA_VERSION;
+    docsPath: typeof DIAGNOSTIC_DOCS_RELATIVE_PATH;
+    codes: readonly DiagnosticCatalogEntry[];
+};
+/**
+ * Static catalog fix for a ruleId when no live violation context is available.
+ * Live adapters should still use deterministicNextAction for specialized edges.
+ */
+declare function catalogFixForRuleId(ruleId: string | null | undefined): string | undefined;
+/**
+ * Static catalog why for a ruleId (agent “why” surface).
+ */
+declare function catalogWhyForRuleId(ruleId: string | null | undefined): string | undefined;
+
 /**
  * Doctor / status / report ArkOrder section. Always notAScore.
  * Residual is a unique ARKORDER finding-id count — never a score or LLM verdict.
@@ -1368,6 +4450,11 @@ type StatusManifest = {
     lastCheck: StatusLastCheckSlice;
     rules: StatusRulesSlice;
     nextAction: StatusNextAction;
+    /**
+     * Contract validity for the resolved config. Present only when a config file exists and
+     * failed the shared contract validator (same fail-closed rules as ark-check / MCP / ESLint).
+     */
+    contract?: StatusContractSlice;
     /**
      * Improvement compass residual map with honesty mode (DF02).
      * Tooling should always supply a projection (including mode=unavailable).
@@ -1386,6 +4473,11 @@ type StatusManifest = {
      */
     arkOrder?: ArkOrderStatusSlice;
 };
+type StatusContractSlice = {
+    valid: false;
+    /** Validator messages (`<json path>: <message>`), in validator order. */
+    errors: string[];
+};
 type StatusVsBaseSlice = {
     baseRef: string;
     line: string;
@@ -1402,6 +4494,11 @@ type StatusManifestFacts = {
     arkgateVersion: string;
     resolvedRoot: string;
     resolvedConfigPath?: string | null;
+    /**
+     * Contract validator messages for the resolved config. Non-empty → the config is invalid
+     * (every enforcing surface refuses it). Empty/omitted → valid or not evaluated.
+     */
+    configErrors?: string[] | null;
     projectId?: string | null;
     /**
      * Optional agent expectation (same shape as MCP `project`).
@@ -1478,10 +4575,6 @@ declare function classifyStatusWritePath(input: {
     activeHost?: string | null;
 }): StatusWritePathClass;
 declare function defaultHonestLabel(writePath: StatusWritePathClass, host: string | null): string;
-/**
- * Deterministic next action from residual facts (no LLM).
- * Prefer explicit override from productHonesty when provided.
- */
 declare function resolveStatusNextAction(facts: StatusManifestFacts, binding: ProjectBinding, activation: StatusActivationSlice, lastCheck: StatusLastCheckSlice, rules: StatusRulesSlice): StatusNextAction;
 declare function buildStatusManifest(facts: StatusManifestFacts): StatusManifest;
 /**
@@ -1688,6 +4781,25 @@ declare const ARK_STATUS_MANIFEST_SCHEMA: {
                 };
             };
         };
+        readonly contract: {
+            readonly type: "object";
+            readonly description: "Present only when the resolved config fails the shared contract validator (the same fail-closed rules ark-check, MCP and ESLint apply).";
+            readonly additionalProperties: false;
+            readonly required: readonly ["valid", "errors"];
+            readonly properties: {
+                readonly valid: {
+                    readonly const: false;
+                };
+                readonly errors: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
         readonly improvementCompass: {
             readonly type: "object";
             readonly description: "Thin improvement-compass residual ids with honesty mode (notAScore). full | subset | unavailable. Never a gate input; full lenses on doctor JSON. When full, residual ids ⊆ doctor residual for the same facts. unavailable never invents green residual.";
@@ -2360,4 +5472,4 @@ declare function agentSkillPackageFileRelativePath(skillName: string): string;
  */
 declare function flatSkillTemplateFileRelativePath(skillName: string): string;
 
-export { AGENT_PROJECTION_BEGIN_MARKER, AGENT_PROJECTION_END_MARKER, AGENT_PROJECTION_ENFORCEMENT_SURFACES, AGENT_PROJECTION_NON_ENFORCEMENT_LABEL, AGENT_SKILLS_PACKAGE_RELATIVE_ROOT, AGENT_SKILL_ENTRY_FILENAME, ARKORDER_RULE_IDS, ARKORDER_TIER1_SENSOR_IDS, ARKRUN_INTERACTION_NAME_INCOMPLETE, ARKRUN_KERNEL_FACTORY_CALLEES, ARKRUN_KERNEL_INTERACTION_CALLEES, ARKRUN_RULE_IDS, ARKRUN_TIER1_SENSOR_IDS, ARKRUN_TRANSPORT_BYPASS_SPECIFIERS, ARK_AGENT_PROJECTION_SCHEMA_VERSION, ARK_AGENT_SKILLS_PACKAGE_SCHEMA_VERSION, ARK_CONFIG_SCHEMA, ARK_CONFIG_SCHEMA_VERSION, ARK_FIRST_CLASS_SKILL_NAMES, ARK_IMPROVEMENT_COMPASS_SCHEMA_VERSION, ARK_PROJECT_IDENTITY_SCHEMA, ARK_PROJECT_IDENTITY_SCHEMA_URL, ARK_PROJECT_IDENTITY_SCHEMA_VERSION, ARK_RULES_SCHEMA, ARK_RULES_SCHEMA_VERSION, ARK_RULE_SENSORS, ARK_RUN_DOCTOR_SCHEMA_VERSION, ARK_SKILL_CAPACITY, ARK_SKILL_CAPACITY_DEDICATED_DOORS, ARK_SKILL_DESCRIPTION_VERSION_PATTERN, ARK_SKILL_NAMES, ARK_SKILL_NAME_COUNT, ARK_SKILL_NORTH_STAR, ARK_SKILL_REQUIRED_SURFACES, ARK_SKILL_STUB_REDIRECTS, ARK_STATUS_MANIFEST_SCHEMA, ARK_STATUS_MANIFEST_SCHEMA_URL, ARK_STATUS_MANIFEST_SCHEMA_VERSION, AdapterViolationInput, type AgentProjectionCatalogEntry, type AgentProjectionFacts, type AgentProjectionLayerSummary, type AgentProjectionMergeAction, type AgentProjectionMergeResult, type AgentProjectionMeta, type AgentProjectionProfile, type AgentSkillPackageEntry, type AgentSkillValidationIssue, ArkConfig, ArkConfigLoadResult, type ArkFirstClassSkillName, type ArkOrderRuleId, type ArkOrderSensorFinding, ArkRulesFile, type ArkRunDoctorSection, type ArkRunRuleId, type ArkRunSensorFinding, type ArkRunStatusSlice, type ArkRunTier1SensorId, type ArkSkillCapacityDedicatedSurface, type ArkSkillCapacitySurface, type ArkSkillName, type ArkSkillNorthStar, type ArkSkillRequiredSurface, type ArkSkillStubName, DEFAULT_AGENT_PROJECTION_RULE_IDS, EXTRA_MERGE_TEETH_GOVERNED_FLOOR, EffectiveArkRules, type EffectiveContract, EffectiveContractError, type EffectiveContractWarning, type EvaluateArkRunSensorsInput, type EvaluateArkRunSensorsResult, type ExtraMergeTeethClassification, FLAT_SKILL_TEMPLATES_RELATIVE_ROOT, IMPROVEMENT_COMPASS_OUT_OF_SCOPE_LENSES, IMPROVEMENT_COMPASS_TOP_RESIDUAL_CAP, IMPROVEMENT_LENS_IDS, type ImprovementCompass, type ImprovementCompassEvidence, type ImprovementCompassFacts, type ImprovementCompassNextAction, type ImprovementCompassSmellFact, type ImprovementCompassViolationFact, type ImprovementLens, type ImprovementLensId, type ImprovementLensStatus, MERGE_PLANES_DUAL_STAMP, type MergePlanesHonesty, PROJECT_BINDING_SCHEMA, PROJECT_EXPECTATION_SCHEMA, type ParseSkillDocumentResult, type ParsedSkillFrontmatter, type ProjectBinding, type ProjectExpectation, type ProjectIdentity, ResolvedArkRunCompositionRootHitFact, ResolvedArkRunDeclarationFact, ResolvedArkRunKernelCallFact, ResolvedArkRunKernelCallKind, ResolvedArkRunManagedNewFact, ResolvedDependencyFact, ResolvedFactsReason, type RulesInventoryCandidate, type RulesInventoryResult, STATUS_COMPASS_FACTS_SOURCES, STATUS_COMPASS_MODES, STATUS_COMPASS_REASON_CODES, type SkillProductCapacityIssue, type SkillProductCapacityIssueCode, type StatusActivationSlice, type StatusCheckVerdict, type StatusCompassFactsSource, type StatusCompassMode, type StatusCompassReasonCode, type StatusImprovementCompassSlice, type StatusLastCheckSlice, type StatusManifest, type StatusManifestFacts, type StatusNextAction, type StatusProjectIdentitySlice, type StatusRulesSlice, type StatusWritePathClass, type ValidateAgentSkillDocumentInput, type ValidateAgentSkillsPackageResult, type ValidateSkillProductCapacityInput, type ValidateSkillProductCapacityResult, adapterDocsCodePath, adapterFindingOccurrenceTargetKeys, adapterFindingRefFromTargetKey, adapterFindingTargetKey, agentProjectionContentIdentity, agentSkillEntryRelativePath, agentSkillPackageFileRelativePath, arkRunKernelCallKind, arkSkillStubRedirect, buildAgentProjectionBeginMarker, buildAgentProjectionBlock, buildAgentProjectionBody, buildAgentProjectionMeta, buildEffectiveArkRules, buildImprovementCompass, buildRulesInventory, buildStatusManifest, classifyResolvedLayerCoverage, classifyStatusWritePath, composeMergePlanesHonesty, createProjectId, createProjectIdentity, defaultHonestLabel, demoteExtraPlaneTeethUnderClassificationFloor, effectiveContractPolicyPayload, emptyEffectiveArkRules, evaluateArkOrderSensors, evaluateArkRunEditorSensors, evaluateArkRunEditorSensorsFromSource, evaluateArkRunSensors, evaluateStatusBinding, extraMergeTeethAllowed, extractAgentProjectionBlock, extractArkRunDeclarationsFromSource, extractArkRunImportedConstructorNamesFromSource, extractArkRunKernelCallsFromSource, extractArkRunManagedNewsFromSource, extractArkRunValueImportDependenciesFromSource, flatSkillTemplateFileRelativePath, formatAgentProjectionCatalogShortList, formatAgentProjectionLayers, formatArkRunDoctorLines, formatImprovementCompassDoctorLines, formatImprovementCompassResidualLabels, inventoryToExtractionCard, isArkOrderRuleId, isArkRunKernelModuleSpecifier, isArkRunRuleId, isArkRunTransportBypassSpecifier, isArkSkillName, isExtraPlaneFinding, isFirstClassArkSkillName, isValidAgentSkillName, loadArkConfigContract, loadArkRulesContract, mergeAgentProjectionDocument, normalizeExtraMergeTeethClassification, normalizeSkillContent, normalizeStatusImprovementCompass, parseAgentProjectionStamp, parseArkConfigJson, parseArkRulesJson, parseSkillDescriptionVersion, parseSkillDocument, primaryImprovementCompassNextAction, projectStatusArkRun, projectStatusImprovementCompass, projectionHasNonEnforcementLabel, projectionMatchesPackageVersion, resolveEffectiveContract, resolveStatusNextAction, skillDescriptionVersionPrefix, stampSkillDescription, statusCompassResidualIsSubsetOfDoctor, stripSkillDescriptionVersion, summarizeArkRunSection, unavailableStatusImprovementCompass, validateAgentSkillDocument, validateAgentSkillsPackage, validateSkillProductCapacity };
+export { ADAPTER_DIAGNOSTIC_DOCS_RELATIVE_PATH, AGENT_PROJECTION_BEGIN_MARKER, AGENT_PROJECTION_END_MARKER, AGENT_PROJECTION_ENFORCEMENT_SURFACES, AGENT_PROJECTION_NON_ENFORCEMENT_LABEL, AGENT_SKILLS_PACKAGE_RELATIVE_ROOT, AGENT_SKILL_ENTRY_FILENAME, type AICodeGate, type AICodeGateContext, type AICodeGateOptions, type AICodeGateResult, type AICodeGateViolation, type AIGateExtension, ANALYSIS_IR_SCHEMA_VERSION, ARKORDER_RULE_IDS, ARKORDER_TIER1_SENSOR_IDS, ARKRUN_INTERACTION_NAME_INCOMPLETE, ARKRUN_KERNEL_FACTORY_CALLEES, ARKRUN_KERNEL_INTERACTION_CALLEES, ARKRUN_RULE_IDS, ARKRUN_TIER1_SENSOR_IDS, ARKRUN_TRANSPORT_BYPASS_SPECIFIERS, ARK_AGENT_PROJECTION_SCHEMA_VERSION, ARK_AGENT_SKILLS_PACKAGE_SCHEMA_VERSION, ARK_ANALYSIS_RESULT_SCHEMA, ARK_ANALYSIS_RESULT_SCHEMA_VERSION, ARK_CONFIG_SCHEMA, ARK_CONFIG_SCHEMA_VERSION, ARK_DESIGN_DELTA_SCHEMA_VERSION, ARK_ENFORCEMENT_STATE_SCHEMA_VERSION, ARK_FIRST_CLASS_SKILL_NAMES, ARK_IMPROVEMENT_COMPASS_SCHEMA_VERSION, ARK_PROJECT_IDENTITY_SCHEMA, ARK_PROJECT_IDENTITY_SCHEMA_URL, ARK_PROJECT_IDENTITY_SCHEMA_VERSION, ARK_RULES_SCHEMA, ARK_RULES_SCHEMA_VERSION, ARK_RULE_SENSORS, ARK_RUN_DOCTOR_SCHEMA_VERSION, ARK_SKILL_CAPACITY, ARK_SKILL_CAPACITY_DEDICATED_DOORS, ARK_SKILL_DESCRIPTION_VERSION_PATTERN, ARK_SKILL_NAMES, ARK_SKILL_NAME_COUNT, ARK_SKILL_NORTH_STAR, ARK_SKILL_REQUIRED_SURFACES, ARK_SKILL_STUB_REDIRECTS, ARK_STATUS_MANIFEST_SCHEMA, ARK_STATUS_MANIFEST_SCHEMA_URL, ARK_STATUS_MANIFEST_SCHEMA_VERSION, type AdapterCompletenessReason, type AdapterDiagnostic, type AdapterResult, type AdapterSeverity, type AdapterViolationInput, type AgentProjectionCatalogEntry, type AgentProjectionFacts, type AgentProjectionLayerSummary, type AgentProjectionMergeAction, type AgentProjectionMergeResult, type AgentProjectionMeta, type AgentProjectionProfile, type AgentSkillPackageEntry, type AgentSkillValidationIssue, type AnalysisCapabilityUse, type AnalysisCompilerOptions, type AnalysisCompleteness, type AnalysisContract, type AnalysisEvidence, type AnalysisFile, type AnalysisFileChange, type AnalysisFileInput, type AnalysisImportEdge, type AnalysisIr, type AnalysisMode, type AnalysisResult, type AnalysisViolation, type AnalyzeArchitectureConvergenceInput, type AnalyzeChangeInput, type AnalyzePolicyDeltaInput, type AnalyzeProjectInput, type AnalyzeResolvedProjectInput, type ArchitectureActualChange, type ArchitectureChangeMap, type ArchitectureChangeMapContract, type ArchitectureChangeMapDependency, type ArchitectureChangeMapFile, type ArchitectureChangeOperation, type ArchitectureConvergenceClassification, type ArchitectureConvergenceFinding, type ArchitectureConvergenceResult, type ArchitectureDependency, type ArchitectureEngineEdge, type ArchitectureEngineResult, type ArchitectureEngineViolation, type ArchitectureLayer, type ArchitectureLayerConfig, type ArchitectureProfile, type ArchitectureRule, type ArkCheckConfig, ArkConfig, ArkConfigLoadResult, type ArkDesignDeltaResult, type ArkEnforcementHost, type ArkEnforcementState, type ArkFirstClassSkillName, type ArkOrderRuleId, type ArkOrderSensorFinding, type ArkRuleSensorViolation, type ArkRulesFile, type ArkRulesIssue, ArkRulesValidationError, type ArkRunDoctorSection, type ArkRunRuleId, type ArkRunSensorFinding, type ArkRunStatusSlice, type ArkRunTier1SensorId, type ArkSkillCapacityDedicatedSurface, type ArkSkillCapacitySurface, type ArkSkillName, type ArkSkillNorthStar, type ArkSkillRequiredSurface, type ArkSkillStubName, type ChangePreflightResult, type ClassShapeFact, type CollectAnalysisConfigWarningsInput, type CoverageEvidence, type CoverageFiles, type CoverageInvariant, type CreateArchitectureProfileFromArkConfigOptions, type CreateArchitectureProfileOptions, type CreateElevenLayerArkConfigOptions, DEFAULT_AGENT_PROJECTION_RULE_IDS, DIAGNOSTIC_CATALOG, DIAGNOSTIC_CATALOG_SCHEMA_VERSION, DIAGNOSTIC_DOCS_RELATIVE_PATH, DIAGNOSTIC_RULE_IDS, type DeclarationShape, type DesignDeltaChange, type DesignDeltaEnforcementScope, type DesignDeltaIdentity, type DesignSmellEvidence, type DesignSmellFinding, type DesignSmellId, type DiagnosticCatalogEntry, type DiagnosticCategory, EXTRA_MERGE_TEETH_GOVERNED_FLOOR, type EffectiveArkRules, type EffectiveContract, EffectiveContractError, type EffectiveContractWarning, type EnforcementBoundaryState, type EnforcementEvidence, type EnforcementEvidenceField, type EnforcementVerification, type EvaluateArchitectureGraphInput, type EvaluateArkRunSensorsInput, type EvaluateArkRunSensorsResult, type ExtraMergeTeethClassification, FLAT_SKILL_TEMPLATES_RELATIVE_ROOT, type ForbiddenCapabilityUse, IMPROVEMENT_COMPASS_OUT_OF_SCOPE_LENSES, IMPROVEMENT_COMPASS_TOP_RESIDUAL_CAP, IMPROVEMENT_LENS_IDS, type ImprovementCompass, type ImprovementCompassEvidence, type ImprovementCompassFacts, type ImprovementCompassNextAction, type ImprovementCompassSmellFact, type ImprovementCompassViolationFact, type ImprovementLens, type ImprovementLensId, type ImprovementLensStatus, type InvariantCoverageEvidence, MERGE_PLANES_DUAL_STAMP, type MentionContext, type MergePlanesHonesty, POLICY_DELTA_SCHEMA_VERSION, PROJECT_BINDING_SCHEMA, PROJECT_EXPECTATION_SCHEMA, type ParseSkillDocumentResult, type ParsedSkillFrontmatter, type PolicyDelta, type PolicyDeltaAcknowledgement, type PolicyDeltaAnalysis, type PolicyDeltaClassification, type PolicyDeltaFinding, type PreflightResolvedChangeInput, type PreparedChangeFile, type ProjectBinding, type ProjectExpectation, type ProjectIdentity, RESOLVED_CANDIDATE_FACTS_SCHEMA, RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION, type ResolvedAmbientFact, type ResolvedAnalysisFile, type ResolvedAnalysisIr, type ResolvedAnalysisResult, type ResolvedArkRunCompositionRootHitFact, type ResolvedArkRunDeclarationFact, type ResolvedArkRunKernelCallFact, type ResolvedArkRunKernelCallKind, type ResolvedArkRunManagedNewFact, type ResolvedCandidateFacts, type ResolvedCandidateFactsInput, type ResolvedCapability, type ResolvedCapabilityFact, type ResolvedChangePreflightResult, type ResolvedDependencyFact, type ResolvedDependencyKind, type ResolvedDependencyState, type ResolvedFactsCompleteness, type ResolvedFactsReason, type ResolvedFileFact, type ResolvedIntentReferenceFact, type ResolvedPublishFact, type ResolvedSafetyFact, type ResolvedSafetyKind, type ResolvedSafetyReport, type RulesInventoryCandidate, type RulesInventoryResult, STATUS_COMPASS_FACTS_SOURCES, STATUS_COMPASS_MODES, STATUS_COMPASS_REASON_CODES, type SemanticDependency, type SemanticDependencyKind, type SkillProductCapacityIssue, type SkillProductCapacityIssueCode, type StatusActivationSlice, type StatusCheckVerdict, type StatusCompassFactsSource, type StatusCompassMode, type StatusCompassReasonCode, type StatusImprovementCompassSlice, type StatusLastCheckSlice, type StatusManifest, type StatusManifestFacts, type StatusNextAction, type StatusProjectIdentitySlice, type StatusRulesSlice, type StatusWritePathClass, type ValidateAgentSkillDocumentInput, type ValidateAgentSkillsPackageResult, type ValidateSkillProductCapacityInput, type ValidateSkillProductCapacityResult, adapterDocsCodePath, adapterFindingOccurrenceTargetKeys, adapterFindingRefFromTargetKey, adapterFindingTargetKey, agentProjectionContentIdentity, agentSkillEntryRelativePath, agentSkillPackageFileRelativePath, analyzeArchitectureConvergence, analyzeChange, analyzePolicyDelta, analyzeProject, analyzeResolvedProject, arkRunKernelCallKind, arkSkillStubRedirect, buildAgentProjectionBeginMarker, buildAgentProjectionBlock, buildAgentProjectionBody, buildAgentProjectionMeta, buildArkRuleFileHints, buildEffectiveArkRules, buildImprovementCompass, buildRulesInventory, buildStatusManifest, canPromoteInvariant, catalogFixForRuleId, catalogWhyForRuleId, classifyArkPolicyDelta, classifyCoverage, classifyResolvedLayerCoverage, classifyStatusWritePath, collectAnalysisConfigWarnings, collectEmptyAppliesToFindings, collectForbiddenCapabilityUses, composeMergePlanesHonesty, countsAsCoverage, createAICodeGate, createAdapterResult, createArchitectureProfile, createArchitectureProfileFromArkConfig, createElevenLayerArkConfig, createProjectId, createProjectIdentity, createResolvedCandidateFacts, defaultHonestLabel, demoteExtraPlaneTeethUnderClassificationFloor, deriveArkRuleFileHints, describeCoverage, detectArchitectureCycles, deterministicHash, diagnosticDocsFragment, diagnosticDocsPath, effectiveContractPolicyPayload, elevenLayerProfile, emptyEffectiveArkRules, evaluateArchitectureGraph, evaluateArkOrderSensors, evaluateArkRuleSensors, evaluateArkRunEditorSensors, evaluateArkRunEditorSensorsFromSource, evaluateArkRunSensors, evaluateInvariantCoverage, evaluateStatusBinding, explainViolation, extraMergeTeethAllowed, extractAgentProjectionBlock, extractArkRunDeclarationsFromSource, extractArkRunImportedConstructorNamesFromSource, extractArkRunKernelCallsFromSource, extractArkRunManagedNewsFromSource, extractArkRunValueImportDependenciesFromSource, extractClassShapesFromSource, extractSemanticDependencies, flatSkillTemplateFileRelativePath, formatAgentProjectionCatalogShortList, formatAgentProjectionLayers, formatArkRunDoctorLines, formatImprovementCompassDoctorLines, formatImprovementCompassResidualLabels, getDiagnosticCatalogEntry, inventoryToExtractionCard, isArkOrderRuleId, isArkRunKernelModuleSpecifier, isArkRunRuleId, isArkRunTransportBypassSpecifier, isArkSkillName, isCataloguedOrArkRuleFamily, isExtraPlaneFinding, isFirstClassArkSkillName, isKnownDiagnosticCode, isValidAgentSkillName, loadArkConfigContract, loadArkRulesContract, loadContract, loadResolvedCandidateFacts, mergeAgentProjectionDocument, normalizeExtraMergeTeethClassification, normalizeSkillContent, normalizeStatusImprovementCompass, parseAgentProjectionStamp, parseArkConfigJson, parseArkRulesJson, parseSkillDescriptionVersion, parseSkillDocument, policyDeltaAcknowledgementMatches, preflightChange, preflightResolvedChange, primaryImprovementCompassNextAction, projectStatusArkRun, projectStatusImprovementCompass, projectionHasNonEnforcementLabel, projectionMatchesPackageVersion, resolveEffectiveContract, resolveStatusNextAction, resolvedFactsEvidenceRequirementsHash, serializeDiagnosticCatalog, skillDescriptionVersionPrefix, stableSerialize, stampSkillDescription, statusCompassResidualIsSubsetOfDoctor, stripSkillDescriptionVersion, summarizeArkRunSection, toAdapterDiagnostic, unavailableStatusImprovementCompass, validateAgentSkillDocument, validateAgentSkillsPackage, validateSkillProductCapacity, version };