@qontinui/shared-types 0.6.0 → 0.8.0

package/dist/ui-bridge-ir.d.cts

@@ -477,7 +477,53 @@ interface IRDocument {
     synthesizedGroups?: IRGroup[];
     /** ID of the initial/starting state, if applicable. */
     initialState?: string;
+    /** Per-page API-contract assertions evaluated by the Spec CI harness. */
+    apiAssertions?: IRApiCheck[];
 }
+/**
+ * A single API-contract check: issue a request, validate the response.
+ */
+interface IRApiCheck {
+    id: string;
+    description?: string;
+    request: {
+        method: string;
+        path: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+    };
+    effect?: "read" | "write" | "destructive";
+    assertions: IRApiAssertion[];
+}
+/**
+ * API assertion: either a value-level assertion (status_code, json_path, etc.)
+ * or a schema-conformance assertion (conforms_to -- Phase 2 placeholder).
+ */
+type IRApiAssertion = {
+    type: "status_code";
+    expected: unknown;
+    operator?: string;
+} | {
+    type: "json_path";
+    jsonPath: string;
+    expected: unknown;
+    operator?: string;
+} | {
+    type: "header";
+    headerName: string;
+    expected: unknown;
+    operator?: string;
+} | {
+    type: "body_contains";
+    expected: unknown;
+} | {
+    type: "response_time";
+    expected: unknown;
+    operator?: string;
+} | {
+    type: "conforms_to";
+    schema: string;
+};
 
 /**
  * IR -> WorkflowConfig adapter.
@@ -978,4 +1024,4 @@ interface ProjectLegacyToIROptions {
  */
 declare function projectLegacyToIR(legacy: LegacySpec, opts?: ProjectLegacyToIROptions): IRDocument;
 
-export { type AdaptedState, type AdaptedTransition, type AdaptedTransitionAction, type AdaptedWaitAfter, type AdaptedWorkflowConfig, type IRAcceptDriftPolicy, type IRAssertion, type IRAssertionTarget, type IRCrossRef, type IRDocument, type IREffect, type IRElementCriteria, type IRGroup, type IRMetadata, type IRPairingAxis, type IRPairingPolicy, type IRProvenance, type IRState, type IRStateCondition, type IRTransition, type IRTransitionAction, type IRVersion, type IRVisualRef, type IRWaitSpec, type LegacyAssertion, type LegacyAssertionTarget, type LegacyCriteria, type LegacyGroup, type LegacyMetadata, type LegacyProcessStep, type LegacySpec, type LegacyStateMachine, type LegacyStateMachineState, type LegacyTransition, type ProjectLegacyToIROptions, adaptIRDocumentToWorkflowConfig, adaptIRState, adaptIRTransition, adaptIRTransitionAction, projectIRToBundledPage, projectLegacyToIR, projectionVersion };
+export { type AdaptedState, type AdaptedTransition, type AdaptedTransitionAction, type AdaptedWaitAfter, type AdaptedWorkflowConfig, type IRAcceptDriftPolicy, type IRApiAssertion, type IRApiCheck, type IRAssertion, type IRAssertionTarget, type IRCrossRef, type IRDocument, type IREffect, type IRElementCriteria, type IRGroup, type IRMetadata, type IRPairingAxis, type IRPairingPolicy, type IRProvenance, type IRState, type IRStateCondition, type IRTransition, type IRTransitionAction, type IRVersion, type IRVisualRef, type IRWaitSpec, type LegacyAssertion, type LegacyAssertionTarget, type LegacyCriteria, type LegacyGroup, type LegacyMetadata, type LegacyProcessStep, type LegacySpec, type LegacyStateMachine, type LegacyStateMachineState, type LegacyTransition, type ProjectLegacyToIROptions, adaptIRDocumentToWorkflowConfig, adaptIRState, adaptIRTransition, adaptIRTransitionAction, projectIRToBundledPage, projectLegacyToIR, projectionVersion };

package/dist/ui-bridge-ir.d.ts

@@ -477,7 +477,53 @@ interface IRDocument {
     synthesizedGroups?: IRGroup[];
     /** ID of the initial/starting state, if applicable. */
     initialState?: string;
+    /** Per-page API-contract assertions evaluated by the Spec CI harness. */
+    apiAssertions?: IRApiCheck[];
 }
+/**
+ * A single API-contract check: issue a request, validate the response.
+ */
+interface IRApiCheck {
+    id: string;
+    description?: string;
+    request: {
+        method: string;
+        path: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+    };
+    effect?: "read" | "write" | "destructive";
+    assertions: IRApiAssertion[];
+}
+/**
+ * API assertion: either a value-level assertion (status_code, json_path, etc.)
+ * or a schema-conformance assertion (conforms_to -- Phase 2 placeholder).
+ */
+type IRApiAssertion = {
+    type: "status_code";
+    expected: unknown;
+    operator?: string;
+} | {
+    type: "json_path";
+    jsonPath: string;
+    expected: unknown;
+    operator?: string;
+} | {
+    type: "header";
+    headerName: string;
+    expected: unknown;
+    operator?: string;
+} | {
+    type: "body_contains";
+    expected: unknown;
+} | {
+    type: "response_time";
+    expected: unknown;
+    operator?: string;
+} | {
+    type: "conforms_to";
+    schema: string;
+};
 
 /**
  * IR -> WorkflowConfig adapter.
@@ -978,4 +1024,4 @@ interface ProjectLegacyToIROptions {
  */
 declare function projectLegacyToIR(legacy: LegacySpec, opts?: ProjectLegacyToIROptions): IRDocument;
 
