kibi-cli 0.19.0 → 2.0.0

package/dist/public/operations/types.d.ts

@@ -1,7 +1,14 @@
 import type { OperationContext } from "./runtime-types.js";
 export type { OperationContext };
-export type OperationName = "kb_query" | "kb_search" | "kb_status" | "kb_skills_list" | "kb_skills_load" | "kb_skills_read" | "kb_find_gaps" | "kb_coverage" | "kb_graph" | "kb_sparql_remote" | "kb_semantic_advisor" | "kb_upsert" | "kb_validate_upsert" | "kb_delete" | "kb_check" | "kb_model_requirement" | "kb_suggest_predicates" | "kb_autopilot_generate";
+export type OperationName = "kb_query" | "kb_search" | "kb_status" | "kb_skills_list" | "kb_skills_load" | "kb_skills_read" | "kb_find_gaps" | "kb_coverage" | "kb_graph" | "kb_sparql_remote" | "kb_semantic_advisor" | "kb_upsert" | "kb_validate_upsert" | "kb_delete" | "kb_check" | "kb_model_requirement" | "kb_suggest_predicates" | "kb_plan_bootstrap" | "kb_compile_intent" | "kb_apply_plan" | "kb_ingest_proof";
 export type OperationEffect = "local-read" | "kb-read" | "workspace-read" | "network-read" | "kb-write" | "workspace-write";
