arkgate 3.7.0 → 3.8.0

package/dist/index.d.ts

@@ -234,11 +234,18 @@ declare function loadArkConfigContract(input: unknown, source?: string): ArkConf
 declare function parseArkConfigJson(json: string, source?: string): ArkConfigLoadResult;
 
 /** ArkGate library version — single source of truth. */
-declare const version = "3.7.0";
+declare const version = "3.8.0";
 
 /** Versioned public result contract shared by every ArkGate enforcement adapter. */
-declare const ARK_ANALYSIS_RESULT_SCHEMA_VERSION: "1.1";
+declare const ARK_ANALYSIS_RESULT_SCHEMA_VERSION: "1.3";
 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;
@@ -251,8 +258,11 @@ type AdapterViolationInput = {
     toLayer?: unknown;
     typeOnly?: unknown;
     targetTypeOnlyExports?: unknown;
+    sourcePureTypeModule?: unknown;
     namedBindingsTypeOnly?: unknown;
+    portProofEligible?: unknown;
     peerIsolation?: unknown;
+    edgeKind?: unknown;
     severity?: unknown;
     nextAction?: unknown;
     /** U04: the denied capability id on CAPABILITY_VIOLATION. */
@@ -272,35 +282,195 @@ type AdapterDiagnostic = {
         fromLayer?: string;
         toLayer?: string;
         typeOnly?: boolean;
+        targetTypeOnlyExports?: boolean;
+        sourcePureTypeModule?: boolean;
+        namedBindingsTypeOnly?: boolean;
+        portProofEligible?: boolean;
+        peerIsolation?: boolean;
+        capability?: string;
+        edgeKind?: string;
     };
     /** Added in schema 1.1; optional in TypeScript so 1.0 consumer-owned values remain valid. */
     nextAction?: string;
 };
-type AdapterResult = {
-    schemaVersion: '1.0' | typeof ARK_ANALYSIS_RESULT_SCHEMA_VERSION;
+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 function toAdapterDiagnostic(violation: AdapterViolationInput, fallbackSeverity?: AdapterSeverity): 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[];
-}): AdapterResult;
+}): CurrentAdapterResult;
 declare const ARK_ANALYSIS_RESULT_SCHEMA: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
