@claude-flow/cli 3.66.2 → 3.67.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/.claude/helpers/helpers.manifest.json +2 -2
- package/catalog-manifest.json +2 -2
- package/dist/src/init/executor.js +1 -1
- package/dist/src/mcp-tools/neural-tools.js +3 -1
- package/dist/src/missions/schemas.d.ts +134 -134
- package/dist/src/mods/command-registry/schema.d.ts +189 -189
- package/dist/src/services/agentic-flow-bridge.d.ts +1 -1
- package/dist/src/update/validator.js +1 -1
- package/node_modules/@claude-flow/security/dist/input-validator.d.ts +6 -6
- package/package.json +6 -6
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"manifest": {
|
|
3
|
-
"version": "3.
|
|
3
|
+
"version": "3.67.0",
|
|
4
4
|
"files": {
|
|
5
5
|
"auto-memory-hook.mjs": "631fac9d518835e2852a406888316bbbddddb49e7ed8e406d2e971f46833df9a",
|
|
6
6
|
"hook-handler.cjs": "0ce70981aa33f76d008b6f49626effaf4269918c4094f1a28c1ef6fceb097d6f",
|
|
@@ -10,6 +10,6 @@
|
|
|
10
10
|
"learning-loop.cjs": "d046cd6f8efb7dd40e1d2451516c181fc8b26477aefb1124c0df5f52a23f9190"
|
|
11
11
|
}
|
|
12
12
|
},
|
|
13
|
-
"signature": "
|
|
13
|
+
"signature": "K7VOlVlBCGMfFbUTVD77kLjnIA0OKGle8ZhkT3d1i769qh/XiZoF2jjUVl6eslNO9h4vktNyimRR9pHk1SMDAQ==",
|
|
14
14
|
"algorithm": "ed25519"
|
|
15
15
|
}
|
package/catalog-manifest.json
CHANGED
|
@@ -2022,7 +2022,7 @@ npx @claude-flow/cli@latest hive-mind consensus --propose "task"
|
|
|
2022
2022
|
### Integrated Packages
|
|
2023
2023
|
| Package | Version | Purpose |
|
|
2024
2024
|
|---------|---------|---------|
|
|
2025
|
-
| agentic-flow | 3.0.0
|
|
2025
|
+
| agentic-flow | 3.0.0 | Core coordination + ReasoningBank + Router |
|
|
2026
2026
|
| agentdb | 3.0.0-alpha.10 | Vector database + 8 controllers |
|
|
2027
2027
|
| @ruvector/attention | 0.1.3 | Flash attention |
|
|
2028
2028
|
| @ruvector/sona | 0.1.5 | Neural learning |
|
|
@@ -145,7 +145,9 @@ function ensureEmbeddings() {
|
|
|
145
145
|
if (!realEmbeddings) {
|
|
146
146
|
const rb = await import('agentic-flow/reasoningbank').catch(() => null);
|
|
147
147
|
if (rb?.computeEmbedding) {
|
|
148
|
-
|
|
148
|
+
// computeEmbedding returns a Float32Array; JSON.stringify writes that as
|
|
149
|
+
// {"0":…,"1":…}, so convert before it reaches the neural store.
|
|
150
|
+
realEmbeddings = { embed: async (text) => Array.from(await rb.computeEmbedding(text)) };
|
|
149
151
|
embeddingServiceName = 'agentic-flow/reasoningbank';
|
|
150
152
|
}
|
|
151
153
|
}
|
|
@@ -45,12 +45,12 @@ export declare const missionRecordSchema: z.ZodObject<{
|
|
|
45
45
|
digest: z.ZodString;
|
|
46
46
|
taskGraphRef: z.ZodString;
|
|
47
47
|
}, "strict", z.ZodTypeAny, {
|
|
48
|
-
revision: number;
|
|
49
48
|
digest: string;
|
|
49
|
+
revision: number;
|
|
50
50
|
taskGraphRef: string;
|
|
51
51
|
}, {
|
|
52
|
-
revision: number;
|
|
53
52
|
digest: string;
|
|
53
|
+
revision: number;
|
|
54
54
|
taskGraphRef: string;
|
|
55
55
|
}>;
|
|
56
56
|
policyRef: z.ZodString;
|
|
@@ -73,56 +73,56 @@ export declare const missionRecordSchema: z.ZodObject<{
|
|
|
73
73
|
createdAt: z.ZodString;
|
|
74
74
|
updatedAt: z.ZodString;
|
|
75
75
|
}, "strict", z.ZodTypeAny, {
|
|
76
|
-
|
|
76
|
+
createdAt: string;
|
|
77
|
+
updatedAt: string;
|
|
77
78
|
schemaVersion: 1;
|
|
79
|
+
state: "completed" | "cancelled" | "failed" | "blocked" | "running" | "paused" | "queued" | "draft" | "planned" | "awaitingAuthorization" | "pauseRequested" | "verifying" | "cancelRequested";
|
|
80
|
+
acceptance: {
|
|
81
|
+
revision: number;
|
|
82
|
+
criteriaDigest: string;
|
|
83
|
+
};
|
|
84
|
+
plan: {
|
|
85
|
+
digest: string;
|
|
86
|
+
revision: number;
|
|
87
|
+
taskGraphRef: string;
|
|
88
|
+
};
|
|
89
|
+
objective: string;
|
|
78
90
|
missionId: string;
|
|
79
91
|
tenantId: string;
|
|
80
92
|
workspaceId: string;
|
|
81
93
|
ownerPrincipalId: string;
|
|
82
94
|
revision: number;
|
|
83
|
-
plan: {
|
|
84
|
-
revision: number;
|
|
85
|
-
digest: string;
|
|
86
|
-
taskGraphRef: string;
|
|
87
|
-
};
|
|
88
95
|
policyRef: string;
|
|
89
96
|
budgetRef: string;
|
|
90
97
|
executionMode: "durable-executor" | "session-bound";
|
|
91
|
-
state: "draft" | "planned" | "awaitingAuthorization" | "queued" | "running" | "pauseRequested" | "paused" | "blocked" | "verifying" | "completed" | "failed" | "cancelRequested" | "cancelled";
|
|
92
98
|
evidenceRefs: string[];
|
|
99
|
+
lastEventSequence: number;
|
|
100
|
+
authorizationRef?: string | undefined;
|
|
101
|
+
}, {
|
|
102
|
+
createdAt: string;
|
|
103
|
+
updatedAt: string;
|
|
104
|
+
schemaVersion: 1;
|
|
105
|
+
state: "completed" | "cancelled" | "failed" | "blocked" | "running" | "paused" | "queued" | "draft" | "planned" | "awaitingAuthorization" | "pauseRequested" | "verifying" | "cancelRequested";
|
|
93
106
|
acceptance: {
|
|
94
107
|
revision: number;
|
|
95
108
|
criteriaDigest: string;
|
|
96
109
|
};
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
}
|
|
110
|
+
plan: {
|
|
111
|
+
digest: string;
|
|
112
|
+
revision: number;
|
|
113
|
+
taskGraphRef: string;
|
|
114
|
+
};
|
|
102
115
|
objective: string;
|
|
103
|
-
schemaVersion: 1;
|
|
104
116
|
missionId: string;
|
|
105
117
|
tenantId: string;
|
|
106
118
|
workspaceId: string;
|
|
107
119
|
ownerPrincipalId: string;
|
|
108
120
|
revision: number;
|
|
109
|
-
plan: {
|
|
110
|
-
revision: number;
|
|
111
|
-
digest: string;
|
|
112
|
-
taskGraphRef: string;
|
|
113
|
-
};
|
|
114
121
|
policyRef: string;
|
|
115
122
|
budgetRef: string;
|
|
116
123
|
executionMode: "durable-executor" | "session-bound";
|
|
117
|
-
state: "draft" | "planned" | "awaitingAuthorization" | "queued" | "running" | "pauseRequested" | "paused" | "blocked" | "verifying" | "completed" | "failed" | "cancelRequested" | "cancelled";
|
|
118
124
|
evidenceRefs: string[];
|
|
119
|
-
acceptance: {
|
|
120
|
-
revision: number;
|
|
121
|
-
criteriaDigest: string;
|
|
122
|
-
};
|
|
123
125
|
lastEventSequence: number;
|
|
124
|
-
createdAt: string;
|
|
125
|
-
updatedAt: string;
|
|
126
126
|
authorizationRef?: string | undefined;
|
|
127
127
|
}>;
|
|
128
128
|
export type MissionRecord = z.infer<typeof missionRecordSchema>;
|
|
@@ -145,8 +145,8 @@ export declare const taskSpecSchema: z.ZodObject<{
|
|
|
145
145
|
checkpoint: z.ZodOptional<z.ZodString>;
|
|
146
146
|
acceptanceEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
|
|
147
147
|
}, "strict", z.ZodTypeAny, {
|
|
148
|
-
title: string;
|
|
149
148
|
id: string;
|
|
149
|
+
title: string;
|
|
150
150
|
dependsOn: string[];
|
|
151
151
|
executor: {
|
|
152
152
|
mode: "durable-executor" | "session-bound";
|
|
@@ -157,16 +157,16 @@ export declare const taskSpecSchema: z.ZodObject<{
|
|
|
157
157
|
acceptanceEvidence: string[];
|
|
158
158
|
checkpoint?: string | undefined;
|
|
159
159
|
}, {
|
|
160
|
-
title: string;
|
|
161
160
|
id: string;
|
|
161
|
+
title: string;
|
|
162
162
|
executor: {
|
|
163
163
|
mode: "durable-executor" | "session-bound";
|
|
164
164
|
requirement: string;
|
|
165
165
|
};
|
|
166
|
+
checkpoint?: string | undefined;
|
|
166
167
|
dependsOn?: string[] | undefined;
|
|
167
168
|
capabilityCeiling?: string[] | undefined;
|
|
168
169
|
estimatedCostMinor?: number | undefined;
|
|
169
|
-
checkpoint?: string | undefined;
|
|
170
170
|
acceptanceEvidence?: string[] | undefined;
|
|
171
171
|
}>;
|
|
172
172
|
export declare const acceptanceCriterionSchema: z.ZodObject<{
|
|
@@ -185,15 +185,15 @@ export declare const acceptanceCriterionSchema: z.ZodObject<{
|
|
|
185
185
|
producer: string;
|
|
186
186
|
independent: boolean;
|
|
187
187
|
mandatory: boolean;
|
|
188
|
-
baseline?: string | undefined;
|
|
189
188
|
threshold?: string | undefined;
|
|
189
|
+
baseline?: string | undefined;
|
|
190
190
|
}, {
|
|
191
191
|
id: string;
|
|
192
192
|
check: string;
|
|
193
193
|
producer: string;
|
|
194
|
-
inputs?: string[] | undefined;
|
|
195
|
-
baseline?: string | undefined;
|
|
196
194
|
threshold?: string | undefined;
|
|
195
|
+
baseline?: string | undefined;
|
|
196
|
+
inputs?: string[] | undefined;
|
|
197
197
|
independent?: boolean | undefined;
|
|
198
198
|
mandatory?: boolean | undefined;
|
|
199
199
|
}>;
|
|
@@ -207,16 +207,16 @@ export declare const budgetSpecSchema: z.ZodObject<{
|
|
|
207
207
|
}, "strict", z.ZodTypeAny, {
|
|
208
208
|
currency: string;
|
|
209
209
|
ceilingMinor: number;
|
|
210
|
+
concurrency?: number | undefined;
|
|
210
211
|
tokens?: number | undefined;
|
|
211
212
|
wallTimeSeconds?: number | undefined;
|
|
212
|
-
concurrency?: number | undefined;
|
|
213
213
|
retries?: number | undefined;
|
|
214
214
|
}, {
|
|
215
215
|
currency: string;
|
|
216
216
|
ceilingMinor: number;
|
|
217
|
+
concurrency?: number | undefined;
|
|
217
218
|
tokens?: number | undefined;
|
|
218
219
|
wallTimeSeconds?: number | undefined;
|
|
219
|
-
concurrency?: number | undefined;
|
|
220
220
|
retries?: number | undefined;
|
|
221
221
|
}>;
|
|
222
222
|
export declare const planBodySchema: z.ZodObject<{
|
|
@@ -239,8 +239,8 @@ export declare const planBodySchema: z.ZodObject<{
|
|
|
239
239
|
checkpoint: z.ZodOptional<z.ZodString>;
|
|
240
240
|
acceptanceEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
|
|
241
241
|
}, "strict", z.ZodTypeAny, {
|
|
242
|
-
title: string;
|
|
243
242
|
id: string;
|
|
243
|
+
title: string;
|
|
244
244
|
dependsOn: string[];
|
|
245
245
|
executor: {
|
|
246
246
|
mode: "durable-executor" | "session-bound";
|
|
@@ -251,16 +251,16 @@ export declare const planBodySchema: z.ZodObject<{
|
|
|
251
251
|
acceptanceEvidence: string[];
|
|
252
252
|
checkpoint?: string | undefined;
|
|
253
253
|
}, {
|
|
254
|
-
title: string;
|
|
255
254
|
id: string;
|
|
255
|
+
title: string;
|
|
256
256
|
executor: {
|
|
257
257
|
mode: "durable-executor" | "session-bound";
|
|
258
258
|
requirement: string;
|
|
259
259
|
};
|
|
260
|
+
checkpoint?: string | undefined;
|
|
260
261
|
dependsOn?: string[] | undefined;
|
|
261
262
|
capabilityCeiling?: string[] | undefined;
|
|
262
263
|
estimatedCostMinor?: number | undefined;
|
|
263
|
-
checkpoint?: string | undefined;
|
|
264
264
|
acceptanceEvidence?: string[] | undefined;
|
|
265
265
|
}>, "many">;
|
|
266
266
|
acceptance: z.ZodArray<z.ZodObject<{
|
|
@@ -279,15 +279,15 @@ export declare const planBodySchema: z.ZodObject<{
|
|
|
279
279
|
producer: string;
|
|
280
280
|
independent: boolean;
|
|
281
281
|
mandatory: boolean;
|
|
282
|
-
baseline?: string | undefined;
|
|
283
282
|
threshold?: string | undefined;
|
|
283
|
+
baseline?: string | undefined;
|
|
284
284
|
}, {
|
|
285
285
|
id: string;
|
|
286
286
|
check: string;
|
|
287
287
|
producer: string;
|
|
288
|
-
inputs?: string[] | undefined;
|
|
289
|
-
baseline?: string | undefined;
|
|
290
288
|
threshold?: string | undefined;
|
|
289
|
+
baseline?: string | undefined;
|
|
290
|
+
inputs?: string[] | undefined;
|
|
291
291
|
independent?: boolean | undefined;
|
|
292
292
|
mandatory?: boolean | undefined;
|
|
293
293
|
}>, "many">;
|
|
@@ -301,16 +301,16 @@ export declare const planBodySchema: z.ZodObject<{
|
|
|
301
301
|
}, "strict", z.ZodTypeAny, {
|
|
302
302
|
currency: string;
|
|
303
303
|
ceilingMinor: number;
|
|
304
|
+
concurrency?: number | undefined;
|
|
304
305
|
tokens?: number | undefined;
|
|
305
306
|
wallTimeSeconds?: number | undefined;
|
|
306
|
-
concurrency?: number | undefined;
|
|
307
307
|
retries?: number | undefined;
|
|
308
308
|
}, {
|
|
309
309
|
currency: string;
|
|
310
310
|
ceilingMinor: number;
|
|
311
|
+
concurrency?: number | undefined;
|
|
311
312
|
tokens?: number | undefined;
|
|
312
313
|
wallTimeSeconds?: number | undefined;
|
|
313
|
-
concurrency?: number | undefined;
|
|
314
314
|
retries?: number | undefined;
|
|
315
315
|
}>;
|
|
316
316
|
scope: z.ZodDefault<z.ZodObject<{
|
|
@@ -322,8 +322,8 @@ export declare const planBodySchema: z.ZodObject<{
|
|
|
322
322
|
}>>;
|
|
323
323
|
}, "strict", z.ZodTypeAny, {
|
|
324
324
|
tasks: {
|
|
325
|
-
title: string;
|
|
326
325
|
id: string;
|
|
326
|
+
title: string;
|
|
327
327
|
dependsOn: string[];
|
|
328
328
|
executor: {
|
|
329
329
|
mode: "durable-executor" | "session-bound";
|
|
@@ -334,6 +334,17 @@ export declare const planBodySchema: z.ZodObject<{
|
|
|
334
334
|
acceptanceEvidence: string[];
|
|
335
335
|
checkpoint?: string | undefined;
|
|
336
336
|
}[];
|
|
337
|
+
scope: {
|
|
338
|
+
capabilities: string[];
|
|
339
|
+
};
|
|
340
|
+
budget: {
|
|
341
|
+
currency: string;
|
|
342
|
+
ceilingMinor: number;
|
|
343
|
+
concurrency?: number | undefined;
|
|
344
|
+
tokens?: number | undefined;
|
|
345
|
+
wallTimeSeconds?: number | undefined;
|
|
346
|
+
retries?: number | undefined;
|
|
347
|
+
};
|
|
337
348
|
acceptance: {
|
|
338
349
|
id: string;
|
|
339
350
|
check: string;
|
|
@@ -341,52 +352,41 @@ export declare const planBodySchema: z.ZodObject<{
|
|
|
341
352
|
producer: string;
|
|
342
353
|
independent: boolean;
|
|
343
354
|
mandatory: boolean;
|
|
344
|
-
baseline?: string | undefined;
|
|
345
355
|
threshold?: string | undefined;
|
|
356
|
+
baseline?: string | undefined;
|
|
346
357
|
}[];
|
|
347
|
-
budget: {
|
|
348
|
-
currency: string;
|
|
349
|
-
ceilingMinor: number;
|
|
350
|
-
tokens?: number | undefined;
|
|
351
|
-
wallTimeSeconds?: number | undefined;
|
|
352
|
-
concurrency?: number | undefined;
|
|
353
|
-
retries?: number | undefined;
|
|
354
|
-
};
|
|
355
|
-
scope: {
|
|
356
|
-
capabilities: string[];
|
|
357
|
-
};
|
|
358
358
|
}, {
|
|
359
359
|
tasks: {
|
|
360
|
-
title: string;
|
|
361
360
|
id: string;
|
|
361
|
+
title: string;
|
|
362
362
|
executor: {
|
|
363
363
|
mode: "durable-executor" | "session-bound";
|
|
364
364
|
requirement: string;
|
|
365
365
|
};
|
|
366
|
+
checkpoint?: string | undefined;
|
|
366
367
|
dependsOn?: string[] | undefined;
|
|
367
368
|
capabilityCeiling?: string[] | undefined;
|
|
368
369
|
estimatedCostMinor?: number | undefined;
|
|
369
|
-
checkpoint?: string | undefined;
|
|
370
370
|
acceptanceEvidence?: string[] | undefined;
|
|
371
371
|
}[];
|
|
372
|
+
budget: {
|
|
373
|
+
currency: string;
|
|
374
|
+
ceilingMinor: number;
|
|
375
|
+
concurrency?: number | undefined;
|
|
376
|
+
tokens?: number | undefined;
|
|
377
|
+
wallTimeSeconds?: number | undefined;
|
|
378
|
+
retries?: number | undefined;
|
|
379
|
+
};
|
|
372
380
|
acceptance: {
|
|
373
381
|
id: string;
|
|
374
382
|
check: string;
|
|
375
383
|
producer: string;
|
|
376
|
-
inputs?: string[] | undefined;
|
|
377
|
-
baseline?: string | undefined;
|
|
378
384
|
threshold?: string | undefined;
|
|
385
|
+
baseline?: string | undefined;
|
|
386
|
+
inputs?: string[] | undefined;
|
|
379
387
|
independent?: boolean | undefined;
|
|
380
388
|
mandatory?: boolean | undefined;
|
|
381
389
|
}[];
|
|
382
|
-
budget: {
|
|
383
|
-
currency: string;
|
|
384
|
-
ceilingMinor: number;
|
|
385
|
-
tokens?: number | undefined;
|
|
386
|
-
wallTimeSeconds?: number | undefined;
|
|
387
|
-
concurrency?: number | undefined;
|
|
388
|
-
retries?: number | undefined;
|
|
389
|
-
};
|
|
390
390
|
scope?: {
|
|
391
391
|
capabilities?: string[] | undefined;
|
|
392
392
|
} | undefined;
|
|
@@ -397,11 +397,11 @@ export declare const createInputSchema: z.ZodObject<{
|
|
|
397
397
|
requestId: z.ZodString;
|
|
398
398
|
objective: z.ZodString;
|
|
399
399
|
}, "strict", z.ZodTypeAny, {
|
|
400
|
-
objective: string;
|
|
401
400
|
requestId: string;
|
|
402
|
-
}, {
|
|
403
401
|
objective: string;
|
|
402
|
+
}, {
|
|
404
403
|
requestId: string;
|
|
404
|
+
objective: string;
|
|
405
405
|
}>;
|
|
406
406
|
export declare const planInputSchema: z.ZodObject<{
|
|
407
407
|
requestId: z.ZodString;
|
|
@@ -427,8 +427,8 @@ export declare const planInputSchema: z.ZodObject<{
|
|
|
427
427
|
checkpoint: z.ZodOptional<z.ZodString>;
|
|
428
428
|
acceptanceEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
|
|
429
429
|
}, "strict", z.ZodTypeAny, {
|
|
430
|
-
title: string;
|
|
431
430
|
id: string;
|
|
431
|
+
title: string;
|
|
432
432
|
dependsOn: string[];
|
|
433
433
|
executor: {
|
|
434
434
|
mode: "durable-executor" | "session-bound";
|
|
@@ -439,16 +439,16 @@ export declare const planInputSchema: z.ZodObject<{
|
|
|
439
439
|
acceptanceEvidence: string[];
|
|
440
440
|
checkpoint?: string | undefined;
|
|
441
441
|
}, {
|
|
442
|
-
title: string;
|
|
443
442
|
id: string;
|
|
443
|
+
title: string;
|
|
444
444
|
executor: {
|
|
445
445
|
mode: "durable-executor" | "session-bound";
|
|
446
446
|
requirement: string;
|
|
447
447
|
};
|
|
448
|
+
checkpoint?: string | undefined;
|
|
448
449
|
dependsOn?: string[] | undefined;
|
|
449
450
|
capabilityCeiling?: string[] | undefined;
|
|
450
451
|
estimatedCostMinor?: number | undefined;
|
|
451
|
-
checkpoint?: string | undefined;
|
|
452
452
|
acceptanceEvidence?: string[] | undefined;
|
|
453
453
|
}>, "many">;
|
|
454
454
|
acceptance: z.ZodArray<z.ZodObject<{
|
|
@@ -467,15 +467,15 @@ export declare const planInputSchema: z.ZodObject<{
|
|
|
467
467
|
producer: string;
|
|
468
468
|
independent: boolean;
|
|
469
469
|
mandatory: boolean;
|
|
470
|
-
baseline?: string | undefined;
|
|
471
470
|
threshold?: string | undefined;
|
|
471
|
+
baseline?: string | undefined;
|
|
472
472
|
}, {
|
|
473
473
|
id: string;
|
|
474
474
|
check: string;
|
|
475
475
|
producer: string;
|
|
476
|
-
inputs?: string[] | undefined;
|
|
477
|
-
baseline?: string | undefined;
|
|
478
476
|
threshold?: string | undefined;
|
|
477
|
+
baseline?: string | undefined;
|
|
478
|
+
inputs?: string[] | undefined;
|
|
479
479
|
independent?: boolean | undefined;
|
|
480
480
|
mandatory?: boolean | undefined;
|
|
481
481
|
}>, "many">;
|
|
@@ -489,16 +489,16 @@ export declare const planInputSchema: z.ZodObject<{
|
|
|
489
489
|
}, "strict", z.ZodTypeAny, {
|
|
490
490
|
currency: string;
|
|
491
491
|
ceilingMinor: number;
|
|
492
|
+
concurrency?: number | undefined;
|
|
492
493
|
tokens?: number | undefined;
|
|
493
494
|
wallTimeSeconds?: number | undefined;
|
|
494
|
-
concurrency?: number | undefined;
|
|
495
495
|
retries?: number | undefined;
|
|
496
496
|
}, {
|
|
497
497
|
currency: string;
|
|
498
498
|
ceilingMinor: number;
|
|
499
|
+
concurrency?: number | undefined;
|
|
499
500
|
tokens?: number | undefined;
|
|
500
501
|
wallTimeSeconds?: number | undefined;
|
|
501
|
-
concurrency?: number | undefined;
|
|
502
502
|
retries?: number | undefined;
|
|
503
503
|
}>;
|
|
504
504
|
scope: z.ZodDefault<z.ZodObject<{
|
|
@@ -510,8 +510,8 @@ export declare const planInputSchema: z.ZodObject<{
|
|
|
510
510
|
}>>;
|
|
511
511
|
}, "strict", z.ZodTypeAny, {
|
|
512
512
|
tasks: {
|
|
513
|
-
title: string;
|
|
514
513
|
id: string;
|
|
514
|
+
title: string;
|
|
515
515
|
dependsOn: string[];
|
|
516
516
|
executor: {
|
|
517
517
|
mode: "durable-executor" | "session-bound";
|
|
@@ -522,6 +522,17 @@ export declare const planInputSchema: z.ZodObject<{
|
|
|
522
522
|
acceptanceEvidence: string[];
|
|
523
523
|
checkpoint?: string | undefined;
|
|
524
524
|
}[];
|
|
525
|
+
scope: {
|
|
526
|
+
capabilities: string[];
|
|
527
|
+
};
|
|
528
|
+
budget: {
|
|
529
|
+
currency: string;
|
|
530
|
+
ceilingMinor: number;
|
|
531
|
+
concurrency?: number | undefined;
|
|
532
|
+
tokens?: number | undefined;
|
|
533
|
+
wallTimeSeconds?: number | undefined;
|
|
534
|
+
retries?: number | undefined;
|
|
535
|
+
};
|
|
525
536
|
acceptance: {
|
|
526
537
|
id: string;
|
|
527
538
|
check: string;
|
|
@@ -529,63 +540,51 @@ export declare const planInputSchema: z.ZodObject<{
|
|
|
529
540
|
producer: string;
|
|
530
541
|
independent: boolean;
|
|
531
542
|
mandatory: boolean;
|
|
532
|
-
baseline?: string | undefined;
|
|
533
543
|
threshold?: string | undefined;
|
|
544
|
+
baseline?: string | undefined;
|
|
534
545
|
}[];
|
|
535
|
-
budget: {
|
|
536
|
-
currency: string;
|
|
537
|
-
ceilingMinor: number;
|
|
538
|
-
tokens?: number | undefined;
|
|
539
|
-
wallTimeSeconds?: number | undefined;
|
|
540
|
-
concurrency?: number | undefined;
|
|
541
|
-
retries?: number | undefined;
|
|
542
|
-
};
|
|
543
|
-
scope: {
|
|
544
|
-
capabilities: string[];
|
|
545
|
-
};
|
|
546
546
|
}, {
|
|
547
547
|
tasks: {
|
|
548
|
-
title: string;
|
|
549
548
|
id: string;
|
|
549
|
+
title: string;
|
|
550
550
|
executor: {
|
|
551
551
|
mode: "durable-executor" | "session-bound";
|
|
552
552
|
requirement: string;
|
|
553
553
|
};
|
|
554
|
+
checkpoint?: string | undefined;
|
|
554
555
|
dependsOn?: string[] | undefined;
|
|
555
556
|
capabilityCeiling?: string[] | undefined;
|
|
556
557
|
estimatedCostMinor?: number | undefined;
|
|
557
|
-
checkpoint?: string | undefined;
|
|
558
558
|
acceptanceEvidence?: string[] | undefined;
|
|
559
559
|
}[];
|
|
560
|
+
budget: {
|
|
561
|
+
currency: string;
|
|
562
|
+
ceilingMinor: number;
|
|
563
|
+
concurrency?: number | undefined;
|
|
564
|
+
tokens?: number | undefined;
|
|
565
|
+
wallTimeSeconds?: number | undefined;
|
|
566
|
+
retries?: number | undefined;
|
|
567
|
+
};
|
|
560
568
|
acceptance: {
|
|
561
569
|
id: string;
|
|
562
570
|
check: string;
|
|
563
571
|
producer: string;
|
|
564
|
-
inputs?: string[] | undefined;
|
|
565
|
-
baseline?: string | undefined;
|
|
566
572
|
threshold?: string | undefined;
|
|
573
|
+
baseline?: string | undefined;
|
|
574
|
+
inputs?: string[] | undefined;
|
|
567
575
|
independent?: boolean | undefined;
|
|
568
576
|
mandatory?: boolean | undefined;
|
|
569
577
|
}[];
|
|
570
|
-
budget: {
|
|
571
|
-
currency: string;
|
|
572
|
-
ceilingMinor: number;
|
|
573
|
-
tokens?: number | undefined;
|
|
574
|
-
wallTimeSeconds?: number | undefined;
|
|
575
|
-
concurrency?: number | undefined;
|
|
576
|
-
retries?: number | undefined;
|
|
577
|
-
};
|
|
578
578
|
scope?: {
|
|
579
579
|
capabilities?: string[] | undefined;
|
|
580
580
|
} | undefined;
|
|
581
581
|
}>;
|
|
582
582
|
}, "strict", z.ZodTypeAny, {
|
|
583
583
|
requestId: string;
|
|
584
|
-
missionId: string;
|
|
585
584
|
plan: {
|
|
586
585
|
tasks: {
|
|
587
|
-
title: string;
|
|
588
586
|
id: string;
|
|
587
|
+
title: string;
|
|
589
588
|
dependsOn: string[];
|
|
590
589
|
executor: {
|
|
591
590
|
mode: "durable-executor" | "session-bound";
|
|
@@ -596,6 +595,17 @@ export declare const planInputSchema: z.ZodObject<{
|
|
|
596
595
|
acceptanceEvidence: string[];
|
|
597
596
|
checkpoint?: string | undefined;
|
|
598
597
|
}[];
|
|
598
|
+
scope: {
|
|
599
|
+
capabilities: string[];
|
|
600
|
+
};
|
|
601
|
+
budget: {
|
|
602
|
+
currency: string;
|
|
603
|
+
ceilingMinor: number;
|
|
604
|
+
concurrency?: number | undefined;
|
|
605
|
+
tokens?: number | undefined;
|
|
606
|
+
wallTimeSeconds?: number | undefined;
|
|
607
|
+
retries?: number | undefined;
|
|
608
|
+
};
|
|
599
609
|
acceptance: {
|
|
600
610
|
id: string;
|
|
601
611
|
check: string;
|
|
@@ -603,61 +613,51 @@ export declare const planInputSchema: z.ZodObject<{
|
|
|
603
613
|
producer: string;
|
|
604
614
|
independent: boolean;
|
|
605
615
|
mandatory: boolean;
|
|
606
|
-
baseline?: string | undefined;
|
|
607
616
|
threshold?: string | undefined;
|
|
617
|
+
baseline?: string | undefined;
|
|
608
618
|
}[];
|
|
609
|
-
budget: {
|
|
610
|
-
currency: string;
|
|
611
|
-
ceilingMinor: number;
|
|
612
|
-
tokens?: number | undefined;
|
|
613
|
-
wallTimeSeconds?: number | undefined;
|
|
614
|
-
concurrency?: number | undefined;
|
|
615
|
-
retries?: number | undefined;
|
|
616
|
-
};
|
|
617
|
-
scope: {
|
|
618
|
-
capabilities: string[];
|
|
619
|
-
};
|
|
620
619
|
};
|
|
620
|
+
missionId: string;
|
|
621
621
|
expectedRevision: number;
|
|
622
622
|
}, {
|
|
623
623
|
requestId: string;
|
|
624
|
-
missionId: string;
|
|
625
624
|
plan: {
|
|
626
625
|
tasks: {
|
|
627
|
-
title: string;
|
|
628
626
|
id: string;
|
|
627
|
+
title: string;
|
|
629
628
|
executor: {
|
|
630
629
|
mode: "durable-executor" | "session-bound";
|
|
631
630
|
requirement: string;
|
|
632
631
|
};
|
|
632
|
+
checkpoint?: string | undefined;
|
|
633
633
|
dependsOn?: string[] | undefined;
|
|
634
634
|
capabilityCeiling?: string[] | undefined;
|
|
635
635
|
estimatedCostMinor?: number | undefined;
|
|
636
|
-
checkpoint?: string | undefined;
|
|
637
636
|
acceptanceEvidence?: string[] | undefined;
|
|
638
637
|
}[];
|
|
638
|
+
budget: {
|
|
639
|
+
currency: string;
|
|
640
|
+
ceilingMinor: number;
|
|
641
|
+
concurrency?: number | undefined;
|
|
642
|
+
tokens?: number | undefined;
|
|
643
|
+
wallTimeSeconds?: number | undefined;
|
|
644
|
+
retries?: number | undefined;
|
|
645
|
+
};
|
|
639
646
|
acceptance: {
|
|
640
647
|
id: string;
|
|
641
648
|
check: string;
|
|
642
649
|
producer: string;
|
|
643
|
-
inputs?: string[] | undefined;
|
|
644
|
-
baseline?: string | undefined;
|
|
645
650
|
threshold?: string | undefined;
|
|
651
|
+
baseline?: string | undefined;
|
|
652
|
+
inputs?: string[] | undefined;
|
|
646
653
|
independent?: boolean | undefined;
|
|
647
654
|
mandatory?: boolean | undefined;
|
|
648
655
|
}[];
|
|
649
|
-
budget: {
|
|
650
|
-
currency: string;
|
|
651
|
-
ceilingMinor: number;
|
|
652
|
-
tokens?: number | undefined;
|
|
653
|
-
wallTimeSeconds?: number | undefined;
|
|
654
|
-
concurrency?: number | undefined;
|
|
655
|
-
retries?: number | undefined;
|
|
656
|
-
};
|
|
657
656
|
scope?: {
|
|
658
657
|
capabilities?: string[] | undefined;
|
|
659
658
|
} | undefined;
|
|
660
659
|
};
|
|
660
|
+
missionId: string;
|
|
661
661
|
expectedRevision: number;
|
|
662
662
|
}>;
|
|
663
663
|
export declare const getInputSchema: z.ZodObject<{
|
|
@@ -672,13 +672,13 @@ export declare const eventsInputSchema: z.ZodObject<{
|
|
|
672
672
|
afterSequence: z.ZodDefault<z.ZodNumber>;
|
|
673
673
|
limit: z.ZodDefault<z.ZodNumber>;
|
|
674
674
|
}, "strict", z.ZodTypeAny, {
|
|
675
|
+
limit: number;
|
|
675
676
|
missionId: string;
|
|
676
677
|
afterSequence: number;
|
|
677
|
-
limit: number;
|
|
678
678
|
}, {
|
|
679
679
|
missionId: string;
|
|
680
|
-
afterSequence?: number | undefined;
|
|
681
680
|
limit?: number | undefined;
|
|
681
|
+
afterSequence?: number | undefined;
|
|
682
682
|
}>;
|
|
683
683
|
export declare const requestActionInputSchema: z.ZodObject<{
|
|
684
684
|
requestId: z.ZodString;
|
|
@@ -687,16 +687,16 @@ export declare const requestActionInputSchema: z.ZodObject<{
|
|
|
687
687
|
action: z.ZodEnum<["pause", "resume", "cancel", "requestAuthorization", "admit"]>;
|
|
688
688
|
reason: z.ZodOptional<z.ZodString>;
|
|
689
689
|
}, "strict", z.ZodTypeAny, {
|
|
690
|
+
action: "pause" | "resume" | "cancel" | "requestAuthorization" | "admit";
|
|
690
691
|
requestId: string;
|
|
691
692
|
missionId: string;
|
|
692
693
|
expectedRevision: number;
|
|
693
|
-
action: "pause" | "resume" | "cancel" | "requestAuthorization" | "admit";
|
|
694
694
|
reason?: string | undefined;
|
|
695
695
|
}, {
|
|
696
|
+
action: "pause" | "resume" | "cancel" | "requestAuthorization" | "admit";
|
|
696
697
|
requestId: string;
|
|
697
698
|
missionId: string;
|
|
698
699
|
expectedRevision: number;
|
|
699
|
-
action: "pause" | "resume" | "cancel" | "requestAuthorization" | "admit";
|
|
700
700
|
reason?: string | undefined;
|
|
701
701
|
}>;
|
|
702
702
|
export type CreateInput = z.infer<typeof createInputSchema>;
|