@unbrained/pm-cli 2026.10.14 → 2026.10.17

package/dist/sdk/governance/assurance.d.ts

@@ -1,9 +1,9 @@
 /** Current serialized assurance registry format. */
-export declare const ASSURANCE_DOCUMENT_VERSION: 1;
+export declare const ASSURANCE_DOCUMENT_VERSION:1;
 /** Supported lifecycle points that can evaluate a gate. */
-export declare const ASSURANCE_GATE_TRIGGERS: readonly ["pre-commit", "pre-push", "pre-merge", "ci", "pre-release", "post-release", "scheduled", "on-claim", "on-close"];
+export declare const ASSURANCE_GATE_TRIGGERS:readonly ["pre-commit","pre-push","pre-merge","ci","pre-release","post-release","scheduled","on-claim","on-close"];
 /** Supported discriminants for built-in, delegated, and derived measurements. */
-export declare const ASSURANCE_MEASUREMENT_SOURCE_KINDS: readonly ["items", "dependency_kind", "prose_edge_gap", "graph", "validate", "health", "history", "links", "provider", "derived"];
+export declare const ASSURANCE_MEASUREMENT_SOURCE_KINDS:readonly ["items","dependency_kind","prose_edge_gap","graph","validate","health","history","links","provider","derived"];
 /** Gate lifecycle trigger. */
 export type AssuranceGateTrigger = (typeof ASSURANCE_GATE_TRIGGERS)[number];
 /** Assertion enforcement strength. */
