opencode-plugin-flow 4.3.7 → 4.3.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. package/CHANGELOG.md +43 -0
  2. package/README.md +14 -6
  3. package/dist/adapters/opencode/tools.d.ts +97 -0
  4. package/dist/cli.js +332 -15
  5. package/dist/cli.js.map +2 -2
  6. package/dist/index.js +614 -60
  7. package/dist/index.js.map +5 -5
  8. package/dist/runtime/api.d.ts +77 -0
  9. package/dist/runtime/schema.d.ts +729 -1
  10. package/dist/runtime/transitions.d.ts +51 -0
  11. package/package.json +1 -1
package/dist/runtime/schema.d.ts CHANGED
@@ -35,6 +35,248 @@ export declare const FinalReviewPolicySchema: z.ZodEnum<{
35
35
  broad: "broad";
36
36
  detailed: "detailed";
37
37
  }>;
38
+ export declare const OrchestrationPassKindSchema: z.ZodEnum<{
39
+ discovery: "discovery";
40
+ audit: "audit";
41
+ review: "review";
42
+ validation: "validation";
43
+ verification: "verification";
44
+ candidate: "candidate";
45
+ "implementation-decision": "implementation-decision";
46
+ }>;
47
+ export declare const OrchestrationModeSchema: z.ZodEnum<{
48
+ audit: "audit";
49
+ review: "review";
50
+ validation: "validation";
51
+ evidence: "evidence";
52
+ verifier: "verifier";
53
+ "candidate-implementation": "candidate-implementation";
54
+ }>;
55
+ export declare const OrchestrationDecisionSchema: z.ZodEnum<{
56
+ serial: "serial";
57
+ parallel: "parallel";
58
+ "candidate-exact-path": "candidate-exact-path";
59
+ "candidate-worktree": "candidate-worktree";
60
+ tournament: "tournament";
61
+ skipped: "skipped";
62
+ }>;
63
+ export declare const OrchestrationCandidateEligibilitySchema: z.ZodEnum<{
64
+ eligible: "eligible";
65
+ not_eligible: "not_eligible";
66
+ unknown: "unknown";
67
+ }>;
68
+ export declare const OrchestrationCandidateDecisionSchema: z.ZodEnum<{
69
+ skipped: "skipped";
70
+ used: "used";
71
+ serial_required: "serial_required";
72
+ }>;
73
+ export declare const OrchestrationDecisionFactorSchema: z.ZodEnum<{
74
+ shared_state: "shared_state";
75
+ overlapping_files: "overlapping_files";
76
+ small_slice: "small_slice";
77
+ needs_manager_judgment: "needs_manager_judgment";
78
+ independent_surface: "independent_surface";
79
+ validation_available: "validation_available";
80
+ }>;
81
+ export declare const OrchestrationWriteScopeSchema: z.ZodEnum<{
82
+ none: "none";
83
+ "manager-serial": "manager-serial";
84
+ "exact-path": "exact-path";
85
+ "isolated-worktree": "isolated-worktree";
86
+ mixed: "mixed";
87
+ }>;
88
+ export declare const OrchestrationVerificationStatusSchema: z.ZodEnum<{
89
+ pending: "pending";
90
+ passed: "passed";
91
+ failed: "failed";
92
+ mixed: "mixed";
93
+ "not-needed": "not-needed";
94
+ downgraded: "downgraded";
95
+ }>;
96
+ export declare const OrchestrationOutcomeSchema: z.ZodEnum<{
97
+ accepted: "accepted";
98
+ modified: "modified";
99
+ rejected: "rejected";
100
+ partial: "partial";
101
+ "not-covered": "not-covered";
102
+ superseded: "superseded";
103
+ }>;
104
+ export declare function isCandidateShapedDecision(decision: string | undefined): boolean;
105
+ export declare function hasCandidateExecutionEvidence(pass: {
106
+ kind: string;
107
+ modes: readonly string[];
108
+ candidateWorkerCount: number;
109
+ }): boolean;
110
+ export declare function hasVerifierExecutionEvidence(pass: {
111
+ kind: string;
112
+ modes: readonly string[];
113
+ verifierWorkerCount: number;
114
+ }): boolean;
115
+ export declare const OrchestrationPassRecordSchema: z.ZodObject<{
116
+ id: z.ZodString;
117
+ kind: z.ZodEnum<{
118
+ discovery: "discovery";
119
+ audit: "audit";
120
+ review: "review";
121
+ validation: "validation";
122
+ verification: "verification";
123
+ candidate: "candidate";
124
+ "implementation-decision": "implementation-decision";
125
+ }>;
126
+ decision: z.ZodOptional<z.ZodEnum<{
127
+ serial: "serial";
128
+ parallel: "parallel";
129
+ "candidate-exact-path": "candidate-exact-path";
130
+ "candidate-worktree": "candidate-worktree";
131
+ tournament: "tournament";
132
+ skipped: "skipped";
133
+ }>>;
134
+ decisionReason: z.ZodOptional<z.ZodString>;
135
+ candidateEligibility: z.ZodDefault<z.ZodEnum<{
136
+ eligible: "eligible";
137
+ not_eligible: "not_eligible";
138
+ unknown: "unknown";
139
+ }>>;
140
+ candidateDecision: z.ZodOptional<z.ZodEnum<{
141
+ skipped: "skipped";
142
+ used: "used";
143
+ serial_required: "serial_required";
144
+ }>>;
145
+ decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
146
+ shared_state: "shared_state";
147
+ overlapping_files: "overlapping_files";
148
+ small_slice: "small_slice";
149
+ needs_manager_judgment: "needs_manager_judgment";
150
+ independent_surface: "independent_surface";
151
+ validation_available: "validation_available";
152
+ }>>>;
153
+ modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
154
+ audit: "audit";
155
+ review: "review";
156
+ validation: "validation";
157
+ evidence: "evidence";
158
+ verifier: "verifier";
159
+ "candidate-implementation": "candidate-implementation";
160
+ }>>>;
161
+ workerCount: z.ZodDefault<z.ZodNumber>;
162
+ candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
163
+ verifierWorkerCount: z.ZodDefault<z.ZodNumber>;
164
+ sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
165
+ dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
166
+ writeScope: z.ZodDefault<z.ZodEnum<{
167
+ none: "none";
168
+ "manager-serial": "manager-serial";
169
+ "exact-path": "exact-path";
170
+ "isolated-worktree": "isolated-worktree";
171
+ mixed: "mixed";
172
+ }>>;
173
+ handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
174
+ verificationStatus: z.ZodDefault<z.ZodEnum<{
175
+ pending: "pending";
176
+ passed: "passed";
177
+ failed: "failed";
178
+ mixed: "mixed";
179
+ "not-needed": "not-needed";
180
+ downgraded: "downgraded";
181
+ }>>;
182
+ outcome: z.ZodDefault<z.ZodEnum<{
183
+ accepted: "accepted";
184
+ modified: "modified";
185
+ rejected: "rejected";
186
+ partial: "partial";
187
+ "not-covered": "not-covered";
188
+ superseded: "superseded";
189
+ }>>;
190
+ synthesisRef: z.ZodOptional<z.ZodString>;
191
+ }, z.core.$strict>;
192
+ export declare const OrchestrationTelemetrySchema: z.ZodObject<{
193
+ passCount: z.ZodDefault<z.ZodNumber>;
194
+ workerCount: z.ZodDefault<z.ZodNumber>;
195
+ candidatePassCount: z.ZodDefault<z.ZodNumber>;
196
+ verifierPassCount: z.ZodDefault<z.ZodNumber>;
197
+ candidateEligibleCount: z.ZodDefault<z.ZodNumber>;
198
+ candidateUsedDecisionCount: z.ZodDefault<z.ZodNumber>;
199
+ candidateSerialRequiredDecisionCount: z.ZodDefault<z.ZodNumber>;
200
+ skippedCandidateDecisionCount: z.ZodDefault<z.ZodNumber>;
201
+ recordedPassIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
202
+ latestPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
203
+ id: z.ZodString;
204
+ kind: z.ZodEnum<{
205
+ discovery: "discovery";
206
+ audit: "audit";
207
+ review: "review";
208
+ validation: "validation";
209
+ verification: "verification";
210
+ candidate: "candidate";
211
+ "implementation-decision": "implementation-decision";
212
+ }>;
213
+ decision: z.ZodOptional<z.ZodEnum<{
214
+ serial: "serial";
215
+ parallel: "parallel";
216
+ "candidate-exact-path": "candidate-exact-path";
217
+ "candidate-worktree": "candidate-worktree";
218
+ tournament: "tournament";
219
+ skipped: "skipped";
220
+ }>>;
221
+ decisionReason: z.ZodOptional<z.ZodString>;
222
+ candidateEligibility: z.ZodDefault<z.ZodEnum<{
223
+ eligible: "eligible";
224
+ not_eligible: "not_eligible";
225
+ unknown: "unknown";
226
+ }>>;
227
+ candidateDecision: z.ZodOptional<z.ZodEnum<{
228
+ skipped: "skipped";
229
+ used: "used";
230
+ serial_required: "serial_required";
231
+ }>>;
232
+ decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
233
+ shared_state: "shared_state";
234
+ overlapping_files: "overlapping_files";
235
+ small_slice: "small_slice";
236
+ needs_manager_judgment: "needs_manager_judgment";
237
+ independent_surface: "independent_surface";
238
+ validation_available: "validation_available";
239
+ }>>>;
240
+ modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
241
+ audit: "audit";
242
+ review: "review";
243
+ validation: "validation";
244
+ evidence: "evidence";
245
+ verifier: "verifier";
246
+ "candidate-implementation": "candidate-implementation";
247
+ }>>>;
248
+ workerCount: z.ZodDefault<z.ZodNumber>;
249
+ candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
250
+ verifierWorkerCount: z.ZodDefault<z.ZodNumber>;
251
+ sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
252
+ dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
253
+ writeScope: z.ZodDefault<z.ZodEnum<{
254
+ none: "none";
255
+ "manager-serial": "manager-serial";
256
+ "exact-path": "exact-path";
257
+ "isolated-worktree": "isolated-worktree";
258
+ mixed: "mixed";
259
+ }>>;
260
+ handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
261
+ verificationStatus: z.ZodDefault<z.ZodEnum<{
262
+ pending: "pending";
263
+ passed: "passed";
264
+ failed: "failed";
265
+ mixed: "mixed";
266
+ "not-needed": "not-needed";
267
+ downgraded: "downgraded";
268
+ }>>;
269
+ outcome: z.ZodDefault<z.ZodEnum<{
270
+ accepted: "accepted";
271
+ modified: "modified";
272
+ rejected: "rejected";
273
+ partial: "partial";
274
+ "not-covered": "not-covered";
275
+ superseded: "superseded";
276
+ }>>;
277
+ synthesisRef: z.ZodOptional<z.ZodString>;
278
+ }, z.core.$strict>>>;
279
+ }, z.core.$strict>;
38
280
  export declare const ReviewFindingSchema: z.ZodObject<{
39
281
  summary: z.ZodString;
40
282
  severity: z.ZodDefault<z.ZodEnum<{
@@ -247,6 +489,83 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
247
489
  summary: z.ZodOptional<z.ZodString>;
248
490
  resolutionHint: z.ZodOptional<z.ZodString>;
249
491
  }, z.core.$strict>>;
492
+ orchestrationPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
493
+ id: z.ZodString;
494
+ kind: z.ZodEnum<{
495
+ discovery: "discovery";
496
+ audit: "audit";
497
+ review: "review";
498
+ validation: "validation";
499
+ verification: "verification";
500
+ candidate: "candidate";
501
+ "implementation-decision": "implementation-decision";
502
+ }>;
503
+ decision: z.ZodOptional<z.ZodEnum<{
504
+ serial: "serial";
505
+ parallel: "parallel";
506
+ "candidate-exact-path": "candidate-exact-path";
507
+ "candidate-worktree": "candidate-worktree";
508
+ tournament: "tournament";
509
+ skipped: "skipped";
510
+ }>>;
511
+ decisionReason: z.ZodOptional<z.ZodString>;
512
+ candidateEligibility: z.ZodDefault<z.ZodEnum<{
513
+ eligible: "eligible";
514
+ not_eligible: "not_eligible";
515
+ unknown: "unknown";
516
+ }>>;
517
+ candidateDecision: z.ZodOptional<z.ZodEnum<{
518
+ skipped: "skipped";
519
+ used: "used";
520
+ serial_required: "serial_required";
521
+ }>>;
522
+ decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
523
+ shared_state: "shared_state";
524
+ overlapping_files: "overlapping_files";
525
+ small_slice: "small_slice";
526
+ needs_manager_judgment: "needs_manager_judgment";
527
+ independent_surface: "independent_surface";
528
+ validation_available: "validation_available";
529
+ }>>>;
530
+ modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
531
+ audit: "audit";
532
+ review: "review";
533
+ validation: "validation";
534
+ evidence: "evidence";
535
+ verifier: "verifier";
536
+ "candidate-implementation": "candidate-implementation";
537
+ }>>>;
538
+ workerCount: z.ZodDefault<z.ZodNumber>;
539
+ candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
540
+ verifierWorkerCount: z.ZodDefault<z.ZodNumber>;
541
+ sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
542
+ dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
543
+ writeScope: z.ZodDefault<z.ZodEnum<{
544
+ none: "none";
545
+ "manager-serial": "manager-serial";
546
+ "exact-path": "exact-path";
547
+ "isolated-worktree": "isolated-worktree";
548
+ mixed: "mixed";
549
+ }>>;
550
+ handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
551
+ verificationStatus: z.ZodDefault<z.ZodEnum<{
552
+ pending: "pending";
553
+ passed: "passed";
554
+ failed: "failed";
555
+ mixed: "mixed";
556
+ "not-needed": "not-needed";
557
+ downgraded: "downgraded";
558
+ }>>;
559
+ outcome: z.ZodDefault<z.ZodEnum<{
560
+ accepted: "accepted";
561
+ modified: "modified";
562
+ rejected: "rejected";
563
+ partial: "partial";
564
+ "not-covered": "not-covered";
565
+ superseded: "superseded";
566
+ }>>;
567
+ synthesisRef: z.ZodOptional<z.ZodString>;
568
+ }, z.core.$strict>>>;
250
569
  }, z.core.$strict>, z.ZodObject<{
251
570
  status: z.ZodLiteral<"needs_input">;
252
571
  featureId: z.ZodString;
@@ -312,6 +631,83 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
312
631
  summary: z.ZodString;
313
632
  resolutionHint: z.ZodOptional<z.ZodString>;
314
633
  }, z.core.$strict>;