-    readonly $id: "https://unpkg.com/arkgate@2/schemas/ark.analysis-result.schema.json";
+    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", "valid", "diagnostics"];
+    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.1";
+            readonly const: "1.3";
+        };
+        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: {
@@ -354,6 +524,29 @@ declare const ARK_ANALYSIS_RESULT_SCHEMA: {
                             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 nextAction: {
@@ -398,7 +591,15 @@ interface AICodeGateContext {
     [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> {
@@ -662,92 +863,111 @@ interface AICodeGateOptions<Context = AICodeGateContext> {
 }
 declare function createAICodeGate<Context = AICodeGateContext>(options?: AICodeGateOptions<Context>): AICodeGate<Context>;
 
-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;
-};
+/**
+ * Stable, pure vocabulary for ArkGate's importable analysis engine.
+ *
+ * Parsing and filesystem discovery belong to adapters. This module intentionally
+ * contains only the versioned data contract and deterministic hash primitives.
+ */
 
-type ArchitectureDependency = {
-    from: string;
-    to: string;
+declare const ANALYSIS_IR_SCHEMA_VERSION: "1.0";
+declare const RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION: "1.0";
+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 ArchitectureActualChange = {
+type ResolvedFileFact = {
     path: string;
-    operation: ArchitectureChangeOperation;
+    contentHash: string;
+    parseStatus: 'parsed' | 'invalid';
+    parseDiagnosticCount: number;
+    exportsOnlyTypes: boolean;
+    typeOnlyExportNames: string[];
+    hasTopLevelSideEffects: boolean;
 };
-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 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 ArchitectureConvergenceResult = {
-    schemaVersion: '1.0';
-    readOnly: true;
-    changeMapHash: string;
-    structurallyConverged: boolean;
-    behavioralCompletion: 'not-evaluated';
-    summary: Record<ArchitectureConvergenceClassification, number>;
-    findings: ArchitectureConvergenceFinding[];
+type ResolvedCapabilityFact = {
+    file: string;
+    line: number;
+    symbol: string;
+    capability: ResolvedCapability;
+    source: 'ambient-global' | 'import-based';
 };
-type AnalyzeArchitectureConvergenceInput = {
-    changeMap: ArchitectureChangeMapContract;
-    changes: readonly ArchitectureActualChange[];
-    baseDependencies: readonly ArchitectureDependency[];
-    candidateDependencies: readonly ArchitectureDependency[];
+type ResolvedAmbientFact = {
+    file: string;
+    line: number;
+    symbol: string;
 };
-declare function analyzeArchitectureConvergence(input: AnalyzeArchitectureConvergenceInput): ArchitectureConvergenceResult;
-
-type SemanticDependencyKind = 'import' | 'export' | 'dynamic-import' | 'require';
-type SemanticDependency = {
-    specifier?: string;
-    kind: SemanticDependencyKind;
+type ResolvedPublishFact = {
+    file: string;
     line: number;
-    typeOnly: boolean;
-    unresolved: boolean;
-    node: unknown;
+    rawIntentName?: string;
+    objectHasIntent: boolean;
+    arkPublishCandidate: boolean;
+    hasSource: boolean;
+    sourceIntent?: string;
 };
-type ForbiddenCapabilityUse = {
-    name: string;
+type ResolvedIntentReferenceFact = {
+    file: string;
     line: number;
-    node: unknown;
+    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: 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[];
+};
+type ResolvedCandidateFacts = Omit<ResolvedCandidateFactsInput, 'candidateTreeHash'> & {
+    completenessReasons: ResolvedFactsReason[];
+    candidateTreeHash: string;
+    files: ResolvedFileFact[];
+    dependencies: ResolvedDependencyFact[];
+    capabilityUses: ResolvedCapabilityFact[];
+    ambientUses: ResolvedAmbientFact[];
+    publishCalls: ResolvedPublishFact[];
+    intentReferences: ResolvedIntentReferenceFact[];
+    safetyUses: ResolvedSafetyFact[];
+    factsHash: string;
 };
-/** 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[];
-
-/**
- * Stable, pure vocabulary for ArkGate's importable analysis engine.
- *
- * Parsing and filesystem discovery belong to adapters. This module intentionally
- * contains only the versioned data contract and deterministic hash primitives.
- */
-declare const ANALYSIS_IR_SCHEMA_VERSION: "1.0";
 type AnalysisFileInput = {
     path: string;
     content: string;
@@ -814,62 +1034,664 @@ type AnalysisIr = {
 declare function deterministicHash(value: string): string;
 /** Serialize JSON-like values with sorted object keys for reproducible hashes. */
 declare function stableSerialize(value: unknown): string;
-
-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;
-};
-declare function classifyArkPolicyDelta(base: ArkConfig, candidate: ArkConfig): PolicyDelta;
-declare function policyDeltaAcknowledgementMatches(acknowledgement: PolicyDeltaAcknowledgement | undefined, expected: {
-    basePolicyHash: string;
-    candidatePolicyHash: string;
-    findingIds: readonly string[];
-}): boolean;
-
-/**
- * Public type vocabulary of the canonical analysis API (U02 pilot 2).
- *
- * Declarations only — the C02 entry point src/kernel/analysis.ts re-exports
- * everything here, so consumer import paths never change.
- */
-
-type AnalysisContract = ArkConfigLoadResult & {
-    policyHash: string;
-};
-type AnalyzeProjectInput = {
-    contract: AnalysisContract;
-    files: readonly AnalysisFileInput[];
-    compilerOptions?: AnalysisCompilerOptions;
-};
-type AnalyzeChangeInput = AnalyzeProjectInput & {
-    changes: readonly AnalysisFileChange[];
-    changeMap?: ArchitectureChangeMapContract;
-};
-type AnalysisResult = {
-    ir: AnalysisIr;
-};
-type AnalyzePolicyDeltaInput = {
-    baseConfig: unknown;
-    candidateConfig: unknown;
+/** 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 const: "1.0";
+        };
+        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 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;
+                };
+            };
+        };
+    }];
+};
+
+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[];
+
+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;
+};
+declare function classifyArkPolicyDelta(base: ArkConfig, candidate: ArkConfig): PolicyDelta;
+declare function policyDeltaAcknowledgementMatches(acknowledgement: PolicyDeltaAcknowledgement | undefined, expected: {
+    basePolicyHash: string;
+    candidatePolicyHash: string;
+    findingIds: readonly string[];
+}): boolean;
+
+/**
+ * Public type vocabulary of the canonical analysis API (U02 pilot 2).
+ *
+ * Declarations only — the C02 entry point src/kernel/analysis.ts re-exports
+ * everything here, so consumer import paths never change.
+ */
+
+type AnalysisContract = ArkConfigLoadResult & {
+    policyHash: string;
+};
+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;
+};
+type PreflightResolvedChangeInput = {
+    contract: AnalysisContract;
+    baseFacts: unknown;
+    candidateFacts: unknown;
+    changes: readonly AnalysisFileChange[];
+    changeMap?: ArchitectureChangeMapContract;
+};
+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;
@@ -898,7 +1720,7 @@ type ArchitectureEngineViolation = {
 };
 type ArchitectureEngineEdge = {
     from: string;
-    fromLayer: string;
+    fromLayer: string | null;
     to?: string;
     toLayer?: string;
     line: number;
@@ -931,12 +1753,17 @@ type PreparedChangeFile = {
 };
 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[];
@@ -973,6 +1800,17 @@ declare function detectArchitectureCycles(graph: ReadonlyMap<string, ReadonlySet
 /** Canonical graph and layer-policy evaluator shared by library, CLI, and MCP adapters. */
 declare function evaluateArchitectureGraph(input: EvaluateArchitectureGraphInput): ArchitectureEngineResult;
 
+/**
+ * Pure evaluation of validated, resolver-supplied candidate facts (ADR 0011).
+ *
+ * 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.
+ */
+
+/** Validate supplied facts and evaluate their graph without host effects. */
+declare function analyzeResolvedProject(input: AnalyzeResolvedProjectInput): ResolvedAnalysisResult;
+
 /**
  * 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
@@ -980,7 +1818,101 @@ declare function evaluateArchitectureGraph(input: EvaluateArchitectureGraphInput
  */
 declare function preflightChange(input: AnalyzeChangeInput): ChangePreflightResult;
 
+/**
+ * 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[];
 
-export { type AICodeGate, type AICodeGateContext, type AICodeGateOptions, type AICodeGateResult, type AICodeGateViolation, type AIGateExtension, ANALYSIS_IR_SCHEMA_VERSION, ARK_ANALYSIS_RESULT_SCHEMA, ARK_ANALYSIS_RESULT_SCHEMA_VERSION, ARK_CONFIG_SCHEMA, ARK_CONFIG_SCHEMA_VERSION, type AdapterDiagnostic, type AdapterResult, type AdapterSeverity, type AdapterViolationInput, type AnalysisCapabilityUse, type AnalysisCompilerOptions, type AnalysisContract, type AnalysisEvidence, type AnalysisFile, type AnalysisFileChange, type AnalysisFileInput, type AnalysisImportEdge, type AnalysisIr, type AnalysisResult, type AnalysisViolation, type AnalyzeArchitectureConvergenceInput, type AnalyzeChangeInput, type AnalyzePolicyDeltaInput, type AnalyzeProjectInput, 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 ChangePreflightResult, type CollectAnalysisConfigWarningsInput, type CreateArchitectureProfileFromArkConfigOptions, type CreateArchitectureProfileOptions, type CreateElevenLayerArkConfigOptions, type EvaluateArchitectureGraphInput, type ForbiddenCapabilityUse, POLICY_DELTA_SCHEMA_VERSION, type PolicyDelta, type PolicyDeltaAcknowledgement, type PolicyDeltaAnalysis, type PolicyDeltaClassification, type PolicyDeltaFinding, type PreparedChangeFile, type SemanticDependency, type SemanticDependencyKind, analyzeArchitectureConvergence, analyzeChange, analyzePolicyDelta, analyzeProject, classifyArkPolicyDelta, collectAnalysisConfigWarnings, collectForbiddenCapabilityUses, createAICodeGate, createAdapterResult, createArchitectureProfile, createArchitectureProfileFromArkConfig, createElevenLayerArkConfig, detectArchitectureCycles, deterministicHash, elevenLayerProfile, evaluateArchitectureGraph, explainViolation, extractSemanticDependencies, loadArkConfigContract, loadContract, parseArkConfigJson, policyDeltaAcknowledgementMatches, preflightChange, stableSerialize, toAdapterDiagnostic, version };
+/** 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;
+};
+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;
+    error?: string;
+};
+
+export { type AICodeGate, type AICodeGateContext, type AICodeGateOptions, type AICodeGateResult, type AICodeGateViolation, type AIGateExtension, ANALYSIS_IR_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, type AdapterCompletenessReason, type AdapterDiagnostic, type AdapterResult, type AdapterSeverity, type AdapterViolationInput, 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 ChangePreflightResult, type CollectAnalysisConfigWarningsInput, type CreateArchitectureProfileFromArkConfigOptions, type CreateArchitectureProfileOptions, type CreateElevenLayerArkConfigOptions, type DesignDeltaChange, type DesignDeltaIdentity, type DesignSmellEvidence, type DesignSmellFinding, type DesignSmellId, type EnforcementBoundaryState, type EnforcementEvidence, type EnforcementEvidenceField, type EnforcementVerification, type EvaluateArchitectureGraphInput, type ForbiddenCapabilityUse, POLICY_DELTA_SCHEMA_VERSION, type PolicyDelta, type PolicyDeltaAcknowledgement, type PolicyDeltaAnalysis, type PolicyDeltaClassification, type PolicyDeltaFinding, type PreflightResolvedChangeInput, type PreparedChangeFile, RESOLVED_CANDIDATE_FACTS_SCHEMA, RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION, type ResolvedAmbientFact, type ResolvedAnalysisFile, type ResolvedAnalysisIr, type ResolvedAnalysisResult, 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 SemanticDependency, type SemanticDependencyKind, analyzeArchitectureConvergence, analyzeChange, analyzePolicyDelta, analyzeProject, analyzeResolvedProject, classifyArkPolicyDelta, collectAnalysisConfigWarnings, collectForbiddenCapabilityUses, createAICodeGate, createAdapterResult, createArchitectureProfile, createArchitectureProfileFromArkConfig, createElevenLayerArkConfig, createResolvedCandidateFacts, detectArchitectureCycles, deterministicHash, elevenLayerProfile, evaluateArchitectureGraph, explainViolation, extractSemanticDependencies, loadArkConfigContract, loadContract, loadResolvedCandidateFacts, parseArkConfigJson, policyDeltaAcknowledgementMatches, preflightChange, preflightResolvedChange, resolvedFactsEvidenceRequirementsHash, stableSerialize, toAdapterDiagnostic, version };