@habitat-ai/service 0.2.0 → 0.2.2

package/dist/service/modules/catalog/model/dto/catalog.js

@@ -302,11 +302,142 @@ const ResolvedRuleApplicationSchema = Type.Object({
         description: "Fully resolved runner and acquisition facts.",
     }),
 }, { additionalProperties: false, description: "One resolved instance/rule application." });
-const CompatibilityRuleSchema = Type.Object({
+const CompatibilityPlacementSchema = Type.Object({
+    niche: Type.String({
+        minLength: 1,
+        description: "Frozen version-two niche classification.",
+    }),
+    blueprint: Type.String({
+        minLength: 1,
+        description: "Frozen version-two blueprint classification.",
+    }),
+    category: Type.Union([
+        Type.Literal("boundary"),
+        Type.Literal("contract"),
+        Type.Literal("execution"),
+        Type.Literal("output"),
+        Type.Literal("policy"),
+        Type.Literal("quality"),
+        Type.Literal("structure"),
+    ], { description: "Frozen version-two rule category." }),
+}, { additionalProperties: false, description: "Legacy rule classification metadata." });
+const CompatibilityPathCoverageSchema = Type.Object({
+    kind: Type.Literal("exact-path", {
+        description: "Legacy exact repository-path subject declaration.",
+    }),
+    patterns: Type.Array(Type.String({
+        minLength: 1,
+        maxLength: 4_096,
+        description: "Repository-relative path or glob admitted for checking and caching.",
+    }), {
+        minItems: 1,
+        uniqueItems: true,
+        description: "Unique repository path patterns covered by the rule.",
+    }),
+}, { additionalProperties: false, description: "Legacy exact-path coverage entry." });
+const CompatibilitySupportFilesSchema = Type.Object({
+    baseline: RelativePathSchema,
+}, { additionalProperties: false, description: "Legacy rule support-file locators." });
+const CompatibilityGritRunnerSourceSchema = Type.Object({
+    name: Type.Literal("grit", { description: "Grit runner identity." }),
+    files: Type.Object({
+        pattern: RelativePathSchema,
+    }, { additionalProperties: false, description: "Grit rule asset locator." }),
+    patternName: PatternNameSchema,
+    acquisition: Type.Object({
+        kind: Type.Literal("check", { description: "Supported compatibility operation." }),
+        roots: Type.Array(RelativePathSchema, {
+            minItems: 1,
+            uniqueItems: true,
+            description: "Concrete repository roots supplied to Grit.",
+        }),
+    }, { additionalProperties: false, description: "Compatibility Grit acquisition roots." }),
+}, { additionalProperties: false, description: "Supported legacy Grit runner declaration." });
+const CompatibilityStructureRunnerSourceSchema = Type.Object({
+    name: Type.Literal("habitat", { description: "Native Habitat runner identity." }),
+    mode: Type.Literal("structure", { description: "Native structure evaluation mode." }),
+    files: Type.Object({
+        structure: RelativePathSchema,
+    }, { additionalProperties: false, description: "Structure rule asset locator." }),
+}, { additionalProperties: false, description: "Supported legacy structure runner declaration." });
+const CompatibilityRuleSourceCommon = {
+    schemaVersion: Type.Literal(2, { description: "Legacy rule schema version." }),
     id: IdSchema,
+    title: Type.String({ minLength: 1, maxLength: 500, description: "Legacy rule title." }),
+    placement: CompatibilityPlacementSchema,
+    operation: Type.Object({
+        kind: Type.Literal("check", { description: "Only admitted compatibility operation." }),
+    }, { additionalProperties: false, description: "Legacy rule operation." }),
+    ownerProject: ProjectIdSchema,
+    lane: Type.Literal("enforced", { description: "Only admitted compatibility policy lane." }),
+    forbids: Type.String({
+        minLength: 1,
+        maxLength: 16_384,
+        description: "State excluded by the compatibility rule.",
+    }),
+    why: Type.String({
+        minLength: 1,
+        maxLength: 16_384,
+        description: "Reason the compatibility rule exists.",
+    }),
+    remediate: Type.String({
+        minLength: 1,
+        maxLength: 16_384,
+        description: "Operator remediation for one finding.",
+    }),
+    message: RuleMessageSchema,
+    pathCoverage: Type.Tuple([CompatibilityPathCoverageSchema], {
+        description: "Single exact-path cache boundary for the compatibility rule.",
+    }),
+    supportFiles: CompatibilitySupportFilesSchema,
+};
+const CompatibilityGritRuleSourceSchema = Type.Object({
+    ...CompatibilityRuleSourceCommon,
+    hookCheck: Type.Literal(true, {
+        description: "The legacy hook executes this Grit check.",
+    }),
+    runner: CompatibilityGritRunnerSourceSchema,
+}, { additionalProperties: false, description: "Supported legacy Grit rule source." });
+const CompatibilityStructureRuleSourceSchema = Type.Object({
+    ...CompatibilityRuleSourceCommon,
+    runner: CompatibilityStructureRunnerSourceSchema,
+}, { additionalProperties: false, description: "Supported legacy structure rule source." });
+const ResolvedCompatibilityGritRunnerSchema = Type.Object({
+    name: Type.Literal("grit", { description: "Grit runner identity." }),
+    pattern: ResolvedRuleAssetSchema,
+    patternName: PatternNameSchema,
+    acquisition: Type.Object({
+        kind: Type.Literal("check", { description: "Resolved compatibility operation." }),
+        entries: Type.Array(Type.Object({
+            kind: PathKindSchema,
+            path: RelativePathSchema,
+        }, { additionalProperties: false, description: "Resolved compatibility subject root." }), {
+            minItems: 1,
+            description: "Concrete compatibility roots in declared order.",
+        }),
+    }, { additionalProperties: false, description: "Resolved compatibility Grit acquisition." }),
+}, { additionalProperties: false, description: "Resolved compatibility Grit runner." });
+const ResolvedCompatibilityStructureRunnerSchema = Type.Object({
+    name: Type.Literal("habitat", { description: "Native Habitat runner identity." }),
+    mode: Type.Literal("structure", { description: "Native structure evaluation mode." }),
+    structure: ResolvedRuleAssetSchema,
+}, { additionalProperties: false, description: "Resolved compatibility structure runner." });
+const CompatibilityRuleSchema = Type.Object({
+    ruleId: IdSchema,
     ownerProject: ProjectIdSchema,
     manifestPath: RelativePathSchema,
-}, { additionalProperties: false, description: "Inert version 2 rule identity summary." });
+    lane: Type.Literal("enforced", { description: "Compatibility rule policy lane." }),
+    message: RuleMessageSchema,
+    remediate: RuleRemediationSchema,
+    provenance: LocalAuthorityProvenanceSchema,
+    coveragePatterns: Type.Array(Type.String({ minLength: 1, maxLength: 4_096 }), {
+        minItems: 1,
+        uniqueItems: true,
+        description: "Repository path patterns that define compatibility subjects and cache inputs.",
+    }),
+    baseline: ResolvedRuleAssetSchema,
+    runner: Type.Union([ResolvedCompatibilityStructureRunnerSchema, ResolvedCompatibilityGritRunnerSchema], { description: "Resolved compatibility runner and its concrete assets." }),
+}, { additionalProperties: false, description: "One executable version 2 compatibility rule." });
 /** Closed compatibility index source schema. */
 export const CompatibilityIndexSchema = Type.Object({
     $comment: Type.Optional(Type.String({ description: "Optional legacy index comment." })),
@@ -316,21 +447,21 @@ export const CompatibilityIndexSchema = Type.Object({
         description: "Legacy owner roots keyed by project identity.",
     }),
 }, { additionalProperties: false, description: "Legacy version 2 registry index." });