634
+ orchestrationPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
635
+ id: z.ZodString;
636
+ kind: z.ZodEnum<{
637
+ discovery: "discovery";
638
+ audit: "audit";
639
+ review: "review";
640
+ validation: "validation";
641
+ verification: "verification";
642
+ candidate: "candidate";
643
+ "implementation-decision": "implementation-decision";
644
+ }>;
645
+ decision: z.ZodOptional<z.ZodEnum<{
646
+ serial: "serial";
647
+ parallel: "parallel";
648
+ "candidate-exact-path": "candidate-exact-path";
649
+ "candidate-worktree": "candidate-worktree";
650
+ tournament: "tournament";
651
+ skipped: "skipped";
652
+ }>>;
653
+ decisionReason: z.ZodOptional<z.ZodString>;
654
+ candidateEligibility: z.ZodDefault<z.ZodEnum<{
655
+ eligible: "eligible";
656
+ not_eligible: "not_eligible";
657
+ unknown: "unknown";
658
+ }>>;
659
+ candidateDecision: z.ZodOptional<z.ZodEnum<{
660
+ skipped: "skipped";
661
+ used: "used";
662
+ serial_required: "serial_required";
663
+ }>>;
664
+ decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
665
+ shared_state: "shared_state";
666
+ overlapping_files: "overlapping_files";
667
+ small_slice: "small_slice";
668
+ needs_manager_judgment: "needs_manager_judgment";
669
+ independent_surface: "independent_surface";
670
+ validation_available: "validation_available";
671
+ }>>>;
672
+ modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
673
+ audit: "audit";
674
+ review: "review";
675
+ validation: "validation";
676
+ evidence: "evidence";
677
+ verifier: "verifier";
678
+ "candidate-implementation": "candidate-implementation";
679
+ }>>>;
680
+ workerCount: z.ZodDefault<z.ZodNumber>;
681
+ candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
682
+ verifierWorkerCount: z.ZodDefault<z.ZodNumber>;
683
+ sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
684
+ dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
685
+ writeScope: z.ZodDefault<z.ZodEnum<{
686
+ none: "none";
687
+ "manager-serial": "manager-serial";
688
+ "exact-path": "exact-path";
689
+ "isolated-worktree": "isolated-worktree";
690
+ mixed: "mixed";
691
+ }>>;
692
+ handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
693
+ verificationStatus: z.ZodDefault<z.ZodEnum<{
694
+ pending: "pending";
695
+ passed: "passed";
696
+ failed: "failed";
697
+ mixed: "mixed";
698
+ "not-needed": "not-needed";
699
+ downgraded: "downgraded";
700
+ }>>;
701
+ outcome: z.ZodDefault<z.ZodEnum<{
702
+ accepted: "accepted";
703
+ modified: "modified";
704
+ rejected: "rejected";
705
+ partial: "partial";
706
+ "not-covered": "not-covered";
707
+ superseded: "superseded";
708
+ }>>;
709
+ synthesisRef: z.ZodOptional<z.ZodString>;
710
+ }, z.core.$strict>>>;
315
711
  }, z.core.$strict>], "status">;
