@petepetrash/circuit 0.1.0

package/dist/schemas/proof-assessment.d.ts

@@ -0,0 +1,542 @@
+import { z } from 'zod';
+export declare const ClaimId: z.ZodString;
+export type ClaimId = z.infer<typeof ClaimId>;
+export declare const EvidenceId: z.ZodString;
+export type EvidenceId = z.infer<typeof EvidenceId>;
+export declare const ProofAssessmentId: z.ZodString;
+export type ProofAssessmentId = z.infer<typeof ProofAssessmentId>;
+export declare const ClaimKind: z.ZodEnum<{
+    bug_fixed: "bug_fixed";
+    behavior_changed: "behavior_changed";
+    test_added: "test_added";
+    docs_changed: "docs_changed";
+    refactor_only: "refactor_only";
+    generated_surface_synced: "generated_surface_synced";
+    absence_of_change: "absence_of_change";
+    scope_respected: "scope_respected";
+    verification_passed: "verification_passed";
+    review_clean: "review_clean";
+}>;
+export type ClaimKind = z.infer<typeof ClaimKind>;
+export declare const ClaimRisk: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+}>;
+export type ClaimRisk = z.infer<typeof ClaimRisk>;
+export declare const ClaimSource: z.ZodEnum<{
+    work_contract: "work_contract";
+    operator: "operator";
+    runtime: "runtime";
+}>;
+export type ClaimSource = z.infer<typeof ClaimSource>;
+export declare const Claim: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        bug_fixed: "bug_fixed";
+        behavior_changed: "behavior_changed";
+        test_added: "test_added";
+        docs_changed: "docs_changed";
+        refactor_only: "refactor_only";
+        generated_surface_synced: "generated_surface_synced";
+        absence_of_change: "absence_of_change";
+        scope_respected: "scope_respected";
+        verification_passed: "verification_passed";
+        review_clean: "review_clean";
+    }>;
+    statement: z.ZodString;
+    scope_refs: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    risk: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+    required: z.ZodBoolean;
+    source: z.ZodEnum<{
+        work_contract: "work_contract";
+        operator: "operator";
+        runtime: "runtime";
+    }>;
+}, z.core.$strict>;
+export type Claim = z.infer<typeof Claim>;
+export declare const EvidenceKind: z.ZodEnum<{
+    command: "command";
+    report_field: "report_field";
+    report: "report";
+    trace: "trace";
+    diff: "diff";
+    generated_surface: "generated_surface";
+    absence_of_change: "absence_of_change";
+    review: "review";
+    source_citation: "source_citation";
+}>;
+export type EvidenceKind = z.infer<typeof EvidenceKind>;
+export declare const EvidenceProducer: z.ZodEnum<{
+    worker: "worker";
+    operator: "operator";
+    runtime: "runtime";
+    independent_worker: "independent_worker";
+}>;
+export type EvidenceProducer = z.infer<typeof EvidenceProducer>;
+export declare const EvidenceIndependence: z.ZodEnum<{
+    external: "external";
+    runtime: "runtime";
+    self: "self";
+    independent: "independent";
+}>;
+export type EvidenceIndependence = z.infer<typeof EvidenceIndependence>;
+export declare const EvidenceResult: z.ZodEnum<{
+    unknown: "unknown";
+    pass: "pass";
+    fail: "fail";
+}>;
+export type EvidenceResult = z.infer<typeof EvidenceResult>;
+export declare const Evidence: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        command: "command";
+        report_field: "report_field";
+        report: "report";
+        trace: "trace";
+        diff: "diff";
+        generated_surface: "generated_surface";
+        absence_of_change: "absence_of_change";
+        review: "review";
+        source_citation: "source_citation";
+    }>;
+    producer: z.ZodEnum<{
+        worker: "worker";
+        operator: "operator";
+        runtime: "runtime";
+        independent_worker: "independent_worker";
+    }>;
+    independence: z.ZodEnum<{
+        external: "external";
+        runtime: "runtime";
+        self: "self";
+        independent: "independent";
+    }>;
+    ref: z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    input_refs: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    covers_claims: z.ZodArray<z.ZodString>;
+    result: z.ZodEnum<{
+        unknown: "unknown";
+        pass: "pass";
+        fail: "fail";
+    }>;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type Evidence = z.infer<typeof Evidence>;
+export declare const ClaimCoverageRule: z.ZodObject<{
+    claim_id: z.ZodString;
+    required_evidence: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report_field: "report_field";
+            report: "report";
+            trace: "trace";
+            diff: "diff";
+            generated_surface: "generated_surface";
+            absence_of_change: "absence_of_change";
+            review: "review";
+            source_citation: "source_citation";
+        }>;
+        min_result: z.ZodLiteral<"pass">;
+        min_independence: z.ZodEnum<{
+            external: "external";
+            runtime: "runtime";
+            independent: "independent";
+        }>;
+        refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        accepted_sources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    optional_evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report_field: "report_field";
+            report: "report";
+            trace: "trace";
+            diff: "diff";
+            generated_surface: "generated_surface";
+            absence_of_change: "absence_of_change";
+            review: "review";
+            source_citation: "source_citation";
+        }>;
+        refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type ClaimCoverageRule = z.infer<typeof ClaimCoverageRule>;
+export declare const ProofStatus: z.ZodEnum<{
+    proven: "proven";
+    weak: "weak";
+    contradicted: "contradicted";
+    unproved: "unproved";
+}>;
+export type ProofStatus = z.infer<typeof ProofStatus>;
+declare const ProofRecovery: z.ZodObject<{
+    route_id: z.ZodString;
+    kind: z.ZodEnum<{
+        handoff: "handoff";
+        retry_same_step_with_feedback: "retry_same_step_with_feedback";
+        narrow_scope: "narrow_scope";
+        run_verification: "run_verification";
+        run_independent_review: "run_independent_review";
+        checkpoint_authority: "checkpoint_authority";
+        safe_apply_reject: "safe_apply_reject";
+        stop_unsafe: "stop_unsafe";
+        escalate: "escalate";
+    }>;
+    reason_code: z.ZodString;
+}, z.core.$strict>;
+export type ProofRecovery = z.infer<typeof ProofRecovery>;
+export declare const ProofAssessmentResult: z.ZodObject<{
+    claim_id: z.ZodString;
+    status: z.ZodEnum<{
+        proven: "proven";
+        weak: "weak";
+        contradicted: "contradicted";
+        unproved: "unproved";
+    }>;
+    evidence_refs: z.ZodArray<z.ZodString>;
+    missing: z.ZodArray<z.ZodString>;
+    contradictions: z.ZodArray<z.ZodString>;
+    recovery: z.ZodOptional<z.ZodObject<{
+        route_id: z.ZodString;
+        kind: z.ZodEnum<{
+            handoff: "handoff";
+            retry_same_step_with_feedback: "retry_same_step_with_feedback";
+            narrow_scope: "narrow_scope";
+            run_verification: "run_verification";
+            run_independent_review: "run_independent_review";
+            checkpoint_authority: "checkpoint_authority";
+            safe_apply_reject: "safe_apply_reject";
+            stop_unsafe: "stop_unsafe";
+            escalate: "escalate";
+        }>;
+        reason_code: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ProofAssessmentResult = z.infer<typeof ProofAssessmentResult>;
+export declare const ProofAssessment: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    assessment_id: z.ZodString;
+    scope: z.ZodObject<{
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    proof_policy_decision_id: z.ZodString;
+    claims: z.ZodArray<z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            bug_fixed: "bug_fixed";
+            behavior_changed: "behavior_changed";
+            test_added: "test_added";
+            docs_changed: "docs_changed";
+            refactor_only: "refactor_only";
+            generated_surface_synced: "generated_surface_synced";
+            absence_of_change: "absence_of_change";
+            scope_respected: "scope_respected";
+            verification_passed: "verification_passed";
+            review_clean: "review_clean";
+        }>;
+        statement: z.ZodString;
+        scope_refs: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        risk: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        required: z.ZodBoolean;
+        source: z.ZodEnum<{
+            work_contract: "work_contract";
+            operator: "operator";
+            runtime: "runtime";
+        }>;
+    }, z.core.$strict>>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            command: "command";
+            report_field: "report_field";
+            report: "report";
+            trace: "trace";
+            diff: "diff";
+            generated_surface: "generated_surface";
+            absence_of_change: "absence_of_change";
+            review: "review";
+            source_citation: "source_citation";
+        }>;
+        producer: z.ZodEnum<{
+            worker: "worker";
+            operator: "operator";
+            runtime: "runtime";
+            independent_worker: "independent_worker";
+        }>;
+        independence: z.ZodEnum<{
+            external: "external";
+            runtime: "runtime";
+            self: "self";
+            independent: "independent";
+        }>;
+        ref: z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        input_refs: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        covers_claims: z.ZodArray<z.ZodString>;
+        result: z.ZodEnum<{
+            unknown: "unknown";
+            pass: "pass";
+            fail: "fail";
+        }>;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    results: z.ZodArray<z.ZodObject<{
+        claim_id: z.ZodString;
+        status: z.ZodEnum<{
+            proven: "proven";
+            weak: "weak";
+            contradicted: "contradicted";
+            unproved: "unproved";
+        }>;
+        evidence_refs: z.ZodArray<z.ZodString>;
+        missing: z.ZodArray<z.ZodString>;
+        contradictions: z.ZodArray<z.ZodString>;
+        recovery: z.ZodOptional<z.ZodObject<{
+            route_id: z.ZodString;
+            kind: z.ZodEnum<{
+                handoff: "handoff";
+                retry_same_step_with_feedback: "retry_same_step_with_feedback";
+                narrow_scope: "narrow_scope";
+                run_verification: "run_verification";
+                run_independent_review: "run_independent_review";
+                checkpoint_authority: "checkpoint_authority";
+                safe_apply_reject: "safe_apply_reject";
+                stop_unsafe: "stop_unsafe";
+                escalate: "escalate";
+            }>;
+            reason_code: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    overall_status: z.ZodEnum<{
+        proven: "proven";
+        weak: "weak";
+        contradicted: "contradicted";
+        unproved: "unproved";
+    }>;
+    close_allowed: z.ZodBoolean;
+}, z.core.$strict>;
+export type ProofAssessment = z.infer<typeof ProofAssessment>;
+export {};
+//# sourceMappingURL=proof-assessment.d.ts.map

package/dist/schemas/proof-assessment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-assessment.d.ts","sourceRoot":"","sources":["../../src/schemas/proof-assessment.ts"],"names":[],"mappings":"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"}