-export { type AdaptedState, type AdaptedTransition, type AdaptedTransitionAction, type AdaptedWaitAfter, type AdaptedWorkflowConfig, type IRAcceptDriftPolicy, type IRAssertion, type IRAssertionTarget, type IRCrossRef, type IRDocument, type IREffect, type IRElementCriteria, type IRGroup, type IRMetadata, type IRPairingAxis, type IRPairingPolicy, type IRProvenance, type IRState, type IRStateCondition, type IRTransition, type IRTransitionAction, type IRVersion, type IRVisualRef, type IRWaitSpec, type LegacyAssertion, type LegacyAssertionTarget, type LegacyCriteria, type LegacyGroup, type LegacyMetadata, type LegacyProcessStep, type LegacySpec, type LegacyStateMachine, type LegacyStateMachineState, type LegacyTransition, type ProjectLegacyToIROptions, adaptIRDocumentToWorkflowConfig, adaptIRState, adaptIRTransition, adaptIRTransitionAction, projectIRToBundledPage, projectLegacyToIR, projectionVersion };
+export { type AdaptedState, type AdaptedTransition, type AdaptedTransitionAction, type AdaptedWaitAfter, type AdaptedWorkflowConfig, type IRAcceptDriftPolicy, type IRApiAssertion, type IRApiCheck, type IRAssertion, type IRAssertionTarget, type IRCrossRef, type IRDocument, type IREffect, type IRElementCriteria, type IRGroup, type IRMetadata, type IRPairingAxis, type IRPairingPolicy, type IRProvenance, type IRState, type IRStateCondition, type IRTransition, type IRTransitionAction, type IRVersion, type IRVisualRef, type IRWaitSpec, type LegacyAssertion, type LegacyAssertionTarget, type LegacyCriteria, type LegacyGroup, type LegacyMetadata, type LegacyProcessStep, type LegacySpec, type LegacyStateMachine, type LegacyStateMachineState, type LegacyTransition, type ProjectLegacyToIROptions, adaptIRDocumentToWorkflowConfig, adaptIRState, adaptIRTransition, adaptIRTransitionAction, projectIRToBundledPage, projectLegacyToIR, projectionVersion };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qontinui/shared-types",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Shared TypeScript types for the Qontinui ecosystem",
   "type": "module",
   "main": "./dist/index.js",

package/src/generated/ActionResponse.d.ts