316
712
  export declare const ExecutionHistoryEntrySchema: z.ZodObject<{
317
713
  featureId: z.ZodString;
@@ -384,6 +780,83 @@ export declare const ExecutionHistoryEntrySchema: z.ZodObject<{
384
780
  summary: z.ZodOptional<z.ZodString>;
385
781
  resolutionHint: z.ZodOptional<z.ZodString>;
386
782
  }, z.core.$strict>>;
783
+ orchestrationPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
784
+ id: z.ZodString;
785
+ kind: z.ZodEnum<{
786
+ discovery: "discovery";
787
+ audit: "audit";
788
+ review: "review";
789
+ validation: "validation";
790
+ verification: "verification";
791
+ candidate: "candidate";
792
+ "implementation-decision": "implementation-decision";
793
+ }>;
794
+ decision: z.ZodOptional<z.ZodEnum<{
795
+ serial: "serial";
796
+ parallel: "parallel";
797
+ "candidate-exact-path": "candidate-exact-path";
798
+ "candidate-worktree": "candidate-worktree";
799
+ tournament: "tournament";
800
+ skipped: "skipped";
801
+ }>>;
802
+ decisionReason: z.ZodOptional<z.ZodString>;
803
+ candidateEligibility: z.ZodDefault<z.ZodEnum<{
804
+ eligible: "eligible";
805
+ not_eligible: "not_eligible";
806
+ unknown: "unknown";
807
+ }>>;
808
+ candidateDecision: z.ZodOptional<z.ZodEnum<{
809
+ skipped: "skipped";
810
+ used: "used";
811
+ serial_required: "serial_required";
812
+ }>>;
813
+ decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
814
+ shared_state: "shared_state";
815
+ overlapping_files: "overlapping_files";
816
+ small_slice: "small_slice";
817
+ needs_manager_judgment: "needs_manager_judgment";
818
+ independent_surface: "independent_surface";
819
+ validation_available: "validation_available";
820
+ }>>>;
821
+ modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
822
+ audit: "audit";
823
+ review: "review";
824
+ validation: "validation";
825
+ evidence: "evidence";
826
+ verifier: "verifier";
827
+ "candidate-implementation": "candidate-implementation";
828
+ }>>>;
829
+ workerCount: z.ZodDefault<z.ZodNumber>;
830
+ candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
831
+ verifierWorkerCount: z.ZodDefault<z.ZodNumber>;
832
+ sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
833
+ dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
834
+ writeScope: z.ZodDefault<z.ZodEnum<{
835
+ none: "none";
836
+ "manager-serial": "manager-serial";
837
+ "exact-path": "exact-path";
838
+ "isolated-worktree": "isolated-worktree";
839
+ mixed: "mixed";
840
+ }>>;
841
+ handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
842
+ verificationStatus: z.ZodDefault<z.ZodEnum<{
843
+ pending: "pending";
844
+ passed: "passed";
845
+ failed: "failed";
846
+ mixed: "mixed";
847
+ "not-needed": "not-needed";
848
+ downgraded: "downgraded";
849
+ }>>;
850
+ outcome: z.ZodDefault<z.ZodEnum<{
851
+ accepted: "accepted";
852
+ modified: "modified";
853
+ rejected: "rejected";
854
+ partial: "partial";
855
+ "not-covered": "not-covered";
856
+ superseded: "superseded";
857
+ }>>;
858
+ synthesisRef: z.ZodOptional<z.ZodString>;
859
+ }, z.core.$strict>>>;
387
860
  }, z.core.$strict>;
