synorch 0.2.0 → 0.4.0-beta.0

package/dist/harness/contracts/packets.d.ts

@@ -0,0 +1,945 @@
+import { z } from "zod";
+import { type Digest } from "./digest.ts";
+export declare const planTaskSchema: z.ZodObject<{
+    key: z.ZodString;
+    role: z.ZodEnum<{
+        explorer: "explorer";
+        implementer: "implementer";
+        debugger: "debugger";
+        reviewer: "reviewer";
+    }>;
+    objective: z.ZodString;
+    depends_on: z.ZodArray<z.ZodString>;
+    owned_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    read_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    risk: z.ZodEnum<{
+        trivial: "trivial";
+        standard: "standard";
+        "high-risk": "high-risk";
+    }>;
+    model_tier: z.ZodEnum<{
+        orchestrator: "orchestrator";
+        complex_worker: "complex_worker";
+        fast_worker: "fast_worker";
+    }>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+        ultra: "ultra";
+    }>>;
+    agent: z.ZodOptional<z.ZodString>;
+    acceptance_criteria: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+    }, z.core.$strict>>;
+    verification: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type PlanTask = z.infer<typeof planTaskSchema>;
+/**
+ * Input of the `plan_propose` tool. Structural only: DAG, ownership and overlap rules are checked
+ * by `planSchema` once the harness adds `schema_version`, `plan_id`, `run_id`, `version`, `created_at`.
+ */
+export declare const planProposalSchema: z.ZodObject<{
+    goal: z.ZodString;
+    risk: z.ZodEnum<{
+        trivial: "trivial";
+        standard: "standard";
+        "high-risk": "high-risk";
+    }>;
+    scope: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    tasks: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        role: z.ZodEnum<{
+            explorer: "explorer";
+            implementer: "implementer";
+            debugger: "debugger";
+            reviewer: "reviewer";
+        }>;
+        objective: z.ZodString;
+        depends_on: z.ZodArray<z.ZodString>;
+        owned_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        read_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        risk: z.ZodEnum<{
+            trivial: "trivial";
+            standard: "standard";
+            "high-risk": "high-risk";
+        }>;
+        model_tier: z.ZodEnum<{
+            orchestrator: "orchestrator";
+            complex_worker: "complex_worker";
+            fast_worker: "fast_worker";
+        }>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            max: "max";
+            ultra: "ultra";
+        }>>;
+        agent: z.ZodOptional<z.ZodString>;
+        acceptance_criteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+        }, z.core.$strict>>;
+        verification: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    expected_external_effects: z.ZodArray<z.ZodString>;
+    verification: z.ZodArray<z.ZodString>;
+    budget: z.ZodObject<{
+        max_wall_time_seconds: z.ZodInt;
+        max_steps: z.ZodInt;
+        max_cost_usd: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    assumptions: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type PlanProposal = z.infer<typeof planProposalSchema>;
+/** The orchestrator's decision on a triaged worker report (`task_triage`, triage consultation only). */
+export declare const TRIAGE_DECISIONS: readonly ["accept", "retry", "review", "fail"];
+/**
+ * Input of the `task_triage` tool. `verification` (replacement verification commands) goes only
+ * with `retry` and only for a plan-caused verification problem; orchestration dry-runs it like
+ * `plan_propose` and revises the plan. Structural only: the decision rules live in orchestration.
+ */
+export declare const taskTriageInputSchema: z.ZodObject<{
+    task: z.ZodString;
+    decision: z.ZodEnum<{
+        review: "review";
+        accept: "accept";
+        retry: "retry";
+        fail: "fail";
+    }>;
+    waive_criteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    guidance: z.ZodOptional<z.ZodString>;
+    verification: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type TaskTriageInput = z.infer<typeof taskTriageInputSchema>;
+export declare const planSchema: z.ZodObject<{
+    created_at: z.ZodISODateTime;
+    goal: z.ZodString;
+    risk: z.ZodEnum<{
+        trivial: "trivial";
+        standard: "standard";
+        "high-risk": "high-risk";
+    }>;
+    scope: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    tasks: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        role: z.ZodEnum<{
+            explorer: "explorer";
+            implementer: "implementer";
+            debugger: "debugger";
+            reviewer: "reviewer";
+        }>;
+        objective: z.ZodString;
+        depends_on: z.ZodArray<z.ZodString>;
+        owned_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        read_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        risk: z.ZodEnum<{
+            trivial: "trivial";
+            standard: "standard";
+            "high-risk": "high-risk";
+        }>;
+        model_tier: z.ZodEnum<{
+            orchestrator: "orchestrator";
+            complex_worker: "complex_worker";
+            fast_worker: "fast_worker";
+        }>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            max: "max";
+            ultra: "ultra";
+        }>>;
+        agent: z.ZodOptional<z.ZodString>;
+        acceptance_criteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+        }, z.core.$strict>>;
+        verification: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    expected_external_effects: z.ZodArray<z.ZodString>;
+    verification: z.ZodArray<z.ZodString>;
+    budget: z.ZodObject<{
+        max_wall_time_seconds: z.ZodInt;
+        max_steps: z.ZodInt;
+        max_cost_usd: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    assumptions: z.ZodArray<z.ZodString>;
+    schema_version: z.ZodLiteral<1>;
+    plan_id: z.core.$ZodBranded<z.ZodString, "PlanId", "out">;
+    run_id: z.core.$ZodBranded<z.ZodString, "RunId", "out">;
+    version: z.ZodInt;
+}, z.core.$strict>;
+export type Plan = z.infer<typeof planSchema>;
+export declare function planDigest(plan: Plan): Digest;
+export declare const TASK_PACKET_SCHEMA_VERSION: 2;
+/** Per-file and total caps for read_paths contents inlined into a packet (ADR-20). */
+export declare const INLINE_SOURCE_MAX_BYTES: number;
+export declare const INLINE_SOURCES_MAX_TOTAL_BYTES: number;
+export declare const taskContextPacketSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<2>;
+    kind: z.ZodLiteral<"full">;
+    task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+    parent_task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+    run_id: z.core.$ZodBranded<z.ZodString, "RunId", "out">;
+    plan_id: z.core.$ZodBranded<z.ZodString, "PlanId", "out">;
+    plan_version: z.ZodInt;
+    plan_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+    role: z.ZodEnum<{
+        explorer: "explorer";
+        implementer: "implementer";
+        debugger: "debugger";
+        reviewer: "reviewer";
+    }>;
+    model_tier: z.ZodEnum<{
+        orchestrator: "orchestrator";
+        complex_worker: "complex_worker";
+        fast_worker: "fast_worker";
+    }>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+        ultra: "ultra";
+    }>>;
+    persona: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        instructions: z.ZodString;
+    }, z.core.$strict>>;
+    risk: z.ZodEnum<{
+        trivial: "trivial";
+        standard: "standard";
+        "high-risk": "high-risk";
+    }>;
+    write_mode: z.ZodEnum<{
+        "read-only": "read-only";
+        "owned-paths": "owned-paths";
+        "rca-only": "rca-only";
+    }>;
+    isolation: z.ZodEnum<{
+        worktree: "worktree";
+        "scoped-dir": "scoped-dir";
+        "shared-read-only": "shared-read-only";
+    }>;
+    objective: z.ZodString;
+    why: z.ZodObject<{
+        user_goal: z.ZodString;
+        plan_reference: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        owned_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        read_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        forbidden_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    }, z.core.$strict>;
+    known_facts: z.ZodArray<z.ZodObject<{
+        statement: z.ZodString;
+        source: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        source_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+        confidence: z.ZodEnum<{
+            verified: "verified";
+            inferred: "inferred";
+        }>;
+    }, z.core.$strict>>;
+    decisions: z.ZodArray<z.ZodString>;
+    relevant_symbols: z.ZodArray<z.ZodObject<{
+        file: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        symbols: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    acceptance_criteria: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+    }, z.core.$strict>>;
+    verification: z.ZodObject<{
+        commands: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    non_goals: z.ZodArray<z.ZodString>;
+    open_questions: z.ZodArray<z.ZodString>;
+    stop_conditions: z.ZodArray<z.ZodString>;
+    limits: z.ZodObject<{
+        max_steps: z.ZodInt;
+        max_wall_time_seconds: z.ZodInt;
+        max_tool_calls: z.ZodOptional<z.ZodInt>;
+        max_cost_usd: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    context: z.ZodObject<{
+        created_at: z.ZodISODateTime;
+        project_snapshot: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+        sources: z.ZodArray<z.ZodObject<{
+            path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+        }, z.core.$strict>>;
+        digest_scheme: z.ZodOptional<z.ZodEnum<{
+            "text-lf-v1": "text-lf-v1";
+            "workspace-raw-v1": "workspace-raw-v1";
+        }>>;
+        inline_sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+            content: z.ZodString;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    expected_report: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type TaskContextPacket = z.infer<typeof taskContextPacketSchema>;
+/**
+ * Follow-up to the same task. It can add criteria, evidence and facts; it can never touch scope,
+ * role, limits or write mode, so a delta cannot widen authority. Widening needs a new full packet.
+ */
+export declare const deltaTaskPacketSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<2>;
+    kind: z.ZodLiteral<"delta">;
+    task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+    extends_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+    plan_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+    created_at: z.ZodISODateTime;
+    delta: z.ZodObject<{
+        new_acceptance_criteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+        }, z.core.$strict>>;
+        new_known_facts: z.ZodArray<z.ZodObject<{
+            statement: z.ZodString;
+            source: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            source_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+            confidence: z.ZodEnum<{
+                verified: "verified";
+                inferred: "inferred";
+            }>;
+        }, z.core.$strict>>;
+        new_evidence: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                file: "file";
+                artifact: "artifact";
+                event: "event";
+                "harness-verification": "harness-verification";
+                "harness-diff": "harness-diff";
+                "tool-call": "tool-call";
+                "test-run": "test-run";
+                review: "review";
+            }>;
+            ref: z.ZodString;
+            digest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+            produced_by: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                reviewer: "reviewer";
+                user: "user";
+                worker: "worker";
+                harness: "harness";
+            }>;
+        }, z.core.$strict>>;
+        notes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type DeltaTaskPacket = z.infer<typeof deltaTaskPacketSchema>;
+export declare const anyTaskPacketSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schema_version: z.ZodLiteral<2>;
+    kind: z.ZodLiteral<"full">;
+    task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+    parent_task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+    run_id: z.core.$ZodBranded<z.ZodString, "RunId", "out">;
+    plan_id: z.core.$ZodBranded<z.ZodString, "PlanId", "out">;
+    plan_version: z.ZodInt;
+    plan_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+    role: z.ZodEnum<{
+        explorer: "explorer";
+        implementer: "implementer";
+        debugger: "debugger";
+        reviewer: "reviewer";
+    }>;
+    model_tier: z.ZodEnum<{
+        orchestrator: "orchestrator";
+        complex_worker: "complex_worker";
+        fast_worker: "fast_worker";
+    }>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+        ultra: "ultra";
+    }>>;
+    persona: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        instructions: z.ZodString;
+    }, z.core.$strict>>;
+    risk: z.ZodEnum<{
+        trivial: "trivial";
+        standard: "standard";
+        "high-risk": "high-risk";
+    }>;
+    write_mode: z.ZodEnum<{
+        "read-only": "read-only";
+        "owned-paths": "owned-paths";
+        "rca-only": "rca-only";
+    }>;
+    isolation: z.ZodEnum<{
+        worktree: "worktree";
+        "scoped-dir": "scoped-dir";
+        "shared-read-only": "shared-read-only";
+    }>;
+    objective: z.ZodString;
+    why: z.ZodObject<{
+        user_goal: z.ZodString;
+        plan_reference: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        owned_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        read_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        forbidden_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    }, z.core.$strict>;
+    known_facts: z.ZodArray<z.ZodObject<{
+        statement: z.ZodString;
+        source: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        source_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+        confidence: z.ZodEnum<{
+            verified: "verified";
+            inferred: "inferred";
+        }>;
+    }, z.core.$strict>>;
+    decisions: z.ZodArray<z.ZodString>;
+    relevant_symbols: z.ZodArray<z.ZodObject<{
+        file: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        symbols: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    acceptance_criteria: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+    }, z.core.$strict>>;
+    verification: z.ZodObject<{
+        commands: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    non_goals: z.ZodArray<z.ZodString>;
+    open_questions: z.ZodArray<z.ZodString>;
+    stop_conditions: z.ZodArray<z.ZodString>;
+    limits: z.ZodObject<{
+        max_steps: z.ZodInt;
+        max_wall_time_seconds: z.ZodInt;
+        max_tool_calls: z.ZodOptional<z.ZodInt>;
+        max_cost_usd: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    context: z.ZodObject<{
+        created_at: z.ZodISODateTime;
+        project_snapshot: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+        sources: z.ZodArray<z.ZodObject<{
+            path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+        }, z.core.$strict>>;
+        digest_scheme: z.ZodOptional<z.ZodEnum<{
+            "text-lf-v1": "text-lf-v1";
+            "workspace-raw-v1": "workspace-raw-v1";
+        }>>;
+        inline_sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+            content: z.ZodString;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    expected_report: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<2>;
+    kind: z.ZodLiteral<"delta">;
+    task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+    extends_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+    plan_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+    created_at: z.ZodISODateTime;
+    delta: z.ZodObject<{
+        new_acceptance_criteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+        }, z.core.$strict>>;
+        new_known_facts: z.ZodArray<z.ZodObject<{
+            statement: z.ZodString;
+            source: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            source_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+            confidence: z.ZodEnum<{
+                verified: "verified";
+                inferred: "inferred";
+            }>;
+        }, z.core.$strict>>;
+        new_evidence: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                file: "file";
+                artifact: "artifact";
+                event: "event";
+                "harness-verification": "harness-verification";
+                "harness-diff": "harness-diff";
+                "tool-call": "tool-call";
+                "test-run": "test-run";
+                review: "review";
+            }>;
+            ref: z.ZodString;
+            digest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+            produced_by: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                reviewer: "reviewer";
+                user: "user";
+                worker: "worker";
+                harness: "harness";
+            }>;
+        }, z.core.$strict>>;
+        notes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "kind">;
+export type AnyTaskPacket = z.infer<typeof anyTaskPacketSchema>;
+export declare const COMPLETION_STATUSES: readonly ["completed", "partial", "failed", "blocked", "needs_context"];
+export declare const completionPacketSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<2>;
+    task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+    attempt_id: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+    packet_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        needs_context: "needs_context";
+        blocked: "blocked";
+        partial: "partial";
+    }>;
+    summary: z.ZodString;
+    changed_paths: z.ZodArray<z.ZodObject<{
+        path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        before: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+        after: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+    }, z.core.$strict>>;
+    artifact_digest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+    tool_call_ids: z.ZodArray<z.ZodString>;
+    acceptance_evidence: z.ZodArray<z.ZodObject<{
+        criterion_id: z.ZodString;
+        evidence: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                file: "file";
+                artifact: "artifact";
+                event: "event";
+                "harness-verification": "harness-verification";
+                "harness-diff": "harness-diff";
+                "tool-call": "tool-call";
+                "test-run": "test-run";
+                review: "review";
+            }>;
+            ref: z.ZodString;
+            digest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+            produced_by: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                reviewer: "reviewer";
+                user: "user";
+                worker: "worker";
+                harness: "harness";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    commands_run: z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        exit_code: z.ZodInt;
+        evidence: z.ZodObject<{
+            kind: z.ZodEnum<{
+                file: "file";
+                artifact: "artifact";
+                event: "event";
+                "harness-verification": "harness-verification";
+                "harness-diff": "harness-diff";
+                "tool-call": "tool-call";
+                "test-run": "test-run";
+                review: "review";
+            }>;
+            ref: z.ZodString;
+            digest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+            produced_by: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                reviewer: "reviewer";
+                user: "user";
+                worker: "worker";
+                harness: "harness";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    decisions_made: z.ZodArray<z.ZodString>;
+    skipped_checks: z.ZodArray<z.ZodObject<{
+        check: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    unresolved_risks: z.ZodArray<z.ZodString>;
+    recommended_context_updates: z.ZodArray<z.ZodString>;
+    root_cause: z.ZodOptional<z.ZodString>;
+    harness_evidence: z.ZodOptional<z.ZodObject<{
+        verification: z.ZodArray<z.ZodObject<{
+            ordinal: z.ZodInt;
+            command: z.ZodString;
+            command_class: z.ZodOptional<z.ZodEnum<{
+                other: "other";
+                "build-test": "build-test";
+                "read-only": "read-only";
+            }>>;
+            status: z.ZodEnum<{
+                failed: "failed";
+                passed: "passed";
+                "not-run": "not-run";
+            }>;
+            termination: z.ZodOptional<z.ZodEnum<{
+                cancelled: "cancelled";
+                timeout: "timeout";
+                exited: "exited";
+                "spawn-failed": "spawn-failed";
+            }>>;
+            exit_code: z.ZodNullable<z.ZodInt>;
+            reason: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    file: "file";
+                    artifact: "artifact";
+                    event: "event";
+                    "harness-verification": "harness-verification";
+                    "harness-diff": "harness-diff";
+                    "tool-call": "tool-call";
+                    "test-run": "test-run";
+                    review: "review";
+                }>;
+                ref: z.ZodString;
+                digest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+                produced_by: z.ZodEnum<{
+                    orchestrator: "orchestrator";
+                    reviewer: "reviewer";
+                    user: "user";
+                    worker: "worker";
+                    harness: "harness";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        diff: z.ZodOptional<z.ZodObject<{
+            evidence: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    file: "file";
+                    artifact: "artifact";
+                    event: "event";
+                    "harness-verification": "harness-verification";
+                    "harness-diff": "harness-diff";
+                    "tool-call": "tool-call";
+                    "test-run": "test-run";
+                    review: "review";
+                }>;
+                ref: z.ZodString;
+                digest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+                produced_by: z.ZodEnum<{
+                    orchestrator: "orchestrator";
+                    reviewer: "reviewer";
+                    user: "user";
+                    worker: "worker";
+                    harness: "harness";
+                }>;
+            }, z.core.$strict>;
+            changed_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    evidence_resolution: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        criterion_id: z.ZodOptional<z.ZodString>;
+        kind: z.ZodEnum<{
+            file: "file";
+            artifact: "artifact";
+            event: "event";
+            "harness-verification": "harness-verification";
+            "harness-diff": "harness-diff";
+            "tool-call": "tool-call";
+            "test-run": "test-run";
+            review: "review";
+        }>;
+        ref: z.ZodString;
+        produced_by: z.ZodEnum<{
+            orchestrator: "orchestrator";
+            reviewer: "reviewer";
+            user: "user";
+            worker: "worker";
+            harness: "harness";
+        }>;
+        status: z.ZodEnum<{
+            resolved: "resolved";
+            unresolved: "unresolved";
+        }>;
+        method: z.ZodOptional<z.ZodEnum<{
+            "tool-call-id": "tool-call-id";
+            "short-ref": "short-ref";
+            "provider-call-id": "provider-call-id";
+            "tool-name-args": "tool-name-args";
+            "path-token": "path-token";
+            "artifact-digest": "artifact-digest";
+            "event-ref": "event-ref";
+            "harness-record": "harness-record";
+            "harness-substitute": "harness-substitute";
+        }>>;
+        tool_call_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ToolCallId", "out">>;
+        path: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    repairs: z.ZodOptional<z.ZodObject<{
+        report_corrections: z.ZodInt;
+        evidence_repairs: z.ZodInt;
+        verification_repairs: z.ZodInt;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CompletionPacket = z.infer<typeof completionPacketSchema>;
+export declare const FINDING_SEVERITIES: readonly ["blocker", "major", "minor", "info"];
+export declare const REVIEW_DECISIONS: readonly ["accept", "revise", "block"];
+export declare const reviewPacketSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<2>;
+    task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+    reviewed_attempt_id: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+    reviewer_attempt_id: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+    completion_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+    reviewed_artifact_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+    reviewer_route: z.ZodObject<{
+        provider_id: z.core.$ZodBranded<z.ZodString, "ProviderId", "out">;
+        model_id: z.core.$ZodBranded<z.ZodString, "ModelId", "out">;
+    }, z.core.$strict>;
+    independence: z.ZodObject<{
+        separate_context: z.ZodLiteral<true>;
+        same_provider: z.ZodBoolean;
+        same_model: z.ZodBoolean;
+    }, z.core.$strict>;
+    criteria: z.ZodArray<z.ZodObject<{
+        criterion_id: z.ZodString;
+        verdict: z.ZodEnum<{
+            met: "met";
+            not_met: "not_met";
+            unverifiable: "unverifiable";
+        }>;
+        evidence: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                file: "file";
+                artifact: "artifact";
+                event: "event";
+                "harness-verification": "harness-verification";
+                "harness-diff": "harness-diff";
+                "tool-call": "tool-call";
+                "test-run": "test-run";
+                review: "review";
+            }>;
+            ref: z.ZodString;
+            digest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+            produced_by: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                reviewer: "reviewer";
+                user: "user";
+                worker: "worker";
+                harness: "harness";
+            }>;
+        }, z.core.$strict>>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    findings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<{
+            info: "info";
+            blocker: "blocker";
+            major: "major";
+            minor: "minor";
+        }>;
+        summary: z.ZodString;
+        path: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        line: z.ZodOptional<z.ZodInt>;
+        reproduction: z.ZodOptional<z.ZodString>;
+        recommendation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    decision: z.ZodEnum<{
+        accept: "accept";
+        revise: "revise";
+        block: "block";
+    }>;
+    evidence_resolution: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        criterion_id: z.ZodOptional<z.ZodString>;
+        kind: z.ZodEnum<{
+            file: "file";
+            artifact: "artifact";
+            event: "event";
+            "harness-verification": "harness-verification";
+            "harness-diff": "harness-diff";
+            "tool-call": "tool-call";
+            "test-run": "test-run";
+            review: "review";
+        }>;
+        ref: z.ZodString;
+        produced_by: z.ZodEnum<{
+            orchestrator: "orchestrator";
+            reviewer: "reviewer";
+            user: "user";
+            worker: "worker";
+            harness: "harness";
+        }>;
+        status: z.ZodEnum<{
+            resolved: "resolved";
+            unresolved: "unresolved";
+        }>;
+        method: z.ZodOptional<z.ZodEnum<{
+            "tool-call-id": "tool-call-id";
+            "short-ref": "short-ref";
+            "provider-call-id": "provider-call-id";
+            "tool-name-args": "tool-name-args";
+            "path-token": "path-token";
+            "artifact-digest": "artifact-digest";
+            "event-ref": "event-ref";
+            "harness-record": "harness-record";
+            "harness-substitute": "harness-substitute";
+        }>>;
+        tool_call_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ToolCallId", "out">>;
+        path: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    repairs: z.ZodOptional<z.ZodObject<{
+        report_corrections: z.ZodInt;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ReviewPacket = z.infer<typeof reviewPacketSchema>;
+/**
+ * Structured report tools (control effect). A worker ends its attempt with `task_report`, a
+ * reviewer with `review_report`, the orchestrator proposes a plan with `plan_propose`. The gateway
+ * validates the input against these schemas (the model gets `invalid_arguments` back and can retry)
+ * and records the call; orchestration reads the arguments of the last *succeeded* report call from
+ * the attempt log. A report is a claim: identity, changed paths, the artifact digest and tool call
+ * ids are always computed by the harness, and every evidence pointer is verified against the log.
+ */
+export declare const REPORT_TOOL_NAMES: {
+    readonly task: "task_report";
+    readonly review: "review_report";
+    readonly plan: "plan_propose";
+};
+export type ReportToolName = (typeof REPORT_TOOL_NAMES)[keyof typeof REPORT_TOOL_NAMES];
+export declare const taskReportInputSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        needs_context: "needs_context";
+        blocked: "blocked";
+        partial: "partial";
+    }>;
+    summary: z.ZodString;
+    acceptance_evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        criterion_id: z.ZodString;
+        evidence: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                file: "file";
+                artifact: "artifact";
+                event: "event";
+                "harness-verification": "harness-verification";
+                "harness-diff": "harness-diff";
+                "tool-call": "tool-call";
+                "test-run": "test-run";
+                review: "review";
+            }>;
+            ref: z.ZodString;
+            digest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+            produced_by: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                reviewer: "reviewer";
+                user: "user";
+                worker: "worker";
+                harness: "harness";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    commands_run: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        exit_code: z.ZodInt;
+        evidence: z.ZodObject<{
+            kind: z.ZodEnum<{
+                file: "file";
+                artifact: "artifact";
+                event: "event";
+                "harness-verification": "harness-verification";
+                "harness-diff": "harness-diff";
+                "tool-call": "tool-call";
+                "test-run": "test-run";
+                review: "review";
+            }>;
+            ref: z.ZodString;
+            digest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+            produced_by: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                reviewer: "reviewer";
+                user: "user";
+                worker: "worker";
+                harness: "harness";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+    decisions_made: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    skipped_checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        check: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>>;
+    unresolved_risks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    recommended_context_updates: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    root_cause: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type TaskReportInput = z.infer<typeof taskReportInputSchema>;
+export declare const reviewReportInputSchema: z.ZodObject<{
+    criteria: z.ZodArray<z.ZodObject<{
+        criterion_id: z.ZodString;
+        verdict: z.ZodEnum<{
+            met: "met";
+            not_met: "not_met";
+            unverifiable: "unverifiable";
+        }>;
+        note: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                file: "file";
+                artifact: "artifact";
+                event: "event";
+                "harness-verification": "harness-verification";
+                "harness-diff": "harness-diff";
+                "tool-call": "tool-call";
+                "test-run": "test-run";
+                review: "review";
+            }>;
+            ref: z.ZodString;
+            digest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+            produced_by: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                reviewer: "reviewer";
+                user: "user";
+                worker: "worker";
+                harness: "harness";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    findings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<{
+            info: "info";
+            blocker: "blocker";
+            major: "major";
+            minor: "minor";
+        }>;
+        summary: z.ZodString;
+        path: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        line: z.ZodOptional<z.ZodInt>;
+        reproduction: z.ZodOptional<z.ZodString>;
+        recommendation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    decision: z.ZodEnum<{
+        accept: "accept";
+        revise: "revise";
+        block: "block";
+    }>;
+}, z.core.$strict>;
+export type ReviewReportInput = z.infer<typeof reviewReportInputSchema>;
+export declare function packetDigest(packet: AnyTaskPacket | CompletionPacket | ReviewPacket): Digest;
+/**
+ * Freshness gate for dispatch: every cited source must still hash to the digest in the packet.
+ * `current` maps workspace-relative paths to their present digests (undefined = missing), computed
+ * with the packet's `context.digest_scheme` in the workspace the packet was computed against (the
+ * attempt workspace for `workspace-raw-v1`, ADR-19).
+ */
+export declare function findStaleSources(packet: TaskContextPacket, current: ReadonlyMap<string, Digest | undefined>): readonly {
+    readonly path: string;
+    readonly expected: Digest;
+    readonly actual: Digest | undefined;
+}[];
+//# sourceMappingURL=packets.d.ts.map