+export type OperationEffectDeclaration = Readonly<{
+    kind: OperationEffect;
+    mutability: "read" | "write";
+    destructive: boolean;
+    retrySafety: "safe" | "unsafe";
+    openWorld: boolean;
+}>;
 export interface OperationContent {
     readonly type: string;
     readonly text?: string;
@@ -10,6 +17,38 @@ export interface OperationResult<O = unknown> {
     readonly content: readonly OperationContent[];
     readonly structuredContent?: O;
 }
+export type KibiResultStatus = "success" | "committed_with_repairs" | "error";
+export type KibiResult<T = unknown> = {
+    readonly kibiProtocol: 1;
+    readonly operation: OperationName | string;
+    readonly resultVersion: string;
+    readonly status: KibiResultStatus;
+    readonly data: T;
+    readonly effects: readonly {
+        readonly kind: string;
+        readonly status: "completed" | "failed" | "not_applicable";
+        readonly detail?: unknown;
+        readonly errorCode?: string;
+    }[];
+    readonly diagnostics: readonly {
+        readonly code?: string;
+        readonly severity?: "info" | "warning" | "error";
+        readonly message: string;
+        readonly detail?: unknown;
+    }[];
+    readonly nextActions: readonly {
+        readonly operation: OperationName | string;
+        readonly input?: unknown;
+        readonly reason: string;
+        readonly required: boolean;
+    }[];
+    readonly error?: {
+        readonly code: string;
+        readonly message: string;
+        readonly retryable: boolean;
+        readonly details?: unknown;
+    };
+};
 export interface OperationSpec<I = Readonly<Record<string, unknown>>, O = unknown> {
     readonly name: OperationName;
     readonly cliName: string;
@@ -17,8 +56,20 @@ export interface OperationSpec<I = Readonly<Record<string, unknown>>, O = unknow
     readonly businessInputSchema: Readonly<Record<string, unknown>>;
     readonly requiresProlog: boolean;
     readonly effects: readonly OperationEffect[];
+    /** Generated effect metadata used by MCP annotations and telemetry. */
+    readonly declaredEffects?: readonly OperationEffectDeclaration[];
+    /** Version of the machine-readable result data for this operation. */
+    readonly resultVersion?: string;
+    /** JSON Schema for the machine-readable result data. */
+    readonly outputSchema?: Readonly<Record<string, unknown>>;
     readonly execute: {
         bivarianceHack(input: I, context: OperationContext): Promise<OperationResult<O>>;
     }["bivarianceHack"];
 }
+/** A catalog spec after its generated machine contract has been attached. */
+export type ResolvedOperationSpec<I = Readonly<Record<string, unknown>>, O = unknown> = OperationSpec<I, O> & {
+    readonly declaredEffects: readonly OperationEffectDeclaration[];
+    readonly resultVersion: string;
+    readonly outputSchema: Readonly<Record<string, unknown>>;
+};
 //# sourceMappingURL=types.d.ts.map

package/dist/public/operations/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/public/operations/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,YAAY,EAAE,gBAAgB,EAAE,CAAC;AACjC,MAAM,MAAM,aAAa,GACrB,UAAU,GACV,WAAW,GACX,WAAW,GACX,gBAAgB,GAChB,gBAAgB,GAChB,gBAAgB,GAChB,cAAc,GACd,aAAa,GACb,UAAU,GACV,kBAAkB,GAClB,qBAAqB,GACrB,WAAW,GACX,oBAAoB,GACpB,WAAW,GACX,UAAU,GACV,sBAAsB,GACtB,uBAAuB,GACvB,uBAAuB,CAAC;AAE5B,MAAM,MAAM,eAAe,GACvB,YAAY,GACZ,SAAS,GACT,gBAAgB,GAChB,cAAc,GACd,UAAU,GACV,iBAAiB,CAAC;AAEtB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO;IAC1C,QAAQ,CAAC,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC9C,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,aAAa,CAC5B,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACrC,CAAC,GAAG,OAAO;IAEX,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAChE,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;IAC7C,QAAQ,CAAC,OAAO,EAAE;QAChB,cAAc,CACZ,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;KAChC,CAAC,gBAAgB,CAAC,CAAC;CACrB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/public/operations/types.ts"],"names":[],"mappings":"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"}

package/dist/public/proof-fingerprint.d.ts

@@ -0,0 +1,54 @@
+import type { ProofBinding, ProofContract, ProofEnvironment } from "./proof-protocol.js";
+export declare function stripCosmetic(value: unknown): unknown;
+export declare function canonicalJson(value: unknown): string;
+export declare function jsonDigest(value: unknown): string;
+/** Kibi canonicalizes the typed environment and derives the environment hash itself. */
+export declare function environmentHash(environment: ProofEnvironment): string;
+export declare function proofContractHash(contract: ProofContract): string;
+/**
+ * Per-contract receipt binding: hashes what the receipt's validity actually
+ * depends on — the test's proof contract and the test's authored document
+ * with any receipt block removed — so a receipt stays valid while unrelated
+ * workspace state changes, and goes stale the moment the test's own contract
+ * or document does. Callers pass the receipt-stripped document content.
+ */
+export interface ReceiptCodeScopeEntry {
+    readonly symbolId: string;
+    readonly sourceHash: string;
+}
+export declare function receiptBindingHash(contract: ProofContract, receiptStrippedTestDocument: string, codeScope?: readonly ReceiptCodeScopeEntry[]): string;
+export type ProofIntegrationExecution = Readonly<{
+    id: string;
+    producer: string;
+    producer_version?: string;
+    command: readonly string[];
+    artifact?: string;
+    targets?: readonly string[];
+    options?: Record<string, unknown>;
+}>;
+export type ProofFingerprintComponents = Readonly<{
+    contract: string;
+    integration: string;
+    command: string;
+    bindings: string;
+    producer: string;
+}>;
+export type ProofFingerprint = Readonly<{
+    fingerprint: string;
+    components: ProofFingerprintComponents;
+}>;
+/**
+ * The effective proof fingerprint binds a receipt to everything that changes
+ * what executes or how evidence maps to obligations: the semantic contract,
+ * the integration's execution semantics, the exact command, and the bindings.
+ * Cosmetic metadata is excluded, so editing a description never stales proof.
+ */
+export declare function effectiveProofFingerprint(input: {
+    contract: ProofContract;
+    integration: ProofIntegrationExecution;
+    bindings: readonly ProofBinding[];
+}): ProofFingerprint;
+export declare const FINGERPRINT_COMPONENT_NAMES: readonly ["contract", "integration", "command", "bindings", "producer"];
+/** Names the fingerprint components that drifted between two executions. */
+export declare function fingerprintDrift(previous: ProofFingerprintComponents, current: ProofFingerprintComponents): string[];
+//# sourceMappingURL=proof-fingerprint.d.ts.map

package/dist/public/proof-fingerprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-fingerprint.d.ts","sourceRoot":"","sources":["../../src/public/proof-fingerprint.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,gBAAgB,EACjB,MAAM,qBAAqB,CAAC;AAe7B,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAYrD;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAYpD;AAMD,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEjD;AAED,wFAAwF;AACxF,wBAAgB,eAAe,CAAC,WAAW,EAAE,gBAAgB,GAAG,MAAM,CAErE;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAEjE;AAED;;;;;;GAMG;AAEH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,aAAa,EACvB,2BAA2B,EAAE,MAAM,EACnC,SAAS,GAAE,SAAS,qBAAqB,EAAO,GAC/C,MAAM,CAeR;AAED,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAAC;IAC/C,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,CAAC,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,QAAQ,CAAC;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,0BAA0B,CAAC;CACxC,CAAC,CAAC;AAiDH;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,QAAQ,EAAE,aAAa,CAAC;IACxB,WAAW,EAAE,yBAAyB,CAAC;IACvC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;CACnC,GAAG,gBAAgB,CAiBnB;AAED,eAAO,MAAM,2BAA2B,yEAM9B,CAAC;AAEX,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,0BAA0B,EACpC,OAAO,EAAE,0BAA0B,GAClC,MAAM,EAAE,CAIV"}

package/dist/public/proof-fingerprint.js

@@ -0,0 +1,141 @@
+import { createHash } from "node:crypto";
+/** Cosmetic integration-config keys that never participate in proof identity. */
+const COSMETIC_KEYS = new Set([
+    "description",
+    "label",
+    "labels",
+    "comment",
+    "comments",
+    "displayName",
+    "display_name",
+    "docs",
+    "notes",
+]);
+export function stripCosmetic(value) {
+    if (Array.isArray(value))
+        return value.map(stripCosmetic);
+    if (value !== null && typeof value === "object") {
+        const source = value;
+        const result = {};
+        for (const key of Object.keys(source).sort()) {
+            if (COSMETIC_KEYS.has(key))
+                continue;
+            result[key] = stripCosmetic(source[key]);
+        }
+        return result;
+    }
+    return value;
+}
+export function canonicalJson(value) {
+    if (value === undefined)
+        return "null";
+    if (Array.isArray(value)) {
+        return `[${value.map(canonicalJson).join(",")}]`;
+    }
+    if (value !== null && typeof value === "object") {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, child]) => `${JSON.stringify(key)}:${canonicalJson(child)}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function jsonDigest(value) {
+    return sha256(canonicalJson(value));
+}
+/** Kibi canonicalizes the typed environment and derives the environment hash itself. */
+export function environmentHash(environment) {
+    return jsonDigest(stripCosmetic(environment));
+}
+export function proofContractHash(contract) {
+    return jsonDigest(contract);
+}
+export function receiptBindingHash(contract, receiptStrippedTestDocument, codeScope = []) {
+    const scope = codeScope
+        .map((entry) => ({
+        symbolId: entry.symbolId,
+        sourceHash: entry.sourceHash,
+    }))
+        .sort((left, right) => left.symbolId.localeCompare(right.symbolId));
+    return jsonDigest({
+        binding: "kibi.receipt-binding.v1",
+        contract: proofContractHash(contract),
+        testDoc: createHash("sha256")
+            .update(receiptStrippedTestDocument)
+            .digest("hex"),
+        codeScope: scope,
+    });
+}
+function integrationExecutionProjection(integration) {
+    return {
+        id: integration.id,
+        producer: integration.producer,
+        ...(integration.producer_version !== undefined
+            ? { producer_version: integration.producer_version }
+            : {}),
+        command: [...integration.command],
+        ...(integration.artifact !== undefined
+            ? { artifact: integration.artifact }
+            : {}),
+        ...(integration.targets !== undefined
+            ? { targets: [...integration.targets] }
+            : {}),
+        ...(integration.options !== undefined
+            ? { options: stripCosmetic(integration.options) }
+            : {}),
+    };
+}
+function normalizedBindings(bindings) {
+    return [...bindings]
+        .map((binding) => ({
+        symbol_id: binding.symbol_id,
+        target: binding.target,
+        ...(binding.native_id !== undefined
+            ? { native_id: binding.native_id }
+            : {}),
+        ...(binding.aliases !== undefined
+            ? { aliases: [...binding.aliases] }
+            : {}),
+        ...(binding.source_file !== undefined
+            ? { source_file: binding.source_file }
+            : {}),
+        ...(binding.line !== undefined ? { line: binding.line } : {}),
+    }))
+        .sort((left, right) => `${left.target}\0${left.symbol_id}`.localeCompare(`${right.target}\0${right.symbol_id}`));
+}
+/**
+ * The effective proof fingerprint binds a receipt to everything that changes
+ * what executes or how evidence maps to obligations: the semantic contract,
+ * the integration's execution semantics, the exact command, and the bindings.
+ * Cosmetic metadata is excluded, so editing a description never stales proof.
+ */
+export function effectiveProofFingerprint(input) {
+    const integrationProjection = integrationExecutionProjection(input.integration);
+    const components = {
+        contract: proofContractHash(input.contract),
+        integration: jsonDigest(integrationProjection),
+        command: jsonDigest([...input.integration.command]),
+        bindings: jsonDigest(normalizedBindings(input.bindings)),
+        producer: jsonDigest({
+            producer: input.integration.producer,
+            ...(input.integration.producer_version !== undefined
+                ? { version: input.integration.producer_version }
+                : {}),
+        }),
+    };
+    return { fingerprint: jsonDigest(components), components };
+}
+export const FINGERPRINT_COMPONENT_NAMES = [
+    "contract",
+    "integration",
+    "command",
+    "bindings",
+    "producer",
+];
+/** Names the fingerprint components that drifted between two executions. */
+export function fingerprintDrift(previous, current) {
+    return FINGERPRINT_COMPONENT_NAMES.filter((name) => previous[name] !== current[name]);
+}

package/dist/public/proof-protocol.d.ts

@@ -0,0 +1,354 @@
+export declare const PROOF_RUN_VERSION: "kibi.proof-run.v1";
+export declare const PROOF_CONTRACT_VERSION: "kibi.proof-contract.v1";
+export declare const PROOF_RECEIPT_VERSION: "kibi.proof-receipt.v1";
+export declare const PROOF_INTEGRATION_VERSION: "kibi.proof-integration.v1";
+export declare const PROOF_RUN_OUTCOMES: readonly ["passed", "failed", "errored", "cancelled", "timed_out", "interrupted", "no_results"];
+export declare const PROOF_RESULT_OUTCOMES: readonly ["passed", "failed", "timed_out", "skipped", "interrupted", "errored"];
+export declare const PROOF_BINDING_KINDS: readonly ["native_case", "aggregate_run"];
+export declare const ATTEMPTS_STATUS: readonly ["complete", "unavailable"];
+export declare const RUN_FAILURE_PHASES: readonly ["setup", "collection", "execution", "teardown", "infrastructure"];
+export declare const SUCCESS_POLICIES: readonly ["all_required_first_attempt"];
+export type { AttemptsStatus, ProducerProvenance, ProofAttempt, ProofAttempts, ProofBinding, ProofBindingKind, ProofContract, ProofEnvironment, ProofObligation, ProofResult, ProofResultOutcome, ProofRun, ProofRunArtifact, ProofRunOutcome, RunFailurePhase, SuccessPolicy, } from "./proof-protocol-types.js";
+export declare const PROOF_RESULT_SCHEMA: {
+    readonly type: "object";
+    readonly description: "One observed proof result. binding distinguishes native-case observations from aggregate-run bindings; attempts must report facts only.";
+    readonly required: readonly ["symbol_id", "target", "outcome", "binding", "attempts"];
+    readonly properties: {
+        readonly symbol_id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Stable proof symbol ID (SYM-*).";
+        };
+        readonly target: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Ecosystem-neutral execution target (browser, runtime, database, device, deployment, or default).";
+        };
+        readonly outcome: {
+            readonly type: "string";
+            readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted", "errored"];
+        };
+        readonly binding: {
+            readonly type: "string";
+            readonly enum: readonly ["native_case", "aggregate_run"];
+        };
+        readonly native_id: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly attempts: {
+            readonly oneOf: readonly [{
+                readonly type: "object";
+                readonly required: readonly ["status", "entries"];
+                readonly properties: {
+                    readonly status: {
+                        readonly type: "string";
+                        readonly const: "complete";
+                    };
+                    readonly entries: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly maxItems: 100;
+                        readonly items: {
+                            readonly type: "object";
+                            readonly required: readonly ["outcome"];
+                            readonly properties: {
+                                readonly outcome: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted", "errored"];
+                                };
+                                readonly duration_ms: {
+                                    readonly type: "number";
+                                    readonly minimum: 0;
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
+                    };
+                };
+                readonly additionalProperties: false;
+            }, {
+                readonly type: "object";
+                readonly required: readonly ["status"];
+                readonly properties: {
+                    readonly status: {
+                        readonly type: "string";
+                        readonly const: "unavailable";
+                    };
+                };
+                readonly additionalProperties: false;
+            }];
+        };
+        readonly diagnostics: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+        };
+    };
+    readonly additionalProperties: false;
+};
+export declare const PROOF_RUN_ARTIFACT_SCHEMA: {
+    readonly type: "object";
+    readonly description: "Producer-emitted kibi.proof-run.v1 proof artifact. Producers report what happened; Kibi evaluates proof obligations and policies. Produce it via `kibi prove` or direct kb_ingest_proof calls.";
+    readonly required: readonly ["version", "producer", "command_argv", "code_snapshot", "environment", "run", "proof_results"];
+    readonly properties: {
+        readonly version: {
+            readonly type: "string";
+            readonly const: "kibi.proof-run.v1";
+        };
+        readonly producer: {
+            readonly type: "object";
+            readonly required: readonly ["name"];
+            readonly properties: {
+                readonly name: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly version: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly executor: {
+            readonly type: "object";
+            readonly required: readonly ["name"];
+            readonly properties: {
+                readonly name: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly version: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly command_argv: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+        };
+        readonly code_snapshot: {
+            readonly type: "string";
+            readonly pattern: "^[a-f0-9]{64}$";
+        };
+        readonly environment: {
+            readonly type: "object";
+            readonly additionalProperties: true;
+        };
+        readonly run: {
+            readonly type: "object";
+            readonly required: readonly ["outcome", "exit_code", "started_at", "finished_at"];
+            readonly properties: {
+                readonly outcome: {
+                    readonly type: "string";
+                    readonly enum: readonly ["passed", "failed", "errored", "cancelled", "timed_out", "interrupted", "no_results"];
+                };
+                readonly exit_code: {
+                    readonly type: "integer";
+                };
+                readonly started_at: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly finished_at: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly failure_phase: {
+                    readonly type: "string";
+                    readonly enum: readonly ["setup", "collection", "execution", "teardown", "infrastructure"];
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly proof_results: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly maxItems: 1000;
+            readonly items: {
+                readonly type: "object";
+                readonly description: "One observed proof result. binding distinguishes native-case observations from aggregate-run bindings; attempts must report facts only.";
+                readonly required: readonly ["symbol_id", "target", "outcome", "binding", "attempts"];
+                readonly properties: {
+                    readonly symbol_id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Stable proof symbol ID (SYM-*).";
+                    };
+                    readonly target: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Ecosystem-neutral execution target (browser, runtime, database, device, deployment, or default).";
+                    };
+                    readonly outcome: {
+                        readonly type: "string";
+                        readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted", "errored"];
+                    };
+                    readonly binding: {
+                        readonly type: "string";
+                        readonly enum: readonly ["native_case", "aggregate_run"];
+                    };
+                    readonly native_id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly attempts: {
+                        readonly oneOf: readonly [{
+                            readonly type: "object";
+                            readonly required: readonly ["status", "entries"];
+                            readonly properties: {
+                                readonly status: {
+                                    readonly type: "string";
+                                    readonly const: "complete";
+                                };
+                                readonly entries: {
+                                    readonly type: "array";
+                                    readonly minItems: 1;
+                                    readonly maxItems: 100;
+                                    readonly items: {
+                                        readonly type: "object";
+                                        readonly required: readonly ["outcome"];
+                                        readonly properties: {
+                                            readonly outcome: {
+                                                readonly type: "string";
+                                                readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted", "errored"];
+                                            };
+                                            readonly duration_ms: {
+                                                readonly type: "number";
+                                                readonly minimum: 0;
+                                            };
+                                        };
+                                        readonly additionalProperties: false;
+                                    };
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        }, {
+                            readonly type: "object";
+                            readonly required: readonly ["status"];
+                            readonly properties: {
+                                readonly status: {
+                                    readonly type: "string";
+                                    readonly const: "unavailable";
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        }];
+                    };
+                    readonly diagnostics: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+        };
+        readonly integration: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly diagnostics: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+        };
+    };
+    readonly additionalProperties: false;
+};
+export declare const PROOF_CONTRACT_SCHEMA: {
+    readonly type: "object";
+    readonly description: "Semantic proof contract binding a test to explicit proof obligations executed by a configured integration.";
+    readonly required: readonly ["version", "integration", "required_proofs", "success_policy"];
+    readonly properties: {
+        readonly version: {
+            readonly type: "string";
+            readonly const: "kibi.proof-contract.v1";
+        };
+        readonly integration: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly required_proofs: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly maxItems: 1000;
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["symbol_id", "target"];
+                readonly properties: {
+                    readonly symbol_id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly target: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+        };
+        readonly success_policy: {
+            readonly type: "string";
+            readonly enum: readonly ["all_required_first_attempt"];
+        };
+    };
+    readonly additionalProperties: false;
+};
+export declare const PROOF_BINDINGS_SCHEMA: {
+    readonly type: "array";
+    readonly description: "Optional native-runner bindings for proof obligations. Bindings are provenance metadata; they never replace the semantic proof contract.";
+    readonly items: {
+        readonly type: "object";
+        readonly required: readonly ["symbol_id", "target"];
+        readonly properties: {
+            readonly symbol_id: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly target: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly native_id: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly aliases: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+            readonly source_file: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly line: {
+                readonly type: "integer";
+                readonly minimum: 1;
+            };
+        };
+        readonly additionalProperties: false;
+    };
+};
+export declare function proofResultErrors(value: unknown, label: string): string[];
+export declare function proofRunArtifactErrors(value: unknown): string[];
+export declare function proofContractErrors(value: unknown): string[];
+export declare function proofBindingsErrors(value: unknown): string[];
+//# sourceMappingURL=proof-protocol.d.ts.map

package/dist/public/proof-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-protocol.d.ts","sourceRoot":"","sources":["../../src/public/proof-protocol.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,iBAAiB,EAAG,mBAA4B,CAAC;AAE9D,eAAO,MAAM,sBAAsB,EAAG,wBAAiC,CAAC;AAExE,eAAO,MAAM,qBAAqB,EAAG,uBAAgC,CAAC;AAEtE,eAAO,MAAM,yBAAyB,EAAG,2BAAoC,CAAC;AAE9E,eAAO,MAAM,kBAAkB,iGAQrB,CAAC;AAEX,eAAO,MAAM,qBAAqB,iFAOxB,CAAC;AAEX,eAAO,MAAM,mBAAmB,2CAA4C,CAAC;AAE7E,eAAO,MAAM,eAAe,sCAAuC,CAAC;AAEpE,eAAO,MAAM,kBAAkB,6EAMrB,CAAC;AAEX,eAAO,MAAM,gBAAgB,yCAA0C,CAAC;AAExE,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,kBAAkB,EAClB,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,aAAa,GACd,MAAM,2BAA2B,CAAC;AAWnC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DtB,CAAC;AAEX,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiE5B,CAAC;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBxB,CAAC;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBxB,CAAC;AA0GX,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAgCzE;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAkG/D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAwD5D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CA8C5D"}