388
861
  export declare const TokenTelemetrySchema: z.ZodObject<{
389
862
  source: z.ZodDefault<z.ZodEnum<{
@@ -419,6 +892,94 @@ export declare const BudgetTelemetrySchema: z.ZodObject<{
419
892
  cacheReadTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
420
893
  nonCacheTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
421
894
  }, z.core.$strict>>;
895
+ orchestration: z.ZodPrefault<z.ZodObject<{
896
+ passCount: z.ZodDefault<z.ZodNumber>;
897
+ workerCount: z.ZodDefault<z.ZodNumber>;
898
+ candidatePassCount: z.ZodDefault<z.ZodNumber>;
899
+ verifierPassCount: z.ZodDefault<z.ZodNumber>;
900
+ candidateEligibleCount: z.ZodDefault<z.ZodNumber>;
901
+ candidateUsedDecisionCount: z.ZodDefault<z.ZodNumber>;
902
+ candidateSerialRequiredDecisionCount: z.ZodDefault<z.ZodNumber>;
903
+ skippedCandidateDecisionCount: z.ZodDefault<z.ZodNumber>;
904
+ recordedPassIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
905
+ latestPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
906
+ id: z.ZodString;
907
+ kind: z.ZodEnum<{
908
+ discovery: "discovery";
909
+ audit: "audit";
910
+ review: "review";
911
+ validation: "validation";
912
+ verification: "verification";
913
+ candidate: "candidate";
914
+ "implementation-decision": "implementation-decision";
915
+ }>;
916
+ decision: z.ZodOptional<z.ZodEnum<{
917
+ serial: "serial";
918
+ parallel: "parallel";
919
+ "candidate-exact-path": "candidate-exact-path";
920
+ "candidate-worktree": "candidate-worktree";
921
+ tournament: "tournament";
922
+ skipped: "skipped";
923
+ }>>;
924
+ decisionReason: z.ZodOptional<z.ZodString>;
925
+ candidateEligibility: z.ZodDefault<z.ZodEnum<{
926
+ eligible: "eligible";
927
+ not_eligible: "not_eligible";
928
+ unknown: "unknown";
929
+ }>>;
930
+ candidateDecision: z.ZodOptional<z.ZodEnum<{
931
+ skipped: "skipped";
932
+ used: "used";
933
+ serial_required: "serial_required";
934
+ }>>;
935
+ decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
936
+ shared_state: "shared_state";
937
+ overlapping_files: "overlapping_files";
938
+ small_slice: "small_slice";
939
+ needs_manager_judgment: "needs_manager_judgment";
940
+ independent_surface: "independent_surface";
941
+ validation_available: "validation_available";
942
+ }>>>;
943
+ modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
944
+ audit: "audit";
945
+ review: "review";
946
+ validation: "validation";
947
+ evidence: "evidence";
948
+ verifier: "verifier";
949
+ "candidate-implementation": "candidate-implementation";
950
+ }>>>;
951
+ workerCount: z.ZodDefault<z.ZodNumber>;
952
+ candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
953
+ verifierWorkerCount: z.ZodDefault<z.ZodNumber>;
954
+ sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
955
+ dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
956
+ writeScope: z.ZodDefault<z.ZodEnum<{
957
+ none: "none";
958
+ "manager-serial": "manager-serial";
959
+ "exact-path": "exact-path";
960
+ "isolated-worktree": "isolated-worktree";
961
+ mixed: "mixed";
962
+ }>>;
963
+ handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
964
+ verificationStatus: z.ZodDefault<z.ZodEnum<{
965
+ pending: "pending";
966
+ passed: "passed";
967
+ failed: "failed";
968
+ mixed: "mixed";
969
+ "not-needed": "not-needed";
970
+ downgraded: "downgraded";
971
+ }>>;
972
+ outcome: z.ZodDefault<z.ZodEnum<{
973
+ accepted: "accepted";
974
+ modified: "modified";
975
+ rejected: "rejected";
976
+ partial: "partial";
977
+ "not-covered": "not-covered";
978
+ superseded: "superseded";
979
+ }>>;
980
+ synthesisRef: z.ZodOptional<z.ZodString>;
981
+ }, z.core.$strict>>>;
982
+ }, z.core.$strict>>;
422
983
  phaseBoundary: z.ZodDefault<z.ZodNullable<z.ZodObject<{
423
984
  reason: z.ZodEnum<{
424
985
  feature_limit: "feature_limit";
@@ -546,8 +1107,85 @@ export declare const SessionSchema: z.ZodObject<{
546
1107
  summary: z.ZodOptional<z.ZodString>;
547
1108
  resolutionHint: z.ZodOptional<z.ZodString>;
548
1109
  }, z.core.$strict>>;
1110
+ orchestrationPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
1111
+ id: z.ZodString;
1112
+ kind: z.ZodEnum<{
1113
+ discovery: "discovery";
1114
+ audit: "audit";
1115
+ review: "review";
1116
+ validation: "validation";
1117
+ verification: "verification";
1118
+ candidate: "candidate";
1119
+ "implementation-decision": "implementation-decision";
1120
+ }>;
1121
+ decision: z.ZodOptional<z.ZodEnum<{
1122
+ serial: "serial";
1123
+ parallel: "parallel";
1124
+ "candidate-exact-path": "candidate-exact-path";
1125
+ "candidate-worktree": "candidate-worktree";
1126
+ tournament: "tournament";
1127
+ skipped: "skipped";
1128
+ }>>;
1129
+ decisionReason: z.ZodOptional<z.ZodString>;
1130
+ candidateEligibility: z.ZodDefault<z.ZodEnum<{
1131
+ eligible: "eligible";
1132
+ not_eligible: "not_eligible";
1133
+ unknown: "unknown";
1134
+ }>>;
1135
+ candidateDecision: z.ZodOptional<z.ZodEnum<{
1136
+ skipped: "skipped";
1137
+ used: "used";
1138
+ serial_required: "serial_required";
1139
+ }>>;
1140
+ decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
1141
+ shared_state: "shared_state";
1142
+ overlapping_files: "overlapping_files";
1143
+ small_slice: "small_slice";
1144
+ needs_manager_judgment: "needs_manager_judgment";
1145
+ independent_surface: "independent_surface";
1146
+ validation_available: "validation_available";
1147
+ }>>>;
1148
+ modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
1149
+ audit: "audit";
1150
+ review: "review";
1151
+ validation: "validation";
1152
+ evidence: "evidence";
1153
+ verifier: "verifier";
1154
+ "candidate-implementation": "candidate-implementation";
1155
+ }>>>;
1156
+ workerCount: z.ZodDefault<z.ZodNumber>;
1157
+ candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
1158
+ verifierWorkerCount: z.ZodDefault<z.ZodNumber>;
1159
+ sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
1160
+ dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
1161
+ writeScope: z.ZodDefault<z.ZodEnum<{
1162
+ none: "none";
1163
+ "manager-serial": "manager-serial";
1164
+ "exact-path": "exact-path";
1165
+ "isolated-worktree": "isolated-worktree";
1166
+ mixed: "mixed";
1167
+ }>>;
1168
+ handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
1169
+ verificationStatus: z.ZodDefault<z.ZodEnum<{
1170
+ pending: "pending";
1171
+ passed: "passed";
1172
+ failed: "failed";
1173
+ mixed: "mixed";
1174
+ "not-needed": "not-needed";
1175
+ downgraded: "downgraded";
1176
+ }>>;
1177
+ outcome: z.ZodDefault<z.ZodEnum<{
1178
+ accepted: "accepted";
1179
+ modified: "modified";
1180
+ rejected: "rejected";
1181
+ partial: "partial";
1182
+ "not-covered": "not-covered";
1183
+ superseded: "superseded";
1184
+ }>>;
1185
+ synthesisRef: z.ZodOptional<z.ZodString>;
1186
+ }, z.core.$strict>>>;
549
1187
  }, z.core.$strict>>>;