-/** Minimum TypeBox admission schema for an inert legacy rule manifest. */
-export const CompatibilityRuleSourceSchema = Type.Object({
-    schemaVersion: Type.Literal(2, { description: "Legacy rule schema version." }),
-    id: IdSchema,
-    ownerProject: ProjectIdSchema,
-}, { additionalProperties: true, description: "Legacy rule source identity projected inertly." });
+/** Closed admission schema for the exact executable legacy rule subset. */
+export const CompatibilityRuleSourceSchema = Type.Union([CompatibilityGritRuleSourceSchema, CompatibilityStructureRuleSourceSchema], { description: "Supported version 2 compatibility rule source." });
+/** Closed empty baseline admitted during compatibility resolution. */
+export const CompatibilityBaselineSchema = Type.Tuple([], {
+    description: "Empty compatibility baseline; every observed finding remains live.",
+});
 const CompatibilityCatalogSchema = Type.Object({
     schemaVersion: Type.Literal(2, { description: "Legacy compatibility catalog version." }),
     ownerRoots: Type.Record(ProjectIdSchema, RelativePathSchema, {
         description: "Validated legacy owner roots keyed by project identity.",
     }),
     rules: Type.Array(CompatibilityRuleSchema, {
-        description: "Stable inert legacy rule identity summaries.",
+        description: "Resolved executable compatibility rules in stable identity order.",
     }),
-}, { additionalProperties: false, description: "Inert version 2 compatibility facts." });
+}, { additionalProperties: false, description: "Version 2 compatibility rule catalog." });
 const ResolvedPolicyPackSchema = Type.Object({
     name: PackageNameSchema,
     version: PackageVersionSchema,

package/dist/service/modules/catalog/model/dto/check.d.ts

@@ -60,6 +60,42 @@ export declare const CheckCatalogResultSchema: Type.TUnion<[Type.TObject<{
             severity: Type.TUnion<[Type.TLiteral<"error">, Type.TLiteral<"advisory">]>;
             baselined: Type.TLiteral<false>;
         }>>;
+    }>, Type.TObject<{
+        ownerProject: Type.TString;
+        instanceId: Type.TNull;
+        ruleId: Type.TString;
+        runner: Type.TLiteral<"grit">;
+        lane: Type.TUnion<[Type.TLiteral<"enforced">, Type.TLiteral<"advisory">]>;
+        locked: Type.TLiteral<true>;
+        status: Type.TUnion<[Type.TLiteral<"pass">, Type.TLiteral<"fail">, Type.TLiteral<"advisory-findings">, Type.TLiteral<"error">]>;
+        message: Type.TString;
+        remediate: Type.TUnion<[Type.TString, Type.TNull]>;
+        disposition: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"evaluated">;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"not-applicable">;
+            reason: Type.TLiteral<"no-matched-acquisition-roots">;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"failed">;
+            reason: Type.TUnion<[Type.TUnion<[Type.TLiteral<"InvalidInput">, Type.TLiteral<"SetupFailed">, Type.TLiteral<"ExecutionFailed">, Type.TLiteral<"TimedOut">, Type.TLiteral<"InvalidOutput">]>, Type.TLiteral<"PatternReadFailed">, Type.TLiteral<"PatternInvalid">, Type.TLiteral<"FindingPathInvalid">]>;
+            detail: Type.TString;
+        }>]>;
+        findings: Type.TArray<Type.TObject<{
+            path: Type.TString;
+            start: Type.TObject<{
+                line: Type.TReadonly<Type.TInteger>;
+                column: Type.TReadonly<Type.TInteger>;
+                offset: Type.TReadonly<Type.TInteger>;
+            }>;
+            end: Type.TObject<{
+                line: Type.TReadonly<Type.TInteger>;
+                column: Type.TReadonly<Type.TInteger>;
+                offset: Type.TReadonly<Type.TInteger>;
+            }>;
+            message: Type.TUnion<[Type.TString, Type.TNull]>;
+            severity: Type.TUnion<[Type.TLiteral<"error">, Type.TLiteral<"advisory">]>;
+            baselined: Type.TLiteral<false>;
+        }>>;
     }>, Type.TObject<{
         ownerProject: Type.TString;
         instanceId: Type.TString;
@@ -84,6 +120,30 @@ export declare const CheckCatalogResultSchema: Type.TUnion<[Type.TObject<{
             severity: Type.TUnion<[Type.TLiteral<"error">, Type.TLiteral<"advisory">]>;
             baselined: Type.TLiteral<false>;
         }>>;
+    }>, Type.TObject<{
+        ownerProject: Type.TString;
+        instanceId: Type.TNull;
+        ruleId: Type.TString;
+        runner: Type.TLiteral<"habitat">;
+        lane: Type.TUnion<[Type.TLiteral<"enforced">, Type.TLiteral<"advisory">]>;
+        locked: Type.TLiteral<true>;
+        status: Type.TUnion<[Type.TLiteral<"pass">, Type.TLiteral<"fail">, Type.TLiteral<"advisory-findings">, Type.TLiteral<"error">]>;
+        message: Type.TString;
+        remediate: Type.TUnion<[Type.TString, Type.TNull]>;
+        disposition: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"evaluated">;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"failed">;
+            reason: Type.TUnion<[Type.TLiteral<"StructureReadFailed">, Type.TLiteral<"StructureInvalid">, Type.TLiteral<"InventoryFailed">, Type.TLiteral<"StructureObservationFailed">]>;
+            detail: Type.TString;
+        }>]>;
+        findings: Type.TArray<Type.TObject<{
+            path: Type.TString;
+            code: Type.TUnion<[Type.TLiteral<"root-missing">, Type.TLiteral<"wrong-root-kind">, Type.TLiteral<"missing-required-child">, Type.TLiteral<"forbidden-child">, Type.TLiteral<"unexpected-child">]>;
+            message: Type.TString;
+            severity: Type.TUnion<[Type.TLiteral<"error">, Type.TLiteral<"advisory">]>;
+            baselined: Type.TLiteral<false>;
+        }>>;
     }>]>>;
 }>]>;
 /** Caller request for one current-catalog check. */

