opencode-plugin-flow 4.4.0 → 5.0.0

package/dist/{runtime → application}/schema.d.ts

@@ -1,64 +1,64 @@
 import { z } from "zod";
-export declare const FEATURE_ID_PATTERN: RegExp;
-export declare const FEATURE_ID_MESSAGE = "Feature ids must be lowercase kebab-case";
+export { hasCandidateExecutionEvidence, hasVerifierExecutionEvidence, isCandidateShapedDecision, } from "../domain/orchestration-policy.js";
+export declare const FeatureIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
 export declare const FeatureStatusSchema: z.ZodEnum<{
-    pending: "pending";
-    in_progress: "in_progress";
-    completed: "completed";
     blocked: "blocked";
+    completed: "completed";
+    in_progress: "in_progress";
+    pending: "pending";
 }>;
 export declare const SessionStatusSchema: z.ZodEnum<{
-    completed: "completed";
     blocked: "blocked";
+    completed: "completed";
     planning: "planning";
     ready: "ready";
     running: "running";
 }>;
 export declare const ReviewStatusSchema: z.ZodEnum<{
-    passed: "passed";
     failed: "failed";
+    passed: "passed";
 }>;
 export declare const ValidationStatusSchema: z.ZodEnum<{
-    passed: "passed";
     failed: "failed";
+    passed: "passed";
 }>;
 export declare const ValidationScopeSchema: z.ZodEnum<{
-    targeted: "targeted";
     broad: "broad";
+    targeted: "targeted";
 }>;
 export declare const FeatureReviewDepthSchema: z.ZodEnum<{
+    detailed: "detailed";
     quick: "quick";
     standard: "standard";
-    detailed: "detailed";
 }>;
 export declare const FinalReviewPolicySchema: z.ZodEnum<{
     broad: "broad";
     detailed: "detailed";
 }>;
 export declare const OrchestrationPassKindSchema: z.ZodEnum<{
-    validation: "validation";
     audit: "audit";
     candidate: "candidate";
     discovery: "discovery";
+    "implementation-decision": "implementation-decision";
     review: "review";
+    validation: "validation";
     verification: "verification";
-    "implementation-decision": "implementation-decision";
 }>;
 export declare const OrchestrationModeSchema: z.ZodEnum<{
+    audit: "audit";
+    "candidate-implementation": "candidate-implementation";
     evidence: "evidence";
+    review: "review";
     validation: "validation";
-    audit: "audit";
     verifier: "verifier";
-    review: "review";
-    "candidate-implementation": "candidate-implementation";
 }>;
 export declare const OrchestrationDecisionSchema: z.ZodEnum<{
-    parallel: "parallel";
-    serial: "serial";
     "candidate-exact-path": "candidate-exact-path";
     "candidate-worktree": "candidate-worktree";
-    tournament: "tournament";
+    parallel: "parallel";
+    serial: "serial";
     skipped: "skipped";
+    tournament: "tournament";
 }>;
 export declare const OrchestrationCandidateEligibilitySchema: z.ZodEnum<{
     eligible: "eligible";
@@ -66,70 +66,59 @@ export declare const OrchestrationCandidateEligibilitySchema: z.ZodEnum<{
     unknown: "unknown";
 }>;
 export declare const OrchestrationCandidateDecisionSchema: z.ZodEnum<{
+    serial_required: "serial_required";
     skipped: "skipped";
     used: "used";
-    serial_required: "serial_required";
 }>;
 export declare const OrchestrationDecisionFactorSchema: z.ZodEnum<{
-    shared_state: "shared_state";
+    independent_surface: "independent_surface";
+    needs_manager_judgment: "needs_manager_judgment";
     overlapping_files: "overlapping_files";
+    shared_state: "shared_state";
     small_slice: "small_slice";
-    needs_manager_judgment: "needs_manager_judgment";
-    independent_surface: "independent_surface";
     validation_available: "validation_available";
 }>;
 export declare const OrchestrationWriteScopeSchema: z.ZodEnum<{
-    none: "none";
-    "manager-serial": "manager-serial";
     "exact-path": "exact-path";
     "isolated-worktree": "isolated-worktree";
+    "manager-serial": "manager-serial";
     mixed: "mixed";
+    none: "none";
 }>;
 export declare const OrchestrationVerificationStatusSchema: z.ZodEnum<{
-    pending: "pending";
-    passed: "passed";
+    downgraded: "downgraded";
     failed: "failed";
     mixed: "mixed";
     "not-needed": "not-needed";
-    downgraded: "downgraded";
+    passed: "passed";
+    pending: "pending";
 }>;
 export declare const OrchestrationOutcomeSchema: z.ZodEnum<{
     accepted: "accepted";
     modified: "modified";
-    rejected: "rejected";
-    partial: "partial";
     "not-covered": "not-covered";
+    partial: "partial";
+    rejected: "rejected";
     superseded: "superseded";
 }>;
-export declare function isCandidateShapedDecision(decision: string | undefined): boolean;
-export declare function hasCandidateExecutionEvidence(pass: {
-    kind: string;
-    modes: readonly string[];
-    candidateWorkerCount: number;
-}): boolean;
-export declare function hasVerifierExecutionEvidence(pass: {
-    kind: string;
-    modes: readonly string[];
-    verifierWorkerCount: number;
-}): boolean;
 export declare const OrchestrationPassRecordSchema: z.ZodObject<{
     id: z.ZodString;
     kind: z.ZodEnum<{
-        validation: "validation";
         audit: "audit";
         candidate: "candidate";
         discovery: "discovery";
+        "implementation-decision": "implementation-decision";
         review: "review";
+        validation: "validation";
         verification: "verification";
-        "implementation-decision": "implementation-decision";
     }>;
     decision: z.ZodOptional<z.ZodEnum<{
-        parallel: "parallel";
-        serial: "serial";
         "candidate-exact-path": "candidate-exact-path";
         "candidate-worktree": "candidate-worktree";
-        tournament: "tournament";
+        parallel: "parallel";
+        serial: "serial";
         skipped: "skipped";
+        tournament: "tournament";
     }>>;
     decisionReason: z.ZodOptional<z.ZodString>;
     candidateEligibility: z.ZodDefault<z.ZodEnum<{
@@ -138,25 +127,25 @@ export declare const OrchestrationPassRecordSchema: z.ZodObject<{
         unknown: "unknown";
     }>>;
     candidateDecision: z.ZodOptional<z.ZodEnum<{
+        serial_required: "serial_required";
         skipped: "skipped";
         used: "used";
-        serial_required: "serial_required";
     }>>;
     decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        shared_state: "shared_state";
+        independent_surface: "independent_surface";
+        needs_manager_judgment: "needs_manager_judgment";
         overlapping_files: "overlapping_files";
+        shared_state: "shared_state";
         small_slice: "small_slice";
-        needs_manager_judgment: "needs_manager_judgment";
-        independent_surface: "independent_surface";
         validation_available: "validation_available";
     }>>>;
     modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        audit: "audit";
+        "candidate-implementation": "candidate-implementation";
         evidence: "evidence";
+        review: "review";
         validation: "validation";
-        audit: "audit";
         verifier: "verifier";
-        review: "review";
-        "candidate-implementation": "candidate-implementation";
     }>>>;
     workerCount: z.ZodDefault<z.ZodNumber>;
     candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
@@ -164,27 +153,27 @@ export declare const OrchestrationPassRecordSchema: z.ZodObject<{
     sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
     dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
     writeScope: z.ZodDefault<z.ZodEnum<{
-        none: "none";
-        "manager-serial": "manager-serial";
         "exact-path": "exact-path";
         "isolated-worktree": "isolated-worktree";
+        "manager-serial": "manager-serial";
         mixed: "mixed";
+        none: "none";
     }>>;
     handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
     verificationStatus: z.ZodDefault<z.ZodEnum<{
-        pending: "pending";
-        passed: "passed";
+        downgraded: "downgraded";
         failed: "failed";
         mixed: "mixed";
         "not-needed": "not-needed";
-        downgraded: "downgraded";
+        passed: "passed";
+        pending: "pending";
     }>>;
     outcome: z.ZodDefault<z.ZodEnum<{
         accepted: "accepted";
         modified: "modified";
-        rejected: "rejected";
-        partial: "partial";
         "not-covered": "not-covered";
+        partial: "partial";
+        rejected: "rejected";
         superseded: "superseded";
     }>>;
     synthesisRef: z.ZodOptional<z.ZodString>;
@@ -198,25 +187,24 @@ export declare const OrchestrationTelemetrySchema: z.ZodObject<{
     candidateUsedDecisionCount: z.ZodDefault<z.ZodNumber>;
     candidateSerialRequiredDecisionCount: z.ZodDefault<z.ZodNumber>;
     skippedCandidateDecisionCount: z.ZodDefault<z.ZodNumber>;
-    recordedPassIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
     latestPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         kind: z.ZodEnum<{
-            validation: "validation";
             audit: "audit";
             candidate: "candidate";
             discovery: "discovery";
+            "implementation-decision": "implementation-decision";
             review: "review";
+            validation: "validation";
             verification: "verification";
-            "implementation-decision": "implementation-decision";
         }>;
         decision: z.ZodOptional<z.ZodEnum<{
-            parallel: "parallel";
-            serial: "serial";
             "candidate-exact-path": "candidate-exact-path";
             "candidate-worktree": "candidate-worktree";
-            tournament: "tournament";
+            parallel: "parallel";
+            serial: "serial";
             skipped: "skipped";
+            tournament: "tournament";
         }>>;
         decisionReason: z.ZodOptional<z.ZodString>;
         candidateEligibility: z.ZodDefault<z.ZodEnum<{
@@ -225,25 +213,25 @@ export declare const OrchestrationTelemetrySchema: z.ZodObject<{
             unknown: "unknown";
         }>>;
         candidateDecision: z.ZodOptional<z.ZodEnum<{
+            serial_required: "serial_required";
             skipped: "skipped";
             used: "used";
-            serial_required: "serial_required";
         }>>;
         decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            shared_state: "shared_state";
+            independent_surface: "independent_surface";
+            needs_manager_judgment: "needs_manager_judgment";
             overlapping_files: "overlapping_files";
+            shared_state: "shared_state";
             small_slice: "small_slice";
-            needs_manager_judgment: "needs_manager_judgment";
-            independent_surface: "independent_surface";
             validation_available: "validation_available";
         }>>>;
         modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            audit: "audit";
+            "candidate-implementation": "candidate-implementation";
             evidence: "evidence";
+            review: "review";
             validation: "validation";
-            audit: "audit";
             verifier: "verifier";
-            review: "review";
-            "candidate-implementation": "candidate-implementation";
         }>>>;
         workerCount: z.ZodDefault<z.ZodNumber>;
         candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
@@ -251,27 +239,27 @@ export declare const OrchestrationTelemetrySchema: z.ZodObject<{
         sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
         dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
         writeScope: z.ZodDefault<z.ZodEnum<{
-            none: "none";
-            "manager-serial": "manager-serial";
             "exact-path": "exact-path";
             "isolated-worktree": "isolated-worktree";
+            "manager-serial": "manager-serial";
             mixed: "mixed";
+            none: "none";
         }>>;
         handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
         verificationStatus: z.ZodDefault<z.ZodEnum<{
-            pending: "pending";
-            passed: "passed";
+            downgraded: "downgraded";
             failed: "failed";
             mixed: "mixed";
             "not-needed": "not-needed";
-            downgraded: "downgraded";
+            passed: "passed";
+            pending: "pending";
         }>>;
         outcome: z.ZodDefault<z.ZodEnum<{
             accepted: "accepted";
             modified: "modified";
-            rejected: "rejected";
-            partial: "partial";
             "not-covered": "not-covered";
+            partial: "partial";
+            rejected: "rejected";
             superseded: "superseded";
         }>>;
         synthesisRef: z.ZodOptional<z.ZodString>;
@@ -280,35 +268,35 @@ export declare const OrchestrationTelemetrySchema: z.ZodObject<{
 export declare const ReviewFindingSchema: z.ZodObject<{
     summary: z.ZodString;
     severity: z.ZodDefault<z.ZodEnum<{
-        blocking: "blocking";
         advisory: "advisory";
+        blocking: "blocking";
     }>>;
 }, z.core.$strict>;
 export declare const ReviewSchema: z.ZodObject<{
     status: z.ZodEnum<{
-        passed: "passed";
         failed: "failed";
+        passed: "passed";
     }>;
     summary: z.ZodString;
     blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
         summary: z.ZodString;
         severity: z.ZodDefault<z.ZodEnum<{
-            blocking: "blocking";
             advisory: "advisory";
+            blocking: "blocking";
         }>>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 export declare const FinalReviewSchema: z.ZodObject<{
     status: z.ZodEnum<{
-        passed: "passed";
         failed: "failed";
+        passed: "passed";
     }>;
     summary: z.ZodString;
     blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
         summary: z.ZodString;
         severity: z.ZodDefault<z.ZodEnum<{
-            blocking: "blocking";
             advisory: "advisory";
+            blocking: "blocking";
         }>>;
     }, z.core.$strict>>>;
     reviewDepth: z.ZodEnum<{
@@ -319,8 +307,8 @@ export declare const FinalReviewSchema: z.ZodObject<{
 export declare const ValidationRunSchema: z.ZodObject<{
     command: z.ZodString;
     status: z.ZodEnum<{
-        passed: "passed";
         failed: "failed";
+        passed: "passed";
     }>;
     summary: z.ZodString;
 }, z.core.$strict>;
@@ -328,23 +316,23 @@ export declare const ArtifactSchema: z.ZodObject<{
     path: z.ZodString;
 }, z.core.$strict>;
 export declare const FeatureSchema: z.ZodObject<{
-    id: z.ZodString;
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
     title: z.ZodString;
     summary: z.ZodString;
     status: z.ZodDefault<z.ZodEnum<{
-        pending: "pending";
-        in_progress: "in_progress";
-        completed: "completed";
         blocked: "blocked";
+        completed: "completed";
+        in_progress: "in_progress";
+        pending: "pending";
     }>>;
     reviewDepth: z.ZodDefault<z.ZodEnum<{
+        detailed: "detailed";
         quick: "quick";
         standard: "standard";
-        detailed: "detailed";
     }>>;
     targets: z.ZodDefault<z.ZodArray<z.ZodString>>;
     validation: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    dependsOn: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>>>;
 }, z.core.$strict>;
 export declare const PlanSchema: z.ZodObject<{
     summary: z.ZodString;
@@ -356,23 +344,23 @@ export declare const PlanSchema: z.ZodObject<{
         detailed: "detailed";
     }>>;
     features: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
+        id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
         title: z.ZodString;
         summary: z.ZodString;
         status: z.ZodDefault<z.ZodEnum<{
-            pending: "pending";
-            in_progress: "in_progress";
-            completed: "completed";
             blocked: "blocked";
+            completed: "completed";
+            in_progress: "in_progress";
+            pending: "pending";
         }>>;
         reviewDepth: z.ZodDefault<z.ZodEnum<{
+            detailed: "detailed";
             quick: "quick";
             standard: "standard";
-            detailed: "detailed";
         }>>;
         targets: z.ZodDefault<z.ZodArray<z.ZodString>>;
         validation: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        dependsOn: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const PlanInputSchema: z.ZodObject<{
@@ -385,47 +373,55 @@ export declare const PlanInputSchema: z.ZodObject<{
         detailed: "detailed";
     }>>;
     features: z.ZodArray<z.ZodObject<{
-        summary: z.ZodString;
-        id: z.ZodString;
+        id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
         title: z.ZodString;
+        summary: z.ZodString;
         status: z.ZodOptional<z.ZodEnum<{
-            pending: "pending";
-            in_progress: "in_progress";
-            completed: "completed";
             blocked: "blocked";
+            completed: "completed";
+            in_progress: "in_progress";
+            pending: "pending";
         }>>;
         reviewDepth: z.ZodOptional<z.ZodEnum<{
+            detailed: "detailed";
             quick: "quick";
             standard: "standard";
-            detailed: "detailed";
         }>>;
         targets: z.ZodOptional<z.ZodArray<z.ZodString>>;
         validation: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dependsOn: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export declare const WorkerOutcomeSchema: z.ZodObject<{
-    kind: z.ZodDefault<z.ZodEnum<{
-        completed: "completed";
-        blocked: "blocked";
-        needs_input: "needs_input";
-        replan_required: "replan_required";
-    }>>;
+export declare const CompletedWorkerOutcomeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"completed">;
     summary: z.ZodOptional<z.ZodString>;
     resolutionHint: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const NeedsInputOutcomeSchema: z.ZodObject<{
-    kind: z.ZodDefault<z.ZodEnum<{
+    kind: z.ZodEnum<{
         blocked: "blocked";
         needs_input: "needs_input";
         replan_required: "replan_required";
-    }>>;
+    }>;
     summary: z.ZodString;
     resolutionHint: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+export declare const WorkerOutcomeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"completed">;
+    summary: z.ZodOptional<z.ZodString>;
+    resolutionHint: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodEnum<{
+        blocked: "blocked";
+        needs_input: "needs_input";
+        replan_required: "replan_required";
+    }>;
+    summary: z.ZodString;
+    resolutionHint: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "kind">;
 export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     status: z.ZodLiteral<"ok">;
-    featureId: z.ZodString;
+    featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
     summary: z.ZodString;
     artifactsChanged: z.ZodDefault<z.ZodArray<z.ZodObject<{
         path: z.ZodString;
@@ -433,45 +429,45 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     validationRun: z.ZodDefault<z.ZodArray<z.ZodObject<{
         command: z.ZodString;
         status: z.ZodEnum<{
-            passed: "passed";
             failed: "failed";
+            passed: "passed";
         }>;
         summary: z.ZodString;
     }, z.core.$strict>>>;
     validationScope: z.ZodEnum<{
-        targeted: "targeted";
         broad: "broad";
+        targeted: "targeted";
     }>;
     featureReviewDepth: z.ZodEnum<{
+        detailed: "detailed";
         quick: "quick";
         standard: "standard";
-        detailed: "detailed";
     }>;
     featureReview: z.ZodObject<{
         status: z.ZodEnum<{
-            passed: "passed";
             failed: "failed";
+            passed: "passed";
         }>;
         summary: z.ZodString;
         blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
             summary: z.ZodString;
             severity: z.ZodDefault<z.ZodEnum<{
-                blocking: "blocking";
                 advisory: "advisory";
+                blocking: "blocking";
             }>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>;
     finalReview: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
-            passed: "passed";
             failed: "failed";
+            passed: "passed";
         }>;
         summary: z.ZodString;
         blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
             summary: z.ZodString;
             severity: z.ZodDefault<z.ZodEnum<{
-                blocking: "blocking";
                 advisory: "advisory";
+                blocking: "blocking";
             }>>;
         }, z.core.$strict>>>;
         reviewDepth: z.ZodEnum<{
@@ -480,33 +476,28 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>;
     }, z.core.$strict>>;
     outcome: z.ZodOptional<z.ZodObject<{
-        kind: z.ZodDefault<z.ZodEnum<{
-            completed: "completed";
-            blocked: "blocked";
-            needs_input: "needs_input";
-            replan_required: "replan_required";
-        }>>;
+        kind: z.ZodLiteral<"completed">;
         summary: z.ZodOptional<z.ZodString>;
         resolutionHint: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     orchestrationPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         kind: z.ZodEnum<{
-            validation: "validation";
             audit: "audit";
             candidate: "candidate";
             discovery: "discovery";
+            "implementation-decision": "implementation-decision";
             review: "review";
+            validation: "validation";
             verification: "verification";
-            "implementation-decision": "implementation-decision";
         }>;
         decision: z.ZodOptional<z.ZodEnum<{
-            parallel: "parallel";
-            serial: "serial";
             "candidate-exact-path": "candidate-exact-path";
             "candidate-worktree": "candidate-worktree";
-            tournament: "tournament";
+            parallel: "parallel";
+            serial: "serial";
             skipped: "skipped";
+            tournament: "tournament";
         }>>;
         decisionReason: z.ZodOptional<z.ZodString>;
         candidateEligibility: z.ZodDefault<z.ZodEnum<{
@@ -515,25 +506,25 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             unknown: "unknown";
         }>>;
         candidateDecision: z.ZodOptional<z.ZodEnum<{
+            serial_required: "serial_required";
             skipped: "skipped";
             used: "used";
-            serial_required: "serial_required";
         }>>;
         decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            shared_state: "shared_state";
+            independent_surface: "independent_surface";
+            needs_manager_judgment: "needs_manager_judgment";
             overlapping_files: "overlapping_files";
+            shared_state: "shared_state";
             small_slice: "small_slice";
-            needs_manager_judgment: "needs_manager_judgment";
-            independent_surface: "independent_surface";
             validation_available: "validation_available";
         }>>>;
         modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            audit: "audit";
+            "candidate-implementation": "candidate-implementation";
             evidence: "evidence";
+            review: "review";
             validation: "validation";
-            audit: "audit";
             verifier: "verifier";
-            review: "review";
-            "candidate-implementation": "candidate-implementation";
         }>>>;
         workerCount: z.ZodDefault<z.ZodNumber>;
         candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
@@ -541,34 +532,34 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
         dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
         writeScope: z.ZodDefault<z.ZodEnum<{
-            none: "none";
-            "manager-serial": "manager-serial";
             "exact-path": "exact-path";
             "isolated-worktree": "isolated-worktree";
+            "manager-serial": "manager-serial";
             mixed: "mixed";
+            none: "none";
         }>>;
         handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
         verificationStatus: z.ZodDefault<z.ZodEnum<{
-            pending: "pending";
-            passed: "passed";
+            downgraded: "downgraded";
             failed: "failed";
             mixed: "mixed";
             "not-needed": "not-needed";
-            downgraded: "downgraded";
+            passed: "passed";
+            pending: "pending";
         }>>;
         outcome: z.ZodDefault<z.ZodEnum<{
             accepted: "accepted";
             modified: "modified";
-            rejected: "rejected";
-            partial: "partial";
             "not-covered": "not-covered";
+            partial: "partial";
+            rejected: "rejected";
             superseded: "superseded";
         }>>;
         synthesisRef: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
 }, z.core.$strict>, z.ZodObject<{
     status: z.ZodLiteral<"needs_input">;
-    featureId: z.ZodString;
+    featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
     summary: z.ZodString;
     artifactsChanged: z.ZodDefault<z.ZodArray<z.ZodObject<{
         path: z.ZodString;
@@ -576,45 +567,45 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     validationRun: z.ZodDefault<z.ZodArray<z.ZodObject<{
         command: z.ZodString;
         status: z.ZodEnum<{
-            passed: "passed";
             failed: "failed";
+            passed: "passed";
         }>;
         summary: z.ZodString;
     }, z.core.$strict>>>;
     validationScope: z.ZodOptional<z.ZodEnum<{
-        targeted: "targeted";
         broad: "broad";
+        targeted: "targeted";
     }>>;
     featureReviewDepth: z.ZodOptional<z.ZodEnum<{
+        detailed: "detailed";
         quick: "quick";
         standard: "standard";
-        detailed: "detailed";
     }>>;
     featureReview: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
-            passed: "passed";
             failed: "failed";
+            passed: "passed";
         }>;
         summary: z.ZodString;
         blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
             summary: z.ZodString;
             severity: z.ZodDefault<z.ZodEnum<{
-                blocking: "blocking";
                 advisory: "advisory";
+                blocking: "blocking";
             }>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
     finalReview: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
-            passed: "passed";
             failed: "failed";
+            passed: "passed";
         }>;
         summary: z.ZodString;
         blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
             summary: z.ZodString;
             severity: z.ZodDefault<z.ZodEnum<{
-                blocking: "blocking";
                 advisory: "advisory";
+                blocking: "blocking";
             }>>;
         }, z.core.$strict>>>;
         reviewDepth: z.ZodEnum<{
@@ -623,32 +614,32 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>;
     }, z.core.$strict>>;
     outcome: z.ZodObject<{
-        kind: z.ZodDefault<z.ZodEnum<{
+        kind: z.ZodEnum<{
             blocked: "blocked";
             needs_input: "needs_input";
             replan_required: "replan_required";
-        }>>;
+        }>;
         summary: z.ZodString;
         resolutionHint: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
     orchestrationPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         kind: z.ZodEnum<{
-            validation: "validation";
             audit: "audit";
             candidate: "candidate";
             discovery: "discovery";
+            "implementation-decision": "implementation-decision";
             review: "review";
+            validation: "validation";
             verification: "verification";
-            "implementation-decision": "implementation-decision";
         }>;
         decision: z.ZodOptional<z.ZodEnum<{
-            parallel: "parallel";
-            serial: "serial";
             "candidate-exact-path": "candidate-exact-path";
             "candidate-worktree": "candidate-worktree";
-            tournament: "tournament";
+            parallel: "parallel";
+            serial: "serial";
             skipped: "skipped";
+            tournament: "tournament";
         }>>;
         decisionReason: z.ZodOptional<z.ZodString>;
         candidateEligibility: z.ZodDefault<z.ZodEnum<{
@@ -657,25 +648,25 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             unknown: "unknown";
         }>>;
         candidateDecision: z.ZodOptional<z.ZodEnum<{
+            serial_required: "serial_required";
             skipped: "skipped";
             used: "used";
-            serial_required: "serial_required";
         }>>;
         decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            shared_state: "shared_state";
+            independent_surface: "independent_surface";
+            needs_manager_judgment: "needs_manager_judgment";
             overlapping_files: "overlapping_files";
+            shared_state: "shared_state";
             small_slice: "small_slice";
-            needs_manager_judgment: "needs_manager_judgment";
-            independent_surface: "independent_surface";
             validation_available: "validation_available";
         }>>>;
         modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            audit: "audit";
+            "candidate-implementation": "candidate-implementation";
             evidence: "evidence";
+            review: "review";
             validation: "validation";
-            audit: "audit";
             verifier: "verifier";
-            review: "review";
-            "candidate-implementation": "candidate-implementation";
         }>>>;
         workerCount: z.ZodDefault<z.ZodNumber>;
         candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
@@ -683,37 +674,37 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
         dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
         writeScope: z.ZodDefault<z.ZodEnum<{
-            none: "none";
-            "manager-serial": "manager-serial";
             "exact-path": "exact-path";
             "isolated-worktree": "isolated-worktree";
+            "manager-serial": "manager-serial";
             mixed: "mixed";
+            none: "none";
         }>>;
         handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
         verificationStatus: z.ZodDefault<z.ZodEnum<{
-            pending: "pending";
-            passed: "passed";
+            downgraded: "downgraded";
             failed: "failed";
             mixed: "mixed";
             "not-needed": "not-needed";
-            downgraded: "downgraded";
+            passed: "passed";
+            pending: "pending";
         }>>;
         outcome: z.ZodDefault<z.ZodEnum<{
             accepted: "accepted";
             modified: "modified";
-            rejected: "rejected";
-            partial: "partial";
             "not-covered": "not-covered";
+            partial: "partial";
+            rejected: "rejected";
             superseded: "superseded";
         }>>;
         synthesisRef: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
 }, z.core.$strict>], "status">;
 export declare const ExecutionHistoryEntrySchema: z.ZodObject<{
-    featureId: z.ZodString;
+    featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
     status: z.ZodEnum<{
-        completed: "completed";
         blocked: "blocked";
+        completed: "completed";
         needs_input: "needs_input";
     }>;
     summary: z.ZodString;
@@ -724,45 +715,45 @@ export declare const ExecutionHistoryEntrySchema: z.ZodObject<{
     validationRun: z.ZodDefault<z.ZodArray<z.ZodObject<{
         command: z.ZodString;
         status: z.ZodEnum<{
-            passed: "passed";
             failed: "failed";
+            passed: "passed";
         }>;
         summary: z.ZodString;
     }, z.core.$strict>>>;
     validationScope: z.ZodOptional<z.ZodEnum<{
-        targeted: "targeted";
         broad: "broad";
+        targeted: "targeted";
     }>>;
     featureReviewDepth: z.ZodOptional<z.ZodEnum<{
+        detailed: "detailed";
         quick: "quick";
         standard: "standard";
-        detailed: "detailed";
     }>>;
     featureReview: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
-            passed: "passed";
             failed: "failed";
+            passed: "passed";
         }>;
         summary: z.ZodString;
         blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
             summary: z.ZodString;
             severity: z.ZodDefault<z.ZodEnum<{
-                blocking: "blocking";
                 advisory: "advisory";
+                blocking: "blocking";
             }>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
     finalReview: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
-            passed: "passed";
             failed: "failed";
+            passed: "passed";
         }>;
         summary: z.ZodString;
         blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
             summary: z.ZodString;
             severity: z.ZodDefault<z.ZodEnum<{
-                blocking: "blocking";
                 advisory: "advisory";
+                blocking: "blocking";
             }>>;
         }, z.core.$strict>>>;
         reviewDepth: z.ZodEnum<{
@@ -770,34 +761,37 @@ export declare const ExecutionHistoryEntrySchema: z.ZodObject<{
             detailed: "detailed";
         }>;
     }, z.core.$strict>>;
-    outcome: z.ZodOptional<z.ZodObject<{
-        kind: z.ZodDefault<z.ZodEnum<{
-            completed: "completed";
+    outcome: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"completed">;
+        summary: z.ZodOptional<z.ZodString>;
+        resolutionHint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodEnum<{
             blocked: "blocked";
             needs_input: "needs_input";
             replan_required: "replan_required";
-        }>>;
-        summary: z.ZodOptional<z.ZodString>;
+        }>;
+        summary: z.ZodString;
         resolutionHint: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">>;
     orchestrationPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         kind: z.ZodEnum<{
-            validation: "validation";
             audit: "audit";
             candidate: "candidate";
             discovery: "discovery";
+            "implementation-decision": "implementation-decision";
             review: "review";
+            validation: "validation";
             verification: "verification";
-            "implementation-decision": "implementation-decision";
         }>;
         decision: z.ZodOptional<z.ZodEnum<{
-            parallel: "parallel";
-            serial: "serial";
             "candidate-exact-path": "candidate-exact-path";
             "candidate-worktree": "candidate-worktree";
-            tournament: "tournament";
+            parallel: "parallel";
+            serial: "serial";
             skipped: "skipped";
+            tournament: "tournament";
         }>>;
         decisionReason: z.ZodOptional<z.ZodString>;
         candidateEligibility: z.ZodDefault<z.ZodEnum<{
@@ -806,25 +800,25 @@ export declare const ExecutionHistoryEntrySchema: z.ZodObject<{
             unknown: "unknown";
         }>>;
         candidateDecision: z.ZodOptional<z.ZodEnum<{
+            serial_required: "serial_required";
             skipped: "skipped";
             used: "used";
-            serial_required: "serial_required";
         }>>;
         decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            shared_state: "shared_state";
+            independent_surface: "independent_surface";
+            needs_manager_judgment: "needs_manager_judgment";
             overlapping_files: "overlapping_files";
+            shared_state: "shared_state";
             small_slice: "small_slice";
-            needs_manager_judgment: "needs_manager_judgment";
-            independent_surface: "independent_surface";
             validation_available: "validation_available";
         }>>>;
         modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            audit: "audit";
+            "candidate-implementation": "candidate-implementation";
             evidence: "evidence";
+            review: "review";
             validation: "validation";
-            audit: "audit";
             verifier: "verifier";
-            review: "review";
-            "candidate-implementation": "candidate-implementation";
         }>>>;
         workerCount: z.ZodDefault<z.ZodNumber>;
         candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
@@ -832,66 +826,36 @@ export declare const ExecutionHistoryEntrySchema: z.ZodObject<{
         sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
         dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
         writeScope: z.ZodDefault<z.ZodEnum<{
-            none: "none";
-            "manager-serial": "manager-serial";
             "exact-path": "exact-path";
             "isolated-worktree": "isolated-worktree";
+            "manager-serial": "manager-serial";
             mixed: "mixed";
+            none: "none";
         }>>;
         handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
         verificationStatus: z.ZodDefault<z.ZodEnum<{
-            pending: "pending";
-            passed: "passed";
+            downgraded: "downgraded";
             failed: "failed";
             mixed: "mixed";
             "not-needed": "not-needed";
-            downgraded: "downgraded";
+            passed: "passed";
+            pending: "pending";
         }>>;
         outcome: z.ZodDefault<z.ZodEnum<{
             accepted: "accepted";
             modified: "modified";
-            rejected: "rejected";
-            partial: "partial";
             "not-covered": "not-covered";
+            partial: "partial";
+            rejected: "rejected";
             superseded: "superseded";
         }>>;
         synthesisRef: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
-export declare const TokenTelemetrySchema: z.ZodObject<{
-    source: z.ZodDefault<z.ZodEnum<{
-        host_unavailable: "host_unavailable";
-        reported: "reported";
-    }>>;
-    visibleTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
-    cacheReadTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
-    nonCacheTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
-}, z.core.$strict>;
-export declare const PhaseBoundarySchema: z.ZodObject<{
-    reason: z.ZodEnum<{
-        feature_limit: "feature_limit";
-        token_limit: "token_limit";
-        review_failure_limit: "review_failure_limit";
-    }>;
-    summary: z.ZodString;
-    resumeInstructions: z.ZodString;
-    recordedAt: z.ZodString;
-}, z.core.$strict>;
 export declare const BudgetTelemetrySchema: z.ZodObject<{
-    phaseStartedAt: z.ZodDefault<z.ZodString>;
-    completedFeaturesSinceBoundary: z.ZodDefault<z.ZodNumber>;
     reviewCount: z.ZodDefault<z.ZodNumber>;
     failedReviewCount: z.ZodDefault<z.ZodNumber>;
     failedReviewAttemptsByFeature: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-    tokenTelemetry: z.ZodDefault<z.ZodObject<{
-        source: z.ZodDefault<z.ZodEnum<{
-            host_unavailable: "host_unavailable";
-            reported: "reported";
-        }>>;
-        visibleTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
-        cacheReadTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
-        nonCacheTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
-    }, z.core.$strict>>;
     orchestration: z.ZodPrefault<z.ZodObject<{
         passCount: z.ZodDefault<z.ZodNumber>;
         workerCount: z.ZodDefault<z.ZodNumber>;
@@ -901,25 +865,24 @@ export declare const BudgetTelemetrySchema: z.ZodObject<{
         candidateUsedDecisionCount: z.ZodDefault<z.ZodNumber>;
         candidateSerialRequiredDecisionCount: z.ZodDefault<z.ZodNumber>;
         skippedCandidateDecisionCount: z.ZodDefault<z.ZodNumber>;
-        recordedPassIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
         latestPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             kind: z.ZodEnum<{
-                validation: "validation";
                 audit: "audit";
                 candidate: "candidate";
                 discovery: "discovery";
+                "implementation-decision": "implementation-decision";
                 review: "review";
+                validation: "validation";
                 verification: "verification";
-                "implementation-decision": "implementation-decision";
             }>;
             decision: z.ZodOptional<z.ZodEnum<{
-                parallel: "parallel";
-                serial: "serial";
                 "candidate-exact-path": "candidate-exact-path";
                 "candidate-worktree": "candidate-worktree";
-                tournament: "tournament";
+                parallel: "parallel";
+                serial: "serial";
                 skipped: "skipped";
+                tournament: "tournament";
             }>>;
             decisionReason: z.ZodOptional<z.ZodString>;
             candidateEligibility: z.ZodDefault<z.ZodEnum<{
@@ -928,25 +891,25 @@ export declare const BudgetTelemetrySchema: z.ZodObject<{
                 unknown: "unknown";
             }>>;
             candidateDecision: z.ZodOptional<z.ZodEnum<{
+                serial_required: "serial_required";
                 skipped: "skipped";
                 used: "used";
-                serial_required: "serial_required";
             }>>;
             decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                shared_state: "shared_state";
+                independent_surface: "independent_surface";
+                needs_manager_judgment: "needs_manager_judgment";
                 overlapping_files: "overlapping_files";
+                shared_state: "shared_state";
                 small_slice: "small_slice";
-                needs_manager_judgment: "needs_manager_judgment";
-                independent_surface: "independent_surface";
                 validation_available: "validation_available";
             }>>>;
             modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                audit: "audit";
+                "candidate-implementation": "candidate-implementation";
                 evidence: "evidence";
+                review: "review";
                 validation: "validation";
-                audit: "audit";
                 verifier: "verifier";
-                review: "review";
-                "candidate-implementation": "candidate-implementation";
             }>>>;
             workerCount: z.ZodDefault<z.ZodNumber>;
             candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
@@ -954,57 +917,47 @@ export declare const BudgetTelemetrySchema: z.ZodObject<{
             sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
             dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
             writeScope: z.ZodDefault<z.ZodEnum<{
-                none: "none";
-                "manager-serial": "manager-serial";
                 "exact-path": "exact-path";
                 "isolated-worktree": "isolated-worktree";
+                "manager-serial": "manager-serial";
                 mixed: "mixed";
+                none: "none";
             }>>;
             handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                pending: "pending";
-                passed: "passed";
+                downgraded: "downgraded";
                 failed: "failed";
                 mixed: "mixed";
                 "not-needed": "not-needed";
-                downgraded: "downgraded";
+                passed: "passed";
+                pending: "pending";
             }>>;
             outcome: z.ZodDefault<z.ZodEnum<{
                 accepted: "accepted";
                 modified: "modified";
-                rejected: "rejected";
-                partial: "partial";
                 "not-covered": "not-covered";
+                partial: "partial";
+                rejected: "rejected";
                 superseded: "superseded";
             }>>;
             synthesisRef: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
-    phaseBoundary: z.ZodDefault<z.ZodNullable<z.ZodObject<{
-        reason: z.ZodEnum<{
-            feature_limit: "feature_limit";
-            token_limit: "token_limit";
-            review_failure_limit: "review_failure_limit";
-        }>;
-        summary: z.ZodString;
-        resumeInstructions: z.ZodString;
-        recordedAt: z.ZodString;
-    }, z.core.$strict>>>;
 }, z.core.$strict>;
 export declare const SessionSchema: z.ZodObject<{
-    version: z.ZodLiteral<2>;
-    id: z.ZodString;
+    version: z.ZodLiteral<3>;
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").SessionId, string>>;
     goal: z.ZodString;
     status: z.ZodEnum<{
-        completed: "completed";
         blocked: "blocked";
+        completed: "completed";
         planning: "planning";
         ready: "ready";
         running: "running";
     }>;
     approval: z.ZodEnum<{
-        pending: "pending";
         approved: "approved";
+        pending: "pending";
     }>;
     plan: z.ZodNullable<z.ZodObject<{
         summary: z.ZodString;
@@ -1016,31 +969,31 @@ export declare const SessionSchema: z.ZodObject<{
             detailed: "detailed";
         }>>;
         features: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
+            id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
             title: z.ZodString;
             summary: z.ZodString;
             status: z.ZodDefault<z.ZodEnum<{
-                pending: "pending";
-                in_progress: "in_progress";
-                completed: "completed";
                 blocked: "blocked";
+                completed: "completed";
+                in_progress: "in_progress";
+                pending: "pending";
             }>>;
             reviewDepth: z.ZodDefault<z.ZodEnum<{
+                detailed: "detailed";
                 quick: "quick";
                 standard: "standard";
-                detailed: "detailed";
             }>>;
             targets: z.ZodDefault<z.ZodArray<z.ZodString>>;
             validation: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            dependsOn: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
-    activeFeatureId: z.ZodNullable<z.ZodString>;
+    activeFeatureId: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>>;
     history: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        featureId: z.ZodString;
+        featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
         status: z.ZodEnum<{
-            completed: "completed";
             blocked: "blocked";
+            completed: "completed";
             needs_input: "needs_input";
         }>;
         summary: z.ZodString;
@@ -1051,45 +1004,45 @@ export declare const SessionSchema: z.ZodObject<{
         validationRun: z.ZodDefault<z.ZodArray<z.ZodObject<{
             command: z.ZodString;
             status: z.ZodEnum<{
-                passed: "passed";
                 failed: "failed";
+                passed: "passed";
             }>;
             summary: z.ZodString;
         }, z.core.$strict>>>;
         validationScope: z.ZodOptional<z.ZodEnum<{
-            targeted: "targeted";
             broad: "broad";
+            targeted: "targeted";
         }>>;
         featureReviewDepth: z.ZodOptional<z.ZodEnum<{
+            detailed: "detailed";
             quick: "quick";
             standard: "standard";
-            detailed: "detailed";
         }>>;
         featureReview: z.ZodOptional<z.ZodObject<{
             status: z.ZodEnum<{
-                passed: "passed";
                 failed: "failed";
+                passed: "passed";
             }>;
             summary: z.ZodString;
             blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 summary: z.ZodString;
                 severity: z.ZodDefault<z.ZodEnum<{
-                    blocking: "blocking";
                     advisory: "advisory";
+                    blocking: "blocking";
                 }>>;
             }, z.core.$strict>>>;
         }, z.core.$strict>>;
         finalReview: z.ZodOptional<z.ZodObject<{
             status: z.ZodEnum<{
-                passed: "passed";
                 failed: "failed";
+                passed: "passed";
             }>;
             summary: z.ZodString;
             blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 summary: z.ZodString;
                 severity: z.ZodDefault<z.ZodEnum<{
-                    blocking: "blocking";
                     advisory: "advisory";
+                    blocking: "blocking";
                 }>>;
             }, z.core.$strict>>>;
             reviewDepth: z.ZodEnum<{
@@ -1097,34 +1050,37 @@ export declare const SessionSchema: z.ZodObject<{
                 detailed: "detailed";
             }>;
         }, z.core.$strict>>;
-        outcome: z.ZodOptional<z.ZodObject<{
-            kind: z.ZodDefault<z.ZodEnum<{
-                completed: "completed";
+        outcome: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"completed">;
+            summary: z.ZodOptional<z.ZodString>;
+            resolutionHint: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodEnum<{
                 blocked: "blocked";
                 needs_input: "needs_input";
                 replan_required: "replan_required";
-            }>>;
-            summary: z.ZodOptional<z.ZodString>;
+            }>;
+            summary: z.ZodString;
             resolutionHint: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
+        }, z.core.$strict>], "kind">>;
         orchestrationPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             kind: z.ZodEnum<{
-                validation: "validation";
                 audit: "audit";
                 candidate: "candidate";
                 discovery: "discovery";
+                "implementation-decision": "implementation-decision";
                 review: "review";
+                validation: "validation";
                 verification: "verification";
-                "implementation-decision": "implementation-decision";
             }>;
             decision: z.ZodOptional<z.ZodEnum<{
-                parallel: "parallel";
-                serial: "serial";
                 "candidate-exact-path": "candidate-exact-path";
                 "candidate-worktree": "candidate-worktree";
-                tournament: "tournament";
+                parallel: "parallel";
+                serial: "serial";
                 skipped: "skipped";
+                tournament: "tournament";
             }>>;
             decisionReason: z.ZodOptional<z.ZodString>;
             candidateEligibility: z.ZodDefault<z.ZodEnum<{
@@ -1133,25 +1089,25 @@ export declare const SessionSchema: z.ZodObject<{
                 unknown: "unknown";
             }>>;
             candidateDecision: z.ZodOptional<z.ZodEnum<{
+                serial_required: "serial_required";
                 skipped: "skipped";
                 used: "used";
-                serial_required: "serial_required";
             }>>;
             decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                shared_state: "shared_state";
+                independent_surface: "independent_surface";
+                needs_manager_judgment: "needs_manager_judgment";
                 overlapping_files: "overlapping_files";
+                shared_state: "shared_state";
                 small_slice: "small_slice";
-                needs_manager_judgment: "needs_manager_judgment";
-                independent_surface: "independent_surface";
                 validation_available: "validation_available";
             }>>>;
             modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                audit: "audit";
+                "candidate-implementation": "candidate-implementation";
                 evidence: "evidence";
+                review: "review";
                 validation: "validation";
-                audit: "audit";
                 verifier: "verifier";
-                review: "review";
-                "candidate-implementation": "candidate-implementation";
             }>>>;
             workerCount: z.ZodDefault<z.ZodNumber>;
             candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
@@ -1159,47 +1115,36 @@ export declare const SessionSchema: z.ZodObject<{
             sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
             dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
             writeScope: z.ZodDefault<z.ZodEnum<{
-                none: "none";
-                "manager-serial": "manager-serial";
                 "exact-path": "exact-path";
                 "isolated-worktree": "isolated-worktree";
+                "manager-serial": "manager-serial";
                 mixed: "mixed";
+                none: "none";
             }>>;
             handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
             verificationStatus: z.ZodDefault<z.ZodEnum<{
-                pending: "pending";
-                passed: "passed";
+                downgraded: "downgraded";
                 failed: "failed";
                 mixed: "mixed";
                 "not-needed": "not-needed";
-                downgraded: "downgraded";
+                passed: "passed";
+                pending: "pending";
             }>>;
             outcome: z.ZodDefault<z.ZodEnum<{
                 accepted: "accepted";
                 modified: "modified";
-                rejected: "rejected";
-                partial: "partial";
                 "not-covered": "not-covered";
+                partial: "partial";
+                rejected: "rejected";
                 superseded: "superseded";
             }>>;
             synthesisRef: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>>;
     budget: z.ZodPrefault<z.ZodObject<{
-        phaseStartedAt: z.ZodDefault<z.ZodString>;
-        completedFeaturesSinceBoundary: z.ZodDefault<z.ZodNumber>;
         reviewCount: z.ZodDefault<z.ZodNumber>;
         failedReviewCount: z.ZodDefault<z.ZodNumber>;
         failedReviewAttemptsByFeature: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-        tokenTelemetry: z.ZodDefault<z.ZodObject<{
-            source: z.ZodDefault<z.ZodEnum<{
-                host_unavailable: "host_unavailable";
-                reported: "reported";
-            }>>;
-            visibleTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
-            cacheReadTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
-            nonCacheTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
-        }, z.core.$strict>>;
         orchestration: z.ZodPrefault<z.ZodObject<{
             passCount: z.ZodDefault<z.ZodNumber>;
             workerCount: z.ZodDefault<z.ZodNumber>;
@@ -1209,25 +1154,24 @@ export declare const SessionSchema: z.ZodObject<{
             candidateUsedDecisionCount: z.ZodDefault<z.ZodNumber>;
             candidateSerialRequiredDecisionCount: z.ZodDefault<z.ZodNumber>;
             skippedCandidateDecisionCount: z.ZodDefault<z.ZodNumber>;
-            recordedPassIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
             latestPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
                 kind: z.ZodEnum<{
-                    validation: "validation";
                     audit: "audit";
                     candidate: "candidate";
                     discovery: "discovery";
+                    "implementation-decision": "implementation-decision";
                     review: "review";
+                    validation: "validation";
                     verification: "verification";
-                    "implementation-decision": "implementation-decision";
                 }>;
                 decision: z.ZodOptional<z.ZodEnum<{
-                    parallel: "parallel";
-                    serial: "serial";
                     "candidate-exact-path": "candidate-exact-path";
                     "candidate-worktree": "candidate-worktree";
-                    tournament: "tournament";
+                    parallel: "parallel";
+                    serial: "serial";
                     skipped: "skipped";
+                    tournament: "tournament";
                 }>>;
                 decisionReason: z.ZodOptional<z.ZodString>;
                 candidateEligibility: z.ZodDefault<z.ZodEnum<{
@@ -1236,25 +1180,25 @@ export declare const SessionSchema: z.ZodObject<{
                     unknown: "unknown";
                 }>>;
                 candidateDecision: z.ZodOptional<z.ZodEnum<{
+                    serial_required: "serial_required";
                     skipped: "skipped";
                     used: "used";
-                    serial_required: "serial_required";
                 }>>;
                 decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                    shared_state: "shared_state";
+                    independent_surface: "independent_surface";
+                    needs_manager_judgment: "needs_manager_judgment";
                     overlapping_files: "overlapping_files";
+                    shared_state: "shared_state";
                     small_slice: "small_slice";
-                    needs_manager_judgment: "needs_manager_judgment";
-                    independent_surface: "independent_surface";
                     validation_available: "validation_available";
                 }>>>;
                 modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                    audit: "audit";
+                    "candidate-implementation": "candidate-implementation";
                     evidence: "evidence";
+                    review: "review";
                     validation: "validation";
-                    audit: "audit";
                     verifier: "verifier";
-                    review: "review";
-                    "candidate-implementation": "candidate-implementation";
                 }>>>;
                 workerCount: z.ZodDefault<z.ZodNumber>;
                 candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
@@ -1262,48 +1206,38 @@ export declare const SessionSchema: z.ZodObject<{
                 sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
                 dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
                 writeScope: z.ZodDefault<z.ZodEnum<{
-                    none: "none";
-                    "manager-serial": "manager-serial";
                     "exact-path": "exact-path";
                     "isolated-worktree": "isolated-worktree";
+                    "manager-serial": "manager-serial";
                     mixed: "mixed";
+                    none: "none";
                 }>>;
                 handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                 verificationStatus: z.ZodDefault<z.ZodEnum<{
-                    pending: "pending";
-                    passed: "passed";
+                    downgraded: "downgraded";
                     failed: "failed";
                     mixed: "mixed";
                     "not-needed": "not-needed";
-                    downgraded: "downgraded";
+                    passed: "passed";
+                    pending: "pending";
                 }>>;
                 outcome: z.ZodDefault<z.ZodEnum<{
                     accepted: "accepted";
                     modified: "modified";
-                    rejected: "rejected";
-                    partial: "partial";
                     "not-covered": "not-covered";
+                    partial: "partial";
+                    rejected: "rejected";
                     superseded: "superseded";
                 }>>;
                 synthesisRef: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>>>;
         }, z.core.$strict>>;
-        phaseBoundary: z.ZodDefault<z.ZodNullable<z.ZodObject<{
-            reason: z.ZodEnum<{
-                feature_limit: "feature_limit";
-                token_limit: "token_limit";
-                review_failure_limit: "review_failure_limit";
-            }>;
-            summary: z.ZodString;
-            resumeInstructions: z.ZodString;
-            recordedAt: z.ZodString;
-        }, z.core.$strict>>>;
     }, z.core.$strict>>;
     closure: z.ZodNullable<z.ZodObject<{
         kind: z.ZodEnum<{
+            abandoned: "abandoned";
             completed: "completed";
             deferred: "deferred";
-            abandoned: "abandoned";
         }>;
         summary: z.ZodString;
         recordedAt: z.ZodString;
@@ -1320,18 +1254,4 @@ export declare const SessionSchema: z.ZodObject<{
         completedAt: z.ZodNullable<z.ZodString>;
     }, z.core.$strict>;
 }, z.core.$strict>;
-export type Artifact = z.infer<typeof ArtifactSchema>;
-export type BudgetTelemetry = z.infer<typeof BudgetTelemetrySchema>;
-export type ExecutionHistoryEntry = z.infer<typeof ExecutionHistoryEntrySchema>;
-export type Feature = z.infer<typeof FeatureSchema>;
-export type FeatureReviewDepth = z.infer<typeof FeatureReviewDepthSchema>;
-export type FinalReview = z.infer<typeof FinalReviewSchema>;
-export type OrchestrationPassRecord = z.infer<typeof OrchestrationPassRecordSchema>;
-export type OrchestrationTelemetry = z.infer<typeof OrchestrationTelemetrySchema>;
-export type PhaseBoundary = z.infer<typeof PhaseBoundarySchema>;
-export type Plan = z.infer<typeof PlanSchema>;
-export type PlanInput = z.input<typeof PlanInputSchema>;
-export type Review = z.infer<typeof ReviewSchema>;
-export type Session = z.infer<typeof SessionSchema>;
-export type ValidationRun = z.infer<typeof ValidationRunSchema>;
-export type WorkerResult = z.infer<typeof WorkerResultSchema>;
+export type { Artifact, BudgetTelemetry, ExecutionHistoryEntry, Feature, FeatureReviewDepth, FinalReview, OrchestrationPassRecord, OrchestrationTelemetry, Plan, PlanInput, Review, Session, ValidationRun, WorkerResult, } from "../domain/session.js";