taphound 0.2.0-dev.1 → 0.2.0-dev.12

package/dist/domain/contract.d.ts

@@ -0,0 +1,413 @@
+import { z } from "zod";
+export declare const ContractPreconditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"installed">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"activity">;
+    activity: z.ZodString;
+    timeoutMs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"screen">;
+    screen: z.ZodString;
+    timeoutMs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"anchor">;
+    anchor: z.ZodString;
+    timeoutMs: z.ZodNumber;
+}, z.core.$strict>], "kind">;
+export declare const ContractAssertionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"activity">;
+    activity: z.ZodString;
+    timeoutMs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"element">;
+    locator: z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>;
+    visibility: z.ZodDefault<z.ZodEnum<{
+        absent: "absent";
+        visible: "visible";
+    }>>;
+    packageName: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"screen">;
+    screen: z.ZodString;
+    timeoutMs: z.ZodNumber;
+}, z.core.$strict>], "type">;
+export declare const EvidenceRequirementSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        logcat: "logcat";
+        screenshot: "screenshot";
+        uiHierarchy: "uiHierarchy";
+    }>;
+    scope: z.ZodDefault<z.ZodEnum<{
+        final: "final";
+        anyStep: "anyStep";
+    }>>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const ContractJourneyBindingSchema: z.ZodObject<{
+    path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    sha256: z.ZodString;
+}, z.core.$strict>;
+export declare const AcceptanceContractSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    id: z.ZodString;
+    goal: z.ZodString;
+    targetScreen: z.ZodOptional<z.ZodString>;
+    journey: z.ZodObject<{
+        path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        sha256: z.ZodString;
+    }, z.core.$strict>;
+    preconditions: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"installed">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"activity">;
+        activity: z.ZodString;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"screen">;
+        screen: z.ZodString;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"anchor">;
+        anchor: z.ZodString;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>], "kind">>>;
+    assertions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"activity">;
+        activity: z.ZodString;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"element">;
+        locator: z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>;
+        visibility: z.ZodDefault<z.ZodEnum<{
+            absent: "absent";
+            visible: "visible";
+        }>>;
+        packageName: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"screen">;
+        screen: z.ZodString;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>], "type">>;
+    requiredCheckpoints: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    evidenceRequirements: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            logcat: "logcat";
+            screenshot: "screenshot";
+            uiHierarchy: "uiHierarchy";
+        }>;
+        scope: z.ZodDefault<z.ZodEnum<{
+            final: "final";
+            anyStep: "anyStep";
+        }>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const ContractVerdictSchema: z.ZodEnum<{
+    invalid: "invalid";
+    pass: "pass";
+    fail: "fail";
+    inconclusive: "inconclusive";
+    needsReview: "needsReview";
+}>;
+export declare const ContractVerdictReasonSchema: z.ZodEnum<{
+    CONTRACT_INVALID: "CONTRACT_INVALID";
+    CHECKPOINT_FAILED: "CHECKPOINT_FAILED";
+    CHECKPOINT_UNRESOLVED: "CHECKPOINT_UNRESOLVED";
+    CONTRACT_OK: "CONTRACT_OK";
+    RUN_FAILED: "RUN_FAILED";
+    RUN_ERROR: "RUN_ERROR";
+    RUN_MANUAL_REQUIRED: "RUN_MANUAL_REQUIRED";
+    PRECONDITION_FAILED: "PRECONDITION_FAILED";
+    PRECONDITION_UNRESOLVED: "PRECONDITION_UNRESOLVED";
+    ASSERTION_FAILED: "ASSERTION_FAILED";
+    ASSERTION_UNRESOLVED: "ASSERTION_UNRESOLVED";
+    EVIDENCE_INSUFFICIENT: "EVIDENCE_INSUFFICIENT";
+    REVIEW_FINDINGS: "REVIEW_FINDINGS";
+    JOURNEY_DRIFT: "JOURNEY_DRIFT";
+    JOURNEY_MISSING: "JOURNEY_MISSING";
+    KNOWLEDGE_UNAVAILABLE: "KNOWLEDGE_UNAVAILABLE";
+}>;
+export declare const CONTRACT_VERDICT_POLICY_VERSION = "1";
+export declare const ContractReviewFindingSchema: z.ZodObject<{
+    finding: z.ZodString;
+    region: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    confidence: z.ZodNumber;
+    recommendedAction: z.ZodDefault<z.ZodEnum<{
+        review: "review";
+        fix: "fix";
+    }>>;
+}, z.core.$strict>;
+export declare const ContractReviewInputSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    source: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    promptVersion: z.ZodOptional<z.ZodString>;
+    findings: z.ZodArray<z.ZodObject<{
+        finding: z.ZodString;
+        region: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+        confidence: z.ZodNumber;
+        recommendedAction: z.ZodDefault<z.ZodEnum<{
+            review: "review";
+            fix: "fix";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const ContractReviewSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    source: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    promptVersion: z.ZodOptional<z.ZodString>;
+    findings: z.ZodArray<z.ZodObject<{
+        finding: z.ZodString;
+        region: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+        confidence: z.ZodNumber;
+        recommendedAction: z.ZodDefault<z.ZodEnum<{
+            review: "review";
+            fix: "fix";
+        }>>;
+    }, z.core.$strict>>;
+    appliedAt: z.ZodISODateTime;
+    applied: z.ZodBoolean;
+    baseVerdict: z.ZodEnum<{
+        invalid: "invalid";
+        pass: "pass";
+        fail: "fail";
+        inconclusive: "inconclusive";
+        needsReview: "needsReview";
+    }>;
+    baseReason: z.ZodEnum<{
+        CONTRACT_INVALID: "CONTRACT_INVALID";
+        CHECKPOINT_FAILED: "CHECKPOINT_FAILED";
+        CHECKPOINT_UNRESOLVED: "CHECKPOINT_UNRESOLVED";
+        CONTRACT_OK: "CONTRACT_OK";
+        RUN_FAILED: "RUN_FAILED";
+        RUN_ERROR: "RUN_ERROR";
+        RUN_MANUAL_REQUIRED: "RUN_MANUAL_REQUIRED";
+        PRECONDITION_FAILED: "PRECONDITION_FAILED";
+        PRECONDITION_UNRESOLVED: "PRECONDITION_UNRESOLVED";
+        ASSERTION_FAILED: "ASSERTION_FAILED";
+        ASSERTION_UNRESOLVED: "ASSERTION_UNRESOLVED";
+        EVIDENCE_INSUFFICIENT: "EVIDENCE_INSUFFICIENT";
+        REVIEW_FINDINGS: "REVIEW_FINDINGS";
+        JOURNEY_DRIFT: "JOURNEY_DRIFT";
+        JOURNEY_MISSING: "JOURNEY_MISSING";
+        KNOWLEDGE_UNAVAILABLE: "KNOWLEDGE_UNAVAILABLE";
+    }>;
+}, z.core.$strict>;
+export declare const ContractProvenanceSchema: z.ZodObject<{
+    policyVersion: z.ZodString;
+    taphoundVersion: z.ZodOptional<z.ZodString>;
+    toolVersions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strict>;
+export declare const ContractPreconditionOutcomeSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        anchor: "anchor";
+        activity: "activity";
+        screen: "screen";
+        installed: "installed";
+    }>;
+    status: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+        notRun: "notRun";
+        unresolved: "unresolved";
+    }>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ContractAssertionOutcomeSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        activity: "activity";
+        screen: "screen";
+        element: "element";
+    }>;
+    status: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+        notRun: "notRun";
+        unresolved: "unresolved";
+    }>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ContractEvidenceOutcomeSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        logcat: "logcat";
+        screenshot: "screenshot";
+        uiHierarchy: "uiHierarchy";
+    }>;
+    required: z.ZodBoolean;
+    satisfied: z.ZodBoolean;
+    detail: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ContractCheckpointOutcomeSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+        notRun: "notRun";
+        unresolved: "unresolved";
+    }>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ContractVerdictViewSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    contractId: z.ZodString;
+    contractSha256: z.ZodString;
+    journeySha256: z.ZodString;
+    verdict: z.ZodEnum<{
+        invalid: "invalid";
+        pass: "pass";
+        fail: "fail";
+        inconclusive: "inconclusive";
+        needsReview: "needsReview";
+    }>;
+    reason: z.ZodEnum<{
+        CONTRACT_INVALID: "CONTRACT_INVALID";
+        CHECKPOINT_FAILED: "CHECKPOINT_FAILED";
+        CHECKPOINT_UNRESOLVED: "CHECKPOINT_UNRESOLVED";
+        CONTRACT_OK: "CONTRACT_OK";
+        RUN_FAILED: "RUN_FAILED";
+        RUN_ERROR: "RUN_ERROR";
+        RUN_MANUAL_REQUIRED: "RUN_MANUAL_REQUIRED";
+        PRECONDITION_FAILED: "PRECONDITION_FAILED";
+        PRECONDITION_UNRESOLVED: "PRECONDITION_UNRESOLVED";
+        ASSERTION_FAILED: "ASSERTION_FAILED";
+        ASSERTION_UNRESOLVED: "ASSERTION_UNRESOLVED";
+        EVIDENCE_INSUFFICIENT: "EVIDENCE_INSUFFICIENT";
+        REVIEW_FINDINGS: "REVIEW_FINDINGS";
+        JOURNEY_DRIFT: "JOURNEY_DRIFT";
+        JOURNEY_MISSING: "JOURNEY_MISSING";
+        KNOWLEDGE_UNAVAILABLE: "KNOWLEDGE_UNAVAILABLE";
+    }>;
+    message: z.ZodString;
+    preconditions: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            anchor: "anchor";
+            activity: "activity";
+            screen: "screen";
+            installed: "installed";
+        }>;
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+            notRun: "notRun";
+            unresolved: "unresolved";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    assertions: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            activity: "activity";
+            screen: "screen";
+            element: "element";
+        }>;
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+            notRun: "notRun";
+            unresolved: "unresolved";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    checkpoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+            notRun: "notRun";
+            unresolved: "unresolved";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    evidence: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            logcat: "logcat";
+            screenshot: "screenshot";
+            uiHierarchy: "uiHierarchy";
+        }>;
+        required: z.ZodBoolean;
+        satisfied: z.ZodBoolean;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    reportPath: z.ZodOptional<z.ZodString>;
+    reportStatus: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        passed: "passed";
+        failed: "failed";
+        manualRequired: "manualRequired";
+    }>>;
+    startedAt: z.ZodISODateTime;
+    finishedAt: z.ZodISODateTime;
+    environment: z.ZodObject<{
+        projectRoot: z.ZodString;
+        packageName: z.ZodString;
+        devices: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        policyVersion: z.ZodString;
+        taphoundVersion: z.ZodOptional<z.ZodString>;
+        toolVersions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>;
+    review: z.ZodOptional<z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        source: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+        promptVersion: z.ZodOptional<z.ZodString>;
+        findings: z.ZodArray<z.ZodObject<{
+            finding: z.ZodString;
+            region: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+            confidence: z.ZodNumber;
+            recommendedAction: z.ZodDefault<z.ZodEnum<{
+                review: "review";
+                fix: "fix";
+            }>>;
+        }, z.core.$strict>>;
+        appliedAt: z.ZodISODateTime;
+        applied: z.ZodBoolean;
+        baseVerdict: z.ZodEnum<{
+            invalid: "invalid";
+            pass: "pass";
+            fail: "fail";
+            inconclusive: "inconclusive";
+            needsReview: "needsReview";
+        }>;
+        baseReason: z.ZodEnum<{
+            CONTRACT_INVALID: "CONTRACT_INVALID";
+            CHECKPOINT_FAILED: "CHECKPOINT_FAILED";
+            CHECKPOINT_UNRESOLVED: "CHECKPOINT_UNRESOLVED";
+            CONTRACT_OK: "CONTRACT_OK";
+            RUN_FAILED: "RUN_FAILED";
+            RUN_ERROR: "RUN_ERROR";
+            RUN_MANUAL_REQUIRED: "RUN_MANUAL_REQUIRED";
+            PRECONDITION_FAILED: "PRECONDITION_FAILED";
+            PRECONDITION_UNRESOLVED: "PRECONDITION_UNRESOLVED";
+            ASSERTION_FAILED: "ASSERTION_FAILED";
+            ASSERTION_UNRESOLVED: "ASSERTION_UNRESOLVED";
+            EVIDENCE_INSUFFICIENT: "EVIDENCE_INSUFFICIENT";
+            REVIEW_FINDINGS: "REVIEW_FINDINGS";
+            JOURNEY_DRIFT: "JOURNEY_DRIFT";
+            JOURNEY_MISSING: "JOURNEY_MISSING";
+            KNOWLEDGE_UNAVAILABLE: "KNOWLEDGE_UNAVAILABLE";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ContractPrecondition = z.infer<typeof ContractPreconditionSchema>;
+export type ContractAssertion = z.infer<typeof ContractAssertionSchema>;
+export type EvidenceRequirement = z.infer<typeof EvidenceRequirementSchema>;
+export type AcceptanceContract = z.infer<typeof AcceptanceContractSchema>;
+export type ContractVerdict = z.infer<typeof ContractVerdictSchema>;
+export type ContractVerdictReason = z.infer<typeof ContractVerdictReasonSchema>;
+export type ContractReviewFinding = z.infer<typeof ContractReviewFindingSchema>;
+export type ContractReviewInput = z.infer<typeof ContractReviewInputSchema>;
+export type ContractReview = z.infer<typeof ContractReviewSchema>;
+export type ContractProvenance = z.infer<typeof ContractProvenanceSchema>;
+export type ContractPreconditionOutcome = z.infer<typeof ContractPreconditionOutcomeSchema>;
+export type ContractAssertionOutcome = z.infer<typeof ContractAssertionOutcomeSchema>;
+export type ContractEvidenceOutcome = z.infer<typeof ContractEvidenceOutcomeSchema>;
+export type ContractCheckpointOutcome = z.infer<typeof ContractCheckpointOutcomeSchema>;
+export type ContractVerdictView = z.infer<typeof ContractVerdictViewSchema>;

package/dist/domain/contract.js

@@ -0,0 +1,196 @@
+import { z } from "zod";
+import { KnowledgeIdSchema, KnowledgeSha256Schema, QualifiedNameSchema } from "./knowledge.js";
+import { LocatorSchema } from "./layout.js";
+import { ProjectRelativePathSchema } from "./project-context.js";
+const QualifiedActivitySchema = z.string().regex(/^(?:[A-Za-z_$][\w$]*\.)+[A-Za-z_$][\w$]*$/, "Activity must be fully qualified");
+const TimeoutMsSchema = z.number().int().positive();
+export const ContractPreconditionSchema = z.discriminatedUnion("kind", [
+    z.strictObject({
+        kind: z.literal("installed")
+    }),
+    z.strictObject({
+        kind: z.literal("activity"),
+        activity: QualifiedActivitySchema,
+        timeoutMs: TimeoutMsSchema
+    }),
+    z.strictObject({
+        kind: z.literal("screen"),
+        screen: KnowledgeIdSchema,
+        timeoutMs: TimeoutMsSchema
+    }),
+    z.strictObject({
+        kind: z.literal("anchor"),
+        anchor: KnowledgeIdSchema,
+        timeoutMs: TimeoutMsSchema
+    })
+]);
+export const ContractAssertionSchema = z.discriminatedUnion("type", [
+    z.strictObject({
+        type: z.literal("activity"),
+        activity: QualifiedActivitySchema,
+        timeoutMs: TimeoutMsSchema
+    }),
+    z.strictObject({
+        type: z.literal("element"),
+        locator: LocatorSchema,
+        visibility: z.enum(["visible", "absent"]).default("visible"),
+        packageName: QualifiedNameSchema.optional(),
+        timeoutMs: TimeoutMsSchema
+    }),
+    z.strictObject({
+        type: z.literal("screen"),
+        screen: KnowledgeIdSchema,
+        timeoutMs: TimeoutMsSchema
+    })
+]);
+export const EvidenceRequirementSchema = z.strictObject({
+    kind: z.enum(["screenshot", "uiHierarchy", "logcat"]),
+    scope: z.enum(["final", "anyStep"]).default("final"),
+    required: z.boolean().default(true)
+});
+export const ContractJourneyBindingSchema = z.strictObject({
+    path: ProjectRelativePathSchema,
+    sha256: KnowledgeSha256Schema
+});
+export const AcceptanceContractSchema = z.strictObject({
+    version: z.literal(1),
+    id: KnowledgeIdSchema,
+    goal: z.string().trim().min(1),
+    targetScreen: KnowledgeIdSchema.optional(),
+    journey: ContractJourneyBindingSchema,
+    preconditions: z.array(ContractPreconditionSchema).default([]),
+    assertions: z.array(ContractAssertionSchema).min(1),
+    requiredCheckpoints: z.array(KnowledgeIdSchema).default([]),
+    evidenceRequirements: z.array(EvidenceRequirementSchema).default([])
+}).superRefine((contract, context) => {
+    const checkpointIds = new Set();
+    for (const [index, id] of contract.requiredCheckpoints.entries()) {
+        if (checkpointIds.has(id)) {
+            context.addIssue({
+                code: "custom",
+                path: ["requiredCheckpoints", index],
+                message: `Required Checkpoint "${id}" appears more than once`
+            });
+        }
+        checkpointIds.add(id);
+    }
+    const preconditionKinds = new Set();
+    for (const [index, precondition] of contract.preconditions.entries()) {
+        if (preconditionKinds.has(precondition.kind)) {
+            context.addIssue({
+                code: "custom",
+                path: ["preconditions", index, "kind"],
+                message: `Precondition kind "${precondition.kind}" appears more than once`
+            });
+        }
+        preconditionKinds.add(precondition.kind);
+    }
+    const evidenceKeys = new Set();
+    for (const [index, requirement] of contract.evidenceRequirements.entries()) {
+        const key = `${requirement.kind}:${requirement.scope}`;
+        if (evidenceKeys.has(key)) {
+            context.addIssue({
+                code: "custom",
+                path: ["evidenceRequirements", index],
+                message: `Evidence requirement "${key}" appears more than once`
+            });
+        }
+        evidenceKeys.add(key);
+    }
+});
+export const ContractVerdictSchema = z.enum([
+    "pass",
+    "fail",
+    "inconclusive",
+    "needsReview",
+    "invalid"
+]);
+export const ContractVerdictReasonSchema = z.enum([
+    "CONTRACT_OK",
+    "RUN_FAILED",
+    "RUN_ERROR",
+    "RUN_MANUAL_REQUIRED",
+    "CHECKPOINT_FAILED",
+    "CHECKPOINT_UNRESOLVED",
+    "PRECONDITION_FAILED",
+    "PRECONDITION_UNRESOLVED",
+    "ASSERTION_FAILED",
+    "ASSERTION_UNRESOLVED",
+    "EVIDENCE_INSUFFICIENT",
+    "REVIEW_FINDINGS",
+    "JOURNEY_DRIFT",
+    "JOURNEY_MISSING",
+    "KNOWLEDGE_UNAVAILABLE",
+    "CONTRACT_INVALID"
+]);
+export const CONTRACT_VERDICT_POLICY_VERSION = "1";
+export const ContractReviewFindingSchema = z.strictObject({
+    finding: z.string().trim().min(1),
+    region: z.string().trim().min(1).optional(),
+    description: z.string().trim().min(1),
+    confidence: z.number().min(0).max(1),
+    recommendedAction: z.enum(["review", "fix"]).default("review")
+});
+export const ContractReviewInputSchema = z.strictObject({
+    version: z.literal(1),
+    source: z.string().trim().min(1),
+    model: z.string().trim().min(1).optional(),
+    promptVersion: z.string().trim().min(1).optional(),
+    findings: z.array(ContractReviewFindingSchema).min(1)
+});
+export const ContractReviewSchema = ContractReviewInputSchema.extend({
+    appliedAt: z.iso.datetime(),
+    applied: z.boolean(),
+    baseVerdict: ContractVerdictSchema,
+    baseReason: ContractVerdictReasonSchema
+}).strict();
+export const ContractProvenanceSchema = z.strictObject({
+    policyVersion: z.string().trim().min(1),
+    taphoundVersion: z.string().trim().min(1).optional(),
+    toolVersions: z.record(z.string(), z.string()).optional()
+});
+export const ContractPreconditionOutcomeSchema = z.strictObject({
+    kind: z.enum(["installed", "activity", "screen", "anchor"]),
+    status: z.enum(["passed", "failed", "unresolved", "notRun"]),
+    message: z.string().trim().min(1).optional()
+});
+export const ContractAssertionOutcomeSchema = z.strictObject({
+    type: z.enum(["activity", "element", "screen"]),
+    status: z.enum(["passed", "failed", "unresolved", "notRun"]),
+    message: z.string().trim().min(1).optional()
+});
+export const ContractEvidenceOutcomeSchema = z.strictObject({
+    kind: z.enum(["screenshot", "uiHierarchy", "logcat"]),
+    required: z.boolean(),
+    satisfied: z.boolean(),
+    detail: z.string().trim().min(1).optional()
+});
+export const ContractCheckpointOutcomeSchema = z.strictObject({
+    id: KnowledgeIdSchema,
+    status: z.enum(["passed", "failed", "unresolved", "notRun"]),
+    message: z.string().trim().min(1).optional()
+});
+export const ContractVerdictViewSchema = z.strictObject({
+    version: z.literal(1),
+    contractId: z.string().trim().min(1),
+    contractSha256: KnowledgeSha256Schema,
+    journeySha256: KnowledgeSha256Schema,
+    verdict: ContractVerdictSchema,
+    reason: ContractVerdictReasonSchema,
+    message: z.string().trim().min(1),
+    preconditions: z.array(ContractPreconditionOutcomeSchema),
+    assertions: z.array(ContractAssertionOutcomeSchema),
+    checkpoints: z.array(ContractCheckpointOutcomeSchema).optional(),
+    evidence: z.array(ContractEvidenceOutcomeSchema),
+    reportPath: z.string().trim().min(1).optional(),
+    reportStatus: z.enum(["passed", "failed", "error", "manualRequired"]).optional(),
+    startedAt: z.iso.datetime(),
+    finishedAt: z.iso.datetime(),
+    environment: z.strictObject({
+        projectRoot: z.string().trim().min(1),
+        packageName: z.string().trim().min(1),
+        devices: z.array(z.string().trim().min(1)).min(1)
+    }),
+    provenance: ContractProvenanceSchema.optional(),
+    review: ContractReviewSchema.optional()
+});