@@ -17,444 +17,444 @@ export type AssuranceValue = number | string[];
 /** Minimal dependency row used by built-in relationship measurements. */
 export interface AssuranceDependencyRecord {
 /** Target item id. */
-id: string;
+id:string;
 /** Typed relationship kind. */
-kind: string;
+kind:string;
 /** Provenance channel that created or justified the edge. */
-source_kind?: string;
+source_kind?:string;
 }
 /** Minimal item projection consumed by built-in measurement sources. */
 export interface AssuranceItemRecord {
 /** Stable item id. */
-id: string;
+id:string;
 /** Lifecycle status. */
-status: string;
+status:string;
 /** Item type. */
-type: string;
+type:string;
 /** Optional tags. */
-tags?: string[];
+tags?:string[];
 /** Optional priority. */
-priority?: string | number;
+priority?:string | number;
 /** Typed relationships. */
-dependencies?: AssuranceDependencyRecord[];
+dependencies?:AssuranceDependencyRecord[];
 /** Linked files. */
-files?: object[];
+files?:object[];
 /** Linked tests. */
-tests?: object[];
+tests?:object[];
 /** Linked docs. */
-docs?: object[];
+docs?:object[];
 /** Extension-owned metadata remains filterable. */
-[key: string]: unknown;
+[key:string]:unknown;
 }
 /** Minimal immutable-history row consumed by history measurements. */
 export interface AssuranceHistoryRecord {
 /** Mutation operation. */
-op: string;
+op:string;
 /** Mutation author. */
-author: string;
+author:string;
 /** Optional detected harness. */
-agent_harness?: string;
+agent_harness?:string;
 /** Optional detected model. */
-agent_model?: string;
+agent_model?:string;
 /** Extensible history metadata. */
-[key: string]: unknown;
+[key:string]:unknown;
 }
 /** Item-population measurement source. */
 export interface AssuranceItemsSource {
 /** Source discriminant. */
-kind: "items";
+kind:"items";
 /** Allowed statuses. */
-statuses?: string[];
+statuses?:string[];
 /** Allowed item types. */
-types?: string[];
+types?:string[];
 /** Tags that must all be present. */
-tags?: string[];
+tags?:string[];
 /** Optional metadata field. */
-field?: string;
+field?:string;
 /** Required exact value for field. */
-equals?: string | number | boolean | null;
+equals?:string | number | boolean | null;
 /** Presence predicate for the selected field. */
-state?: "present" | "missing";
+state?:"present" | "missing";
 }
 /** Typed relationship-count source. */
 export interface AssuranceDependencyKindSource {
 /** Source discriminant. */
-kind: "dependency_kind";
+kind:"dependency_kind";
 /** Relationship kind to count. */
-dependency_kind: string;
+dependency_kind:string;
 /** Require an exact dependency provenance channel. */
-source_kind?: string;
+source_kind?:string;
 /** Require a dependency provenance channel with this prefix. */
-source_kind_prefix?: string;
+source_kind_prefix?:string;
 /** Require dependency provenance to be present or missing. */
-source_kind_state?: "present" | "missing";
+source_kind_state?:"present" | "missing";
 }
 /** Evidence-backed exemption from prose-to-edge parity. */
 export interface AssuranceProseEdgeExemption {
 /** Holder whose prose contains the reference. */
-holder_id: string;
+holder_id:string;
 /** Optional referenced item; omission exempts every matching pair on the holder. */
-target_id?: string;
+target_id?:string;
 /** Optional literal that must occur in the same prose segment as the reference. */
-text_contains?: string;
+text_contains?:string;
 /** Reviewable explanation for why no typed edge should exist. */
-reason: string;
+reason:string;
 }
 /** Prose-reference parity source evaluated directly over authoritative item rows. */
 export interface AssuranceProseEdgeGapSource {
 /** Source discriminant. */
-kind: "prose_edge_gap";
+kind:"prose_edge_gap";
 /** Explicit false-positive ledger; every row requires a reason. */
-exemptions?: AssuranceProseEdgeExemption[];
+exemptions?:AssuranceProseEdgeExemption[];
 /** Maximum diagnostic contributors retained after the counts are computed. */
-sample_limit?: number;
+sample_limit?:number;
 }
 /** Graph-analytics source delegated to a host adapter. */
 export interface AssuranceGraphSource {
 /** Source discriminant. */
-kind: "graph";
+kind:"graph";
 /** Graph analytic to execute. */
-operation: string;
+operation:string;
 /** Numeric or labelled-set field to select. */
-field: string;
+field:string;
 /** Optional analytic arguments. */
-parameters?: Record<string, string | number | boolean>;
+parameters?:Record<string,string | number | boolean>;
 }
 /** Validator source delegated to a host adapter. */
 export interface AssuranceValidateSource {
 /** Source discriminant. */
-kind: "validate";
+kind:"validate";
 /** Stable validator check id. */
-check: string;
+check:string;
 /** Numeric field within the check result. */
-field: string;
+field:string;
 }
 /** Health-check source delegated to a host adapter. */
 export interface AssuranceHealthSource {
 /** Source discriminant. */
-kind: "health";
+kind:"health";
 /** Stable health check id. */
-check: string;
+check:string;
 /** Numeric field within the check result. */
-field: string;
+field:string;
 }
 /** Immutable-history population source. */
 export interface AssuranceHistorySource {
 /** Source discriminant. */
-kind: "history";
+kind:"history";
 /** Optional operation filter. */
-op?: string;
+op?:string;
 /** Optional author filter. */
-author?: string;
+author?:string;
 /** Optional harness filter. */
-harness?: string;
+harness?:string;
 /** Optional model filter. */
-model?: string;
+model?:string;
 }
 /** Linked evidence population source. */
 export interface AssuranceLinksSource {
 /** Source discriminant. */
-kind: "links";
+kind:"links";
 /** Evidence collection to inspect. */
-link: "files" | "tests" | "docs";
+link:"files" | "tests" | "docs";
 /** Count items with or without at least one link. */
-state: "present" | "missing";
+state:"present" | "missing";
 }
 /** Extension- or host-contributed measurement source. */
 export interface AssuranceProviderSource {
 /** Source discriminant. */
-kind: "provider";
+kind:"provider";
 /** Stable provider id. */
-provider: string;
+provider:string;
 /** Provider-owned measurement key. */
-key: string;
+key:string;
 /** Provider-owned JSON-compatible parameters. */
-parameters?: Record<string, string | number | boolean | null>;
+parameters?:Record<string,string | number | boolean | null>;
 }
 /** Reference to another measurement inside a derived expression. */
 export interface AssuranceMeasurementReference {
 /** Referenced measurement id. */
-measurement: string;
+measurement:string;
 }
 /** Literal numeric term inside a derived expression. */
 export interface AssuranceLiteralExpression {
 /** Literal number. */
-literal: number;
+literal:number;
 }
 /** Arithmetic expression over measurement references and literals. */
 export interface AssuranceArithmeticExpression {
 /** Deterministic arithmetic operation. */
-operator: "add" | "subtract" | "multiply" | "divide" | "min" | "max";
+operator:"add" | "subtract" | "multiply" | "divide" | "min" | "max";
 /** Ordered operands. */
-operands: AssuranceDerivedExpression[];
+operands:AssuranceDerivedExpression[];
 }
 /** Recursive derived-measurement expression. */
 export type AssuranceDerivedExpression = AssuranceMeasurementReference | AssuranceLiteralExpression | AssuranceArithmeticExpression;
 /** Derived arithmetic source. */
 export interface AssuranceDerivedSource {
 /** Source discriminant. */
-kind: "derived";
+kind:"derived";
 /** Arithmetic expression. */
-expression: AssuranceDerivedExpression;
+expression:AssuranceDerivedExpression;
 }
 /** Complete measurement source vocabulary. */
 export type AssuranceMeasurementSource = AssuranceItemsSource | AssuranceDependencyKindSource | AssuranceProseEdgeGapSource | AssuranceGraphSource | AssuranceValidateSource | AssuranceHealthSource | AssuranceHistorySource | AssuranceLinksSource | AssuranceProviderSource | AssuranceDerivedSource;
 /** Persisted measurement declaration. */
 export interface AssuranceMeasurementDefinition {
 /** Stable registry id. */
-id: string;
+id:string;
 /** Optional intent description. */
-description?: string;
+description?:string;
 /** Measurement source. */
-source: AssuranceMeasurementSource;
+source:AssuranceMeasurementSource;
 /** Maximum abstract compute units accepted for one evaluation. */
-max_cost?: number;
+max_cost?:number;
 }
 /** Explicit population scope asserted by a bound. */
 export type AssuranceScope = {
-kind: "all";
+kind:"all";
 } | {
-kind: "active";
+kind:"active";
 } | {
 /** Scope discriminant. */
-kind: "filter";
+kind:"filter";
 /** Saved measurement whose population defines the scope. */
-measurement_id: string;
+measurement_id:string;
 };
 /** One assertion negative-control case. */
 export interface AssuranceNegativeControlCase {
 /** Synthetic observation. */
-observed: AssuranceValue;
+observed:AssuranceValue;
 /** Expected comparator result. */
-expected: "pass" | "fail";
+expected:"pass" | "fail";
 }
 /** Required negative-control suite proving a bound can both pass and fail. */
 export interface AssuranceNegativeControl {
 /** Synthetic comparator cases. */
-cases: AssuranceNegativeControlCase[];
+cases:AssuranceNegativeControlCase[];
 }
 /** Persisted assertion declaration. Exactly one polarity field is valid. */
 export interface AssuranceAssertionDefinition {
 /** Stable registry id. */
-id: string;
+id:string;
 /** Registry key of the observation constrained by this guarantee. */
-measurement_id: string;
+measurement_id:string;
 /** pm item that owns this guarantee. */
-owner_item_id: string;
+owner_item_id:string;
 /** Explicit asserted population scope. */
-scope: AssuranceScope;
+scope:AssuranceScope;
 /** Maximum permitted value. */
-ceiling?: number;
+ceiling?:number;
 /** Minimum permitted value. */
-floor?: number;
+floor?:number;
 /** Exact permitted scalar or labelled set. */
-equals?: AssuranceValue;
+equals?:AssuranceValue;
 /** Require numeric zero. */
-zero?: true;
+zero?:true;
 /** Require no decrease from the numeric baseline. */
-monotone_nondecreasing?: number;
+monotone_nondecreasing?:number;
 /** Require no increase from the numeric baseline. */
-monotone_nonincreasing?: number;
+monotone_nonincreasing?:number;
 /** Require the observed labelled set to be a subset. */
-subset_of?: string[];
+subset_of?:string[];
 /** Behavior after owner termination. */
-lifetime?: AssuranceLifetime;
+lifetime?:AssuranceLifetime;
 /** Required explanation when lifetime retires. */
-retire_reason?: string;
+retire_reason?:string;
 /** Enforcement strength. */
-enforcement: AssuranceEnforcement;
+enforcement:AssuranceEnforcement;
 /** Required proof that the comparator distinguishes good and bad values. */
-negative_control: AssuranceNegativeControl;
+negative_control:AssuranceNegativeControl;
 /** Decision item authorizing a loosening update. */
-authorization_decision?: string;
+authorization_decision?:string;
 }
 /** Persisted gate declaration. */
 export interface AssuranceGateDefinition {
 /** Stable registry id. */
-id: string;
+id:string;
 /** Assertion ids evaluated by this gate. */
-assertion_ids: string[];
+assertion_ids:string[];
 /** Lifecycle triggers allowed to run it. */
-triggers: AssuranceGateTrigger[];
+triggers:AssuranceGateTrigger[];
 /** Optional description. */
-description?: string;
+description?:string;
 /** Explicit provider allow-list and trigger-specific execution policy. */
-provider_policy?: {
+provider_policy?:{
 /** Provider ids this gate may invoke. An empty set refuses every provider. */
-allowed_providers: string[];
+allowed_providers:string[];
 /** Trigger rules; an omitted rule refuses provider execution for that trigger. */
-triggers: Partial<Record<AssuranceGateTrigger, {
+triggers:Partial<Record<AssuranceGateTrigger,{
 /** Highest provider cost class allowed at this trigger. */
-max_cost_class: AssuranceProviderCostClass;
+max_cost_class:AssuranceProviderCostClass;
 /** Whether network-declaring providers may run. */
-allow_network: boolean;
+allow_network:boolean;
 }>>;
 };
 }
 /** Complete persisted assurance registry. */
 export interface AssuranceDocument {
 /** Storage format version. */
-version: typeof ASSURANCE_DOCUMENT_VERSION;
+version:typeof ASSURANCE_DOCUMENT_VERSION;
 /** Measurement declarations. */
-measurements: AssuranceMeasurementDefinition[];
+measurements:AssuranceMeasurementDefinition[];
 /** Assertion declarations. */
-assertions: AssuranceAssertionDefinition[];
+assertions:AssuranceAssertionDefinition[];
 /** Gate declarations. */
-gates: AssuranceGateDefinition[];
+gates:AssuranceGateDefinition[];
 }
 /** Atomic set of ordinary declarations used by presets and accepted proposals. */
 export interface AssuranceDeclarationBundle {
 /** Measurement declarations to create without overwriting divergent ids. */
-measurements: AssuranceMeasurementDefinition[];
+measurements:AssuranceMeasurementDefinition[];
 /** Assertion declarations to create without overwriting divergent ids. */
-assertions: AssuranceAssertionDefinition[];
+assertions:AssuranceAssertionDefinition[];
 /** Gate declarations to create without overwriting divergent ids. */
-gates: AssuranceGateDefinition[];
+gates:AssuranceGateDefinition[];
 }
 /** Audited receipt for one atomic assurance bundle application. */
 export interface AssuranceBundleMutationReceipt {
 /** Whether persistence changed. */
-changed: boolean;
+changed:boolean;
 /** Stable ids created by the bundle. */
-created_ids: string[];
+created_ids:string[];
 /** Stable ids already present with byte-equivalent declarations. */
-unchanged_ids: string[];
+unchanged_ids:string[];
 }
 /** Host adapter result for graph, validate, health, or provider sources. */
 export interface AssuranceExternalMeasurementResult {
 /** Observed value. */
-value: AssuranceValue;
+value:AssuranceValue;
 /** Population denominator. */
-population_size: number;
+population_size:number;
 /** Abstract compute units charged by the adapter. */
-cost: number;
+cost:number;
 /** Optional contributors that moved the value. */
-contributors?: string[];
+contributors?:string[];
 /** Optional exact named sub-populations within the observed value. */
-partitions?: Readonly<Record<string, number>>;
+partitions?:Readonly<Record<string,number>>;
 }
 /** SDK evaluation inputs supplied by a host. */
 export interface AssuranceEvaluationContext {
 /** Commit, tree, snapshot, or workspace identity being judged. */
-tree_id: string;
+tree_id:string;
 /** Item rows for built-in sources. */
-items: AssuranceItemRecord[];
+items:AssuranceItemRecord[];
 /** Immutable history rows for built-in history sources. */
-history: AssuranceHistoryRecord[];
+history:AssuranceHistoryRecord[];
 /** Status ids that make an assertion owner terminal. */
-terminal_statuses?: string[];
+terminal_statuses?:string[];
 /** Host-declared capabilities for provider-policy enforcement. */
-provider_capabilities?: Readonly<Record<string, {
-cost_class: AssuranceProviderCostClass;
-network: boolean;
+provider_capabilities?:Readonly<Record<string,{
+cost_class:AssuranceProviderCostClass;
+network:boolean;
 }>>;
 /** External source adapter. Implementations must enforce an appropriate timeout. */
-external: (source: AssuranceGraphSource | AssuranceValidateSource | AssuranceHealthSource | AssuranceProviderSource) => Promise<AssuranceExternalMeasurementResult>;
+external:(source:AssuranceGraphSource | AssuranceValidateSource | AssuranceHealthSource | AssuranceProviderSource) => Promise<AssuranceExternalMeasurementResult>;
 }
 /** Compute receipt for one measurement. */
 export interface AssuranceMeasurementCost {
 /** Total abstract units. */
-units: number;
+units:number;
 /** Item rows scanned. */
-items_scanned: number;
+items_scanned:number;
 /** History rows scanned. */
-history_entries: number;
+history_entries:number;
 /** External provider calls. */
-provider_calls: number;
+provider_calls:number;
 /** Wall-clock duration. */
-duration_ms: number;
+duration_ms:number;
 }
 /** Evaluated measurement receipt. */
 export interface AssuranceMeasurementResult {
 /** Measurement id. */
-id: string;
+id:string;
 /** Stable fingerprint of the exact declaration that produced this result. */
-definition_fingerprint: string;
+definition_fingerprint:string;
 /** Observed value. */
-value: AssuranceValue;
+value:AssuranceValue;
 /** Population denominator. */
-population_size: number;
+population_size:number;
 /** Compute receipt. */
-cost: AssuranceMeasurementCost;
+cost:AssuranceMeasurementCost;
 /** Optional contributors. */
-contributors: string[];
+contributors:string[];
 /** Optional exact named sub-populations within the observed value. */
-partitions?: Readonly<Record<string, number>>;
+partitions?:Readonly<Record<string,number>>;
 }
 /** Structured assertion bound. */
 export interface AssuranceBound {
 /** Comparator applied to the observed value and declared bound. */
-polarity: "ceiling" | "floor" | "equals" | "zero" | "monotone_nondecreasing" | "monotone_nonincreasing" | "subset_of";
+polarity:"ceiling" | "floor" | "equals" | "zero" | "monotone_nondecreasing" | "monotone_nonincreasing" | "subset_of";
 /** Declared bound value. */
-value: AssuranceValue;
+value:AssuranceValue;
 }
 /** One assertion row inside a gate verdict. */
 export interface AssuranceAssertionVerdict {
 /** Stable guarantee key that produced this evaluation row. */
-assertion_id: string;
+assertion_id:string;
 /** Stable observation key used to obtain the evaluated value. */
-measurement_id: string;
+measurement_id:string;
 /** Stable fingerprint of the measurement declaration used for this verdict. */
-measurement_definition_fingerprint: string;
+measurement_definition_fingerprint:string;
 /** Explicit scope. */
-scope: AssuranceScope;
+scope:AssuranceScope;
 /** Population denominator. */
-population_size: number;
+population_size:number;
 /** Numeric or labelled-set value captured for the judged population. */
-observed: AssuranceValue;
+observed:AssuranceValue;
 /** Structured bound. */
-bound: AssuranceBound;
+bound:AssuranceBound;
 /** Signed numeric distance when applicable. */
-distance: number | null;
+distance:number | null;
 /** Assertion result. */
-verdict: "pass" | "fail" | "retired";
+verdict:"pass" | "fail" | "retired";
 /** Enforcement strength. */
-enforcement: AssuranceEnforcement;
+enforcement:AssuranceEnforcement;
 /** Whether negative controls proved the comparator. */
-negative_control_proven: boolean;
+negative_control_proven:boolean;
 /** Compute receipt. */
-cost: AssuranceMeasurementCost;
+cost:AssuranceMeasurementCost;
 /** Optional contributors. */
-contributors: string[];
+contributors:string[];
 /** Optional exact named sub-populations within the observed value. */
-partitions?: Readonly<Record<string, number>>;
+partitions?:Readonly<Record<string,number>>;
 }
 /** Complete gate verdict shared by every presentation and execution surface. */
 export interface AssuranceGateVerdict {
 /** Stable lifecycle-policy key that produced this verdict. */
-gate_id: string;
+gate_id:string;
 /** Judged tree identity. */
-tree_id: string;
+tree_id:string;
 /** Evaluation trigger. */
-trigger: AssuranceGateTrigger;
+trigger:AssuranceGateTrigger;
 /** Whether history persistence was intentionally skipped. */
-dry_run: boolean;
+dry_run:boolean;
 /** ISO timestamp. */
-evaluated_at: string;
+evaluated_at:string;
 /** Overall result. */
-verdict: "pass" | "warn" | "block";
+verdict:"pass" | "warn" | "block";
 /** Stable process exit code. */
-exit_code: 0 | 1;
+exit_code:0 | 1;
 /** Per-assertion receipts. */
-assertions: AssuranceAssertionVerdict[];
+assertions:AssuranceAssertionVerdict[];
 /** Total assertions evaluated before any transport projection or compaction. */
-assertions_total: number;
+assertions_total:number;
 /** Stable selector for iterating assertion evidence across transports. */
-row_contract: {
-row_keys: ["assertions"];
-jq_selector: ".assertions[]";
+row_contract:{
+row_keys:["assertions"];
+jq_selector:".assertions[]";
 };
 /** Aggregate compute receipt. */
-cost: AssuranceMeasurementCost;
+cost:AssuranceMeasurementCost;
 }
 /** Mutation attribution accepted by registry and verdict writes. */
 export interface AssuranceMutationOptions {
 /** Explicit author override; normal callers omit it for harness detection. */
-author?: string;
+author?:string;
 /** Optional audited rationale. */
-message?: string;
+message?:string;
 /** Decision item ids the caller has verified as authorization. */
-authorized_decision_ids?: string[];
+authorized_decision_ids?:string[];
 }
 /** Declaration collection kind. */
 export type AssuranceDeclarationKind = "measurement" | "assertion" | "gate";
@@ -463,58 +463,58 @@ export type AssuranceDeclaration = AssuranceMeasurementDefinition | AssuranceAss
 /** Registry mutation receipt. */
 export interface AssuranceMutationReceipt {
 /** Whether serialized state changed. */
-changed: boolean;
+changed:boolean;
 /** Mutation outcome. */
-action: "created" | "updated" | "removed";
+action:"created" | "updated" | "removed";
 /** Declaration kind. */
-kind: AssuranceDeclarationKind;
+kind:AssuranceDeclarationKind;
 /** Declaration id. */
-id: string;
+id:string;
 }
 /** Return true when an assertion update weakens scope, bound, lifetime, or enforcement. */
-export declare function assuranceAssertionUpdateIsLoosening(before: AssuranceAssertionDefinition, after: AssuranceAssertionDefinition): boolean;
+export declare function assuranceAssertionUpdateIsLoosening(before:AssuranceAssertionDefinition,after:AssuranceAssertionDefinition):boolean;
 /** Validate and return one measurement declaration. */
-export declare function validateMeasurementDefinition(definition: AssuranceMeasurementDefinition): AssuranceMeasurementDefinition;
+export declare function validateMeasurementDefinition(definition:AssuranceMeasurementDefinition):AssuranceMeasurementDefinition;
 /** Validate and return one assertion declaration. */
-export declare function validateAssertionDefinition(definition: AssuranceAssertionDefinition): AssuranceAssertionDefinition;
+export declare function validateAssertionDefinition(definition:AssuranceAssertionDefinition):AssuranceAssertionDefinition;
 /** Validate and return one gate declaration. */
-export declare function validateGateDefinition(definition: AssuranceGateDefinition): AssuranceGateDefinition;
+export declare function validateGateDefinition(definition:AssuranceGateDefinition):AssuranceGateDefinition;
 /** Validate registry references, uniqueness, and declaration-local contracts. */
-export declare function validateAssuranceDocument(document: AssuranceDocument): AssuranceDocument;
+export declare function validateAssuranceDocument(document:AssuranceDocument):AssuranceDocument;
 /** Create an empty, valid assurance registry. */
-export declare function createEmptyAssuranceDocument(): AssuranceDocument;
+export declare function createEmptyAssuranceDocument():AssuranceDocument;
 /** Evaluate one measurement with cycle detection and a complete cost receipt. */
-export declare function evaluateMeasurement(definition: AssuranceMeasurementDefinition, context: AssuranceEvaluationContext, definitions?: AssuranceMeasurementDefinition[]): Promise<AssuranceMeasurementResult>;
+export declare function evaluateMeasurement(definition:AssuranceMeasurementDefinition,context:AssuranceEvaluationContext,definitions?:AssuranceMeasurementDefinition[]):Promise<AssuranceMeasurementResult>;
 /** Evaluate one assertion against a precomputed measurement receipt. */
-export declare function evaluateAssuranceAssertion(definition: AssuranceAssertionDefinition, measurement: AssuranceMeasurementResult, options?: {
-/** Whether the owning item is terminal. */ owner_terminal?: boolean;
-}): AssuranceAssertionVerdict;
+export declare function evaluateAssuranceAssertion(definition:AssuranceAssertionDefinition,measurement:AssuranceMeasurementResult,options?:{
+/** Whether the owning item is terminal. */ owner_terminal?:boolean;
+}):AssuranceAssertionVerdict;
 /** Evaluate a named gate into one presentation-independent verdict document. */
-export declare function evaluateAssuranceGate(gateId: string, document: AssuranceDocument, context: AssuranceEvaluationContext, options: {
-/** Trigger being evaluated. */ trigger: AssuranceGateTrigger;
-/** Skip persistence in the caller. */ dry_run?: boolean;
-}): Promise<AssuranceGateVerdict>;
+export declare function evaluateAssuranceGate(gateId:string,document:AssuranceDocument,context:AssuranceEvaluationContext,options:{
+/** Trigger being evaluated. */ trigger:AssuranceGateTrigger;
+/** Skip persistence in the caller. */ dry_run?:boolean;
+}):Promise<AssuranceGateVerdict>;
 /** Read all declarations of one kind with a stable row selector receipt. */
-export declare function listAssuranceDeclarations(pmRoot: string, kind: AssuranceDeclarationKind): Promise<{
-items: AssuranceDeclaration[];
-count: number;
-row_contract: {
-row_keys: ["items"];
-jq_selector: ".items[]";
+export declare function listAssuranceDeclarations(pmRoot:string,kind:AssuranceDeclarationKind):Promise<{
+items:AssuranceDeclaration[];
+count:number;
+row_contract:{
+row_keys:["items"];
+jq_selector:".items[]";
 };
 }>;
 /** Read one named declaration or fail loudly. */
-export declare function getAssuranceDeclaration(pmRoot: string, kind: AssuranceDeclarationKind, id: string): Promise<AssuranceDeclaration>;
+export declare function getAssuranceDeclaration(pmRoot:string,kind:AssuranceDeclarationKind,id:string):Promise<AssuranceDeclaration>;
 /** Create or update one declaration through audited singleton persistence. */
-export declare function putAssuranceDeclaration(pmRoot: string, kind: AssuranceDeclarationKind, definition: AssuranceDeclaration, options?: AssuranceMutationOptions): Promise<AssuranceMutationReceipt>;
+export declare function putAssuranceDeclaration(pmRoot:string,kind:AssuranceDeclarationKind,definition:AssuranceDeclaration,options?:AssuranceMutationOptions):Promise<AssuranceMutationReceipt>;
 /** Apply a declaration bundle atomically, idempotently, and without replacing divergent ids. */
-export declare function putAssuranceDeclarationBundle(pmRoot: string, bundle: AssuranceDeclarationBundle, options?: AssuranceMutationOptions): Promise<AssuranceBundleMutationReceipt>;
+export declare function putAssuranceDeclarationBundle(pmRoot:string,bundle:AssuranceDeclarationBundle,options?:AssuranceMutationOptions):Promise<AssuranceBundleMutationReceipt>;
 /** Remove an unreferenced declaration through audited singleton persistence. */
-export declare function removeAssuranceDeclaration(pmRoot: string, kind: AssuranceDeclarationKind, id: string, options?: AssuranceMutationOptions): Promise<AssuranceMutationReceipt>;
+export declare function removeAssuranceDeclaration(pmRoot:string,kind:AssuranceDeclarationKind,id:string,options?:AssuranceMutationOptions):Promise<AssuranceMutationReceipt>;
 /** Append one immutable gate verdict without changing registry state. */
-export declare function recordAssuranceVerdict(pmRoot: string, verdict: AssuranceGateVerdict, options?: AssuranceMutationOptions): Promise<void>;
+export declare function recordAssuranceVerdict(pmRoot:string,verdict:AssuranceGateVerdict,options?:AssuranceMutationOptions):Promise<void>;
 /** Query durable assurance verdicts from the verified workspace stream. */
-export declare function listAssuranceVerdicts(pmRoot: string, options?: {
-/** Optional gate filter. */ gate_id?: string;
-/** Maximum newest matching verdicts returned. */ limit?: number;
-}): Promise<AssuranceGateVerdict[]>;
+export declare function listAssuranceVerdicts(pmRoot:string,options?:{
+/** Optional gate filter. */ gate_id?:string;
+/** Maximum newest matching verdicts returned. */ limit?:number;
+}):Promise<AssuranceGateVerdict[]>;