package/dist/service/modules/catalog/model/dto/check.js

@@ -67,6 +67,44 @@ const CheckSelectionIssueSchema = Type.Object({
     additionalProperties: false,
     description: "One expected application-selection refusal.",
 });
+const ReportOwnerProjectSchema = Type.String({
+    minLength: 1,
+    maxLength: 250,
+    description: "Repository project that owns the checked rule.",
+});
+const ReportInstanceIdSchema = Type.String({
+    minLength: 1,
+    maxLength: 250,
+    description: "Repository-unique version-three instance identity.",
+});
+const ReportRuleIdSchema = Type.String({
+    minLength: 1,
+    maxLength: 200,
+    description: "Resolved rule identity.",
+});
+const ReportLaneSchema = Type.Union([Type.Literal("enforced"), Type.Literal("advisory")], {
+    description: "Rule lane that determines finding severity and terminal status.",
+});
+const ReportMessageSchema = Type.String({
+    minLength: 1,
+    maxLength: 8_192,
+    description: "Rule-authored diagnostic message.",
+});
+const ReportRemediationSchema = Type.Union([Type.String({ maxLength: 16_384 }), Type.Null()], {
+    description: "Rule-authored remediation when supplied.",
+});
+const InstanceReportLockSchema = Type.Literal(false, {
+    description: "Version-three applications do not use compatibility baseline locking.",
+});
+const CompatibilityReportLockSchema = Type.Literal(true, {
+    description: "The compatibility rule has an admitted exact empty baseline.",
+});
+const GritRunnerSchema = Type.Literal("grit", {
+    description: "Mechanical Grit runner used by this check.",
+});
+const StructureRunnerSchema = Type.Literal("habitat", {
+    description: "Native Habitat structure runner used by this check.",
+});
 const GritCheckFindingSchema = Type.Object({
     path: Type.String({
         minLength: 1,
@@ -82,7 +120,7 @@ const GritCheckFindingSchema = Type.Object({
         description: "Service-owned severity derived from the application lane.",
     }),
     baselined: Type.Literal(false, {
-        description: "Version-three findings are not admitted through the predecessor baseline model.",
+        description: "No admitted baseline suppresses this observed finding.",
     }),
 }, {
     additionalProperties: false,
@@ -96,80 +134,83 @@ const CheckApplicationStatusSchema = Type.Union([
 ], {
     description: "Semantic terminal status for one resolved application.",
 });
-const GritCheckApplicationDispositionSchema = Type.Union([
-    Type.Object({
-        kind: Type.Literal("evaluated", {
-            description: "The application completed mechanical evaluation.",
-        }),
-    }, {
-        additionalProperties: false,
-        description: "Completed mechanical evaluation disposition.",
+const GritEvaluatedDispositionSchema = Type.Object({
+    kind: Type.Literal("evaluated", {
+        description: "The application completed mechanical evaluation.",
     }),
-    Type.Object({
-        kind: Type.Literal("failed", {
-            description: "The application could not produce trusted findings.",
-        }),
-        reason: Type.Union([
-            RuleEvaluationFailureReasonSchema,
-            Type.Literal("PatternReadFailed"),
-            Type.Literal("PatternInvalid"),
-            Type.Literal("FindingPathInvalid"),
-        ], {
-            description: "Stable operational failure reason.",
-        }),
-        detail: Type.String({
-            minLength: 1,
-            maxLength: 4_096,
-            description: "Bounded operational failure detail.",
-        }),
-    }, {
-        additionalProperties: false,
-        description: "Failed application evaluation disposition.",
-    }),
-], {
-    description: "Mechanical disposition underlying one semantic application status.",
+}, {
+    additionalProperties: false,
+    description: "Completed mechanical evaluation disposition.",
 });
-const GritCheckApplicationReportSchema = Type.Object({
-    ownerProject: Type.String({
-        minLength: 1,
-        maxLength: 250,
-        description: "Repository project that owns the resolved application.",
-    }),
-    instanceId: Type.String({
-        minLength: 1,
-        maxLength: 250,
-        description: "Repository-unique instance identity.",
-    }),
-    ruleId: Type.String({
+const GritFailedDispositionSchema = Type.Object({
+    kind: Type.Literal("failed", {
+        description: "The application could not produce trusted findings.",
+    }),
+    reason: Type.Union([
+        RuleEvaluationFailureReasonSchema,
+        Type.Literal("PatternReadFailed"),
+        Type.Literal("PatternInvalid"),
+        Type.Literal("FindingPathInvalid"),
+    ], {
+        description: "Stable operational failure reason.",
+    }),
+    detail: Type.String({
         minLength: 1,
-        maxLength: 200,
-        description: "Resolved rule identity.",
-    }),
-    runner: Type.Literal("grit", {
-        description: "Mechanical runner used by this check operation.",
+        maxLength: 4_096,
+        description: "Bounded operational failure detail.",
     }),
-    lane: Type.Union([Type.Literal("enforced"), Type.Literal("advisory")], {
-        description: "Application policy lane.",
+}, {
+    additionalProperties: false,
+    description: "Failed application evaluation disposition.",
+});
+const GritNotApplicableDispositionSchema = Type.Object({
+    kind: Type.Literal("not-applicable", {
+        description: "The compatibility rule had no live exact-coverage subjects.",
     }),
-    locked: Type.Literal(false, {
-        description: "Version-three applications do not inherit predecessor baseline locking.",
+    reason: Type.Literal("no-matched-acquisition-roots", {
+        description: "No regular file matched both exact coverage and declared authority.",
     }),
+}, {
+    additionalProperties: false,
+    description: "Compatibility rule with no current subject files.",
+});
+const GritCheckApplicationDispositionSchema = Type.Union([GritEvaluatedDispositionSchema, GritFailedDispositionSchema], { description: "Version-three Grit evaluation disposition." });
+const CompatibilityGritCheckApplicationDispositionSchema = Type.Union([GritEvaluatedDispositionSchema, GritNotApplicableDispositionSchema, GritFailedDispositionSchema], { description: "Compatibility Grit evaluation disposition." });
+const GritInstanceCheckApplicationReportSchema = Type.Object({
+    ownerProject: ReportOwnerProjectSchema,
+    instanceId: ReportInstanceIdSchema,
+    ruleId: ReportRuleIdSchema,
+    runner: GritRunnerSchema,
+    lane: ReportLaneSchema,
+    locked: InstanceReportLockSchema,
     status: CheckApplicationStatusSchema,
-    message: Type.String({
-        minLength: 1,
-        maxLength: 8_192,
-        description: "Rule-authored finding message.",
-    }),
-    remediate: Type.Union([Type.String({ maxLength: 16_384 }), Type.Null()], {
-        description: "Rule-authored remediation when supplied.",
-    }),
+    message: ReportMessageSchema,
+    remediate: ReportRemediationSchema,
     disposition: GritCheckApplicationDispositionSchema,
     findings: Type.Array(GritCheckFindingSchema, {
         description: "Deterministically ordered findings for this application.",
     }),
 }, {
     additionalProperties: false,
-    description: "One resolved application check report.",
+    description: "One version-three Grit application report.",
+});
+const CompatibilityGritCheckApplicationReportSchema = Type.Object({
+    ownerProject: ReportOwnerProjectSchema,
+    instanceId: Type.Null({ description: "Compatibility rules have no version-three instance." }),
+    ruleId: ReportRuleIdSchema,
+    runner: GritRunnerSchema,
+    lane: ReportLaneSchema,
+    locked: CompatibilityReportLockSchema,
+    status: CheckApplicationStatusSchema,
+    message: ReportMessageSchema,
+    remediate: ReportRemediationSchema,
+    disposition: CompatibilityGritCheckApplicationDispositionSchema,
+    findings: Type.Array(GritCheckFindingSchema, {
+        description: "Deterministically ordered findings for this compatibility rule.",
+    }),
+}, {
+    additionalProperties: false,
+    description: "One version-two compatibility Grit report.",
 });
 const StructureFindingCodeSchema = Type.Union([
     Type.Literal("root-missing"),
@@ -194,7 +235,7 @@ const StructureCheckFindingSchema = Type.Object({
         description: "Service-owned severity derived from the application lane.",
     }),
     baselined: Type.Literal(false, {
-        description: "Version-three findings do not inherit predecessor baselines.",
+        description: "No admitted baseline suppresses this observed finding.",
     }),
 }, { additionalProperties: false, description: "One path-only native structure finding." });
 const StructureCheckApplicationDispositionSchema = Type.Union([
@@ -220,46 +261,42 @@ const StructureCheckApplicationDispositionSchema = Type.Union([
         }),
     }, { additionalProperties: false, description: "Failed native structure evaluation." }),
 ], { description: "Native structure evaluation disposition." });
-const StructureCheckApplicationReportSchema = Type.Object({
-    ownerProject: Type.String({
-        minLength: 1,
-        maxLength: 250,
-        description: "Repository project that owns this structure application.",
-    }),
-    instanceId: Type.String({
-        minLength: 1,
-        maxLength: 250,
-        description: "Resolved instance evaluated by this structure application.",
-    }),
-    ruleId: Type.String({
-        minLength: 1,
-        maxLength: 200,
-        description: "Native structure rule evaluated for this instance.",
-    }),
-    runner: Type.Literal("habitat", {
-        description: "Native Habitat runner used by this application.",
-    }),
-    lane: Type.Union([Type.Literal("enforced"), Type.Literal("advisory")], {
-        description: "Policy lane that determines finding severity and completion status.",
-    }),
-    locked: Type.Literal(false, {
-        description: "Native structure reports do not expose Grit lock semantics.",
-    }),
+const StructureInstanceCheckApplicationReportSchema = Type.Object({
+    ownerProject: ReportOwnerProjectSchema,
+    instanceId: ReportInstanceIdSchema,
+    ruleId: ReportRuleIdSchema,
+    runner: StructureRunnerSchema,
+    lane: ReportLaneSchema,
+    locked: InstanceReportLockSchema,
     status: CheckApplicationStatusSchema,
-    message: Type.String({
-        minLength: 1,
-        maxLength: 8_192,
-        description: "Catalog-authored human guidance for this structure rule.",
-    }),
-    remediate: Type.Union([Type.String({ maxLength: 16_384 }), Type.Null()], {
-        description: "Optional catalog-authored remediation guidance.",
-    }),
+    message: ReportMessageSchema,
+    remediate: ReportRemediationSchema,
     disposition: StructureCheckApplicationDispositionSchema,
     findings: Type.Array(StructureCheckFindingSchema, {
         description: "Deterministically ordered path-only structure findings.",
     }),
-}, { additionalProperties: false, description: "One native Habitat structure report." });
-const CheckApplicationReportSchema = Type.Union([GritCheckApplicationReportSchema, StructureCheckApplicationReportSchema], { description: "Runner-discriminated application check report." });
+}, { additionalProperties: false, description: "One version-three native structure report." });
+const CompatibilityStructureCheckApplicationReportSchema = Type.Object({
+    ownerProject: ReportOwnerProjectSchema,
+    instanceId: Type.Null({ description: "Compatibility rules have no version-three instance." }),
+    ruleId: ReportRuleIdSchema,
+    runner: StructureRunnerSchema,
+    lane: ReportLaneSchema,
+    locked: CompatibilityReportLockSchema,
+    status: CheckApplicationStatusSchema,
+    message: ReportMessageSchema,
+    remediate: ReportRemediationSchema,
+    disposition: StructureCheckApplicationDispositionSchema,
+    findings: Type.Array(StructureCheckFindingSchema, {
+        description: "Deterministically ordered path-only compatibility findings.",
+    }),
+}, { additionalProperties: false, description: "One version-two compatibility structure report." });
+const CheckApplicationReportSchema = Type.Union([
+    GritInstanceCheckApplicationReportSchema,
+    CompatibilityGritCheckApplicationReportSchema,
+    StructureInstanceCheckApplicationReportSchema,
+    CompatibilityStructureCheckApplicationReportSchema,
+], { description: "Runner- and authority-discriminated application check report." });
 /** Closed total result for one current-catalog check. */
 export const CheckCatalogResultSchema = Type.Union([
     Type.Object({

package/dist/service/modules/catalog/model/dto/structure.d.ts

@@ -17,7 +17,25 @@ export declare const StructureDocumentSchema: Type.TRefine<Type.TObject<{
         forbidden: Type.TOptional<Type.TArray<Type.TRefine<Type.TString>>>;
     }>>;
 }>>;
+/** Sole structural authority for one version-one compatibility structure document. */
+export declare const CompatibilityStructureDocumentSchema: Type.TRefine<Type.TObject<{
+    schemaVersion: Type.TLiteral<1>;
+    scopes: Type.TArray<Type.TObject<{
+        name: Type.TString;
+        root: Type.TRefine<Type.TString>;
+        kind: Type.TUnion<[Type.TLiteral<"directory">, Type.TLiteral<"file">]>;
+        mode: Type.TUnion<[Type.TLiteral<"open">, Type.TLiteral<"closed">]>;
+        allowEmpty: Type.TOptional<Type.TBoolean>;
+        required: Type.TOptional<Type.TArray<Type.TRefine<Type.TString>>>;
+        allowed: Type.TOptional<Type.TArray<Type.TRefine<Type.TString>>>;
+        forbidden: Type.TOptional<Type.TArray<Type.TRefine<Type.TString>>>;
+    }>>;
+}>>;
 /** Schema-admitted version-two Habitat structure document. */
 export type StructureDocument = Static<typeof StructureDocumentSchema>;
 /** One schema-admitted structure scope. */
 export type StructureScope = StructureDocument["scopes"][number];
+/** Schema-admitted version-one compatibility structure document. */
+export type CompatibilityStructureDocument = Static<typeof CompatibilityStructureDocumentSchema>;
+/** One schema-admitted version-one compatibility structure scope. */
+export type CompatibilityStructureScope = CompatibilityStructureDocument["scopes"][number];

package/dist/service/modules/catalog/model/dto/structure.js

@@ -50,6 +50,33 @@ const StructureScopeSchema = Type.Object({
         description: "Unique direct-child globs rejected in every scope mode.",
     })),
 }, { additionalProperties: false, description: "One closed Habitat structure scope." });
+const CompatibilityStructureScopeSchema = Type.Object({
+    name: Type.String({
+        minLength: 1,
+        maxLength: 200,
+        description: "Stable identity for one compatibility structure scope.",
+    }),
+    root: RootRelativePatternSchema,
+    kind: Type.Union([Type.Literal("directory"), Type.Literal("file")], {
+        description: "Expected kind for every matched scope root.",
+    }),
+    mode: Type.Union([Type.Literal("open"), Type.Literal("closed")], {
+        description: "Whether unmatched direct children are admitted.",
+    }),
+    allowEmpty: Type.Optional(Type.Boolean({ description: "Whether a scope may match no visible roots." })),
+    required: Type.Optional(Type.Array(DirectChildPatternSchema, {
+        uniqueItems: true,
+        description: "Unique direct-child globs that must each match at least one child.",
+    })),
+    allowed: Type.Optional(Type.Array(DirectChildPatternSchema, {
+        uniqueItems: true,
+        description: "Unique direct-child globs admitted by a closed scope.",
+    })),
+    forbidden: Type.Optional(Type.Array(DirectChildPatternSchema, {
+        uniqueItems: true,
+        description: "Unique direct-child globs rejected in every scope mode.",
+    })),
+}, { additionalProperties: false, description: "One closed compatibility structure scope." });
 const StructureDocumentShapeSchema = Type.Object({
     schemaVersion: Type.Literal(2, { description: "Structure document schema version." }),
     scopes: Type.Array(StructureScopeSchema, {
@@ -59,9 +86,21 @@ const StructureDocumentShapeSchema = Type.Object({
 }, { additionalProperties: false, description: "Closed Habitat structure document." });
 /** Sole structural authority for one version-two Habitat structure document. */
 export const StructureDocumentSchema = Type.Refine(StructureDocumentShapeSchema, hasUniqueScopeNames, () => "Expected unique structure scope names");
+const CompatibilityStructureDocumentShapeSchema = Type.Object({
+    schemaVersion: Type.Literal(1, { description: "Compatibility structure schema version." }),
+    scopes: Type.Array(CompatibilityStructureScopeSchema, {
+        minItems: 1,
+        description: "Compatibility structure scopes evaluated in declared order.",
+    }),
+}, { additionalProperties: false, description: "Closed compatibility structure document." });
+/** Sole structural authority for one version-one compatibility structure document. */
+export const CompatibilityStructureDocumentSchema = Type.Refine(CompatibilityStructureDocumentShapeSchema, hasUniqueCompatibilityScopeNames, () => "Expected unique compatibility structure scope names");
 function hasUniqueScopeNames(document) {
     return new Set(document.scopes.map((scope) => scope.name)).size === document.scopes.length;
 }
+function hasUniqueCompatibilityScopeNames(document) {
+    return new Set(document.scopes.map((scope) => scope.name)).size === document.scopes.length;
+}
 function isSafeRootRelativePattern(value) {
     if (!isValidGlob(value))
         return false;

package/dist/service/modules/catalog/model/policy/catalog.d.ts

@@ -1,5 +1,5 @@
 import type { Path } from "effect";
-import { type BlueprintDefinition, type CatalogIssue, type CompatibilityIndex, type CompatibilityRuleSource, type HabitatInstanceManifest, type PolicyPackManifest, type PolicyPackPackageJson, type ResolveCatalogResult } from "../dto/catalog.js";
+import { type BlueprintDefinition, type CatalogIssue, type CompatibilityBaseline, type CompatibilityIndex, type CompatibilityRuleSource, type HabitatInstanceManifest, type PolicyPackManifest, type PolicyPackPackageJson, type ResolveCatalogResult } from "../dto/catalog.js";
 /** One schema-admitted local blueprint source. */
 export type BlueprintSource = {
     readonly definition: BlueprintDefinition;
@@ -23,11 +23,15 @@ export type InstanceSource = {
     readonly manifest: HabitatInstanceManifest;
     readonly relativePath: string;
 };
-/** One schema-admitted inert compatibility rule source. */
-export type CompatibilityRuleDocument = {
+/** One schema-admitted compatibility rule source before support-file admission. */
+export type CompatibilityRuleSourceDocument = {
     readonly rule: CompatibilityRuleSource;
     readonly relativePath: string;
 };
+/** One compatibility rule whose empty baseline has been admitted. */
+export type CompatibilityRuleDocument = CompatibilityRuleSourceDocument & {
+    readonly baseline: CompatibilityBaseline;
+};
 /** Schema-admitted authority documents observed by the resolve handler. */
 export type CatalogDocuments = {
     readonly policyPack: PolicyPackSource;
@@ -96,7 +100,15 @@ export declare function admitCompatibilityIndex(value: unknown, relativePath: st
 /** Admits only the inert identity fields required from a legacy rule source. */
 export declare function admitCompatibilityRule(value: unknown, relativePath: string): {
     readonly ok: true;
-    readonly source: CompatibilityRuleDocument;
+    readonly source: CompatibilityRuleSourceDocument;
+} | {
+    readonly ok: false;
+    readonly issues: readonly CatalogIssue[];
+};
+/** Admits the exact empty baseline supported by compatibility execution. */
+export declare function admitCompatibilityBaseline(value: unknown, relativePath: string): {
+    readonly ok: true;
+    readonly value: CompatibilityBaseline;
 } | {
     readonly ok: false;
     readonly issues: readonly CatalogIssue[];