@@ -16,6 +16,25 @@ export interface ActionResponse {
    * Time taken to execute the action in milliseconds.
    */
   durationMs: number;
+  /**
+   * D3 effect-calculus verification: the predicted-vs-observed outcome for
+   * this action, present only when a handler effect signature resolved for
+   * the `(action, element)` (opt-in; absent otherwise).
+   *
+   * Carried as an opaque JSON object on the wire, deliberately matching the
+   * established lean-wire / rich-SDK split (the SDK's `EffectVerification`
+   * has a richer shape than any consumer needs to type). The runner
+   * deserializes the sub-shape it asserts on (`outcome` / `cause` /
+   * `containment` / `durationMs`) with its own local struct in the
+   * `effect_check` step handler, and relays the rest into `result_json`. See
+   * `ui-bridge/.../control/effect-types.ts` for the SDK-side producer. Kept
+   * opaque here so the nested effect types need no top-level codegen
+   * registration (which would couple this crate's bindings to a runner
+   * `schema_export.rs` change).
+   */
+  effectVerification?: {
+    [k: string]: unknown;
+  };
   /**
    * Updated element state after the action (if applicable).
    */

package/src/generated/ApiStyle.d.ts

@@ -0,0 +1,11 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+/**
+ * API style the generated backend exposes.
+ */
+export type ApiStyle = "rest" | "graphql";

package/src/generated/ArchitectureProfile.d.ts

@@ -0,0 +1,25 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+/**
+ * Architectural shape + testing bar the generators must hold to.
+ */
+export interface ArchitectureProfile {
+  /**
+   * Minimum line/branch coverage percentage the generated tests must reach.
+   */
+  minCoveragePct?: number | null;
+  /**
+   * e.g. `"layered"`, `"hexagonal"`, `"mvc"`.
+   */
+  pattern: string;
+  /**
+   * e.g. `"unit"`, `"unit+integration"`, `"unit+integration+e2e"`.
+   */
+  testingBar?: string | null;
+  [k: string]: unknown;
+}

package/src/generated/AssumptionEntry.d.ts

@@ -0,0 +1,32 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+/**
+ * One collated assumption — a node whose provenance is `Assumed`. The operator
+ * reviews/overrides these directly (v0 override surface = a file edit of this
+ * ledger).
+ */
+export interface AssumptionEntry {
+  /**
+   * The best-practice default the generator applied.
+   */
+  defaultApplied: string;
+  /**
+   * Optional free-form operator note (e.g. an override rationale).
+   */
+  note?: string | null;
+  /**
+   * Whether the operator may override this fill. Defaults to `true`.
+   */
+  overridable: boolean;
+  /**
+   * Dotted ref into the spec the assumption belongs to, e.g.
+   * `"operations.createInvoice.effect"`.
+   */
+  ref: string;
+  [k: string]: unknown;
+}

package/src/generated/AuthModel.d.ts

@@ -0,0 +1,24 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { AuthRole } from './AuthRole';
+import type { SpecProvenance } from './SpecProvenance';
+
+/**
+ * The auth / permission model inferred from login flows + gated routes.
+ */
+export interface AuthModel {
+  confidence: SpecProvenance;
+  credibility?: number | null;
+  /**
+   * `"none"`, `"session"`, `"jwt"`, `"oauth"`, `"basic"`, …
+   */
+  model: string;
+  provenance?: string | null;
+  roles?: AuthRole[];
+  [k: string]: unknown;
+}

package/src/generated/AuthRole.d.ts

@@ -0,0 +1,20 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { SpecProvenance } from './SpecProvenance';
+
+/**
+ * A role surfaced by the auth model (e.g. inferred from nav items only some
+ * sessions see).
+ */
+export interface AuthRole {
+  confidence: SpecProvenance;
+  credibility?: number | null;
+  name: string;
+  provenance?: string | null;
+  [k: string]: unknown;
+}

package/src/generated/BackendProfile.d.ts

@@ -0,0 +1,33 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { ApiStyle } from './ApiStyle';
+
+/**
+ * Target backend stack.
+ */
+export interface BackendProfile {
+  apiStyle: ApiStyle;
+  /**
+   * Backend auth strategy (e.g. `"jwt"`, `"session"`). Free-form; `None` lets
+   * the generator default from the spec's observed [`crate::functional_spec::AuthModel`].
+   */
+  auth?: string | null;
+  /**
+   * e.g. `"postgres"`, `"sqlite"`, `"mongodb"`.
+   */
+  datastore: string;
+  /**
+   * e.g. `"fastapi"`, `"express"`, `"axum"`.
+   */
+  framework: string;
+  /**
+   * e.g. `"python"`, `"typescript"`, `"rust"`, `"go"`.
+   */
+  language: string;
+  [k: string]: unknown;
+}

package/src/generated/CompletenessVerdict.d.ts

@@ -0,0 +1,85 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { AssertionMiss } from './AssertionMiss';
+import type { AssertionOutcome } from './AssertionOutcome';
+import type { AssertionResult } from './AssertionResult';
+import type { AssertionSeverityCounts } from './AssertionSeverityCounts';
+import type { BridgeFingerprint } from './BridgeFingerprint';
+import type { CandidateMiss } from './CandidateMiss';
+import type { CoverageGap } from './CoverageGap';
+import type { FieldDiff } from './FieldDiff';
+import type { GapReason } from './GapReason';
+import type { MatchOutcome } from './MatchOutcome';
+import type { MatchedElement } from './MatchedElement';
+import type { MissReason } from './MissReason';
+import type { ProvenanceMix } from './ProvenanceMix';
+import type { RecommendedState } from './RecommendedState';
+import type { SectionVerdict } from './SectionVerdict';
+import type { SpecCheckConfidence } from './SpecCheckConfidence';
+import type { SpecCheckResult } from './SpecCheckResult';
+import type { SpecCheckSummary } from './SpecCheckSummary';
+import type { SpecProvenance } from './SpecProvenance';
+import type { SpecSection } from './SpecSection';
+import type { StateMatchResult } from './StateMatchResult';
+
+/**
+ * The output of the test-phase verify subtask: how completely a generated
+ * app+backend covers the source-observed Functional Spec.
+ *
+ * Serializes as an A2A `DataPart` in `completion_reports.artifacts`. Durable,
+ * fully re-derivable — the reconciler re-reads it each tick.
+ *
+ * Does not derive `PartialEq`: the embedded [`crate::spec_check::SpecCheckResult`]
+ * does not implement it. Compare verdicts by their serialized JSON when needed.
+ */
+export interface CompletenessVerdict {
+  /**
+   * Fraction of `Assumed` nodes the generator filled ∈ [0,1] — reported
+   * **separately**, never folded into `coverage`.
+   */
+  assumedFillRate: number;
+  /**
+   * Overall coverage ∈ [0,1] of `Observed` + `Inferred` nodes confirmed
+   * present-and-behaving. The headline number. (Shared `DriftVerdict` key.)
+   */
+  coverage: number;
+  /**
+   * Mean credibility of `Inferred` nodes ∈ [0,1]. (Shared `DriftVerdict` key.)
+   */
+  credibility: number;
+  /**
+   * ISO-8601 UTC timestamp the verdict was computed.
+   */
+  evaluatedAt: string;
+  /**
+   * The gap work-list — uncovered `Observed`/`Inferred` nodes the reconciler
+   * re-dispatches generation for.
+   */
+  gaps?: CoverageGap[];
+  provenanceMix: ProvenanceMix;
+  /**
+   * Per-section breakdown.
+   */
+  sections?: SectionVerdict[];
+  /**
+   * The `spec_version` of the [`crate::functional_spec::FunctionalSpec`] this
+   * verdict scores.
+   */
+  specVersion: string;
+  /**
+   * Freshness of the binding observation when answered from a cached fallback;
+   * `None` on a fresh live answer. (Shared `DriftVerdict` key.)
+   */
+  stalenessSeconds?: number | null;
+  /**
+   * Embedded Spec-Check result for the `ui_states` / `navigation` dimension —
+   * reused, not recomputed. `None` when the UI dimension was not evaluated.
+   */
+  uiStatesSpecCheck?: SpecCheckResult | null;
+  [k: string]: unknown;
+}

package/src/generated/CoverageGap.d.ts

@@ -0,0 +1,30 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { GapReason } from './GapReason';
+import type { SpecProvenance } from './SpecProvenance';
+import type { SpecSection } from './SpecSection';
+
+/**
+ * One uncovered `Observed`/`Inferred` node — a work-list item the orchestration
+ * reconciler re-dispatches generation for.
+ */
+export interface CoverageGap {
+  /**
+   * Free-form diagnostic detail (e.g. the verifier's near-miss explanation).
+   */
+  detail?: string | null;
+  nodeProvenance: SpecProvenance;
+  reason: GapReason;
+  /**
+   * Dotted ref into the spec, e.g. `"entities.Invoice.fields.amount"` or
+   * `"operations.createInvoice"`.
+   */
+  ref: string;
+  section: SpecSection;
+  [k: string]: unknown;
+}

package/src/generated/EnforcementProfile.d.ts

@@ -0,0 +1,23 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+/**
+ * How the generation loop enforces quality — names existing claude-config skills
+ * to run and which of them are hard blockers.
+ */
+export interface EnforcementProfile {
+  /**
+   * Which categories block the loop on failure (e.g. `["security"]`). A skill
+   * in `run` but not `block_on` is advisory.
+   */
+  blockOn?: string[];
+  /**
+   * Skills to run on generated code (e.g. `["code-reviewer", "security-scan"]`).
+   */
+  run?: string[];
+  [k: string]: unknown;
+}

package/src/generated/Entity.d.ts

@@ -0,0 +1,30 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { EntityField } from './EntityField';
+import type { Relationship } from './Relationship';
+import type { SpecProvenance } from './SpecProvenance';
+
+/**
+ * A domain entity inferred from rendered data shapes.
+ */
+export interface Entity {
+  confidence: SpecProvenance;
+  /**
+   * Optional deduction strength ∈ [0,1]. Present only on `Inferred` nodes;
+   * meaningless (and omitted) on `Observed` / `Assumed`.
+   */
+  credibility?: number | null;
+  fields?: EntityField[];
+  name: string;
+  /**
+   * Free-form evidence string (e.g. `"detail view + list view both render it"`).
+   */
+  provenance?: string | null;
+  relationships?: Relationship[];
+  [k: string]: unknown;
+}

package/src/generated/EntityField.d.ts

@@ -0,0 +1,29 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { SpecProvenance } from './SpecProvenance';
+
+/**
+ * A field of an [`Entity`].
+ */
+export interface EntityField {
+  confidence: SpecProvenance;
+  credibility?: number | null;
+  name: string;
+  provenance?: string | null;
+  /**
+   * Coarse semantic type: `"string"`, `"money"`, `"enum"`, `"date"`,
+   * `"bool"`, `"number"`, `"reference"`, … Free-form so comprehension can
+   * introduce new types without a schema bump.
+   */
+  type: string;
+  /**
+   * Enumerated values when `field_type == "enum"`.
+   */
+  values?: string[];
+  [k: string]: unknown;
+}

package/src/generated/FunctionalSpec.d.ts

@@ -0,0 +1,76 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { AssumptionEntry } from './AssumptionEntry';
+import type { AuthModel } from './AuthModel';
+import type { AuthRole } from './AuthRole';
+import type { Entity } from './Entity';
+import type { EntityField } from './EntityField';
+import type { IrAssertion } from './IrAssertion';
+import type { IrAssertionTarget } from './IrAssertionTarget';
+import type { IrCrossRef } from './IrCrossRef';
+import type { IrElementCriteria } from './IrElementCriteria';
+import type { IrMetadata } from './IrMetadata';
+import type { IrProvenance } from './IrProvenance';
+import type { IrState } from './IrState';
+import type { IrStateCondition } from './IrStateCondition';
+import type { IrTransition } from './IrTransition';
+import type { IrTransitionAction } from './IrTransitionAction';
+import type { IrWaitSpec } from './IrWaitSpec';
+import type { Operation } from './Operation';
+import type { OperationEffect } from './OperationEffect';
+import type { OperationInput } from './OperationInput';
+import type { ProposalStatus } from './ProposalStatus';
+import type { Relationship } from './Relationship';
+import type { SpecProvenance } from './SpecProvenance';
+import type { SpecTarget } from './SpecTarget';
+import type { ValidationRule } from './ValidationRule';
+
+/**
+ * The v0 Functional Spec. Five sections, each node confidence- and
+ * provenance-tagged. Serializes as an A2A `DataPart` inside a worker's
+ * `completion_reports.artifacts`; it is the durable, fully re-derivable
+ * hand-off artifact between conductor ticks (orchestration handoff contract §6).
+ */
+export interface FunctionalSpec {
+  /**
+   * Section (5) ASSUMPTIONS LEDGER — every node with provenance `Assumed`, collated so
+   * the operator can review/override the generator's best-practice fills. For
+   * v0 the override surface is a direct edit of this ledger (`overridable`).
+   */
+  assumptions?: AssumptionEntry[];
+  /**
+   * Section (4) AUTH / PERMISSION MODEL — from login flows + gated routes.
+   */
+  auth?: AuthModel | null;
+  /**
+   * Section (1) DOMAIN — entities + relationships inferred from rendered data shapes.
+   */
+  entities?: Entity[];
+  /**
+   * Section (3b) NAVIGATION — the exact `crate::ir::IrTransition` values
+   * `IrPageSpec.transitions` carries. Reused (not re-declared) so app-gen's
+   * emitted IR re-parses to the identical spec subset.
+   */
+  navigation?: IrTransition[];
+  /**
+   * Section (2) CAPABILITIES — operations the frontend exposes. Existence is
+   * high-confidence; server-side effect is low-confidence by construction.
+   */
+  operations?: Operation[];
+  /**
+   * Schema version. Currently always `"0"`. Additive-only until `"1"`.
+   */
+  specVersion: string;
+  target: SpecTarget;
+  /**
+   * Section (3a) UI STATES — a literal superset of the UI Bridge IR. These are the
+   * exact `crate::ir::IrState` values `IrPageSpec.states` carries.
+   */
+  uiStates?: IrState[];
+  [k: string]: unknown;
+}

package/src/generated/GapReason.d.ts

@@ -0,0 +1,12 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+/**
+ * Why an `Observed`/`Inferred` node is not covered in the generated app.
+ * (`Assumed` nodes never produce a gap — they are reported via the fill rate.)
+ */
+export type GapReason = "not_generated" | "behavior_mismatch" | "unverifiable";

package/src/generated/IrPageSpec.d.ts

@@ -27,6 +27,12 @@ import type { ProposalStatus } from './ProposalStatus';
  * surface — the projection layer derives the runtime `LegacySpec` from this.
  */
 export interface IrPageSpec {
+  /**
+   * Per-page API-contract assertions evaluated by the Spec CI harness.
+   * Phase 1: value-level assertions (status_code, json_path, header,
+   * body_contains, response_time). Phase 2 will add schema conformance.
+   */
+  apiAssertions?: IrApiCheck[] | null;
   description?: string | null;
   id: string;
   initialState?: string | null;

package/src/generated/LoopPhase.d.ts

@@ -21,6 +21,9 @@ export type LoopPhase =
   | "waiting_for_runner"
   | "stall_detecting"
   | "planning"
+  | "dispatching_worker"
+  | "reconciling"
+  | "elaborating"
   | "complete"
   | "stopped"
   | "error";

package/src/generated/Operation.d.ts

@@ -0,0 +1,37 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { OperationEffect } from './OperationEffect';
+import type { OperationInput } from './OperationInput';
+import type { SpecProvenance } from './SpecProvenance';
+import type { ValidationRule } from './ValidationRule';
+
+/**
+ * An operation the frontend exposes. Existence (`confidence`) is typically
+ * `Observed`; the server-side [`OperationEffect`] is `Assumed` by construction
+ * (the frontend cannot reveal what persists server-side).
+ */
+export interface Operation {
+  confidence: SpecProvenance;
+  credibility?: number | null;
+  /**
+   * The (largely assumed) server-side effect.
+   */
+  effect?: OperationEffect | null;
+  /**
+   * Target entity, when the operation acts on one.
+   */
+  entity?: string | null;
+  inputs?: OperationInput[];
+  name: string;
+  provenance?: string | null;
+  /**
+   * `"create"`, `"read"`, `"update"`, `"delete"`, `"custom"`.
+   */
+  verb: string;
+  [k: string]: unknown;
+}

package/src/generated/OperationEffect.d.ts

@@ -0,0 +1,24 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { SpecProvenance } from './SpecProvenance';
+
+/**
+ * The server-side effect of an [`Operation`]. `Assumed` by construction; the
+ * `assumption` field records the best-practice default the generator applied.
+ */
+export interface OperationEffect {
+  /**
+   * The best-practice default applied when `confidence == Assumed`
+   * (e.g. `"persists + returns created row (REST 201 default)"`).
+   */
+  assumption?: string | null;
+  confidence: SpecProvenance;
+  credibility?: number | null;
+  provenance?: string | null;
+  [k: string]: unknown;
+}

package/src/generated/OperationInput.d.ts

@@ -0,0 +1,25 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { SpecProvenance } from './SpecProvenance';
+import type { ValidationRule } from './ValidationRule';
+
+/**
+ * One input of an [`Operation`].
+ */
+export interface OperationInput {
+  /**
+   * Field name (usually maps to an [`EntityField::name`]).
+   */
+  field: string;
+  required: boolean;
+  /**
+   * Client-side validation rule observed on the input, when any.
+   */
+  validation?: ValidationRule | null;
+  [k: string]: unknown;
+}

package/src/generated/Profile.d.ts

@@ -0,0 +1,37 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { ApiStyle } from './ApiStyle';
+import type { ArchitectureProfile } from './ArchitectureProfile';
+import type { BackendProfile } from './BackendProfile';
+import type { EnforcementProfile } from './EnforcementProfile';
+
+/**
+ * The top-level Priorities Profile.
+ */
+export interface Profile {
+  architecture: ArchitectureProfile;
+  backend: BackendProfile;
+  /**
+   * Naming / mapping conventions, as free-form `key -> value` pairs (e.g.
+   * `"naming" -> "snake_case"`, `"entityToTable" -> "pluralize"`). A `BTreeMap`
+   * so JSON serialization is deterministic. Open-ended by design so a profile
+   * can express conventions the schema didn't anticipate.
+   */
+  conventions?: {
+    [k: string]: string;
+  };
+  /**
+   * How the generation loop enforces quality.
+   */
+  enforcement?: EnforcementProfile | null;
+  /**
+   * Schema version. Currently always `"0"`. Additive-only until `"1"`.
+   */
+  profileVersion: string;
+  [k: string]: unknown;
+}

package/src/generated/ProvenanceMix.d.ts

@@ -0,0 +1,18 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+/**
+ * Count of nodes by provenance, within a section or overall. The
+ * `observed + inferred` sum is the coverage denominator; `assumed` is tracked
+ * separately for the assumption-fill rate.
+ */
+export interface ProvenanceMix {
+  assumed: number;
+  inferred: number;
+  observed: number;
+  [k: string]: unknown;
+}

package/src/generated/Relationship.d.ts

@@ -0,0 +1,26 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { SpecProvenance } from './SpecProvenance';
+
+/**
+ * A relationship from one entity to another.
+ */
+export interface Relationship {
+  confidence: SpecProvenance;
+  credibility?: number | null;
+  /**
+   * `"one-to-one"`, `"one-to-many"`, `"many-to-one"`, `"many-to-many"`.
+   */
+  kind: string;
+  provenance?: string | null;
+  /**
+   * Target entity name.
+   */
+  to: string;
+  [k: string]: unknown;
+}

package/src/generated/SectionVerdict.d.ts

@@ -0,0 +1,35 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { ProvenanceMix } from './ProvenanceMix';
+import type { SpecSection } from './SpecSection';
+
+/**
+ * Per-section coverage breakdown. Mirrors the overall-verdict shape so a consumer
+ * can render the same widget at either granularity.
+ */
+export interface SectionVerdict {
+  /**
+   * Fraction of this section's `assumed` nodes the generator filled.
+   */
+  assumedFillRate: number;
+  /**
+   * `numerator / denominator` for this section (`1.0` when denominator is 0).
+   */
+  coverage: number;
+  /**
+   * Mean credibility of this section's `inferred` nodes (∈ [0,1]).
+   */
+  credibility: number;
+  provenanceMix: ProvenanceMix;
+  section: SpecSection;
+  /**
+   * Freshness of the binding observation, when answered from a cached fallback.
+   */
+  stalenessSeconds?: number | null;
+  [k: string]: unknown;
+}

package/src/generated/SpecProvenance.d.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+/**
+ * How a spec node was established, relative to what the frontend *reveals*.
+ *
+ * Named `SpecProvenance` (not `Confidence`) to stay distinct from the
+ * match-confidence axis `crate::spec_check::Confidence`
+ * (`high`/`medium`/`low`), which is orthogonal: that one scores how well an
+ * observed element matched an assertion; this one scores how the spec node
+ * itself was derived from observation.
+ *
+ * The three buckets keep the coverage accounting split crisp: the rubric's
+ * denominator is `Observed + Inferred`; `Assumed` is reported separately as
+ * an assumption-fill rate and never folded into the headline coverage number.
+ */
+export type SpecProvenance = "observed" | "inferred" | "assumed";

package/src/generated/SpecSection.d.ts

@@ -0,0 +1,11 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+/**
+ * The five scorable sections of a [`crate::functional_spec::FunctionalSpec`].
+ */
+export type SpecSection = "entities" | "operations" | "uiStates" | "navigation" | "auth";

package/src/generated/SpecTarget.d.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+/**
+ * What was observed and when.
+ */
+export interface SpecTarget {
+  /**
+   * ISO-8601 UTC timestamp; stamped post-run when the observation completed.
+   */
+  observedAt?: string | null;
+  /**
+   * The source website URL the spec was synthesized from.
+   */
+  sourceUrl: string;
+  [k: string]: unknown;
+}

package/src/generated/UiBridgeHttpErrorEnvelope.d.ts

@@ -0,0 +1,47 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+/**
+ * Canonical error envelope for the qontinui-web Next.js UI-Bridge proxy.
+ *
+ * The catch-all route at
+ * `qontinui-web/frontend/src/app/api/ui-bridge/[...path]/route.ts`
+ * short-circuits requests the SDK would otherwise 404 on — and the
+ * browser-required routes that can't respond without a live SDK client —
+ * to a structured HTTP 503 with this body
+ * (`route.ts::noBrowserResponse`):
+ *
+ * ```json
+ * { "success": false, "code": "NO_BROWSER_CONNECTED",
+ *   "message": "<path> requires a browser SDK client" }
+ * ```
+ *
+ * Modeled as a *generic* error envelope rather than a one-off
+ * `NoBrowserConnected` type: the `{success:false, code, message}` shape is
+ * the canonical structured-error contract for the whole proxy surface (not
+ * just the no-browser path), so a single reusable type is the more
+ * scalable and cleaner home. `code` stays a free-form `String` — the
+ * discriminator set (currently just `NO_BROWSER_CONNECTED`) is expected to
+ * grow, and pinning it to an enum here would force a schemas release on every
+ * new proxy error code. `success` is always `false` on this envelope (the
+ * success path uses [`UiBridgeHttpHealthEnvelope`] / the SDK's own envelopes).
+ */
+export interface UiBridgeHttpErrorEnvelope {
+  /**
+   * Machine-readable error discriminator (e.g. `"NO_BROWSER_CONNECTED"`).
+   */
+  code: string;
+  /**
+   * Human-readable explanation (e.g. `"<path> requires a browser SDK client"`).
+   */
+  message: string;
+  /**
+   * Always `false` — this envelope is only emitted on the error path.
+   */
+  success: boolean;
+  [k: string]: unknown;
+}

package/src/generated/UiBridgeHttpHealthAppInfo.d.ts

@@ -0,0 +1,36 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+/**
+ * UI-Bridge metadata block included in the health envelope for the app
+ * discovery scanner. Spread of `config.appInfo` plus a fixed `capabilities`
+ * list. Present only when the server is configured with `appInfo` (the
+ * qontinui-web proxy always is — `route.ts` sets `appId: "qontinui-web"`).
+ */
+export interface UiBridgeHttpHealthAppInfo {
+  /**
+   * Stable app identifier (e.g. `"qontinui-web"`).
+   */
+  appId: string;
+  /**
+   * Human-readable app name.
+   */
+  appName: string;
+  /**
+   * App surface type (e.g. `"web"`).
+   */
+  appType: string;
+  /**
+   * Advertised UI-Bridge capabilities (e.g. `["control","renderLog","debug"]`).
+   */
+  capabilities: string[];
+  /**
+   * UI framework (e.g. `"nextjs"`).
+   */
+  framework: string;
+  [k: string]: unknown;
+}

package/src/generated/UiBridgeHttpHealthData.d.ts

@@ -0,0 +1,30 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+/**
+ * Inner `data` payload of the UI-Bridge SDK HTTP health envelope.
+ *
+ * Emitted by the SDK's relay-transport handler for `GET /health`
+ * (`@qontinui/ui-bridge/server` `handleRelayRoute`, `nextjs.ts`): the
+ * `responsive` + `lastHeartbeat` fields plus a spread of the relay's
+ * `TransportDiagnostics`. Only `responsive` and `lastHeartbeat` are modeled
+ * explicitly here — the diagnostics spread (pendingCommandCount, connectedTabs,
+ * buildId, …) is intentionally left open (no `additionalProperties: false`,
+ * which schemars omits by default) so the diagnostics surface can evolve
+ * without a schemas release while the two stable health signals stay typed.
+ */
+export interface UiBridgeHttpHealthData {
+  /**
+   * Max heartbeat timestamp (ms since epoch) across all tabs; `0` when none.
+   */
+  lastHeartbeat: number;
+  /**
+   * True when at least one connected tab has a fresh heartbeat.
+   */
+  responsive: boolean;
+  [k: string]: unknown;
+}

package/src/generated/UiBridgeHttpHealthEnvelope.d.ts

@@ -0,0 +1,44 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { UiBridgeHttpHealthAppInfo } from './UiBridgeHttpHealthAppInfo';
+import type { UiBridgeHttpHealthData } from './UiBridgeHttpHealthData';
+
+/**
+ * Canonical success envelope for `GET /api/ui-bridge/health`.
+ *
+ * Distinct from [`UiBridgeResponseEnvelope`]: the HTTP health envelope has
+ * no `requestId` / `type`, and carries an app-discovery `uiBridge` block.
+ * Wire shape (`nextjs.ts::handleRelayRoute`):
+ *
+ * ```json
+ * { "success": true,
+ *   "data": { "responsive": false, "lastHeartbeat": 0, ...diagnostics },
+ *   "timestamp": 1713200000000,
+ *   "uiBridge": { "appId": "qontinui-web", ..., "capabilities": [...] } }
+ * ```
+ *
+ * `uiBridge` is optional (omitted when the server has no `appInfo`); the
+ * other three fields are always present.
+ */
+export interface UiBridgeHttpHealthEnvelope {
+  data: UiBridgeHttpHealthData;
+  /**
+   * Always `true` on the health path.
+   */
+  success: boolean;
+  /**
+   * Server-side timestamp (ms since epoch) of when the response was produced.
+   */
+  timestamp: number;
+  /**
+   * App-discovery metadata; present only when the server is configured
+   * with `appInfo`.
+   */
+  uiBridge?: UiBridgeHttpHealthAppInfo | null;
+  [k: string]: unknown;
+}

package/src/generated/ValidationRule.d.ts

@@ -0,0 +1,22 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with `just generate-types` or
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { SpecProvenance } from './SpecProvenance';
+
+/**
+ * A client-side validation rule observed on an input.
+ */
+export interface ValidationRule {
+  confidence: SpecProvenance;
+  credibility?: number | null;
+  provenance?: string | null;
+  /**
+   * The rule expression as observed (e.g. `"> 0"`, `"email"`, `"maxLength 80"`).
+   */
+  rule: string;
+  [k: string]: unknown;
+}

package/src/generated/index.ts

@@ -25,17 +25,23 @@ export type { ApiAssertion } from './ApiAssertion';
 export type { ApiAssertionOperator } from './ApiAssertionOperator';
 export type { ApiAssertionType } from './ApiAssertionType';
 export type { ApiContentType } from './ApiContentType';
+export type { ApiStyle } from './ApiStyle';
 export type { ApiVariableExtraction } from './ApiVariableExtraction';
 export type { App } from './App';
 export type { AppError } from './AppError';
 export type { AppEvent } from './AppEvent';
 export type { AppListResponse } from './AppListResponse';
+export type { ArchitectureProfile } from './ArchitectureProfile';
 export type { AssertionMiss } from './AssertionMiss';
 export type { AssertionOutcome } from './AssertionOutcome';
 export type { AssertionResult } from './AssertionResult';
 export type { AssertionScope } from './AssertionScope';
 export type { AssertionSeverityCounts } from './AssertionSeverityCounts';
+export type { AssumptionEntry } from './AssumptionEntry';
+export type { AuthModel } from './AuthModel';
+export type { AuthRole } from './AuthRole';
 export type { AvailableTransitionsResult } from './AvailableTransitionsResult';
+export type { BackendProfile } from './BackendProfile';
 export type { BaseStepFields } from './BaseStepFields';
 export type { BatchComputeEmbeddingRequest } from './BatchComputeEmbeddingRequest';
 export type { BatchComputeEmbeddingResponse } from './BatchComputeEmbeddingResponse';
@@ -56,6 +62,7 @@ export type { CodeExecutionStep } from './CodeExecutionStep';
 export type { CommandMode } from './CommandMode';
 export type { CommandStep } from './CommandStep';
 export type { CommandStepPhase } from './CommandStepPhase';
+export type { CompletenessVerdict } from './CompletenessVerdict';
 export type { ComponentActionInfo } from './ComponentActionInfo';
 export type { ComponentActionRequest } from './ComponentActionRequest';
 export type { ComputeEmbeddingRequest } from './ComputeEmbeddingRequest';
@@ -81,6 +88,7 @@ export type { Coordinates } from './Coordinates';
 export type { CostTrendDataPoint } from './CostTrendDataPoint';
 export type { CostTrendResponse } from './CostTrendResponse';
 export type { CoverageData } from './CoverageData';
+export type { CoverageGap } from './CoverageGap';
 export type { CreateMcpCallInput } from './CreateMcpCallInput';
 export type { CreateMcpServerInput } from './CreateMcpServerInput';
 export type { CreateOlConfigRequest } from './CreateOlConfigRequest';
@@ -122,6 +130,9 @@ export type { EmbeddingListResponse } from './EmbeddingListResponse';
 export type { EmbeddingResultItem } from './EmbeddingResultItem';
 export type { EmbeddingResultsRequest } from './EmbeddingResultsRequest';
 export type { EmbeddingResultsResponse } from './EmbeddingResultsResponse';
+export type { EnforcementProfile } from './EnforcementProfile';
+export type { Entity } from './Entity';
+export type { EntityField } from './EntityField';
 export type { ErrorType } from './ErrorType';
 export type { ExecutePlaybookStep } from './ExecutePlaybookStep';
 export type { ExecutionActionType } from './ExecutionActionType';
@@ -169,7 +180,9 @@ export type { FindingUserInput } from './FindingUserInput';
 export type { FindingsSummary } from './FindingsSummary';
 export type { FlowEvent } from './FlowEvent';
 export type { FullRunnerStep } from './FullRunnerStep';
+export type { FunctionalSpec } from './FunctionalSpec';
 export type { GUIElementChunk } from './GUIElementChunk';
+export type { GapReason } from './GapReason';
 export type { GateEvaluationResult } from './GateEvaluationResult';
 export type { GitOpListResponse } from './GitOpListResponse';
 export type { GitOpRecord } from './GitOpRecord';
@@ -259,6 +272,9 @@ export type { NodeStatus } from './NodeStatus';
 export type { NodeType } from './NodeType';
 export type { OcrEngine } from './OcrEngine';
 export type { OlConfig } from './OlConfig';
+export type { Operation } from './Operation';
+export type { OperationEffect } from './OperationEffect';
+export type { OperationInput } from './OperationInput';
 export type { OrchestrationLoopConfig } from './OrchestrationLoopConfig';
 export type { OrchestrationLoopStatus } from './OrchestrationLoopStatus';
 export type { Outcome } from './Outcome';
@@ -283,9 +299,11 @@ export type { PollingConfig } from './PollingConfig';
 export type { ProcessConfig } from './ProcessConfig';
 export type { ProcessState } from './ProcessState';
 export type { ProcessStatus } from './ProcessStatus';
+export type { Profile } from './Profile';
 export type { PromptStep } from './PromptStep';
 export type { PromptStepPhase } from './PromptStepPhase';
 export type { ProposalStatus } from './ProposalStatus';
+export type { ProvenanceMix } from './ProvenanceMix';
 export type { RAGDashboardStats } from './RAGDashboardStats';
 export type { RagCompletionEvent } from './RagCompletionEvent';
 export type { RagProcessingStatus } from './RagProcessingStatus';
@@ -297,6 +315,7 @@ export type { RecordGitOpRequest } from './RecordGitOpRequest';
 export type { ReflectionFixOutput } from './ReflectionFixOutput';
 export type { Region } from './Region';
 export type { RegisterAppRequest } from './RegisterAppRequest';
+export type { Relationship } from './Relationship';
 export type { RepositoryInactiveCondition } from './RepositoryInactiveCondition';
 export type { RepositoryWatch } from './RepositoryWatch';
 export type { ResolvedInitialStates } from './ResolvedInitialStates';
@@ -340,6 +359,7 @@ export type { ScrollDirection } from './ScrollDirection';
 export type { SearchOptions } from './SearchOptions';
 export type { SearchResultItem } from './SearchResultItem';
 export type { SearchStrategy } from './SearchStrategy';
+export type { SectionVerdict } from './SectionVerdict';
 export type { SemanticSearchRequest } from './SemanticSearchRequest';
 export type { SemanticSearchResponse } from './SemanticSearchResponse';
 export type { SpecApiEvent } from './SpecApiEvent';
@@ -348,6 +368,9 @@ export type { SpecCheckPolicy } from './SpecCheckPolicy';
 export type { SpecCheckResult } from './SpecCheckResult';
 export type { SpecCheckStepConfig } from './SpecCheckStepConfig';
 export type { SpecCheckSummary } from './SpecCheckSummary';
+export type { SpecProvenance } from './SpecProvenance';
+export type { SpecSection } from './SpecSection';
+export type { SpecTarget } from './SpecTarget';
 export type { SpecValidation } from './SpecValidation';
 export type { StageCondition } from './StageCondition';
 export type { StageInput } from './StageInput';
@@ -445,6 +468,10 @@ export type { UiBridgeAction } from './UiBridgeAction';
 export type { UiBridgeAssertType } from './UiBridgeAssertType';
 export type { UiBridgeComparisonMode } from './UiBridgeComparisonMode';
 export type { UiBridgeDesignAuditStep } from './UiBridgeDesignAuditStep';
+export type { UiBridgeHttpErrorEnvelope } from './UiBridgeHttpErrorEnvelope';
+export type { UiBridgeHttpHealthAppInfo } from './UiBridgeHttpHealthAppInfo';
+export type { UiBridgeHttpHealthData } from './UiBridgeHttpHealthData';
+export type { UiBridgeHttpHealthEnvelope } from './UiBridgeHttpHealthEnvelope';
 export type { UiBridgeRequestEnvelope } from './UiBridgeRequestEnvelope';
 export type { UiBridgeResponseEnvelope } from './UiBridgeResponseEnvelope';
 export type { UiBridgeSeverity } from './UiBridgeSeverity';
@@ -459,6 +486,7 @@ export type { UpdateOlConfigRequest } from './UpdateOlConfigRequest';
 export type { UpdateScheduledTaskRequest } from './UpdateScheduledTaskRequest';
 export type { ValidateConfigRequest } from './ValidateConfigRequest';
 export type { ValidateConfigResponse } from './ValidateConfigResponse';
+export type { ValidationRule } from './ValidationRule';
 export type { VectorSearchResult } from './VectorSearchResult';
 export type { VerificationAgentContext } from './VerificationAgentContext';
 export type { VerificationCategoryKind } from './VerificationCategoryKind';

package/src/ui-bridge-ir/document.ts

@@ -111,4 +111,39 @@ export interface IRDocument {
 
   /** ID of the initial/starting state, if applicable. */
   initialState?: string;
+
+  /** Per-page API-contract assertions evaluated by the Spec CI harness. */
+  apiAssertions?: IRApiCheck[];
 }
+
+// ---------------------------------------------------------------------------
+// API-contract checks (Spec CI harness)
+// ---------------------------------------------------------------------------
+
+/**
+ * A single API-contract check: issue a request, validate the response.
+ */
+export interface IRApiCheck {
+  id: string;
+  description?: string;
+  request: {
+    method: string;
+    path: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+  };
+  effect?: "read" | "write" | "destructive";
+  assertions: IRApiAssertion[];
+}
+
+/**
+ * API assertion: either a value-level assertion (status_code, json_path, etc.)
+ * or a schema-conformance assertion (conforms_to -- Phase 2 placeholder).
+ */
+export type IRApiAssertion =
+  | { type: "status_code"; expected: unknown; operator?: string }
+  | { type: "json_path"; jsonPath: string; expected: unknown; operator?: string }
+  | { type: "header"; headerName: string; expected: unknown; operator?: string }
+  | { type: "body_contains"; expected: unknown }
+  | { type: "response_time"; expected: unknown; operator?: string }
+  | { type: "conforms_to"; schema: string };