550
- budget: z.ZodDefault<z.ZodObject<{
1188
+ budget: z.ZodPrefault<z.ZodObject<{
551
1189
  phaseStartedAt: z.ZodDefault<z.ZodString>;
552
1190
  completedFeaturesSinceBoundary: z.ZodDefault<z.ZodNumber>;
553
1191
  reviewCount: z.ZodDefault<z.ZodNumber>;
@@ -562,6 +1200,94 @@ export declare const SessionSchema: z.ZodObject<{
562
1200
  cacheReadTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
563
1201
  nonCacheTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
564
1202
  }, z.core.$strict>>;
1203
+ orchestration: z.ZodPrefault<z.ZodObject<{
1204
+ passCount: z.ZodDefault<z.ZodNumber>;
1205
+ workerCount: z.ZodDefault<z.ZodNumber>;
1206
+ candidatePassCount: z.ZodDefault<z.ZodNumber>;
1207
+ verifierPassCount: z.ZodDefault<z.ZodNumber>;
1208
+ candidateEligibleCount: z.ZodDefault<z.ZodNumber>;
1209
+ candidateUsedDecisionCount: z.ZodDefault<z.ZodNumber>;
1210
+ candidateSerialRequiredDecisionCount: z.ZodDefault<z.ZodNumber>;
1211
+ skippedCandidateDecisionCount: z.ZodDefault<z.ZodNumber>;
1212
+ recordedPassIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
1213
+ latestPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
1214
+ id: z.ZodString;
1215
+ kind: z.ZodEnum<{
1216
+ discovery: "discovery";
1217
+ audit: "audit";
1218
+ review: "review";
1219
+ validation: "validation";
1220
+ verification: "verification";
1221
+ candidate: "candidate";
1222
+ "implementation-decision": "implementation-decision";
1223
+ }>;
1224
+ decision: z.ZodOptional<z.ZodEnum<{
1225
+ serial: "serial";
1226
+ parallel: "parallel";
1227
+ "candidate-exact-path": "candidate-exact-path";
1228
+ "candidate-worktree": "candidate-worktree";
1229
+ tournament: "tournament";
1230
+ skipped: "skipped";
1231
+ }>>;
1232
+ decisionReason: z.ZodOptional<z.ZodString>;
1233
+ candidateEligibility: z.ZodDefault<z.ZodEnum<{
1234
+ eligible: "eligible";
1235
+ not_eligible: "not_eligible";
1236
+ unknown: "unknown";
1237
+ }>>;
1238
+ candidateDecision: z.ZodOptional<z.ZodEnum<{
1239
+ skipped: "skipped";
1240
+ used: "used";
1241
+ serial_required: "serial_required";
1242
+ }>>;
1243
+ decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
1244
+ shared_state: "shared_state";
1245
+ overlapping_files: "overlapping_files";
1246
+ small_slice: "small_slice";
1247
+ needs_manager_judgment: "needs_manager_judgment";
1248
+ independent_surface: "independent_surface";
1249
+ validation_available: "validation_available";
1250
+ }>>>;
1251
+ modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
1252
+ audit: "audit";
1253
+ review: "review";
1254
+ validation: "validation";
1255
+ evidence: "evidence";
1256
+ verifier: "verifier";
1257
+ "candidate-implementation": "candidate-implementation";
1258
+ }>>>;
1259
+ workerCount: z.ZodDefault<z.ZodNumber>;
1260
+ candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
1261
+ verifierWorkerCount: z.ZodDefault<z.ZodNumber>;
1262
+ sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
1263
+ dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
1264
+ writeScope: z.ZodDefault<z.ZodEnum<{
1265
+ none: "none";
1266
+ "manager-serial": "manager-serial";
1267
+ "exact-path": "exact-path";
1268
+ "isolated-worktree": "isolated-worktree";
1269
+ mixed: "mixed";
1270
+ }>>;
1271
+ handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
1272
+ verificationStatus: z.ZodDefault<z.ZodEnum<{
1273
+ pending: "pending";
1274
+ passed: "passed";
1275
+ failed: "failed";
1276
+ mixed: "mixed";
1277
+ "not-needed": "not-needed";
1278
+ downgraded: "downgraded";
1279
+ }>>;
1280
+ outcome: z.ZodDefault<z.ZodEnum<{
1281
+ accepted: "accepted";
1282
+ modified: "modified";
1283
+ rejected: "rejected";
1284
+ partial: "partial";
1285
+ "not-covered": "not-covered";
1286
+ superseded: "superseded";
1287
+ }>>;
1288
+ synthesisRef: z.ZodOptional<z.ZodString>;
1289
+ }, z.core.$strict>>>;
1290
+ }, z.core.$strict>>;
565
1291
  phaseBoundary: z.ZodDefault<z.ZodNullable<z.ZodObject<{
566
1292
  reason: z.ZodEnum<{
567
1293
  feature_limit: "feature_limit";
@@ -600,6 +1326,8 @@ export type ExecutionHistoryEntry = z.infer<typeof ExecutionHistoryEntrySchema>;
600
1326
  export type Feature = z.infer<typeof FeatureSchema>;
601
1327
  export type FeatureReviewDepth = z.infer<typeof FeatureReviewDepthSchema>;
602
1328
  export type FinalReview = z.infer<typeof FinalReviewSchema>;
1329
+ export type OrchestrationPassRecord = z.infer<typeof OrchestrationPassRecordSchema>;
1330
+ export type OrchestrationTelemetry = z.infer<typeof OrchestrationTelemetrySchema>;
603
1331
  export type PhaseBoundary = z.infer<typeof PhaseBoundarySchema>;
604
1332
  export type Plan = z.infer<typeof PlanSchema>;
605
1333
  export type PlanInput = z.input<typeof PlanInputSchema>;