opencode-plugin-flow 4.4.0 → 5.1.0
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.
- package/CHANGELOG.md +90 -0
- package/README.md +60 -43
- package/dist/application/errors.d.ts +5 -0
- package/dist/application/flow-service.d.ts +339 -0
- package/dist/application/ports/evidence-artifact-store.d.ts +28 -0
- package/dist/application/ports/session-repository.d.ts +18 -0
- package/dist/application/ports/source-identity.d.ts +61 -0
- package/dist/application/replay/canonical-json.d.ts +7 -0
- package/dist/application/replay/contract.d.ts +2007 -0
- package/dist/application/replay/engine.d.ts +101 -0
- package/dist/application/replay/index.d.ts +7 -0
- package/dist/application/replay/privacy.d.ts +14 -0
- package/dist/{runtime → application}/schema.d.ts +1176 -370
- package/dist/cli.js +295 -2721
- package/dist/cli.js.map +7 -6
- package/dist/config-shared.d.ts +28 -14
- package/dist/config.d.ts +1 -1
- package/dist/distribution/legacy-cleanup.d.ts +25 -0
- package/dist/domain/feature-id.d.ts +3 -0
- package/dist/domain/limits.d.ts +1 -0
- package/dist/domain/orchestration-policy.d.ts +27 -0
- package/dist/domain/session.d.ts +355 -0
- package/dist/domain/transitions.d.ts +163 -0
- package/dist/domain/validation-command.d.ts +8 -0
- package/dist/guidance/catalog.d.ts +18 -0
- package/dist/guidance/ids.d.ts +4 -0
- package/dist/index.d.ts +1 -1
- package/dist/index.js +4495 -1817
- package/dist/index.js.map +30 -18
- package/dist/infrastructure/fs/evidence-artifact-store.d.ts +5 -0
- package/dist/infrastructure/fs/session-repository.d.ts +2 -0
- package/dist/infrastructure/fs/source-identity.d.ts +26 -0
- package/dist/infrastructure/fs/workspace-flow-service.d.ts +9 -0
- package/dist/{runtime → infrastructure/fs}/workspace.d.ts +12 -15
- package/dist/infrastructure/system/transition-environment.d.ts +2 -0
- package/dist/platform/opencode/config.d.ts +2 -0
- package/dist/{adapters → platform}/opencode/plugin.d.ts +1 -1
- package/dist/{adapters → platform}/opencode/sdk.d.ts +0 -1
- package/dist/platform/opencode/tools.d.ts +6 -0
- package/dist/prompt-model-evaluation.d.ts +19 -30
- package/dist/prompt-quality.d.ts +1 -1
- package/dist/version.d.ts +1 -0
- package/package.json +18 -11
- package/dist/adapters/opencode/config.d.ts +0 -3
- package/dist/adapters/opencode/tools.d.ts +0 -322
- package/dist/distribution/flow-skill-definitions.d.ts +0 -9
- package/dist/distribution/sync.d.ts +0 -69
- package/dist/runtime/api.d.ts +0 -211
- package/dist/runtime/time.d.ts +0 -2
- package/dist/runtime/transitions.d.ts +0 -230
- /package/dist/{runtime/json/strict-object.d.ts → infrastructure/fs/strict-json-object.d.ts} +0 -0
- /package/dist/{adapters → platform}/opencode/logging.d.ts +0 -0
|
@@ -1,64 +1,88 @@
|
|
|
1
1
|
import { z } from "zod";
|
|
2
|
-
|
|
3
|
-
export
|
|
2
|
+
import { type Session } from "../domain/session.js";
|
|
3
|
+
export { hasCandidateExecutionEvidence, hasVerifierExecutionEvidence, isCandidateShapedDecision, } from "../domain/orchestration-policy.js";
|
|
4
|
+
export declare const FeatureIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
|
|
5
|
+
export declare const DigestSchema: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
6
|
+
export declare const SnapshotIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
7
|
+
export declare const EvidenceIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
8
|
+
export declare const OperationIdSchema: z.ZodString;
|
|
9
|
+
export declare const CausalRevisionSchema: z.ZodNumber;
|
|
4
10
|
export declare const FeatureStatusSchema: z.ZodEnum<{
|
|
5
|
-
pending: "pending";
|
|
6
|
-
in_progress: "in_progress";
|
|
7
|
-
completed: "completed";
|
|
8
11
|
blocked: "blocked";
|
|
12
|
+
completed: "completed";
|
|
13
|
+
in_progress: "in_progress";
|
|
14
|
+
pending: "pending";
|
|
9
15
|
}>;
|
|
10
16
|
export declare const SessionStatusSchema: z.ZodEnum<{
|
|
11
|
-
completed: "completed";
|
|
12
17
|
blocked: "blocked";
|
|
18
|
+
completed: "completed";
|
|
13
19
|
planning: "planning";
|
|
14
20
|
ready: "ready";
|
|
15
21
|
running: "running";
|
|
16
22
|
}>;
|
|
17
23
|
export declare const ReviewStatusSchema: z.ZodEnum<{
|
|
24
|
+
failed: "failed";
|
|
18
25
|
passed: "passed";
|
|
26
|
+
}>;
|
|
27
|
+
export declare const ReviewFindingTaxonomySchema: z.ZodEnum<{
|
|
28
|
+
advisory: "advisory";
|
|
29
|
+
evidence_gap: "evidence_gap";
|
|
30
|
+
implementation_defect: "implementation_defect";
|
|
31
|
+
regression_coverage_gap: "regression_coverage_gap";
|
|
32
|
+
}>;
|
|
33
|
+
export declare const ReviewKindSchema: z.ZodEnum<{
|
|
34
|
+
feature: "feature";
|
|
35
|
+
final: "final";
|
|
36
|
+
}>;
|
|
37
|
+
export declare const ReviewVerdictSchema: z.ZodEnum<{
|
|
19
38
|
failed: "failed";
|
|
39
|
+
passed: "passed";
|
|
40
|
+
}>;
|
|
41
|
+
export declare const ReviewTerminalDispositionSchema: z.ZodEnum<{
|
|
42
|
+
observed_unsubmitted: "observed_unsubmitted";
|
|
43
|
+
submitted: "submitted";
|
|
20
44
|
}>;
|
|
21
45
|
export declare const ValidationStatusSchema: z.ZodEnum<{
|
|
22
|
-
passed: "passed";
|
|
23
46
|
failed: "failed";
|
|
47
|
+
passed: "passed";
|
|
24
48
|
}>;
|
|
25
49
|
export declare const ValidationScopeSchema: z.ZodEnum<{
|
|
26
|
-
targeted: "targeted";
|
|
27
50
|
broad: "broad";
|
|
51
|
+
targeted: "targeted";
|
|
28
52
|
}>;
|
|
29
53
|
export declare const FeatureReviewDepthSchema: z.ZodEnum<{
|
|
54
|
+
detailed: "detailed";
|
|
30
55
|
quick: "quick";
|
|
31
56
|
standard: "standard";
|
|
32
|
-
detailed: "detailed";
|
|
33
57
|
}>;
|
|
34
58
|
export declare const FinalReviewPolicySchema: z.ZodEnum<{
|
|
35
59
|
broad: "broad";
|
|
36
60
|
detailed: "detailed";
|
|
37
61
|
}>;
|
|
38
62
|
export declare const OrchestrationPassKindSchema: z.ZodEnum<{
|
|
39
|
-
validation: "validation";
|
|
40
63
|
audit: "audit";
|
|
41
64
|
candidate: "candidate";
|
|
42
65
|
discovery: "discovery";
|
|
66
|
+
"implementation-decision": "implementation-decision";
|
|
43
67
|
review: "review";
|
|
68
|
+
validation: "validation";
|
|
44
69
|
verification: "verification";
|
|
45
|
-
"implementation-decision": "implementation-decision";
|
|
46
70
|
}>;
|
|
47
71
|
export declare const OrchestrationModeSchema: z.ZodEnum<{
|
|
72
|
+
audit: "audit";
|
|
73
|
+
"candidate-implementation": "candidate-implementation";
|
|
48
74
|
evidence: "evidence";
|
|
75
|
+
review: "review";
|
|
49
76
|
validation: "validation";
|
|
50
|
-
audit: "audit";
|
|
51
77
|
verifier: "verifier";
|
|
52
|
-
review: "review";
|
|
53
|
-
"candidate-implementation": "candidate-implementation";
|
|
54
78
|
}>;
|
|
55
79
|
export declare const OrchestrationDecisionSchema: z.ZodEnum<{
|
|
56
|
-
parallel: "parallel";
|
|
57
|
-
serial: "serial";
|
|
58
80
|
"candidate-exact-path": "candidate-exact-path";
|
|
59
81
|
"candidate-worktree": "candidate-worktree";
|
|
60
|
-
|
|
82
|
+
parallel: "parallel";
|
|
83
|
+
serial: "serial";
|
|
61
84
|
skipped: "skipped";
|
|
85
|
+
tournament: "tournament";
|
|
62
86
|
}>;
|
|
63
87
|
export declare const OrchestrationCandidateEligibilitySchema: z.ZodEnum<{
|
|
64
88
|
eligible: "eligible";
|
|
@@ -66,70 +90,59 @@ export declare const OrchestrationCandidateEligibilitySchema: z.ZodEnum<{
|
|
|
66
90
|
unknown: "unknown";
|
|
67
91
|
}>;
|
|
68
92
|
export declare const OrchestrationCandidateDecisionSchema: z.ZodEnum<{
|
|
93
|
+
serial_required: "serial_required";
|
|
69
94
|
skipped: "skipped";
|
|
70
95
|
used: "used";
|
|
71
|
-
serial_required: "serial_required";
|
|
72
96
|
}>;
|
|
73
97
|
export declare const OrchestrationDecisionFactorSchema: z.ZodEnum<{
|
|
74
|
-
|
|
98
|
+
independent_surface: "independent_surface";
|
|
99
|
+
needs_manager_judgment: "needs_manager_judgment";
|
|
75
100
|
overlapping_files: "overlapping_files";
|
|
101
|
+
shared_state: "shared_state";
|
|
76
102
|
small_slice: "small_slice";
|
|
77
|
-
needs_manager_judgment: "needs_manager_judgment";
|
|
78
|
-
independent_surface: "independent_surface";
|
|
79
103
|
validation_available: "validation_available";
|
|
80
104
|
}>;
|
|
81
105
|
export declare const OrchestrationWriteScopeSchema: z.ZodEnum<{
|
|
82
|
-
none: "none";
|
|
83
|
-
"manager-serial": "manager-serial";
|
|
84
106
|
"exact-path": "exact-path";
|
|
85
107
|
"isolated-worktree": "isolated-worktree";
|
|
108
|
+
"manager-serial": "manager-serial";
|
|
86
109
|
mixed: "mixed";
|
|
110
|
+
none: "none";
|
|
87
111
|
}>;
|
|
88
112
|
export declare const OrchestrationVerificationStatusSchema: z.ZodEnum<{
|
|
89
|
-
|
|
90
|
-
passed: "passed";
|
|
113
|
+
downgraded: "downgraded";
|
|
91
114
|
failed: "failed";
|
|
92
115
|
mixed: "mixed";
|
|
93
116
|
"not-needed": "not-needed";
|
|
94
|
-
|
|
117
|
+
passed: "passed";
|
|
118
|
+
pending: "pending";
|
|
95
119
|
}>;
|
|
96
120
|
export declare const OrchestrationOutcomeSchema: z.ZodEnum<{
|
|
97
121
|
accepted: "accepted";
|
|
98
122
|
modified: "modified";
|
|
99
|
-
rejected: "rejected";
|
|
100
|
-
partial: "partial";
|
|
101
123
|
"not-covered": "not-covered";
|
|
124
|
+
partial: "partial";
|
|
125
|
+
rejected: "rejected";
|
|
102
126
|
superseded: "superseded";
|
|
103
127
|
}>;
|
|
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
128
|
export declare const OrchestrationPassRecordSchema: z.ZodObject<{
|
|
116
129
|
id: z.ZodString;
|
|
117
130
|
kind: z.ZodEnum<{
|
|
118
|
-
validation: "validation";
|
|
119
131
|
audit: "audit";
|
|
120
132
|
candidate: "candidate";
|
|
121
133
|
discovery: "discovery";
|
|
134
|
+
"implementation-decision": "implementation-decision";
|
|
122
135
|
review: "review";
|
|
136
|
+
validation: "validation";
|
|
123
137
|
verification: "verification";
|
|
124
|
-
"implementation-decision": "implementation-decision";
|
|
125
138
|
}>;
|
|
126
139
|
decision: z.ZodOptional<z.ZodEnum<{
|
|
127
|
-
parallel: "parallel";
|
|
128
|
-
serial: "serial";
|
|
129
140
|
"candidate-exact-path": "candidate-exact-path";
|
|
130
141
|
"candidate-worktree": "candidate-worktree";
|
|
131
|
-
|
|
142
|
+
parallel: "parallel";
|
|
143
|
+
serial: "serial";
|
|
132
144
|
skipped: "skipped";
|
|
145
|
+
tournament: "tournament";
|
|
133
146
|
}>>;
|
|
134
147
|
decisionReason: z.ZodOptional<z.ZodString>;
|
|
135
148
|
candidateEligibility: z.ZodDefault<z.ZodEnum<{
|
|
@@ -138,25 +151,25 @@ export declare const OrchestrationPassRecordSchema: z.ZodObject<{
|
|
|
138
151
|
unknown: "unknown";
|
|
139
152
|
}>>;
|
|
140
153
|
candidateDecision: z.ZodOptional<z.ZodEnum<{
|
|
154
|
+
serial_required: "serial_required";
|
|
141
155
|
skipped: "skipped";
|
|
142
156
|
used: "used";
|
|
143
|
-
serial_required: "serial_required";
|
|
144
157
|
}>>;
|
|
145
158
|
decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
146
|
-
|
|
159
|
+
independent_surface: "independent_surface";
|
|
160
|
+
needs_manager_judgment: "needs_manager_judgment";
|
|
147
161
|
overlapping_files: "overlapping_files";
|
|
162
|
+
shared_state: "shared_state";
|
|
148
163
|
small_slice: "small_slice";
|
|
149
|
-
needs_manager_judgment: "needs_manager_judgment";
|
|
150
|
-
independent_surface: "independent_surface";
|
|
151
164
|
validation_available: "validation_available";
|
|
152
165
|
}>>>;
|
|
153
166
|
modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
167
|
+
audit: "audit";
|
|
168
|
+
"candidate-implementation": "candidate-implementation";
|
|
154
169
|
evidence: "evidence";
|
|
170
|
+
review: "review";
|
|
155
171
|
validation: "validation";
|
|
156
|
-
audit: "audit";
|
|
157
172
|
verifier: "verifier";
|
|
158
|
-
review: "review";
|
|
159
|
-
"candidate-implementation": "candidate-implementation";
|
|
160
173
|
}>>>;
|
|
161
174
|
workerCount: z.ZodDefault<z.ZodNumber>;
|
|
162
175
|
candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
|
|
@@ -164,27 +177,27 @@ export declare const OrchestrationPassRecordSchema: z.ZodObject<{
|
|
|
164
177
|
sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
165
178
|
dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
166
179
|
writeScope: z.ZodDefault<z.ZodEnum<{
|
|
167
|
-
none: "none";
|
|
168
|
-
"manager-serial": "manager-serial";
|
|
169
180
|
"exact-path": "exact-path";
|
|
170
181
|
"isolated-worktree": "isolated-worktree";
|
|
182
|
+
"manager-serial": "manager-serial";
|
|
171
183
|
mixed: "mixed";
|
|
184
|
+
none: "none";
|
|
172
185
|
}>>;
|
|
173
186
|
handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
174
187
|
verificationStatus: z.ZodDefault<z.ZodEnum<{
|
|
175
|
-
|
|
176
|
-
passed: "passed";
|
|
188
|
+
downgraded: "downgraded";
|
|
177
189
|
failed: "failed";
|
|
178
190
|
mixed: "mixed";
|
|
179
191
|
"not-needed": "not-needed";
|
|
180
|
-
|
|
192
|
+
passed: "passed";
|
|
193
|
+
pending: "pending";
|
|
181
194
|
}>>;
|
|
182
195
|
outcome: z.ZodDefault<z.ZodEnum<{
|
|
183
196
|
accepted: "accepted";
|
|
184
197
|
modified: "modified";
|
|
185
|
-
rejected: "rejected";
|
|
186
|
-
partial: "partial";
|
|
187
198
|
"not-covered": "not-covered";
|
|
199
|
+
partial: "partial";
|
|
200
|
+
rejected: "rejected";
|
|
188
201
|
superseded: "superseded";
|
|
189
202
|
}>>;
|
|
190
203
|
synthesisRef: z.ZodOptional<z.ZodString>;
|
|
@@ -198,25 +211,24 @@ export declare const OrchestrationTelemetrySchema: z.ZodObject<{
|
|
|
198
211
|
candidateUsedDecisionCount: z.ZodDefault<z.ZodNumber>;
|
|
199
212
|
candidateSerialRequiredDecisionCount: z.ZodDefault<z.ZodNumber>;
|
|
200
213
|
skippedCandidateDecisionCount: z.ZodDefault<z.ZodNumber>;
|
|
201
|
-
recordedPassIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
202
214
|
latestPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
203
215
|
id: z.ZodString;
|
|
204
216
|
kind: z.ZodEnum<{
|
|
205
|
-
validation: "validation";
|
|
206
217
|
audit: "audit";
|
|
207
218
|
candidate: "candidate";
|
|
208
219
|
discovery: "discovery";
|
|
220
|
+
"implementation-decision": "implementation-decision";
|
|
209
221
|
review: "review";
|
|
222
|
+
validation: "validation";
|
|
210
223
|
verification: "verification";
|
|
211
|
-
"implementation-decision": "implementation-decision";
|
|
212
224
|
}>;
|
|
213
225
|
decision: z.ZodOptional<z.ZodEnum<{
|
|
214
|
-
parallel: "parallel";
|
|
215
|
-
serial: "serial";
|
|
216
226
|
"candidate-exact-path": "candidate-exact-path";
|
|
217
227
|
"candidate-worktree": "candidate-worktree";
|
|
218
|
-
|
|
228
|
+
parallel: "parallel";
|
|
229
|
+
serial: "serial";
|
|
219
230
|
skipped: "skipped";
|
|
231
|
+
tournament: "tournament";
|
|
220
232
|
}>>;
|
|
221
233
|
decisionReason: z.ZodOptional<z.ZodString>;
|
|
222
234
|
candidateEligibility: z.ZodDefault<z.ZodEnum<{
|
|
@@ -225,25 +237,25 @@ export declare const OrchestrationTelemetrySchema: z.ZodObject<{
|
|
|
225
237
|
unknown: "unknown";
|
|
226
238
|
}>>;
|
|
227
239
|
candidateDecision: z.ZodOptional<z.ZodEnum<{
|
|
240
|
+
serial_required: "serial_required";
|
|
228
241
|
skipped: "skipped";
|
|
229
242
|
used: "used";
|
|
230
|
-
serial_required: "serial_required";
|
|
231
243
|
}>>;
|
|
232
244
|
decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
233
|
-
|
|
245
|
+
independent_surface: "independent_surface";
|
|
246
|
+
needs_manager_judgment: "needs_manager_judgment";
|
|
234
247
|
overlapping_files: "overlapping_files";
|
|
248
|
+
shared_state: "shared_state";
|
|
235
249
|
small_slice: "small_slice";
|
|
236
|
-
needs_manager_judgment: "needs_manager_judgment";
|
|
237
|
-
independent_surface: "independent_surface";
|
|
238
250
|
validation_available: "validation_available";
|
|
239
251
|
}>>>;
|
|
240
252
|
modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
253
|
+
audit: "audit";
|
|
254
|
+
"candidate-implementation": "candidate-implementation";
|
|
241
255
|
evidence: "evidence";
|
|
256
|
+
review: "review";
|
|
242
257
|
validation: "validation";
|
|
243
|
-
audit: "audit";
|
|
244
258
|
verifier: "verifier";
|
|
245
|
-
review: "review";
|
|
246
|
-
"candidate-implementation": "candidate-implementation";
|
|
247
259
|
}>>>;
|
|
248
260
|
workerCount: z.ZodDefault<z.ZodNumber>;
|
|
249
261
|
candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
|
|
@@ -251,27 +263,27 @@ export declare const OrchestrationTelemetrySchema: z.ZodObject<{
|
|
|
251
263
|
sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
252
264
|
dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
253
265
|
writeScope: z.ZodDefault<z.ZodEnum<{
|
|
254
|
-
none: "none";
|
|
255
|
-
"manager-serial": "manager-serial";
|
|
256
266
|
"exact-path": "exact-path";
|
|
257
267
|
"isolated-worktree": "isolated-worktree";
|
|
268
|
+
"manager-serial": "manager-serial";
|
|
258
269
|
mixed: "mixed";
|
|
270
|
+
none: "none";
|
|
259
271
|
}>>;
|
|
260
272
|
handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
261
273
|
verificationStatus: z.ZodDefault<z.ZodEnum<{
|
|
262
|
-
|
|
263
|
-
passed: "passed";
|
|
274
|
+
downgraded: "downgraded";
|
|
264
275
|
failed: "failed";
|
|
265
276
|
mixed: "mixed";
|
|
266
277
|
"not-needed": "not-needed";
|
|
267
|
-
|
|
278
|
+
passed: "passed";
|
|
279
|
+
pending: "pending";
|
|
268
280
|
}>>;
|
|
269
281
|
outcome: z.ZodDefault<z.ZodEnum<{
|
|
270
282
|
accepted: "accepted";
|
|
271
283
|
modified: "modified";
|
|
272
|
-
rejected: "rejected";
|
|
273
|
-
partial: "partial";
|
|
274
284
|
"not-covered": "not-covered";
|
|
285
|
+
partial: "partial";
|
|
286
|
+
rejected: "rejected";
|
|
275
287
|
superseded: "superseded";
|
|
276
288
|
}>>;
|
|
277
289
|
synthesisRef: z.ZodOptional<z.ZodString>;
|
|
@@ -280,35 +292,142 @@ export declare const OrchestrationTelemetrySchema: z.ZodObject<{
|
|
|
280
292
|
export declare const ReviewFindingSchema: z.ZodObject<{
|
|
281
293
|
summary: z.ZodString;
|
|
282
294
|
severity: z.ZodDefault<z.ZodEnum<{
|
|
283
|
-
blocking: "blocking";
|
|
284
295
|
advisory: "advisory";
|
|
296
|
+
blocking: "blocking";
|
|
285
297
|
}>>;
|
|
286
298
|
}, z.core.$strict>;
|
|
299
|
+
export declare const ReviewSnapshotIdSchema: z.ZodPipe<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>>;
|
|
300
|
+
export declare const ReviewExecutionFindingInputSchema: z.ZodObject<{
|
|
301
|
+
taxonomy: z.ZodEnum<{
|
|
302
|
+
advisory: "advisory";
|
|
303
|
+
evidence_gap: "evidence_gap";
|
|
304
|
+
implementation_defect: "implementation_defect";
|
|
305
|
+
regression_coverage_gap: "regression_coverage_gap";
|
|
306
|
+
}>;
|
|
307
|
+
subject: z.ZodString;
|
|
308
|
+
requirementOrRisk: z.ZodString;
|
|
309
|
+
evidenceLocator: z.ZodString;
|
|
310
|
+
summary: z.ZodString;
|
|
311
|
+
severity: z.ZodEnum<{
|
|
312
|
+
advisory: "advisory";
|
|
313
|
+
blocking: "blocking";
|
|
314
|
+
}>;
|
|
315
|
+
}, z.core.$strict>;
|
|
316
|
+
export declare const ReviewExecutionFindingSchema: z.ZodObject<{
|
|
317
|
+
taxonomy: z.ZodEnum<{
|
|
318
|
+
advisory: "advisory";
|
|
319
|
+
evidence_gap: "evidence_gap";
|
|
320
|
+
implementation_defect: "implementation_defect";
|
|
321
|
+
regression_coverage_gap: "regression_coverage_gap";
|
|
322
|
+
}>;
|
|
323
|
+
subject: z.ZodString;
|
|
324
|
+
requirementOrRisk: z.ZodString;
|
|
325
|
+
evidenceLocator: z.ZodString;
|
|
326
|
+
summary: z.ZodString;
|
|
327
|
+
severity: z.ZodEnum<{
|
|
328
|
+
advisory: "advisory";
|
|
329
|
+
blocking: "blocking";
|
|
330
|
+
}>;
|
|
331
|
+
fingerprint: z.ZodString;
|
|
332
|
+
}, z.core.$strict>;
|
|
333
|
+
export declare const ReviewExecutionInputSchema: z.ZodObject<{
|
|
334
|
+
attemptId: z.ZodString;
|
|
335
|
+
logicalPassId: z.ZodString;
|
|
336
|
+
featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
|
|
337
|
+
reviewKind: z.ZodEnum<{
|
|
338
|
+
feature: "feature";
|
|
339
|
+
final: "final";
|
|
340
|
+
}>;
|
|
341
|
+
reviewSnapshotId: z.ZodPipe<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>>;
|
|
342
|
+
verdict: z.ZodEnum<{
|
|
343
|
+
failed: "failed";
|
|
344
|
+
passed: "passed";
|
|
345
|
+
}>;
|
|
346
|
+
startedAt: z.ZodString;
|
|
347
|
+
completedAt: z.ZodString;
|
|
348
|
+
terminalDisposition: z.ZodEnum<{
|
|
349
|
+
observed_unsubmitted: "observed_unsubmitted";
|
|
350
|
+
submitted: "submitted";
|
|
351
|
+
}>;
|
|
352
|
+
findings: z.ZodArray<z.ZodObject<{
|
|
353
|
+
taxonomy: z.ZodEnum<{
|
|
354
|
+
advisory: "advisory";
|
|
355
|
+
evidence_gap: "evidence_gap";
|
|
356
|
+
implementation_defect: "implementation_defect";
|
|
357
|
+
regression_coverage_gap: "regression_coverage_gap";
|
|
358
|
+
}>;
|
|
359
|
+
subject: z.ZodString;
|
|
360
|
+
requirementOrRisk: z.ZodString;
|
|
361
|
+
evidenceLocator: z.ZodString;
|
|
362
|
+
summary: z.ZodString;
|
|
363
|
+
severity: z.ZodEnum<{
|
|
364
|
+
advisory: "advisory";
|
|
365
|
+
blocking: "blocking";
|
|
366
|
+
}>;
|
|
367
|
+
}, z.core.$strict>>;
|
|
368
|
+
}, z.core.$strict>;
|
|
369
|
+
export declare const ReviewExecutionSchema: z.ZodObject<{
|
|
370
|
+
attemptId: z.ZodString;
|
|
371
|
+
logicalPassId: z.ZodString;
|
|
372
|
+
featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
|
|
373
|
+
reviewKind: z.ZodEnum<{
|
|
374
|
+
feature: "feature";
|
|
375
|
+
final: "final";
|
|
376
|
+
}>;
|
|
377
|
+
reviewSnapshotId: z.ZodPipe<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>>;
|
|
378
|
+
verdict: z.ZodEnum<{
|
|
379
|
+
failed: "failed";
|
|
380
|
+
passed: "passed";
|
|
381
|
+
}>;
|
|
382
|
+
startedAt: z.ZodString;
|
|
383
|
+
completedAt: z.ZodString;
|
|
384
|
+
terminalDisposition: z.ZodEnum<{
|
|
385
|
+
observed_unsubmitted: "observed_unsubmitted";
|
|
386
|
+
submitted: "submitted";
|
|
387
|
+
}>;
|
|
388
|
+
findings: z.ZodArray<z.ZodObject<{
|
|
389
|
+
taxonomy: z.ZodEnum<{
|
|
390
|
+
advisory: "advisory";
|
|
391
|
+
evidence_gap: "evidence_gap";
|
|
392
|
+
implementation_defect: "implementation_defect";
|
|
393
|
+
regression_coverage_gap: "regression_coverage_gap";
|
|
394
|
+
}>;
|
|
395
|
+
subject: z.ZodString;
|
|
396
|
+
requirementOrRisk: z.ZodString;
|
|
397
|
+
evidenceLocator: z.ZodString;
|
|
398
|
+
summary: z.ZodString;
|
|
399
|
+
severity: z.ZodEnum<{
|
|
400
|
+
advisory: "advisory";
|
|
401
|
+
blocking: "blocking";
|
|
402
|
+
}>;
|
|
403
|
+
fingerprint: z.ZodString;
|
|
404
|
+
}, z.core.$strict>>;
|
|
405
|
+
}, z.core.$strict>;
|
|
287
406
|
export declare const ReviewSchema: z.ZodObject<{
|
|
288
407
|
status: z.ZodEnum<{
|
|
289
|
-
passed: "passed";
|
|
290
408
|
failed: "failed";
|
|
409
|
+
passed: "passed";
|
|
291
410
|
}>;
|
|
292
411
|
summary: z.ZodString;
|
|
293
412
|
blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
294
413
|
summary: z.ZodString;
|
|
295
414
|
severity: z.ZodDefault<z.ZodEnum<{
|
|
296
|
-
blocking: "blocking";
|
|
297
415
|
advisory: "advisory";
|
|
416
|
+
blocking: "blocking";
|
|
298
417
|
}>>;
|
|
299
418
|
}, z.core.$strict>>>;
|
|
300
419
|
}, z.core.$strict>;
|
|
301
420
|
export declare const FinalReviewSchema: z.ZodObject<{
|
|
302
421
|
status: z.ZodEnum<{
|
|
303
|
-
passed: "passed";
|
|
304
422
|
failed: "failed";
|
|
423
|
+
passed: "passed";
|
|
305
424
|
}>;
|
|
306
425
|
summary: z.ZodString;
|
|
307
426
|
blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
308
427
|
summary: z.ZodString;
|
|
309
428
|
severity: z.ZodDefault<z.ZodEnum<{
|
|
310
|
-
blocking: "blocking";
|
|
311
429
|
advisory: "advisory";
|
|
430
|
+
blocking: "blocking";
|
|
312
431
|
}>>;
|
|
313
432
|
}, z.core.$strict>>>;
|
|
314
433
|
reviewDepth: z.ZodEnum<{
|
|
@@ -319,32 +438,230 @@ export declare const FinalReviewSchema: z.ZodObject<{
|
|
|
319
438
|
export declare const ValidationRunSchema: z.ZodObject<{
|
|
320
439
|
command: z.ZodString;
|
|
321
440
|
status: z.ZodEnum<{
|
|
322
|
-
passed: "passed";
|
|
323
441
|
failed: "failed";
|
|
442
|
+
passed: "passed";
|
|
324
443
|
}>;
|
|
325
444
|
summary: z.ZodString;
|
|
326
445
|
}, z.core.$strict>;
|
|
446
|
+
export declare const ValidationEvidenceSchema: z.ZodObject<{
|
|
447
|
+
evidenceId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
448
|
+
snapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
449
|
+
sourceDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
450
|
+
startedAt: z.ZodString;
|
|
451
|
+
completedAt: z.ZodString;
|
|
452
|
+
commandClass: z.ZodEnum<{
|
|
453
|
+
build: "build";
|
|
454
|
+
format: "format";
|
|
455
|
+
lint: "lint";
|
|
456
|
+
other: "other";
|
|
457
|
+
smoke: "smoke";
|
|
458
|
+
test: "test";
|
|
459
|
+
typecheck: "typecheck";
|
|
460
|
+
}>;
|
|
461
|
+
exitCode: z.ZodNumber;
|
|
462
|
+
outputDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
463
|
+
artifactRef: z.ZodOptional<z.ZodObject<{
|
|
464
|
+
kind: z.ZodLiteral<"restricted_evidence_v1">;
|
|
465
|
+
digest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
466
|
+
byteLength: z.ZodNumber;
|
|
467
|
+
}, z.core.$strict>>;
|
|
468
|
+
environmentKeys: z.ZodArray<z.ZodString>;
|
|
469
|
+
kind: z.ZodLiteral<"validation">;
|
|
470
|
+
}, z.core.$strict>;
|
|
471
|
+
export declare const ReviewEvidenceSchema: z.ZodObject<{
|
|
472
|
+
evidenceId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
473
|
+
snapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
474
|
+
sourceDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
475
|
+
startedAt: z.ZodString;
|
|
476
|
+
completedAt: z.ZodString;
|
|
477
|
+
kind: z.ZodLiteral<"review">;
|
|
478
|
+
attemptId: z.ZodString;
|
|
479
|
+
packetDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
480
|
+
}, z.core.$strict>;
|
|
481
|
+
export declare const EvidenceRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
482
|
+
evidenceId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
483
|
+
snapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
484
|
+
sourceDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
485
|
+
startedAt: z.ZodString;
|
|
486
|
+
completedAt: z.ZodString;
|
|
487
|
+
commandClass: z.ZodEnum<{
|
|
488
|
+
build: "build";
|
|
489
|
+
format: "format";
|
|
490
|
+
lint: "lint";
|
|
491
|
+
other: "other";
|
|
492
|
+
smoke: "smoke";
|
|
493
|
+
test: "test";
|
|
494
|
+
typecheck: "typecheck";
|
|
495
|
+
}>;
|
|
496
|
+
exitCode: z.ZodNumber;
|
|
497
|
+
outputDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
498
|
+
artifactRef: z.ZodOptional<z.ZodObject<{
|
|
499
|
+
kind: z.ZodLiteral<"restricted_evidence_v1">;
|
|
500
|
+
digest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
501
|
+
byteLength: z.ZodNumber;
|
|
502
|
+
}, z.core.$strict>>;
|
|
503
|
+
environmentKeys: z.ZodArray<z.ZodString>;
|
|
504
|
+
kind: z.ZodLiteral<"validation">;
|
|
505
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
506
|
+
evidenceId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
507
|
+
snapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
508
|
+
sourceDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
509
|
+
startedAt: z.ZodString;
|
|
510
|
+
completedAt: z.ZodString;
|
|
511
|
+
kind: z.ZodLiteral<"review">;
|
|
512
|
+
attemptId: z.ZodString;
|
|
513
|
+
packetDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
514
|
+
}, z.core.$strict>], "kind">;
|
|
515
|
+
export declare const ValidationObservationSchema: z.ZodObject<{
|
|
516
|
+
startedAt: z.ZodString;
|
|
517
|
+
completedAt: z.ZodString;
|
|
518
|
+
command: z.ZodString;
|
|
519
|
+
summary: z.ZodString;
|
|
520
|
+
exitCode: z.ZodNumber;
|
|
521
|
+
outputDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
522
|
+
artifactRef: z.ZodOptional<z.ZodObject<{
|
|
523
|
+
kind: z.ZodLiteral<"restricted_evidence_v1">;
|
|
524
|
+
digest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
525
|
+
byteLength: z.ZodNumber;
|
|
526
|
+
}, z.core.$strict>>;
|
|
527
|
+
environmentKeys: z.ZodArray<z.ZodString>;
|
|
528
|
+
}, z.core.$strict>;
|
|
529
|
+
export declare const CausalMutationRecordSchema: z.ZodObject<{
|
|
530
|
+
operationId: z.ZodString;
|
|
531
|
+
operationKind: z.ZodEnum<{
|
|
532
|
+
evidence_record: "evidence_record";
|
|
533
|
+
feature_complete: "feature_complete";
|
|
534
|
+
feature_reset: "feature_reset";
|
|
535
|
+
plan_approve: "plan_approve";
|
|
536
|
+
plan_save: "plan_save";
|
|
537
|
+
review_record: "review_record";
|
|
538
|
+
run_start: "run_start";
|
|
539
|
+
session_close: "session_close";
|
|
540
|
+
}>;
|
|
541
|
+
requestDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
542
|
+
priorMutationDigest: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>>;
|
|
543
|
+
mutationDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
544
|
+
priorRevision: z.ZodNumber;
|
|
545
|
+
revision: z.ZodNumber;
|
|
546
|
+
priorSnapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
547
|
+
currentSnapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
548
|
+
changedEntity: z.ZodObject<{
|
|
549
|
+
kind: z.ZodEnum<{
|
|
550
|
+
closure: "closure";
|
|
551
|
+
evidence: "evidence";
|
|
552
|
+
feature: "feature";
|
|
553
|
+
plan: "plan";
|
|
554
|
+
review: "review";
|
|
555
|
+
session: "session";
|
|
556
|
+
}>;
|
|
557
|
+
id: z.ZodString;
|
|
558
|
+
}, z.core.$strict>;
|
|
559
|
+
changedFields: z.ZodArray<z.ZodString>;
|
|
560
|
+
blockerDelta: z.ZodObject<{
|
|
561
|
+
added: z.ZodArray<z.ZodString>;
|
|
562
|
+
removed: z.ZodArray<z.ZodString>;
|
|
563
|
+
}, z.core.$strict>;
|
|
564
|
+
evidenceRefs: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>>;
|
|
565
|
+
recordedAt: z.ZodString;
|
|
566
|
+
}, z.core.$strict>;
|
|
567
|
+
export declare const CausalStateSchema: z.ZodObject<{
|
|
568
|
+
revision: z.ZodNumber;
|
|
569
|
+
genesisSnapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
570
|
+
snapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
571
|
+
mutations: z.ZodArray<z.ZodObject<{
|
|
572
|
+
operationId: z.ZodString;
|
|
573
|
+
operationKind: z.ZodEnum<{
|
|
574
|
+
evidence_record: "evidence_record";
|
|
575
|
+
feature_complete: "feature_complete";
|
|
576
|
+
feature_reset: "feature_reset";
|
|
577
|
+
plan_approve: "plan_approve";
|
|
578
|
+
plan_save: "plan_save";
|
|
579
|
+
review_record: "review_record";
|
|
580
|
+
run_start: "run_start";
|
|
581
|
+
session_close: "session_close";
|
|
582
|
+
}>;
|
|
583
|
+
requestDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
584
|
+
priorMutationDigest: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>>;
|
|
585
|
+
mutationDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
586
|
+
priorRevision: z.ZodNumber;
|
|
587
|
+
revision: z.ZodNumber;
|
|
588
|
+
priorSnapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
589
|
+
currentSnapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
590
|
+
changedEntity: z.ZodObject<{
|
|
591
|
+
kind: z.ZodEnum<{
|
|
592
|
+
closure: "closure";
|
|
593
|
+
evidence: "evidence";
|
|
594
|
+
feature: "feature";
|
|
595
|
+
plan: "plan";
|
|
596
|
+
review: "review";
|
|
597
|
+
session: "session";
|
|
598
|
+
}>;
|
|
599
|
+
id: z.ZodString;
|
|
600
|
+
}, z.core.$strict>;
|
|
601
|
+
changedFields: z.ZodArray<z.ZodString>;
|
|
602
|
+
blockerDelta: z.ZodObject<{
|
|
603
|
+
added: z.ZodArray<z.ZodString>;
|
|
604
|
+
removed: z.ZodArray<z.ZodString>;
|
|
605
|
+
}, z.core.$strict>;
|
|
606
|
+
evidenceRefs: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>>;
|
|
607
|
+
recordedAt: z.ZodString;
|
|
608
|
+
}, z.core.$strict>>;
|
|
609
|
+
evidence: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
610
|
+
evidenceId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
611
|
+
snapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
612
|
+
sourceDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
613
|
+
startedAt: z.ZodString;
|
|
614
|
+
completedAt: z.ZodString;
|
|
615
|
+
commandClass: z.ZodEnum<{
|
|
616
|
+
build: "build";
|
|
617
|
+
format: "format";
|
|
618
|
+
lint: "lint";
|
|
619
|
+
other: "other";
|
|
620
|
+
smoke: "smoke";
|
|
621
|
+
test: "test";
|
|
622
|
+
typecheck: "typecheck";
|
|
623
|
+
}>;
|
|
624
|
+
exitCode: z.ZodNumber;
|
|
625
|
+
outputDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
626
|
+
artifactRef: z.ZodOptional<z.ZodObject<{
|
|
627
|
+
kind: z.ZodLiteral<"restricted_evidence_v1">;
|
|
628
|
+
digest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
629
|
+
byteLength: z.ZodNumber;
|
|
630
|
+
}, z.core.$strict>>;
|
|
631
|
+
environmentKeys: z.ZodArray<z.ZodString>;
|
|
632
|
+
kind: z.ZodLiteral<"validation">;
|
|
633
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
634
|
+
evidenceId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
635
|
+
snapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
636
|
+
sourceDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
637
|
+
startedAt: z.ZodString;
|
|
638
|
+
completedAt: z.ZodString;
|
|
639
|
+
kind: z.ZodLiteral<"review">;
|
|
640
|
+
attemptId: z.ZodString;
|
|
641
|
+
packetDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
642
|
+
}, z.core.$strict>], "kind">>;
|
|
643
|
+
}, z.core.$strict>;
|
|
327
644
|
export declare const ArtifactSchema: z.ZodObject<{
|
|
328
645
|
path: z.ZodString;
|
|
329
646
|
}, z.core.$strict>;
|
|
330
647
|
export declare const FeatureSchema: z.ZodObject<{
|
|
331
|
-
id: z.ZodString
|
|
648
|
+
id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
|
|
332
649
|
title: z.ZodString;
|
|
333
650
|
summary: z.ZodString;
|
|
334
651
|
status: z.ZodDefault<z.ZodEnum<{
|
|
335
|
-
pending: "pending";
|
|
336
|
-
in_progress: "in_progress";
|
|
337
|
-
completed: "completed";
|
|
338
652
|
blocked: "blocked";
|
|
653
|
+
completed: "completed";
|
|
654
|
+
in_progress: "in_progress";
|
|
655
|
+
pending: "pending";
|
|
339
656
|
}>>;
|
|
340
657
|
reviewDepth: z.ZodDefault<z.ZodEnum<{
|
|
658
|
+
detailed: "detailed";
|
|
341
659
|
quick: "quick";
|
|
342
660
|
standard: "standard";
|
|
343
|
-
detailed: "detailed";
|
|
344
661
|
}>>;
|
|
345
662
|
targets: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
346
663
|
validation: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
347
|
-
dependsOn: z.ZodDefault<z.ZodArray<z.ZodString
|
|
664
|
+
dependsOn: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>>>;
|
|
348
665
|
}, z.core.$strict>;
|
|
349
666
|
export declare const PlanSchema: z.ZodObject<{
|
|
350
667
|
summary: z.ZodString;
|
|
@@ -356,23 +673,23 @@ export declare const PlanSchema: z.ZodObject<{
|
|
|
356
673
|
detailed: "detailed";
|
|
357
674
|
}>>;
|
|
358
675
|
features: z.ZodArray<z.ZodObject<{
|
|
359
|
-
id: z.ZodString
|
|
676
|
+
id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
|
|
360
677
|
title: z.ZodString;
|
|
361
678
|
summary: z.ZodString;
|
|
362
679
|
status: z.ZodDefault<z.ZodEnum<{
|
|
363
|
-
pending: "pending";
|
|
364
|
-
in_progress: "in_progress";
|
|
365
|
-
completed: "completed";
|
|
366
680
|
blocked: "blocked";
|
|
681
|
+
completed: "completed";
|
|
682
|
+
in_progress: "in_progress";
|
|
683
|
+
pending: "pending";
|
|
367
684
|
}>>;
|
|
368
685
|
reviewDepth: z.ZodDefault<z.ZodEnum<{
|
|
686
|
+
detailed: "detailed";
|
|
369
687
|
quick: "quick";
|
|
370
688
|
standard: "standard";
|
|
371
|
-
detailed: "detailed";
|
|
372
689
|
}>>;
|
|
373
690
|
targets: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
374
691
|
validation: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
375
|
-
dependsOn: z.ZodDefault<z.ZodArray<z.ZodString
|
|
692
|
+
dependsOn: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>>>;
|
|
376
693
|
}, z.core.$strict>>;
|
|
377
694
|
}, z.core.$strict>;
|
|
378
695
|
export declare const PlanInputSchema: z.ZodObject<{
|
|
@@ -385,93 +702,105 @@ export declare const PlanInputSchema: z.ZodObject<{
|
|
|
385
702
|
detailed: "detailed";
|
|
386
703
|
}>>;
|
|
387
704
|
features: z.ZodArray<z.ZodObject<{
|
|
388
|
-
|
|
389
|
-
id: z.ZodString;
|
|
705
|
+
id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
|
|
390
706
|
title: z.ZodString;
|
|
707
|
+
summary: z.ZodString;
|
|
391
708
|
status: z.ZodOptional<z.ZodEnum<{
|
|
392
|
-
pending: "pending";
|
|
393
|
-
in_progress: "in_progress";
|
|
394
|
-
completed: "completed";
|
|
395
709
|
blocked: "blocked";
|
|
710
|
+
completed: "completed";
|
|
711
|
+
in_progress: "in_progress";
|
|
712
|
+
pending: "pending";
|
|
396
713
|
}>>;
|
|
397
714
|
reviewDepth: z.ZodOptional<z.ZodEnum<{
|
|
715
|
+
detailed: "detailed";
|
|
398
716
|
quick: "quick";
|
|
399
717
|
standard: "standard";
|
|
400
|
-
detailed: "detailed";
|
|
401
718
|
}>>;
|
|
402
719
|
targets: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
403
720
|
validation: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
404
|
-
dependsOn: z.ZodOptional<z.ZodArray<z.ZodString
|
|
721
|
+
dependsOn: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>>>;
|
|
405
722
|
}, z.core.$strict>>;
|
|
406
723
|
}, z.core.$strict>;
|
|
407
|
-
export declare const
|
|
408
|
-
kind: z.
|
|
409
|
-
completed: "completed";
|
|
410
|
-
blocked: "blocked";
|
|
411
|
-
needs_input: "needs_input";
|
|
412
|
-
replan_required: "replan_required";
|
|
413
|
-
}>>;
|
|
724
|
+
export declare const CompletedWorkerOutcomeSchema: z.ZodObject<{
|
|
725
|
+
kind: z.ZodLiteral<"completed">;
|
|
414
726
|
summary: z.ZodOptional<z.ZodString>;
|
|
415
727
|
resolutionHint: z.ZodOptional<z.ZodString>;
|
|
416
728
|
}, z.core.$strict>;
|
|
417
729
|
export declare const NeedsInputOutcomeSchema: z.ZodObject<{
|
|
418
|
-
kind: z.
|
|
730
|
+
kind: z.ZodEnum<{
|
|
419
731
|
blocked: "blocked";
|
|
420
732
|
needs_input: "needs_input";
|
|
421
733
|
replan_required: "replan_required";
|
|
422
|
-
}
|
|
734
|
+
}>;
|
|
423
735
|
summary: z.ZodString;
|
|
424
736
|
resolutionHint: z.ZodOptional<z.ZodString>;
|
|
425
737
|
}, z.core.$strict>;
|
|
738
|
+
export declare const WorkerOutcomeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
739
|
+
kind: z.ZodLiteral<"completed">;
|
|
740
|
+
summary: z.ZodOptional<z.ZodString>;
|
|
741
|
+
resolutionHint: z.ZodOptional<z.ZodString>;
|
|
742
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
743
|
+
kind: z.ZodEnum<{
|
|
744
|
+
blocked: "blocked";
|
|
745
|
+
needs_input: "needs_input";
|
|
746
|
+
replan_required: "replan_required";
|
|
747
|
+
}>;
|
|
748
|
+
summary: z.ZodString;
|
|
749
|
+
resolutionHint: z.ZodOptional<z.ZodString>;
|
|
750
|
+
}, z.core.$strict>], "kind">;
|
|
426
751
|
export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
427
752
|
status: z.ZodLiteral<"ok">;
|
|
428
|
-
|
|
753
|
+
operationId: z.ZodString;
|
|
754
|
+
expectedRevision: z.ZodNumber;
|
|
755
|
+
expectedSnapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
756
|
+
requestDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
757
|
+
featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
|
|
429
758
|
summary: z.ZodString;
|
|
430
759
|
artifactsChanged: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
431
760
|
path: z.ZodString;
|
|
432
761
|
}, z.core.$strict>>>;
|
|
433
|
-
validationRun: z.
|
|
762
|
+
validationRun: z.ZodArray<z.ZodObject<{
|
|
434
763
|
command: z.ZodString;
|
|
435
764
|
status: z.ZodEnum<{
|
|
436
|
-
passed: "passed";
|
|
437
765
|
failed: "failed";
|
|
766
|
+
passed: "passed";
|
|
438
767
|
}>;
|
|
439
768
|
summary: z.ZodString;
|
|
440
|
-
}, z.core.$strict
|
|
769
|
+
}, z.core.$strict>>;
|
|
441
770
|
validationScope: z.ZodEnum<{
|
|
442
|
-
targeted: "targeted";
|
|
443
771
|
broad: "broad";
|
|
772
|
+
targeted: "targeted";
|
|
444
773
|
}>;
|
|
445
774
|
featureReviewDepth: z.ZodEnum<{
|
|
775
|
+
detailed: "detailed";
|
|
446
776
|
quick: "quick";
|
|
447
777
|
standard: "standard";
|
|
448
|
-
detailed: "detailed";
|
|
449
778
|
}>;
|
|
450
779
|
featureReview: z.ZodObject<{
|
|
451
780
|
status: z.ZodEnum<{
|
|
452
|
-
passed: "passed";
|
|
453
781
|
failed: "failed";
|
|
782
|
+
passed: "passed";
|
|
454
783
|
}>;
|
|
455
784
|
summary: z.ZodString;
|
|
456
785
|
blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
457
786
|
summary: z.ZodString;
|
|
458
787
|
severity: z.ZodDefault<z.ZodEnum<{
|
|
459
|
-
blocking: "blocking";
|
|
460
788
|
advisory: "advisory";
|
|
789
|
+
blocking: "blocking";
|
|
461
790
|
}>>;
|
|
462
791
|
}, z.core.$strict>>>;
|
|
463
792
|
}, z.core.$strict>;
|
|
464
793
|
finalReview: z.ZodOptional<z.ZodObject<{
|
|
465
794
|
status: z.ZodEnum<{
|
|
466
|
-
passed: "passed";
|
|
467
795
|
failed: "failed";
|
|
796
|
+
passed: "passed";
|
|
468
797
|
}>;
|
|
469
798
|
summary: z.ZodString;
|
|
470
799
|
blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
471
800
|
summary: z.ZodString;
|
|
472
801
|
severity: z.ZodDefault<z.ZodEnum<{
|
|
473
|
-
blocking: "blocking";
|
|
474
802
|
advisory: "advisory";
|
|
803
|
+
blocking: "blocking";
|
|
475
804
|
}>>;
|
|
476
805
|
}, z.core.$strict>>>;
|
|
477
806
|
reviewDepth: z.ZodEnum<{
|
|
@@ -480,33 +809,98 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
480
809
|
}>;
|
|
481
810
|
}, z.core.$strict>>;
|
|
482
811
|
outcome: z.ZodOptional<z.ZodObject<{
|
|
483
|
-
kind: z.
|
|
484
|
-
completed: "completed";
|
|
485
|
-
blocked: "blocked";
|
|
486
|
-
needs_input: "needs_input";
|
|
487
|
-
replan_required: "replan_required";
|
|
488
|
-
}>>;
|
|
812
|
+
kind: z.ZodLiteral<"completed">;
|
|
489
813
|
summary: z.ZodOptional<z.ZodString>;
|
|
490
814
|
resolutionHint: z.ZodOptional<z.ZodString>;
|
|
491
815
|
}, z.core.$strict>>;
|
|
816
|
+
reviewExecutions: z.ZodArray<z.ZodObject<{
|
|
817
|
+
attemptId: z.ZodString;
|
|
818
|
+
logicalPassId: z.ZodString;
|
|
819
|
+
featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
|
|
820
|
+
reviewKind: z.ZodEnum<{
|
|
821
|
+
feature: "feature";
|
|
822
|
+
final: "final";
|
|
823
|
+
}>;
|
|
824
|
+
reviewSnapshotId: z.ZodPipe<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>>;
|
|
825
|
+
verdict: z.ZodEnum<{
|
|
826
|
+
failed: "failed";
|
|
827
|
+
passed: "passed";
|
|
828
|
+
}>;
|
|
829
|
+
startedAt: z.ZodString;
|
|
830
|
+
completedAt: z.ZodString;
|
|
831
|
+
terminalDisposition: z.ZodEnum<{
|
|
832
|
+
observed_unsubmitted: "observed_unsubmitted";
|
|
833
|
+
submitted: "submitted";
|
|
834
|
+
}>;
|
|
835
|
+
findings: z.ZodArray<z.ZodObject<{
|
|
836
|
+
taxonomy: z.ZodEnum<{
|
|
837
|
+
advisory: "advisory";
|
|
838
|
+
evidence_gap: "evidence_gap";
|
|
839
|
+
implementation_defect: "implementation_defect";
|
|
840
|
+
regression_coverage_gap: "regression_coverage_gap";
|
|
841
|
+
}>;
|
|
842
|
+
subject: z.ZodString;
|
|
843
|
+
requirementOrRisk: z.ZodString;
|
|
844
|
+
evidenceLocator: z.ZodString;
|
|
845
|
+
summary: z.ZodString;
|
|
846
|
+
severity: z.ZodEnum<{
|
|
847
|
+
advisory: "advisory";
|
|
848
|
+
blocking: "blocking";
|
|
849
|
+
}>;
|
|
850
|
+
}, z.core.$strict>>;
|
|
851
|
+
}, z.core.$strict>>;
|
|
852
|
+
evidence: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
853
|
+
evidenceId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
854
|
+
snapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
855
|
+
sourceDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
856
|
+
startedAt: z.ZodString;
|
|
857
|
+
completedAt: z.ZodString;
|
|
858
|
+
commandClass: z.ZodEnum<{
|
|
859
|
+
build: "build";
|
|
860
|
+
format: "format";
|
|
861
|
+
lint: "lint";
|
|
862
|
+
other: "other";
|
|
863
|
+
smoke: "smoke";
|
|
864
|
+
test: "test";
|
|
865
|
+
typecheck: "typecheck";
|
|
866
|
+
}>;
|
|
867
|
+
exitCode: z.ZodNumber;
|
|
868
|
+
outputDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
869
|
+
artifactRef: z.ZodOptional<z.ZodObject<{
|
|
870
|
+
kind: z.ZodLiteral<"restricted_evidence_v1">;
|
|
871
|
+
digest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
872
|
+
byteLength: z.ZodNumber;
|
|
873
|
+
}, z.core.$strict>>;
|
|
874
|
+
environmentKeys: z.ZodArray<z.ZodString>;
|
|
875
|
+
kind: z.ZodLiteral<"validation">;
|
|
876
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
877
|
+
evidenceId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
878
|
+
snapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
879
|
+
sourceDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
880
|
+
startedAt: z.ZodString;
|
|
881
|
+
completedAt: z.ZodString;
|
|
882
|
+
kind: z.ZodLiteral<"review">;
|
|
883
|
+
attemptId: z.ZodString;
|
|
884
|
+
packetDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
885
|
+
}, z.core.$strict>], "kind">>;
|
|
492
886
|
orchestrationPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
493
887
|
id: z.ZodString;
|
|
494
888
|
kind: z.ZodEnum<{
|
|
495
|
-
validation: "validation";
|
|
496
889
|
audit: "audit";
|
|
497
890
|
candidate: "candidate";
|
|
498
891
|
discovery: "discovery";
|
|
892
|
+
"implementation-decision": "implementation-decision";
|
|
499
893
|
review: "review";
|
|
894
|
+
validation: "validation";
|
|
500
895
|
verification: "verification";
|
|
501
|
-
"implementation-decision": "implementation-decision";
|
|
502
896
|
}>;
|
|
503
897
|
decision: z.ZodOptional<z.ZodEnum<{
|
|
504
|
-
parallel: "parallel";
|
|
505
|
-
serial: "serial";
|
|
506
898
|
"candidate-exact-path": "candidate-exact-path";
|
|
507
899
|
"candidate-worktree": "candidate-worktree";
|
|
508
|
-
|
|
900
|
+
parallel: "parallel";
|
|
901
|
+
serial: "serial";
|
|
509
902
|
skipped: "skipped";
|
|
903
|
+
tournament: "tournament";
|
|
510
904
|
}>>;
|
|
511
905
|
decisionReason: z.ZodOptional<z.ZodString>;
|
|
512
906
|
candidateEligibility: z.ZodDefault<z.ZodEnum<{
|
|
@@ -515,25 +909,25 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
515
909
|
unknown: "unknown";
|
|
516
910
|
}>>;
|
|
517
911
|
candidateDecision: z.ZodOptional<z.ZodEnum<{
|
|
912
|
+
serial_required: "serial_required";
|
|
518
913
|
skipped: "skipped";
|
|
519
914
|
used: "used";
|
|
520
|
-
serial_required: "serial_required";
|
|
521
915
|
}>>;
|
|
522
916
|
decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
523
|
-
|
|
917
|
+
independent_surface: "independent_surface";
|
|
918
|
+
needs_manager_judgment: "needs_manager_judgment";
|
|
524
919
|
overlapping_files: "overlapping_files";
|
|
920
|
+
shared_state: "shared_state";
|
|
525
921
|
small_slice: "small_slice";
|
|
526
|
-
needs_manager_judgment: "needs_manager_judgment";
|
|
527
|
-
independent_surface: "independent_surface";
|
|
528
922
|
validation_available: "validation_available";
|
|
529
923
|
}>>>;
|
|
530
924
|
modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
925
|
+
audit: "audit";
|
|
926
|
+
"candidate-implementation": "candidate-implementation";
|
|
531
927
|
evidence: "evidence";
|
|
928
|
+
review: "review";
|
|
532
929
|
validation: "validation";
|
|
533
|
-
audit: "audit";
|
|
534
930
|
verifier: "verifier";
|
|
535
|
-
review: "review";
|
|
536
|
-
"candidate-implementation": "candidate-implementation";
|
|
537
931
|
}>>>;
|
|
538
932
|
workerCount: z.ZodDefault<z.ZodNumber>;
|
|
539
933
|
candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
|
|
@@ -541,34 +935,38 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
541
935
|
sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
542
936
|
dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
543
937
|
writeScope: z.ZodDefault<z.ZodEnum<{
|
|
544
|
-
none: "none";
|
|
545
|
-
"manager-serial": "manager-serial";
|
|
546
938
|
"exact-path": "exact-path";
|
|
547
939
|
"isolated-worktree": "isolated-worktree";
|
|
940
|
+
"manager-serial": "manager-serial";
|
|
548
941
|
mixed: "mixed";
|
|
942
|
+
none: "none";
|
|
549
943
|
}>>;
|
|
550
944
|
handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
551
945
|
verificationStatus: z.ZodDefault<z.ZodEnum<{
|
|
552
|
-
|
|
553
|
-
passed: "passed";
|
|
946
|
+
downgraded: "downgraded";
|
|
554
947
|
failed: "failed";
|
|
555
948
|
mixed: "mixed";
|
|
556
949
|
"not-needed": "not-needed";
|
|
557
|
-
|
|
950
|
+
passed: "passed";
|
|
951
|
+
pending: "pending";
|
|
558
952
|
}>>;
|
|
559
953
|
outcome: z.ZodDefault<z.ZodEnum<{
|
|
560
954
|
accepted: "accepted";
|
|
561
955
|
modified: "modified";
|
|
562
|
-
rejected: "rejected";
|
|
563
|
-
partial: "partial";
|
|
564
956
|
"not-covered": "not-covered";
|
|
957
|
+
partial: "partial";
|
|
958
|
+
rejected: "rejected";
|
|
565
959
|
superseded: "superseded";
|
|
566
960
|
}>>;
|
|
567
961
|
synthesisRef: z.ZodOptional<z.ZodString>;
|
|
568
962
|
}, z.core.$strict>>>;
|
|
569
963
|
}, z.core.$strict>, z.ZodObject<{
|
|
570
964
|
status: z.ZodLiteral<"needs_input">;
|
|
571
|
-
|
|
965
|
+
operationId: z.ZodString;
|
|
966
|
+
expectedRevision: z.ZodNumber;
|
|
967
|
+
expectedSnapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
968
|
+
requestDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
969
|
+
featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
|
|
572
970
|
summary: z.ZodString;
|
|
573
971
|
artifactsChanged: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
574
972
|
path: z.ZodString;
|
|
@@ -576,45 +974,45 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
576
974
|
validationRun: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
577
975
|
command: z.ZodString;
|
|
578
976
|
status: z.ZodEnum<{
|
|
579
|
-
passed: "passed";
|
|
580
977
|
failed: "failed";
|
|
978
|
+
passed: "passed";
|
|
581
979
|
}>;
|
|
582
980
|
summary: z.ZodString;
|
|
583
981
|
}, z.core.$strict>>>;
|
|
584
982
|
validationScope: z.ZodOptional<z.ZodEnum<{
|
|
585
|
-
targeted: "targeted";
|
|
586
983
|
broad: "broad";
|
|
984
|
+
targeted: "targeted";
|
|
587
985
|
}>>;
|
|
588
986
|
featureReviewDepth: z.ZodOptional<z.ZodEnum<{
|
|
987
|
+
detailed: "detailed";
|
|
589
988
|
quick: "quick";
|
|
590
989
|
standard: "standard";
|
|
591
|
-
detailed: "detailed";
|
|
592
990
|
}>>;
|
|
593
991
|
featureReview: z.ZodOptional<z.ZodObject<{
|
|
594
992
|
status: z.ZodEnum<{
|
|
595
|
-
passed: "passed";
|
|
596
993
|
failed: "failed";
|
|
994
|
+
passed: "passed";
|
|
597
995
|
}>;
|
|
598
996
|
summary: z.ZodString;
|
|
599
997
|
blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
600
998
|
summary: z.ZodString;
|
|
601
999
|
severity: z.ZodDefault<z.ZodEnum<{
|
|
602
|
-
blocking: "blocking";
|
|
603
1000
|
advisory: "advisory";
|
|
1001
|
+
blocking: "blocking";
|
|
604
1002
|
}>>;
|
|
605
1003
|
}, z.core.$strict>>>;
|
|
606
1004
|
}, z.core.$strict>>;
|
|
607
1005
|
finalReview: z.ZodOptional<z.ZodObject<{
|
|
608
1006
|
status: z.ZodEnum<{
|
|
609
|
-
passed: "passed";
|
|
610
1007
|
failed: "failed";
|
|
1008
|
+
passed: "passed";
|
|
611
1009
|
}>;
|
|
612
1010
|
summary: z.ZodString;
|
|
613
1011
|
blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
614
1012
|
summary: z.ZodString;
|
|
615
1013
|
severity: z.ZodDefault<z.ZodEnum<{
|
|
616
|
-
blocking: "blocking";
|
|
617
1014
|
advisory: "advisory";
|
|
1015
|
+
blocking: "blocking";
|
|
618
1016
|
}>>;
|
|
619
1017
|
}, z.core.$strict>>>;
|
|
620
1018
|
reviewDepth: z.ZodEnum<{
|
|
@@ -623,32 +1021,102 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
623
1021
|
}>;
|
|
624
1022
|
}, z.core.$strict>>;
|
|
625
1023
|
outcome: z.ZodObject<{
|
|
626
|
-
kind: z.
|
|
1024
|
+
kind: z.ZodEnum<{
|
|
627
1025
|
blocked: "blocked";
|
|
628
1026
|
needs_input: "needs_input";
|
|
629
1027
|
replan_required: "replan_required";
|
|
630
|
-
}
|
|
1028
|
+
}>;
|
|
631
1029
|
summary: z.ZodString;
|
|
632
1030
|
resolutionHint: z.ZodOptional<z.ZodString>;
|
|
633
1031
|
}, z.core.$strict>;
|
|
1032
|
+
reviewExecutions: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1033
|
+
attemptId: z.ZodString;
|
|
1034
|
+
logicalPassId: z.ZodString;
|
|
1035
|
+
featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
|
|
1036
|
+
reviewKind: z.ZodEnum<{
|
|
1037
|
+
feature: "feature";
|
|
1038
|
+
final: "final";
|
|
1039
|
+
}>;
|
|
1040
|
+
reviewSnapshotId: z.ZodPipe<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>>;
|
|
1041
|
+
verdict: z.ZodEnum<{
|
|
1042
|
+
failed: "failed";
|
|
1043
|
+
passed: "passed";
|
|
1044
|
+
}>;
|
|
1045
|
+
startedAt: z.ZodString;
|
|
1046
|
+
completedAt: z.ZodString;
|
|
1047
|
+
terminalDisposition: z.ZodEnum<{
|
|
1048
|
+
observed_unsubmitted: "observed_unsubmitted";
|
|
1049
|
+
submitted: "submitted";
|
|
1050
|
+
}>;
|
|
1051
|
+
findings: z.ZodArray<z.ZodObject<{
|
|
1052
|
+
taxonomy: z.ZodEnum<{
|
|
1053
|
+
advisory: "advisory";
|
|
1054
|
+
evidence_gap: "evidence_gap";
|
|
1055
|
+
implementation_defect: "implementation_defect";
|
|
1056
|
+
regression_coverage_gap: "regression_coverage_gap";
|
|
1057
|
+
}>;
|
|
1058
|
+
subject: z.ZodString;
|
|
1059
|
+
requirementOrRisk: z.ZodString;
|
|
1060
|
+
evidenceLocator: z.ZodString;
|
|
1061
|
+
summary: z.ZodString;
|
|
1062
|
+
severity: z.ZodEnum<{
|
|
1063
|
+
advisory: "advisory";
|
|
1064
|
+
blocking: "blocking";
|
|
1065
|
+
}>;
|
|
1066
|
+
}, z.core.$strict>>;
|
|
1067
|
+
}, z.core.$strict>>>;
|
|
1068
|
+
evidence: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1069
|
+
evidenceId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1070
|
+
snapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1071
|
+
sourceDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1072
|
+
startedAt: z.ZodString;
|
|
1073
|
+
completedAt: z.ZodString;
|
|
1074
|
+
commandClass: z.ZodEnum<{
|
|
1075
|
+
build: "build";
|
|
1076
|
+
format: "format";
|
|
1077
|
+
lint: "lint";
|
|
1078
|
+
other: "other";
|
|
1079
|
+
smoke: "smoke";
|
|
1080
|
+
test: "test";
|
|
1081
|
+
typecheck: "typecheck";
|
|
1082
|
+
}>;
|
|
1083
|
+
exitCode: z.ZodNumber;
|
|
1084
|
+
outputDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1085
|
+
artifactRef: z.ZodOptional<z.ZodObject<{
|
|
1086
|
+
kind: z.ZodLiteral<"restricted_evidence_v1">;
|
|
1087
|
+
digest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1088
|
+
byteLength: z.ZodNumber;
|
|
1089
|
+
}, z.core.$strict>>;
|
|
1090
|
+
environmentKeys: z.ZodArray<z.ZodString>;
|
|
1091
|
+
kind: z.ZodLiteral<"validation">;
|
|
1092
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1093
|
+
evidenceId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1094
|
+
snapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1095
|
+
sourceDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1096
|
+
startedAt: z.ZodString;
|
|
1097
|
+
completedAt: z.ZodString;
|
|
1098
|
+
kind: z.ZodLiteral<"review">;
|
|
1099
|
+
attemptId: z.ZodString;
|
|
1100
|
+
packetDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1101
|
+
}, z.core.$strict>], "kind">>>;
|
|
634
1102
|
orchestrationPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
635
1103
|
id: z.ZodString;
|
|
636
1104
|
kind: z.ZodEnum<{
|
|
637
|
-
validation: "validation";
|
|
638
1105
|
audit: "audit";
|
|
639
1106
|
candidate: "candidate";
|
|
640
1107
|
discovery: "discovery";
|
|
1108
|
+
"implementation-decision": "implementation-decision";
|
|
641
1109
|
review: "review";
|
|
1110
|
+
validation: "validation";
|
|
642
1111
|
verification: "verification";
|
|
643
|
-
"implementation-decision": "implementation-decision";
|
|
644
1112
|
}>;
|
|
645
1113
|
decision: z.ZodOptional<z.ZodEnum<{
|
|
646
|
-
parallel: "parallel";
|
|
647
|
-
serial: "serial";
|
|
648
1114
|
"candidate-exact-path": "candidate-exact-path";
|
|
649
1115
|
"candidate-worktree": "candidate-worktree";
|
|
650
|
-
|
|
1116
|
+
parallel: "parallel";
|
|
1117
|
+
serial: "serial";
|
|
651
1118
|
skipped: "skipped";
|
|
1119
|
+
tournament: "tournament";
|
|
652
1120
|
}>>;
|
|
653
1121
|
decisionReason: z.ZodOptional<z.ZodString>;
|
|
654
1122
|
candidateEligibility: z.ZodDefault<z.ZodEnum<{
|
|
@@ -657,25 +1125,25 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
657
1125
|
unknown: "unknown";
|
|
658
1126
|
}>>;
|
|
659
1127
|
candidateDecision: z.ZodOptional<z.ZodEnum<{
|
|
1128
|
+
serial_required: "serial_required";
|
|
660
1129
|
skipped: "skipped";
|
|
661
1130
|
used: "used";
|
|
662
|
-
serial_required: "serial_required";
|
|
663
1131
|
}>>;
|
|
664
1132
|
decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
665
|
-
|
|
1133
|
+
independent_surface: "independent_surface";
|
|
1134
|
+
needs_manager_judgment: "needs_manager_judgment";
|
|
666
1135
|
overlapping_files: "overlapping_files";
|
|
1136
|
+
shared_state: "shared_state";
|
|
667
1137
|
small_slice: "small_slice";
|
|
668
|
-
needs_manager_judgment: "needs_manager_judgment";
|
|
669
|
-
independent_surface: "independent_surface";
|
|
670
1138
|
validation_available: "validation_available";
|
|
671
1139
|
}>>>;
|
|
672
1140
|
modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
1141
|
+
audit: "audit";
|
|
1142
|
+
"candidate-implementation": "candidate-implementation";
|
|
673
1143
|
evidence: "evidence";
|
|
1144
|
+
review: "review";
|
|
674
1145
|
validation: "validation";
|
|
675
|
-
audit: "audit";
|
|
676
1146
|
verifier: "verifier";
|
|
677
|
-
review: "review";
|
|
678
|
-
"candidate-implementation": "candidate-implementation";
|
|
679
1147
|
}>>>;
|
|
680
1148
|
workerCount: z.ZodDefault<z.ZodNumber>;
|
|
681
1149
|
candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
|
|
@@ -683,37 +1151,37 @@ export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
683
1151
|
sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
684
1152
|
dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
685
1153
|
writeScope: z.ZodDefault<z.ZodEnum<{
|
|
686
|
-
none: "none";
|
|
687
|
-
"manager-serial": "manager-serial";
|
|
688
1154
|
"exact-path": "exact-path";
|
|
689
1155
|
"isolated-worktree": "isolated-worktree";
|
|
1156
|
+
"manager-serial": "manager-serial";
|
|
690
1157
|
mixed: "mixed";
|
|
1158
|
+
none: "none";
|
|
691
1159
|
}>>;
|
|
692
1160
|
handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
693
1161
|
verificationStatus: z.ZodDefault<z.ZodEnum<{
|
|
694
|
-
|
|
695
|
-
passed: "passed";
|
|
1162
|
+
downgraded: "downgraded";
|
|
696
1163
|
failed: "failed";
|
|
697
1164
|
mixed: "mixed";
|
|
698
1165
|
"not-needed": "not-needed";
|
|
699
|
-
|
|
1166
|
+
passed: "passed";
|
|
1167
|
+
pending: "pending";
|
|
700
1168
|
}>>;
|
|
701
1169
|
outcome: z.ZodDefault<z.ZodEnum<{
|
|
702
1170
|
accepted: "accepted";
|
|
703
1171
|
modified: "modified";
|
|
704
|
-
rejected: "rejected";
|
|
705
|
-
partial: "partial";
|
|
706
1172
|
"not-covered": "not-covered";
|
|
1173
|
+
partial: "partial";
|
|
1174
|
+
rejected: "rejected";
|
|
707
1175
|
superseded: "superseded";
|
|
708
1176
|
}>>;
|
|
709
1177
|
synthesisRef: z.ZodOptional<z.ZodString>;
|
|
710
1178
|
}, z.core.$strict>>>;
|
|
711
1179
|
}, z.core.$strict>], "status">;
|
|
712
1180
|
export declare const ExecutionHistoryEntrySchema: z.ZodObject<{
|
|
713
|
-
featureId: z.ZodString
|
|
1181
|
+
featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
|
|
714
1182
|
status: z.ZodEnum<{
|
|
715
|
-
completed: "completed";
|
|
716
1183
|
blocked: "blocked";
|
|
1184
|
+
completed: "completed";
|
|
717
1185
|
needs_input: "needs_input";
|
|
718
1186
|
}>;
|
|
719
1187
|
summary: z.ZodString;
|
|
@@ -724,45 +1192,45 @@ export declare const ExecutionHistoryEntrySchema: z.ZodObject<{
|
|
|
724
1192
|
validationRun: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
725
1193
|
command: z.ZodString;
|
|
726
1194
|
status: z.ZodEnum<{
|
|
727
|
-
passed: "passed";
|
|
728
1195
|
failed: "failed";
|
|
1196
|
+
passed: "passed";
|
|
729
1197
|
}>;
|
|
730
1198
|
summary: z.ZodString;
|
|
731
1199
|
}, z.core.$strict>>>;
|
|
732
1200
|
validationScope: z.ZodOptional<z.ZodEnum<{
|
|
733
|
-
targeted: "targeted";
|
|
734
1201
|
broad: "broad";
|
|
1202
|
+
targeted: "targeted";
|
|
735
1203
|
}>>;
|
|
736
1204
|
featureReviewDepth: z.ZodOptional<z.ZodEnum<{
|
|
1205
|
+
detailed: "detailed";
|
|
737
1206
|
quick: "quick";
|
|
738
1207
|
standard: "standard";
|
|
739
|
-
detailed: "detailed";
|
|
740
1208
|
}>>;
|
|
741
1209
|
featureReview: z.ZodOptional<z.ZodObject<{
|
|
742
1210
|
status: z.ZodEnum<{
|
|
743
|
-
passed: "passed";
|
|
744
1211
|
failed: "failed";
|
|
1212
|
+
passed: "passed";
|
|
745
1213
|
}>;
|
|
746
1214
|
summary: z.ZodString;
|
|
747
1215
|
blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
748
1216
|
summary: z.ZodString;
|
|
749
1217
|
severity: z.ZodDefault<z.ZodEnum<{
|
|
750
|
-
blocking: "blocking";
|
|
751
1218
|
advisory: "advisory";
|
|
1219
|
+
blocking: "blocking";
|
|
752
1220
|
}>>;
|
|
753
1221
|
}, z.core.$strict>>>;
|
|
754
1222
|
}, z.core.$strict>>;
|
|
755
1223
|
finalReview: z.ZodOptional<z.ZodObject<{
|
|
756
1224
|
status: z.ZodEnum<{
|
|
757
|
-
passed: "passed";
|
|
758
1225
|
failed: "failed";
|
|
1226
|
+
passed: "passed";
|
|
759
1227
|
}>;
|
|
760
1228
|
summary: z.ZodString;
|
|
761
1229
|
blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
762
1230
|
summary: z.ZodString;
|
|
763
1231
|
severity: z.ZodDefault<z.ZodEnum<{
|
|
764
|
-
blocking: "blocking";
|
|
765
1232
|
advisory: "advisory";
|
|
1233
|
+
blocking: "blocking";
|
|
766
1234
|
}>>;
|
|
767
1235
|
}, z.core.$strict>>>;
|
|
768
1236
|
reviewDepth: z.ZodEnum<{
|
|
@@ -770,34 +1238,37 @@ export declare const ExecutionHistoryEntrySchema: z.ZodObject<{
|
|
|
770
1238
|
detailed: "detailed";
|
|
771
1239
|
}>;
|
|
772
1240
|
}, z.core.$strict>>;
|
|
773
|
-
outcome: z.ZodOptional<z.ZodObject<{
|
|
774
|
-
kind: z.
|
|
775
|
-
|
|
1241
|
+
outcome: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1242
|
+
kind: z.ZodLiteral<"completed">;
|
|
1243
|
+
summary: z.ZodOptional<z.ZodString>;
|
|
1244
|
+
resolutionHint: z.ZodOptional<z.ZodString>;
|
|
1245
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1246
|
+
kind: z.ZodEnum<{
|
|
776
1247
|
blocked: "blocked";
|
|
777
1248
|
needs_input: "needs_input";
|
|
778
1249
|
replan_required: "replan_required";
|
|
779
|
-
}
|
|
780
|
-
summary: z.
|
|
1250
|
+
}>;
|
|
1251
|
+
summary: z.ZodString;
|
|
781
1252
|
resolutionHint: z.ZodOptional<z.ZodString>;
|
|
782
|
-
}, z.core.$strict>>;
|
|
1253
|
+
}, z.core.$strict>], "kind">>;
|
|
783
1254
|
orchestrationPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
784
1255
|
id: z.ZodString;
|
|
785
1256
|
kind: z.ZodEnum<{
|
|
786
|
-
validation: "validation";
|
|
787
1257
|
audit: "audit";
|
|
788
1258
|
candidate: "candidate";
|
|
789
1259
|
discovery: "discovery";
|
|
1260
|
+
"implementation-decision": "implementation-decision";
|
|
790
1261
|
review: "review";
|
|
1262
|
+
validation: "validation";
|
|
791
1263
|
verification: "verification";
|
|
792
|
-
"implementation-decision": "implementation-decision";
|
|
793
1264
|
}>;
|
|
794
1265
|
decision: z.ZodOptional<z.ZodEnum<{
|
|
795
|
-
parallel: "parallel";
|
|
796
|
-
serial: "serial";
|
|
797
1266
|
"candidate-exact-path": "candidate-exact-path";
|
|
798
1267
|
"candidate-worktree": "candidate-worktree";
|
|
799
|
-
|
|
1268
|
+
parallel: "parallel";
|
|
1269
|
+
serial: "serial";
|
|
800
1270
|
skipped: "skipped";
|
|
1271
|
+
tournament: "tournament";
|
|
801
1272
|
}>>;
|
|
802
1273
|
decisionReason: z.ZodOptional<z.ZodString>;
|
|
803
1274
|
candidateEligibility: z.ZodDefault<z.ZodEnum<{
|
|
@@ -806,25 +1277,25 @@ export declare const ExecutionHistoryEntrySchema: z.ZodObject<{
|
|
|
806
1277
|
unknown: "unknown";
|
|
807
1278
|
}>>;
|
|
808
1279
|
candidateDecision: z.ZodOptional<z.ZodEnum<{
|
|
1280
|
+
serial_required: "serial_required";
|
|
809
1281
|
skipped: "skipped";
|
|
810
1282
|
used: "used";
|
|
811
|
-
serial_required: "serial_required";
|
|
812
1283
|
}>>;
|
|
813
1284
|
decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
814
|
-
|
|
1285
|
+
independent_surface: "independent_surface";
|
|
1286
|
+
needs_manager_judgment: "needs_manager_judgment";
|
|
815
1287
|
overlapping_files: "overlapping_files";
|
|
1288
|
+
shared_state: "shared_state";
|
|
816
1289
|
small_slice: "small_slice";
|
|
817
|
-
needs_manager_judgment: "needs_manager_judgment";
|
|
818
|
-
independent_surface: "independent_surface";
|
|
819
1290
|
validation_available: "validation_available";
|
|
820
1291
|
}>>>;
|
|
821
1292
|
modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
1293
|
+
audit: "audit";
|
|
1294
|
+
"candidate-implementation": "candidate-implementation";
|
|
822
1295
|
evidence: "evidence";
|
|
1296
|
+
review: "review";
|
|
823
1297
|
validation: "validation";
|
|
824
|
-
audit: "audit";
|
|
825
1298
|
verifier: "verifier";
|
|
826
|
-
review: "review";
|
|
827
|
-
"candidate-implementation": "candidate-implementation";
|
|
828
1299
|
}>>>;
|
|
829
1300
|
workerCount: z.ZodDefault<z.ZodNumber>;
|
|
830
1301
|
candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
|
|
@@ -832,66 +1303,89 @@ export declare const ExecutionHistoryEntrySchema: z.ZodObject<{
|
|
|
832
1303
|
sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
833
1304
|
dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
834
1305
|
writeScope: z.ZodDefault<z.ZodEnum<{
|
|
835
|
-
none: "none";
|
|
836
|
-
"manager-serial": "manager-serial";
|
|
837
1306
|
"exact-path": "exact-path";
|
|
838
1307
|
"isolated-worktree": "isolated-worktree";
|
|
1308
|
+
"manager-serial": "manager-serial";
|
|
839
1309
|
mixed: "mixed";
|
|
1310
|
+
none: "none";
|
|
840
1311
|
}>>;
|
|
841
1312
|
handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
842
1313
|
verificationStatus: z.ZodDefault<z.ZodEnum<{
|
|
843
|
-
|
|
844
|
-
passed: "passed";
|
|
1314
|
+
downgraded: "downgraded";
|
|
845
1315
|
failed: "failed";
|
|
846
1316
|
mixed: "mixed";
|
|
847
1317
|
"not-needed": "not-needed";
|
|
848
|
-
|
|
1318
|
+
passed: "passed";
|
|
1319
|
+
pending: "pending";
|
|
849
1320
|
}>>;
|
|
850
1321
|
outcome: z.ZodDefault<z.ZodEnum<{
|
|
851
1322
|
accepted: "accepted";
|
|
852
1323
|
modified: "modified";
|
|
853
|
-
rejected: "rejected";
|
|
854
|
-
partial: "partial";
|
|
855
1324
|
"not-covered": "not-covered";
|
|
1325
|
+
partial: "partial";
|
|
1326
|
+
rejected: "rejected";
|
|
856
1327
|
superseded: "superseded";
|
|
857
1328
|
}>>;
|
|
858
1329
|
synthesisRef: z.ZodOptional<z.ZodString>;
|
|
859
1330
|
}, z.core.$strict>>>;
|
|
860
1331
|
}, z.core.$strict>;
|
|
861
|
-
export declare const TokenTelemetrySchema: z.ZodObject<{
|
|
862
|
-
source: z.ZodDefault<z.ZodEnum<{
|
|
863
|
-
host_unavailable: "host_unavailable";
|
|
864
|
-
reported: "reported";
|
|
865
|
-
}>>;
|
|
866
|
-
visibleTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
|
|
867
|
-
cacheReadTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
|
|
868
|
-
nonCacheTokens: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
|
|
869
|
-
}, z.core.$strict>;
|
|
870
|
-
export declare const PhaseBoundarySchema: z.ZodObject<{
|
|
871
|
-
reason: z.ZodEnum<{
|
|
872
|
-
feature_limit: "feature_limit";
|
|
873
|
-
token_limit: "token_limit";
|
|
874
|
-
review_failure_limit: "review_failure_limit";
|
|
875
|
-
}>;
|
|
876
|
-
summary: z.ZodString;
|
|
877
|
-
resumeInstructions: z.ZodString;
|
|
878
|
-
recordedAt: z.ZodString;
|
|
879
|
-
}, z.core.$strict>;
|
|
880
1332
|
export declare const BudgetTelemetrySchema: z.ZodObject<{
|
|
881
|
-
phaseStartedAt: z.ZodDefault<z.ZodString>;
|
|
882
|
-
completedFeaturesSinceBoundary: z.ZodDefault<z.ZodNumber>;
|
|
883
1333
|
reviewCount: z.ZodDefault<z.ZodNumber>;
|
|
884
1334
|
failedReviewCount: z.ZodDefault<z.ZodNumber>;
|
|
885
1335
|
failedReviewAttemptsByFeature: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
|
|
886
|
-
|
|
887
|
-
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
|
|
891
|
-
|
|
892
|
-
|
|
893
|
-
|
|
1336
|
+
reviewExecutions: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1337
|
+
attemptId: z.ZodString;
|
|
1338
|
+
logicalPassId: z.ZodString;
|
|
1339
|
+
featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
|
|
1340
|
+
reviewKind: z.ZodEnum<{
|
|
1341
|
+
feature: "feature";
|
|
1342
|
+
final: "final";
|
|
1343
|
+
}>;
|
|
1344
|
+
reviewSnapshotId: z.ZodPipe<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>>;
|
|
1345
|
+
verdict: z.ZodEnum<{
|
|
1346
|
+
failed: "failed";
|
|
1347
|
+
passed: "passed";
|
|
1348
|
+
}>;
|
|
1349
|
+
startedAt: z.ZodString;
|
|
1350
|
+
completedAt: z.ZodString;
|
|
1351
|
+
terminalDisposition: z.ZodEnum<{
|
|
1352
|
+
observed_unsubmitted: "observed_unsubmitted";
|
|
1353
|
+
submitted: "submitted";
|
|
1354
|
+
}>;
|
|
1355
|
+
findings: z.ZodArray<z.ZodObject<{
|
|
1356
|
+
taxonomy: z.ZodEnum<{
|
|
1357
|
+
advisory: "advisory";
|
|
1358
|
+
evidence_gap: "evidence_gap";
|
|
1359
|
+
implementation_defect: "implementation_defect";
|
|
1360
|
+
regression_coverage_gap: "regression_coverage_gap";
|
|
1361
|
+
}>;
|
|
1362
|
+
subject: z.ZodString;
|
|
1363
|
+
requirementOrRisk: z.ZodString;
|
|
1364
|
+
evidenceLocator: z.ZodString;
|
|
1365
|
+
summary: z.ZodString;
|
|
1366
|
+
severity: z.ZodEnum<{
|
|
1367
|
+
advisory: "advisory";
|
|
1368
|
+
blocking: "blocking";
|
|
1369
|
+
}>;
|
|
1370
|
+
fingerprint: z.ZodString;
|
|
1371
|
+
}, z.core.$strict>>;
|
|
1372
|
+
}, z.core.$strict>>>;
|
|
1373
|
+
reviewLifecycle: z.ZodPrefault<z.ZodObject<{
|
|
1374
|
+
featureAttemptCount: z.ZodDefault<z.ZodNumber>;
|
|
1375
|
+
finalAttemptCount: z.ZodDefault<z.ZodNumber>;
|
|
1376
|
+
passedVerdictCount: z.ZodDefault<z.ZodNumber>;
|
|
1377
|
+
failedVerdictCount: z.ZodDefault<z.ZodNumber>;
|
|
1378
|
+
retryConsumedCount: z.ZodDefault<z.ZodNumber>;
|
|
894
1379
|
}, z.core.$strict>>;
|
|
1380
|
+
observedReviewWorkers: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1381
|
+
source: z.ZodLiteral<"unavailable">;
|
|
1382
|
+
reconciliationStatus: z.ZodLiteral<"unreconciled">;
|
|
1383
|
+
observedExecutionCount: z.ZodNull;
|
|
1384
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1385
|
+
source: z.ZodLiteral<"host_observed">;
|
|
1386
|
+
reconciliationStatus: z.ZodLiteral<"reconciled">;
|
|
1387
|
+
observedExecutionCount: z.ZodNumber;
|
|
1388
|
+
}, z.core.$strict>], "source">>;
|
|
895
1389
|
orchestration: z.ZodPrefault<z.ZodObject<{
|
|
896
1390
|
passCount: z.ZodDefault<z.ZodNumber>;
|
|
897
1391
|
workerCount: z.ZodDefault<z.ZodNumber>;
|
|
@@ -901,25 +1395,24 @@ export declare const BudgetTelemetrySchema: z.ZodObject<{
|
|
|
901
1395
|
candidateUsedDecisionCount: z.ZodDefault<z.ZodNumber>;
|
|
902
1396
|
candidateSerialRequiredDecisionCount: z.ZodDefault<z.ZodNumber>;
|
|
903
1397
|
skippedCandidateDecisionCount: z.ZodDefault<z.ZodNumber>;
|
|
904
|
-
recordedPassIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
905
1398
|
latestPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
906
1399
|
id: z.ZodString;
|
|
907
1400
|
kind: z.ZodEnum<{
|
|
908
|
-
validation: "validation";
|
|
909
1401
|
audit: "audit";
|
|
910
1402
|
candidate: "candidate";
|
|
911
1403
|
discovery: "discovery";
|
|
1404
|
+
"implementation-decision": "implementation-decision";
|
|
912
1405
|
review: "review";
|
|
1406
|
+
validation: "validation";
|
|
913
1407
|
verification: "verification";
|
|
914
|
-
"implementation-decision": "implementation-decision";
|
|
915
1408
|
}>;
|
|
916
1409
|
decision: z.ZodOptional<z.ZodEnum<{
|
|
917
|
-
parallel: "parallel";
|
|
918
|
-
serial: "serial";
|
|
919
1410
|
"candidate-exact-path": "candidate-exact-path";
|
|
920
1411
|
"candidate-worktree": "candidate-worktree";
|
|
921
|
-
|
|
1412
|
+
parallel: "parallel";
|
|
1413
|
+
serial: "serial";
|
|
922
1414
|
skipped: "skipped";
|
|
1415
|
+
tournament: "tournament";
|
|
923
1416
|
}>>;
|
|
924
1417
|
decisionReason: z.ZodOptional<z.ZodString>;
|
|
925
1418
|
candidateEligibility: z.ZodDefault<z.ZodEnum<{
|
|
@@ -928,25 +1421,25 @@ export declare const BudgetTelemetrySchema: z.ZodObject<{
|
|
|
928
1421
|
unknown: "unknown";
|
|
929
1422
|
}>>;
|
|
930
1423
|
candidateDecision: z.ZodOptional<z.ZodEnum<{
|
|
1424
|
+
serial_required: "serial_required";
|
|
931
1425
|
skipped: "skipped";
|
|
932
1426
|
used: "used";
|
|
933
|
-
serial_required: "serial_required";
|
|
934
1427
|
}>>;
|
|
935
1428
|
decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
936
|
-
|
|
1429
|
+
independent_surface: "independent_surface";
|
|
1430
|
+
needs_manager_judgment: "needs_manager_judgment";
|
|
937
1431
|
overlapping_files: "overlapping_files";
|
|
1432
|
+
shared_state: "shared_state";
|
|
938
1433
|
small_slice: "small_slice";
|
|
939
|
-
needs_manager_judgment: "needs_manager_judgment";
|
|
940
|
-
independent_surface: "independent_surface";
|
|
941
1434
|
validation_available: "validation_available";
|
|
942
1435
|
}>>>;
|
|
943
1436
|
modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
1437
|
+
audit: "audit";
|
|
1438
|
+
"candidate-implementation": "candidate-implementation";
|
|
944
1439
|
evidence: "evidence";
|
|
1440
|
+
review: "review";
|
|
945
1441
|
validation: "validation";
|
|
946
|
-
audit: "audit";
|
|
947
1442
|
verifier: "verifier";
|
|
948
|
-
review: "review";
|
|
949
|
-
"candidate-implementation": "candidate-implementation";
|
|
950
1443
|
}>>>;
|
|
951
1444
|
workerCount: z.ZodDefault<z.ZodNumber>;
|
|
952
1445
|
candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
|
|
@@ -954,57 +1447,47 @@ export declare const BudgetTelemetrySchema: z.ZodObject<{
|
|
|
954
1447
|
sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
955
1448
|
dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
956
1449
|
writeScope: z.ZodDefault<z.ZodEnum<{
|
|
957
|
-
none: "none";
|
|
958
|
-
"manager-serial": "manager-serial";
|
|
959
1450
|
"exact-path": "exact-path";
|
|
960
1451
|
"isolated-worktree": "isolated-worktree";
|
|
1452
|
+
"manager-serial": "manager-serial";
|
|
961
1453
|
mixed: "mixed";
|
|
1454
|
+
none: "none";
|
|
962
1455
|
}>>;
|
|
963
1456
|
handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
964
1457
|
verificationStatus: z.ZodDefault<z.ZodEnum<{
|
|
965
|
-
|
|
966
|
-
passed: "passed";
|
|
1458
|
+
downgraded: "downgraded";
|
|
967
1459
|
failed: "failed";
|
|
968
1460
|
mixed: "mixed";
|
|
969
1461
|
"not-needed": "not-needed";
|
|
970
|
-
|
|
1462
|
+
passed: "passed";
|
|
1463
|
+
pending: "pending";
|
|
971
1464
|
}>>;
|
|
972
1465
|
outcome: z.ZodDefault<z.ZodEnum<{
|
|
973
1466
|
accepted: "accepted";
|
|
974
1467
|
modified: "modified";
|
|
975
|
-
rejected: "rejected";
|
|
976
|
-
partial: "partial";
|
|
977
1468
|
"not-covered": "not-covered";
|
|
1469
|
+
partial: "partial";
|
|
1470
|
+
rejected: "rejected";
|
|
978
1471
|
superseded: "superseded";
|
|
979
1472
|
}>>;
|
|
980
1473
|
synthesisRef: z.ZodOptional<z.ZodString>;
|
|
981
1474
|
}, z.core.$strict>>>;
|
|
982
1475
|
}, z.core.$strict>>;
|
|
983
|
-
phaseBoundary: z.ZodDefault<z.ZodNullable<z.ZodObject<{
|
|
984
|
-
reason: z.ZodEnum<{
|
|
985
|
-
feature_limit: "feature_limit";
|
|
986
|
-
token_limit: "token_limit";
|
|
987
|
-
review_failure_limit: "review_failure_limit";
|
|
988
|
-
}>;
|
|
989
|
-
summary: z.ZodString;
|
|
990
|
-
resumeInstructions: z.ZodString;
|
|
991
|
-
recordedAt: z.ZodString;
|
|
992
|
-
}, z.core.$strict>>>;
|
|
993
1476
|
}, z.core.$strict>;
|
|
994
|
-
export declare const SessionSchema: z.ZodObject<{
|
|
995
|
-
version: z.ZodLiteral<
|
|
996
|
-
id: z.ZodString
|
|
1477
|
+
export declare const SessionSchema: z.ZodPipe<z.ZodObject<{
|
|
1478
|
+
version: z.ZodLiteral<3>;
|
|
1479
|
+
id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").SessionId, string>>;
|
|
997
1480
|
goal: z.ZodString;
|
|
998
1481
|
status: z.ZodEnum<{
|
|
999
|
-
completed: "completed";
|
|
1000
1482
|
blocked: "blocked";
|
|
1483
|
+
completed: "completed";
|
|
1001
1484
|
planning: "planning";
|
|
1002
1485
|
ready: "ready";
|
|
1003
1486
|
running: "running";
|
|
1004
1487
|
}>;
|
|
1005
1488
|
approval: z.ZodEnum<{
|
|
1006
|
-
pending: "pending";
|
|
1007
1489
|
approved: "approved";
|
|
1490
|
+
pending: "pending";
|
|
1008
1491
|
}>;
|
|
1009
1492
|
plan: z.ZodNullable<z.ZodObject<{
|
|
1010
1493
|
summary: z.ZodString;
|
|
@@ -1016,31 +1499,31 @@ export declare const SessionSchema: z.ZodObject<{
|
|
|
1016
1499
|
detailed: "detailed";
|
|
1017
1500
|
}>>;
|
|
1018
1501
|
features: z.ZodArray<z.ZodObject<{
|
|
1019
|
-
id: z.ZodString
|
|
1502
|
+
id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
|
|
1020
1503
|
title: z.ZodString;
|
|
1021
1504
|
summary: z.ZodString;
|
|
1022
1505
|
status: z.ZodDefault<z.ZodEnum<{
|
|
1023
|
-
pending: "pending";
|
|
1024
|
-
in_progress: "in_progress";
|
|
1025
|
-
completed: "completed";
|
|
1026
1506
|
blocked: "blocked";
|
|
1507
|
+
completed: "completed";
|
|
1508
|
+
in_progress: "in_progress";
|
|
1509
|
+
pending: "pending";
|
|
1027
1510
|
}>>;
|
|
1028
1511
|
reviewDepth: z.ZodDefault<z.ZodEnum<{
|
|
1512
|
+
detailed: "detailed";
|
|
1029
1513
|
quick: "quick";
|
|
1030
1514
|
standard: "standard";
|
|
1031
|
-
detailed: "detailed";
|
|
1032
1515
|
}>>;
|
|
1033
1516
|
targets: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1034
1517
|
validation: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1035
|
-
dependsOn: z.ZodDefault<z.ZodArray<z.ZodString
|
|
1518
|
+
dependsOn: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>>>;
|
|
1036
1519
|
}, z.core.$strict>>;
|
|
1037
1520
|
}, z.core.$strict>>;
|
|
1038
|
-
activeFeatureId: z.ZodNullable<z.ZodString
|
|
1521
|
+
activeFeatureId: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>>;
|
|
1039
1522
|
history: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1040
|
-
featureId: z.ZodString
|
|
1523
|
+
featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
|
|
1041
1524
|
status: z.ZodEnum<{
|
|
1042
|
-
completed: "completed";
|
|
1043
1525
|
blocked: "blocked";
|
|
1526
|
+
completed: "completed";
|
|
1044
1527
|
needs_input: "needs_input";
|
|
1045
1528
|
}>;
|
|
1046
1529
|
summary: z.ZodString;
|
|
@@ -1051,45 +1534,45 @@ export declare const SessionSchema: z.ZodObject<{
|
|
|
1051
1534
|
validationRun: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1052
1535
|
command: z.ZodString;
|
|
1053
1536
|
status: z.ZodEnum<{
|
|
1054
|
-
passed: "passed";
|
|
1055
1537
|
failed: "failed";
|
|
1538
|
+
passed: "passed";
|
|
1056
1539
|
}>;
|
|
1057
1540
|
summary: z.ZodString;
|
|
1058
1541
|
}, z.core.$strict>>>;
|
|
1059
1542
|
validationScope: z.ZodOptional<z.ZodEnum<{
|
|
1060
|
-
targeted: "targeted";
|
|
1061
1543
|
broad: "broad";
|
|
1544
|
+
targeted: "targeted";
|
|
1062
1545
|
}>>;
|
|
1063
1546
|
featureReviewDepth: z.ZodOptional<z.ZodEnum<{
|
|
1547
|
+
detailed: "detailed";
|
|
1064
1548
|
quick: "quick";
|
|
1065
1549
|
standard: "standard";
|
|
1066
|
-
detailed: "detailed";
|
|
1067
1550
|
}>>;
|
|
1068
1551
|
featureReview: z.ZodOptional<z.ZodObject<{
|
|
1069
1552
|
status: z.ZodEnum<{
|
|
1070
|
-
passed: "passed";
|
|
1071
1553
|
failed: "failed";
|
|
1554
|
+
passed: "passed";
|
|
1072
1555
|
}>;
|
|
1073
1556
|
summary: z.ZodString;
|
|
1074
1557
|
blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1075
1558
|
summary: z.ZodString;
|
|
1076
1559
|
severity: z.ZodDefault<z.ZodEnum<{
|
|
1077
|
-
blocking: "blocking";
|
|
1078
1560
|
advisory: "advisory";
|
|
1561
|
+
blocking: "blocking";
|
|
1079
1562
|
}>>;
|
|
1080
1563
|
}, z.core.$strict>>>;
|
|
1081
1564
|
}, z.core.$strict>>;
|
|
1082
1565
|
finalReview: z.ZodOptional<z.ZodObject<{
|
|
1083
1566
|
status: z.ZodEnum<{
|
|
1084
|
-
passed: "passed";
|
|
1085
1567
|
failed: "failed";
|
|
1568
|
+
passed: "passed";
|
|
1086
1569
|
}>;
|
|
1087
1570
|
summary: z.ZodString;
|
|
1088
1571
|
blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1089
1572
|
summary: z.ZodString;
|
|
1090
1573
|
severity: z.ZodDefault<z.ZodEnum<{
|
|
1091
|
-
blocking: "blocking";
|
|
1092
1574
|
advisory: "advisory";
|
|
1575
|
+
blocking: "blocking";
|
|
1093
1576
|
}>>;
|
|
1094
1577
|
}, z.core.$strict>>>;
|
|
1095
1578
|
reviewDepth: z.ZodEnum<{
|
|
@@ -1097,34 +1580,37 @@ export declare const SessionSchema: z.ZodObject<{
|
|
|
1097
1580
|
detailed: "detailed";
|
|
1098
1581
|
}>;
|
|
1099
1582
|
}, z.core.$strict>>;
|
|
1100
|
-
outcome: z.ZodOptional<z.ZodObject<{
|
|
1101
|
-
kind: z.
|
|
1102
|
-
|
|
1583
|
+
outcome: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1584
|
+
kind: z.ZodLiteral<"completed">;
|
|
1585
|
+
summary: z.ZodOptional<z.ZodString>;
|
|
1586
|
+
resolutionHint: z.ZodOptional<z.ZodString>;
|
|
1587
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1588
|
+
kind: z.ZodEnum<{
|
|
1103
1589
|
blocked: "blocked";
|
|
1104
1590
|
needs_input: "needs_input";
|
|
1105
1591
|
replan_required: "replan_required";
|
|
1106
|
-
}
|
|
1107
|
-
summary: z.
|
|
1592
|
+
}>;
|
|
1593
|
+
summary: z.ZodString;
|
|
1108
1594
|
resolutionHint: z.ZodOptional<z.ZodString>;
|
|
1109
|
-
}, z.core.$strict>>;
|
|
1595
|
+
}, z.core.$strict>], "kind">>;
|
|
1110
1596
|
orchestrationPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1111
1597
|
id: z.ZodString;
|
|
1112
1598
|
kind: z.ZodEnum<{
|
|
1113
|
-
validation: "validation";
|
|
1114
1599
|
audit: "audit";
|
|
1115
1600
|
candidate: "candidate";
|
|
1116
1601
|
discovery: "discovery";
|
|
1602
|
+
"implementation-decision": "implementation-decision";
|
|
1117
1603
|
review: "review";
|
|
1604
|
+
validation: "validation";
|
|
1118
1605
|
verification: "verification";
|
|
1119
|
-
"implementation-decision": "implementation-decision";
|
|
1120
1606
|
}>;
|
|
1121
1607
|
decision: z.ZodOptional<z.ZodEnum<{
|
|
1122
|
-
parallel: "parallel";
|
|
1123
|
-
serial: "serial";
|
|
1124
1608
|
"candidate-exact-path": "candidate-exact-path";
|
|
1125
1609
|
"candidate-worktree": "candidate-worktree";
|
|
1126
|
-
|
|
1610
|
+
parallel: "parallel";
|
|
1611
|
+
serial: "serial";
|
|
1127
1612
|
skipped: "skipped";
|
|
1613
|
+
tournament: "tournament";
|
|
1128
1614
|
}>>;
|
|
1129
1615
|
decisionReason: z.ZodOptional<z.ZodString>;
|
|
1130
1616
|
candidateEligibility: z.ZodDefault<z.ZodEnum<{
|
|
@@ -1133,25 +1619,25 @@ export declare const SessionSchema: z.ZodObject<{
|
|
|
1133
1619
|
unknown: "unknown";
|
|
1134
1620
|
}>>;
|
|
1135
1621
|
candidateDecision: z.ZodOptional<z.ZodEnum<{
|
|
1622
|
+
serial_required: "serial_required";
|
|
1136
1623
|
skipped: "skipped";
|
|
1137
1624
|
used: "used";
|
|
1138
|
-
serial_required: "serial_required";
|
|
1139
1625
|
}>>;
|
|
1140
1626
|
decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
1141
|
-
|
|
1627
|
+
independent_surface: "independent_surface";
|
|
1628
|
+
needs_manager_judgment: "needs_manager_judgment";
|
|
1142
1629
|
overlapping_files: "overlapping_files";
|
|
1630
|
+
shared_state: "shared_state";
|
|
1143
1631
|
small_slice: "small_slice";
|
|
1144
|
-
needs_manager_judgment: "needs_manager_judgment";
|
|
1145
|
-
independent_surface: "independent_surface";
|
|
1146
1632
|
validation_available: "validation_available";
|
|
1147
1633
|
}>>>;
|
|
1148
1634
|
modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
1635
|
+
audit: "audit";
|
|
1636
|
+
"candidate-implementation": "candidate-implementation";
|
|
1149
1637
|
evidence: "evidence";
|
|
1638
|
+
review: "review";
|
|
1150
1639
|
validation: "validation";
|
|
1151
|
-
audit: "audit";
|
|
1152
1640
|
verifier: "verifier";
|
|
1153
|
-
review: "review";
|
|
1154
|
-
"candidate-implementation": "candidate-implementation";
|
|
1155
1641
|
}>>>;
|
|
1156
1642
|
workerCount: z.ZodDefault<z.ZodNumber>;
|
|
1157
1643
|
candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
|
|
@@ -1159,47 +1645,89 @@ export declare const SessionSchema: z.ZodObject<{
|
|
|
1159
1645
|
sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1160
1646
|
dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1161
1647
|
writeScope: z.ZodDefault<z.ZodEnum<{
|
|
1162
|
-
none: "none";
|
|
1163
|
-
"manager-serial": "manager-serial";
|
|
1164
1648
|
"exact-path": "exact-path";
|
|
1165
1649
|
"isolated-worktree": "isolated-worktree";
|
|
1650
|
+
"manager-serial": "manager-serial";
|
|
1166
1651
|
mixed: "mixed";
|
|
1652
|
+
none: "none";
|
|
1167
1653
|
}>>;
|
|
1168
1654
|
handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1169
1655
|
verificationStatus: z.ZodDefault<z.ZodEnum<{
|
|
1170
|
-
|
|
1171
|
-
passed: "passed";
|
|
1656
|
+
downgraded: "downgraded";
|
|
1172
1657
|
failed: "failed";
|
|
1173
1658
|
mixed: "mixed";
|
|
1174
1659
|
"not-needed": "not-needed";
|
|
1175
|
-
|
|
1660
|
+
passed: "passed";
|
|
1661
|
+
pending: "pending";
|
|
1176
1662
|
}>>;
|
|
1177
1663
|
outcome: z.ZodDefault<z.ZodEnum<{
|
|
1178
1664
|
accepted: "accepted";
|
|
1179
1665
|
modified: "modified";
|
|
1180
|
-
rejected: "rejected";
|
|
1181
|
-
partial: "partial";
|
|
1182
1666
|
"not-covered": "not-covered";
|
|
1667
|
+
partial: "partial";
|
|
1668
|
+
rejected: "rejected";
|
|
1183
1669
|
superseded: "superseded";
|
|
1184
1670
|
}>>;
|
|
1185
1671
|
synthesisRef: z.ZodOptional<z.ZodString>;
|
|
1186
1672
|
}, z.core.$strict>>>;
|
|
1187
1673
|
}, z.core.$strict>>>;
|
|
1188
1674
|
budget: z.ZodPrefault<z.ZodObject<{
|
|
1189
|
-
phaseStartedAt: z.ZodDefault<z.ZodString>;
|
|
1190
|
-
completedFeaturesSinceBoundary: z.ZodDefault<z.ZodNumber>;
|
|
1191
1675
|
reviewCount: z.ZodDefault<z.ZodNumber>;
|
|
1192
1676
|
failedReviewCount: z.ZodDefault<z.ZodNumber>;
|
|
1193
1677
|
failedReviewAttemptsByFeature: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
|
|
1194
|
-
|
|
1195
|
-
|
|
1196
|
-
|
|
1197
|
-
|
|
1198
|
-
|
|
1199
|
-
|
|
1200
|
-
|
|
1201
|
-
|
|
1678
|
+
reviewExecutions: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1679
|
+
attemptId: z.ZodString;
|
|
1680
|
+
logicalPassId: z.ZodString;
|
|
1681
|
+
featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
|
|
1682
|
+
reviewKind: z.ZodEnum<{
|
|
1683
|
+
feature: "feature";
|
|
1684
|
+
final: "final";
|
|
1685
|
+
}>;
|
|
1686
|
+
reviewSnapshotId: z.ZodPipe<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>>;
|
|
1687
|
+
verdict: z.ZodEnum<{
|
|
1688
|
+
failed: "failed";
|
|
1689
|
+
passed: "passed";
|
|
1690
|
+
}>;
|
|
1691
|
+
startedAt: z.ZodString;
|
|
1692
|
+
completedAt: z.ZodString;
|
|
1693
|
+
terminalDisposition: z.ZodEnum<{
|
|
1694
|
+
observed_unsubmitted: "observed_unsubmitted";
|
|
1695
|
+
submitted: "submitted";
|
|
1696
|
+
}>;
|
|
1697
|
+
findings: z.ZodArray<z.ZodObject<{
|
|
1698
|
+
taxonomy: z.ZodEnum<{
|
|
1699
|
+
advisory: "advisory";
|
|
1700
|
+
evidence_gap: "evidence_gap";
|
|
1701
|
+
implementation_defect: "implementation_defect";
|
|
1702
|
+
regression_coverage_gap: "regression_coverage_gap";
|
|
1703
|
+
}>;
|
|
1704
|
+
subject: z.ZodString;
|
|
1705
|
+
requirementOrRisk: z.ZodString;
|
|
1706
|
+
evidenceLocator: z.ZodString;
|
|
1707
|
+
summary: z.ZodString;
|
|
1708
|
+
severity: z.ZodEnum<{
|
|
1709
|
+
advisory: "advisory";
|
|
1710
|
+
blocking: "blocking";
|
|
1711
|
+
}>;
|
|
1712
|
+
fingerprint: z.ZodString;
|
|
1713
|
+
}, z.core.$strict>>;
|
|
1714
|
+
}, z.core.$strict>>>;
|
|
1715
|
+
reviewLifecycle: z.ZodPrefault<z.ZodObject<{
|
|
1716
|
+
featureAttemptCount: z.ZodDefault<z.ZodNumber>;
|
|
1717
|
+
finalAttemptCount: z.ZodDefault<z.ZodNumber>;
|
|
1718
|
+
passedVerdictCount: z.ZodDefault<z.ZodNumber>;
|
|
1719
|
+
failedVerdictCount: z.ZodDefault<z.ZodNumber>;
|
|
1720
|
+
retryConsumedCount: z.ZodDefault<z.ZodNumber>;
|
|
1202
1721
|
}, z.core.$strict>>;
|
|
1722
|
+
observedReviewWorkers: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1723
|
+
source: z.ZodLiteral<"unavailable">;
|
|
1724
|
+
reconciliationStatus: z.ZodLiteral<"unreconciled">;
|
|
1725
|
+
observedExecutionCount: z.ZodNull;
|
|
1726
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1727
|
+
source: z.ZodLiteral<"host_observed">;
|
|
1728
|
+
reconciliationStatus: z.ZodLiteral<"reconciled">;
|
|
1729
|
+
observedExecutionCount: z.ZodNumber;
|
|
1730
|
+
}, z.core.$strict>], "source">>;
|
|
1203
1731
|
orchestration: z.ZodPrefault<z.ZodObject<{
|
|
1204
1732
|
passCount: z.ZodDefault<z.ZodNumber>;
|
|
1205
1733
|
workerCount: z.ZodDefault<z.ZodNumber>;
|
|
@@ -1209,25 +1737,24 @@ export declare const SessionSchema: z.ZodObject<{
|
|
|
1209
1737
|
candidateUsedDecisionCount: z.ZodDefault<z.ZodNumber>;
|
|
1210
1738
|
candidateSerialRequiredDecisionCount: z.ZodDefault<z.ZodNumber>;
|
|
1211
1739
|
skippedCandidateDecisionCount: z.ZodDefault<z.ZodNumber>;
|
|
1212
|
-
recordedPassIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1213
1740
|
latestPasses: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1214
1741
|
id: z.ZodString;
|
|
1215
1742
|
kind: z.ZodEnum<{
|
|
1216
|
-
validation: "validation";
|
|
1217
1743
|
audit: "audit";
|
|
1218
1744
|
candidate: "candidate";
|
|
1219
1745
|
discovery: "discovery";
|
|
1746
|
+
"implementation-decision": "implementation-decision";
|
|
1220
1747
|
review: "review";
|
|
1748
|
+
validation: "validation";
|
|
1221
1749
|
verification: "verification";
|
|
1222
|
-
"implementation-decision": "implementation-decision";
|
|
1223
1750
|
}>;
|
|
1224
1751
|
decision: z.ZodOptional<z.ZodEnum<{
|
|
1225
|
-
parallel: "parallel";
|
|
1226
|
-
serial: "serial";
|
|
1227
1752
|
"candidate-exact-path": "candidate-exact-path";
|
|
1228
1753
|
"candidate-worktree": "candidate-worktree";
|
|
1229
|
-
|
|
1754
|
+
parallel: "parallel";
|
|
1755
|
+
serial: "serial";
|
|
1230
1756
|
skipped: "skipped";
|
|
1757
|
+
tournament: "tournament";
|
|
1231
1758
|
}>>;
|
|
1232
1759
|
decisionReason: z.ZodOptional<z.ZodString>;
|
|
1233
1760
|
candidateEligibility: z.ZodDefault<z.ZodEnum<{
|
|
@@ -1236,25 +1763,25 @@ export declare const SessionSchema: z.ZodObject<{
|
|
|
1236
1763
|
unknown: "unknown";
|
|
1237
1764
|
}>>;
|
|
1238
1765
|
candidateDecision: z.ZodOptional<z.ZodEnum<{
|
|
1766
|
+
serial_required: "serial_required";
|
|
1239
1767
|
skipped: "skipped";
|
|
1240
1768
|
used: "used";
|
|
1241
|
-
serial_required: "serial_required";
|
|
1242
1769
|
}>>;
|
|
1243
1770
|
decisionFactors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
1244
|
-
|
|
1771
|
+
independent_surface: "independent_surface";
|
|
1772
|
+
needs_manager_judgment: "needs_manager_judgment";
|
|
1245
1773
|
overlapping_files: "overlapping_files";
|
|
1774
|
+
shared_state: "shared_state";
|
|
1246
1775
|
small_slice: "small_slice";
|
|
1247
|
-
needs_manager_judgment: "needs_manager_judgment";
|
|
1248
|
-
independent_surface: "independent_surface";
|
|
1249
1776
|
validation_available: "validation_available";
|
|
1250
1777
|
}>>>;
|
|
1251
1778
|
modes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
1779
|
+
audit: "audit";
|
|
1780
|
+
"candidate-implementation": "candidate-implementation";
|
|
1252
1781
|
evidence: "evidence";
|
|
1782
|
+
review: "review";
|
|
1253
1783
|
validation: "validation";
|
|
1254
|
-
audit: "audit";
|
|
1255
1784
|
verifier: "verifier";
|
|
1256
|
-
review: "review";
|
|
1257
|
-
"candidate-implementation": "candidate-implementation";
|
|
1258
1785
|
}>>>;
|
|
1259
1786
|
workerCount: z.ZodDefault<z.ZodNumber>;
|
|
1260
1787
|
candidateWorkerCount: z.ZodDefault<z.ZodNumber>;
|
|
@@ -1262,48 +1789,115 @@ export declare const SessionSchema: z.ZodObject<{
|
|
|
1262
1789
|
sliceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1263
1790
|
dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1264
1791
|
writeScope: z.ZodDefault<z.ZodEnum<{
|
|
1265
|
-
none: "none";
|
|
1266
|
-
"manager-serial": "manager-serial";
|
|
1267
1792
|
"exact-path": "exact-path";
|
|
1268
1793
|
"isolated-worktree": "isolated-worktree";
|
|
1794
|
+
"manager-serial": "manager-serial";
|
|
1269
1795
|
mixed: "mixed";
|
|
1796
|
+
none: "none";
|
|
1270
1797
|
}>>;
|
|
1271
1798
|
handoffRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1272
1799
|
verificationStatus: z.ZodDefault<z.ZodEnum<{
|
|
1273
|
-
|
|
1274
|
-
passed: "passed";
|
|
1800
|
+
downgraded: "downgraded";
|
|
1275
1801
|
failed: "failed";
|
|
1276
1802
|
mixed: "mixed";
|
|
1277
1803
|
"not-needed": "not-needed";
|
|
1278
|
-
|
|
1804
|
+
passed: "passed";
|
|
1805
|
+
pending: "pending";
|
|
1279
1806
|
}>>;
|
|
1280
1807
|
outcome: z.ZodDefault<z.ZodEnum<{
|
|
1281
1808
|
accepted: "accepted";
|
|
1282
1809
|
modified: "modified";
|
|
1283
|
-
rejected: "rejected";
|
|
1284
|
-
partial: "partial";
|
|
1285
1810
|
"not-covered": "not-covered";
|
|
1811
|
+
partial: "partial";
|
|
1812
|
+
rejected: "rejected";
|
|
1286
1813
|
superseded: "superseded";
|
|
1287
1814
|
}>>;
|
|
1288
1815
|
synthesisRef: z.ZodOptional<z.ZodString>;
|
|
1289
1816
|
}, z.core.$strict>>>;
|
|
1290
1817
|
}, z.core.$strict>>;
|
|
1291
|
-
|
|
1292
|
-
|
|
1293
|
-
|
|
1294
|
-
|
|
1295
|
-
|
|
1818
|
+
}, z.core.$strict>>;
|
|
1819
|
+
causal: z.ZodOptional<z.ZodObject<{
|
|
1820
|
+
revision: z.ZodNumber;
|
|
1821
|
+
genesisSnapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1822
|
+
snapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1823
|
+
mutations: z.ZodArray<z.ZodObject<{
|
|
1824
|
+
operationId: z.ZodString;
|
|
1825
|
+
operationKind: z.ZodEnum<{
|
|
1826
|
+
evidence_record: "evidence_record";
|
|
1827
|
+
feature_complete: "feature_complete";
|
|
1828
|
+
feature_reset: "feature_reset";
|
|
1829
|
+
plan_approve: "plan_approve";
|
|
1830
|
+
plan_save: "plan_save";
|
|
1831
|
+
review_record: "review_record";
|
|
1832
|
+
run_start: "run_start";
|
|
1833
|
+
session_close: "session_close";
|
|
1296
1834
|
}>;
|
|
1297
|
-
|
|
1298
|
-
|
|
1835
|
+
requestDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1836
|
+
priorMutationDigest: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>>;
|
|
1837
|
+
mutationDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1838
|
+
priorRevision: z.ZodNumber;
|
|
1839
|
+
revision: z.ZodNumber;
|
|
1840
|
+
priorSnapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1841
|
+
currentSnapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1842
|
+
changedEntity: z.ZodObject<{
|
|
1843
|
+
kind: z.ZodEnum<{
|
|
1844
|
+
closure: "closure";
|
|
1845
|
+
evidence: "evidence";
|
|
1846
|
+
feature: "feature";
|
|
1847
|
+
plan: "plan";
|
|
1848
|
+
review: "review";
|
|
1849
|
+
session: "session";
|
|
1850
|
+
}>;
|
|
1851
|
+
id: z.ZodString;
|
|
1852
|
+
}, z.core.$strict>;
|
|
1853
|
+
changedFields: z.ZodArray<z.ZodString>;
|
|
1854
|
+
blockerDelta: z.ZodObject<{
|
|
1855
|
+
added: z.ZodArray<z.ZodString>;
|
|
1856
|
+
removed: z.ZodArray<z.ZodString>;
|
|
1857
|
+
}, z.core.$strict>;
|
|
1858
|
+
evidenceRefs: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>>;
|
|
1299
1859
|
recordedAt: z.ZodString;
|
|
1300
|
-
}, z.core.$strict
|
|
1860
|
+
}, z.core.$strict>>;
|
|
1861
|
+
evidence: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1862
|
+
evidenceId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1863
|
+
snapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1864
|
+
sourceDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1865
|
+
startedAt: z.ZodString;
|
|
1866
|
+
completedAt: z.ZodString;
|
|
1867
|
+
commandClass: z.ZodEnum<{
|
|
1868
|
+
build: "build";
|
|
1869
|
+
format: "format";
|
|
1870
|
+
lint: "lint";
|
|
1871
|
+
other: "other";
|
|
1872
|
+
smoke: "smoke";
|
|
1873
|
+
test: "test";
|
|
1874
|
+
typecheck: "typecheck";
|
|
1875
|
+
}>;
|
|
1876
|
+
exitCode: z.ZodNumber;
|
|
1877
|
+
outputDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1878
|
+
artifactRef: z.ZodOptional<z.ZodObject<{
|
|
1879
|
+
kind: z.ZodLiteral<"restricted_evidence_v1">;
|
|
1880
|
+
digest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1881
|
+
byteLength: z.ZodNumber;
|
|
1882
|
+
}, z.core.$strict>>;
|
|
1883
|
+
environmentKeys: z.ZodArray<z.ZodString>;
|
|
1884
|
+
kind: z.ZodLiteral<"validation">;
|
|
1885
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1886
|
+
evidenceId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1887
|
+
snapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1888
|
+
sourceDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1889
|
+
startedAt: z.ZodString;
|
|
1890
|
+
completedAt: z.ZodString;
|
|
1891
|
+
kind: z.ZodLiteral<"review">;
|
|
1892
|
+
attemptId: z.ZodString;
|
|
1893
|
+
packetDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
|
|
1894
|
+
}, z.core.$strict>], "kind">>;
|
|
1301
1895
|
}, z.core.$strict>>;
|
|
1302
1896
|
closure: z.ZodNullable<z.ZodObject<{
|
|
1303
1897
|
kind: z.ZodEnum<{
|
|
1898
|
+
abandoned: "abandoned";
|
|
1304
1899
|
completed: "completed";
|
|
1305
1900
|
deferred: "deferred";
|
|
1306
|
-
abandoned: "abandoned";
|
|
1307
1901
|
}>;
|
|
1308
1902
|
summary: z.ZodString;
|
|
1309
1903
|
recordedAt: z.ZodString;
|
|
@@ -1319,19 +1913,231 @@ export declare const SessionSchema: z.ZodObject<{
|
|
|
1319
1913
|
updatedAt: z.ZodString;
|
|
1320
1914
|
completedAt: z.ZodNullable<z.ZodString>;
|
|
1321
1915
|
}, z.core.$strict>;
|
|
1322
|
-
}, z.core.$strict
|
|
1323
|
-
|
|
1324
|
-
|
|
1325
|
-
|
|
1326
|
-
|
|
1327
|
-
|
|
1328
|
-
|
|
1329
|
-
|
|
1330
|
-
|
|
1331
|
-
|
|
1332
|
-
|
|
1333
|
-
|
|
1334
|
-
|
|
1335
|
-
|
|
1336
|
-
|
|
1337
|
-
|
|
1916
|
+
}, z.core.$strict>, z.ZodTransform<Session, {
|
|
1917
|
+
version: 3;
|
|
1918
|
+
id: import("../domain/session.js").SessionId;
|
|
1919
|
+
goal: string;
|
|
1920
|
+
status: "blocked" | "completed" | "planning" | "ready" | "running";
|
|
1921
|
+
approval: "approved" | "pending";
|
|
1922
|
+
plan: {
|
|
1923
|
+
summary: string;
|
|
1924
|
+
overview: string;
|
|
1925
|
+
requirements: string[];
|
|
1926
|
+
decisions: string[];
|
|
1927
|
+
finalReviewPolicy: "broad" | "detailed";
|
|
1928
|
+
features: {
|
|
1929
|
+
id: import("../domain/session.js").FeatureId;
|
|
1930
|
+
title: string;
|
|
1931
|
+
summary: string;
|
|
1932
|
+
status: "blocked" | "completed" | "in_progress" | "pending";
|
|
1933
|
+
reviewDepth: "detailed" | "quick" | "standard";
|
|
1934
|
+
targets: string[];
|
|
1935
|
+
validation: string[];
|
|
1936
|
+
dependsOn: import("../domain/session.js").FeatureId[];
|
|
1937
|
+
}[];
|
|
1938
|
+
} | null;
|
|
1939
|
+
activeFeatureId: import("../domain/session.js").FeatureId | null;
|
|
1940
|
+
history: {
|
|
1941
|
+
featureId: import("../domain/session.js").FeatureId;
|
|
1942
|
+
status: "blocked" | "completed" | "needs_input";
|
|
1943
|
+
summary: string;
|
|
1944
|
+
recordedAt: string;
|
|
1945
|
+
artifactsChanged: {
|
|
1946
|
+
path: string;
|
|
1947
|
+
}[];
|
|
1948
|
+
validationRun: {
|
|
1949
|
+
command: string;
|
|
1950
|
+
status: "failed" | "passed";
|
|
1951
|
+
summary: string;
|
|
1952
|
+
}[];
|
|
1953
|
+
validationScope?: "broad" | "targeted" | undefined;
|
|
1954
|
+
featureReviewDepth?: "detailed" | "quick" | "standard" | undefined;
|
|
1955
|
+
featureReview?: {
|
|
1956
|
+
status: "failed" | "passed";
|
|
1957
|
+
summary: string;
|
|
1958
|
+
blockingFindings: {
|
|
1959
|
+
summary: string;
|
|
1960
|
+
severity: "advisory" | "blocking";
|
|
1961
|
+
}[];
|
|
1962
|
+
} | undefined;
|
|
1963
|
+
finalReview?: {
|
|
1964
|
+
status: "failed" | "passed";
|
|
1965
|
+
summary: string;
|
|
1966
|
+
blockingFindings: {
|
|
1967
|
+
summary: string;
|
|
1968
|
+
severity: "advisory" | "blocking";
|
|
1969
|
+
}[];
|
|
1970
|
+
reviewDepth: "broad" | "detailed";
|
|
1971
|
+
} | undefined;
|
|
1972
|
+
outcome?: {
|
|
1973
|
+
kind: "completed";
|
|
1974
|
+
summary?: string | undefined;
|
|
1975
|
+
resolutionHint?: string | undefined;
|
|
1976
|
+
} | {
|
|
1977
|
+
kind: "blocked" | "needs_input" | "replan_required";
|
|
1978
|
+
summary: string;
|
|
1979
|
+
resolutionHint?: string | undefined;
|
|
1980
|
+
} | undefined;
|
|
1981
|
+
orchestrationPasses: {
|
|
1982
|
+
id: string;
|
|
1983
|
+
kind: "audit" | "candidate" | "discovery" | "implementation-decision" | "review" | "validation" | "verification";
|
|
1984
|
+
decision?: "candidate-exact-path" | "candidate-worktree" | "parallel" | "serial" | "skipped" | "tournament" | undefined;
|
|
1985
|
+
decisionReason?: string | undefined;
|
|
1986
|
+
candidateEligibility: "eligible" | "not_eligible" | "unknown";
|
|
1987
|
+
candidateDecision?: "serial_required" | "skipped" | "used" | undefined;
|
|
1988
|
+
decisionFactors: ("independent_surface" | "needs_manager_judgment" | "overlapping_files" | "shared_state" | "small_slice" | "validation_available")[];
|
|
1989
|
+
modes: ("audit" | "candidate-implementation" | "evidence" | "review" | "validation" | "verifier")[];
|
|
1990
|
+
workerCount: number;
|
|
1991
|
+
candidateWorkerCount: number;
|
|
1992
|
+
verifierWorkerCount: number;
|
|
1993
|
+
sliceIds: string[];
|
|
1994
|
+
dependsOn: string[];
|
|
1995
|
+
writeScope: "exact-path" | "isolated-worktree" | "manager-serial" | "mixed" | "none";
|
|
1996
|
+
handoffRefs: string[];
|
|
1997
|
+
verificationStatus: "downgraded" | "failed" | "mixed" | "not-needed" | "passed" | "pending";
|
|
1998
|
+
outcome: "accepted" | "modified" | "not-covered" | "partial" | "rejected" | "superseded";
|
|
1999
|
+
synthesisRef?: string | undefined;
|
|
2000
|
+
}[];
|
|
2001
|
+
}[];
|
|
2002
|
+
budget: {
|
|
2003
|
+
reviewCount: number;
|
|
2004
|
+
failedReviewCount: number;
|
|
2005
|
+
failedReviewAttemptsByFeature: Record<string, number>;
|
|
2006
|
+
reviewExecutions: {
|
|
2007
|
+
attemptId: string;
|
|
2008
|
+
logicalPassId: string;
|
|
2009
|
+
featureId: import("../domain/session.js").FeatureId;
|
|
2010
|
+
reviewKind: "feature" | "final";
|
|
2011
|
+
reviewSnapshotId: `sha256:${string}`;
|
|
2012
|
+
verdict: "failed" | "passed";
|
|
2013
|
+
startedAt: string;
|
|
2014
|
+
completedAt: string;
|
|
2015
|
+
terminalDisposition: "observed_unsubmitted" | "submitted";
|
|
2016
|
+
findings: {
|
|
2017
|
+
taxonomy: "advisory" | "evidence_gap" | "implementation_defect" | "regression_coverage_gap";
|
|
2018
|
+
subject: string;
|
|
2019
|
+
requirementOrRisk: string;
|
|
2020
|
+
evidenceLocator: string;
|
|
2021
|
+
summary: string;
|
|
2022
|
+
severity: "advisory" | "blocking";
|
|
2023
|
+
fingerprint: string;
|
|
2024
|
+
}[];
|
|
2025
|
+
}[];
|
|
2026
|
+
reviewLifecycle: {
|
|
2027
|
+
featureAttemptCount: number;
|
|
2028
|
+
finalAttemptCount: number;
|
|
2029
|
+
passedVerdictCount: number;
|
|
2030
|
+
failedVerdictCount: number;
|
|
2031
|
+
retryConsumedCount: number;
|
|
2032
|
+
};
|
|
2033
|
+
observedReviewWorkers: {
|
|
2034
|
+
source: "unavailable";
|
|
2035
|
+
reconciliationStatus: "unreconciled";
|
|
2036
|
+
observedExecutionCount: null;
|
|
2037
|
+
} | {
|
|
2038
|
+
source: "host_observed";
|
|
2039
|
+
reconciliationStatus: "reconciled";
|
|
2040
|
+
observedExecutionCount: number;
|
|
2041
|
+
};
|
|
2042
|
+
orchestration: {
|
|
2043
|
+
passCount: number;
|
|
2044
|
+
workerCount: number;
|
|
2045
|
+
candidatePassCount: number;
|
|
2046
|
+
verifierPassCount: number;
|
|
2047
|
+
candidateEligibleCount: number;
|
|
2048
|
+
candidateUsedDecisionCount: number;
|
|
2049
|
+
candidateSerialRequiredDecisionCount: number;
|
|
2050
|
+
skippedCandidateDecisionCount: number;
|
|
2051
|
+
latestPasses: {
|
|
2052
|
+
id: string;
|
|
2053
|
+
kind: "audit" | "candidate" | "discovery" | "implementation-decision" | "review" | "validation" | "verification";
|
|
2054
|
+
decision?: "candidate-exact-path" | "candidate-worktree" | "parallel" | "serial" | "skipped" | "tournament" | undefined;
|
|
2055
|
+
decisionReason?: string | undefined;
|
|
2056
|
+
candidateEligibility: "eligible" | "not_eligible" | "unknown";
|
|
2057
|
+
candidateDecision?: "serial_required" | "skipped" | "used" | undefined;
|
|
2058
|
+
decisionFactors: ("independent_surface" | "needs_manager_judgment" | "overlapping_files" | "shared_state" | "small_slice" | "validation_available")[];
|
|
2059
|
+
modes: ("audit" | "candidate-implementation" | "evidence" | "review" | "validation" | "verifier")[];
|
|
2060
|
+
workerCount: number;
|
|
2061
|
+
candidateWorkerCount: number;
|
|
2062
|
+
verifierWorkerCount: number;
|
|
2063
|
+
sliceIds: string[];
|
|
2064
|
+
dependsOn: string[];
|
|
2065
|
+
writeScope: "exact-path" | "isolated-worktree" | "manager-serial" | "mixed" | "none";
|
|
2066
|
+
handoffRefs: string[];
|
|
2067
|
+
verificationStatus: "downgraded" | "failed" | "mixed" | "not-needed" | "passed" | "pending";
|
|
2068
|
+
outcome: "accepted" | "modified" | "not-covered" | "partial" | "rejected" | "superseded";
|
|
2069
|
+
synthesisRef?: string | undefined;
|
|
2070
|
+
}[];
|
|
2071
|
+
};
|
|
2072
|
+
};
|
|
2073
|
+
causal?: {
|
|
2074
|
+
revision: number;
|
|
2075
|
+
genesisSnapshotId: `sha256:${string}`;
|
|
2076
|
+
snapshotId: `sha256:${string}`;
|
|
2077
|
+
mutations: {
|
|
2078
|
+
operationId: string;
|
|
2079
|
+
operationKind: "evidence_record" | "feature_complete" | "feature_reset" | "plan_approve" | "plan_save" | "review_record" | "run_start" | "session_close";
|
|
2080
|
+
requestDigest: `sha256:${string}`;
|
|
2081
|
+
priorMutationDigest: `sha256:${string}` | null;
|
|
2082
|
+
mutationDigest: `sha256:${string}`;
|
|
2083
|
+
priorRevision: number;
|
|
2084
|
+
revision: number;
|
|
2085
|
+
priorSnapshotId: `sha256:${string}`;
|
|
2086
|
+
currentSnapshotId: `sha256:${string}`;
|
|
2087
|
+
changedEntity: {
|
|
2088
|
+
kind: "closure" | "evidence" | "feature" | "plan" | "review" | "session";
|
|
2089
|
+
id: string;
|
|
2090
|
+
};
|
|
2091
|
+
changedFields: string[];
|
|
2092
|
+
blockerDelta: {
|
|
2093
|
+
added: string[];
|
|
2094
|
+
removed: string[];
|
|
2095
|
+
};
|
|
2096
|
+
evidenceRefs: `sha256:${string}`[];
|
|
2097
|
+
recordedAt: string;
|
|
2098
|
+
}[];
|
|
2099
|
+
evidence: ({
|
|
2100
|
+
evidenceId: `sha256:${string}`;
|
|
2101
|
+
snapshotId: `sha256:${string}`;
|
|
2102
|
+
sourceDigest: `sha256:${string}`;
|
|
2103
|
+
startedAt: string;
|
|
2104
|
+
completedAt: string;
|
|
2105
|
+
commandClass: "build" | "format" | "lint" | "other" | "smoke" | "test" | "typecheck";
|
|
2106
|
+
exitCode: number;
|
|
2107
|
+
outputDigest: `sha256:${string}`;
|
|
2108
|
+
artifactRef?: {
|
|
2109
|
+
kind: "restricted_evidence_v1";
|
|
2110
|
+
digest: `sha256:${string}`;
|
|
2111
|
+
byteLength: number;
|
|
2112
|
+
} | undefined;
|
|
2113
|
+
environmentKeys: string[];
|
|
2114
|
+
kind: "validation";
|
|
2115
|
+
} | {
|
|
2116
|
+
evidenceId: `sha256:${string}`;
|
|
2117
|
+
snapshotId: `sha256:${string}`;
|
|
2118
|
+
sourceDigest: `sha256:${string}`;
|
|
2119
|
+
startedAt: string;
|
|
2120
|
+
completedAt: string;
|
|
2121
|
+
kind: "review";
|
|
2122
|
+
attemptId: string;
|
|
2123
|
+
packetDigest: `sha256:${string}`;
|
|
2124
|
+
})[];
|
|
2125
|
+
} | undefined;
|
|
2126
|
+
closure: {
|
|
2127
|
+
kind: "abandoned" | "completed" | "deferred";
|
|
2128
|
+
summary: string;
|
|
2129
|
+
recordedAt: string;
|
|
2130
|
+
} | null;
|
|
2131
|
+
lastError: {
|
|
2132
|
+
tool: string;
|
|
2133
|
+
summary: string;
|
|
2134
|
+
recovery?: string | undefined;
|
|
2135
|
+
recordedAt: string;
|
|
2136
|
+
} | null;
|
|
2137
|
+
timestamps: {
|
|
2138
|
+
createdAt: string;
|
|
2139
|
+
updatedAt: string;
|
|
2140
|
+
completedAt: string | null;
|
|
2141
|
+
};
|
|
2142
|
+
}>>;
|
|
2143
|
+
export type { Artifact, BudgetTelemetry, CausalMutationRecord, CausalState, EvidenceId, EvidenceRecord, ExecutionHistoryEntry, Feature, FeatureReviewDepth, FinalReview, ObservedReviewWorkerLedger, OrchestrationPassRecord, OrchestrationTelemetry, Plan, PlanInput, Review, ReviewExecution, ReviewExecutionFinding, ReviewExecutionFindingInput, ReviewExecutionInput, ReviewFindingTaxonomy, ReviewLifecycleTelemetry, Session, SnapshotId, ValidationRun, WorkerResult, } from "../domain/session.js";
|