@claude-flow/cli 3.54.0 → 3.54.1
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 +3 -3
- package/.claude/helpers/hook-handler.cjs +65 -3
- package/catalog-manifest.json +2 -2
- package/dist/src/blocking-stdio.d.ts +11 -0
- package/dist/src/blocking-stdio.js +23 -0
- package/dist/src/commands/session.js +11 -37
- package/dist/src/index.js +3 -0
- package/dist/src/init/executor.js +1 -0
- package/dist/src/init/helpers-generator.js +65 -3
- package/dist/src/mcp-tools/agentdb-tools.js +13 -1
- package/dist/src/mcp-tools/hooks-tools.js +1 -1
- package/dist/src/mcp-tools/session-tools.js +4 -1
- package/dist/src/memory/graph-edge-writer.js +3 -2
- package/dist/src/memory/lucene-bm25.js +11 -19
- package/dist/src/memory/memory-bridge.d.ts +1 -0
- package/dist/src/memory/memory-bridge.js +14 -1
- package/dist/src/memory/memory-initializer.js +5 -4
- package/dist/src/memory/shared-sqlite.d.ts +7 -0
- package/dist/src/memory/shared-sqlite.js +45 -0
- package/dist/src/missions/schemas.d.ts +125 -125
- package/dist/src/mods/command-registry/schema.d.ts +199 -199
- package/dist/src/mods/probe.d.ts +7 -0
- package/dist/src/mods/probe.js +29 -1
- package/dist/src/production/monitoring.d.ts +2 -0
- package/dist/src/production/monitoring.js +8 -3
- package/dist/src/production/rate-limiter.js +8 -5
- package/dist/src/production/retry.js +2 -0
- package/dist/src/services/git-workspace-identity.js +20 -3
- package/dist/src/services/worker-queue.d.ts +1 -0
- package/dist/src/services/worker-queue.js +9 -1
- package/package.json +2 -2
|
@@ -0,0 +1,45 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* #3693 — one better-sqlite3 identity per process.
|
|
3
|
+
*
|
|
4
|
+
* AgentDB (via @claude-flow/memory) owns a live native handle on memory.db. If
|
|
5
|
+
* the CLI opens its own handle through a DIFFERENT installed copy of
|
|
6
|
+
* better-sqlite3 (a nested `agentdb/node_modules/better-sqlite3` next to a
|
|
7
|
+
* hoisted one is the common layout), the two copies each statically link their
|
|
8
|
+
* own SQLite and keep separate per-process file bookkeeping. Closing the CLI's
|
|
9
|
+
* handle (graph-edge idle release: wal_checkpoint(TRUNCATE) + close) then looks
|
|
10
|
+
* like "last connection" to that copy and deletes the -wal/-shm sidecars out
|
|
11
|
+
* from under AgentDB's still-open handle.
|
|
12
|
+
*
|
|
13
|
+
* Resolve the constructor from the same place AgentDB resolves it, so both
|
|
14
|
+
* share one SQLite instance (and its connection bookkeeping). Falls back to the
|
|
15
|
+
* CLI's own copy when agentdb cannot be resolved.
|
|
16
|
+
*/
|
|
17
|
+
import { createRequire } from 'node:module';
|
|
18
|
+
let cached;
|
|
19
|
+
/** Test seam: pass `from` to resolve relative to another entry file. */
|
|
20
|
+
export function resolveAgentdbBetterSqlite3(from) {
|
|
21
|
+
if (!from && cached !== undefined)
|
|
22
|
+
return cached;
|
|
23
|
+
let found = null;
|
|
24
|
+
try {
|
|
25
|
+
const own = createRequire(import.meta.url);
|
|
26
|
+
const agentdbEntry = from ?? own.resolve('agentdb');
|
|
27
|
+
const mod = createRequire(agentdbEntry)('better-sqlite3');
|
|
28
|
+
found = (mod?.default ?? mod);
|
|
29
|
+
}
|
|
30
|
+
catch {
|
|
31
|
+
found = null;
|
|
32
|
+
}
|
|
33
|
+
if (!from)
|
|
34
|
+
cached = found;
|
|
35
|
+
return found;
|
|
36
|
+
}
|
|
37
|
+
/** Constructor shared with AgentDB when possible, else the CLI's own copy. */
|
|
38
|
+
export async function loadBetterSqlite3() {
|
|
39
|
+
const shared = resolveAgentdbBetterSqlite3();
|
|
40
|
+
if (shared)
|
|
41
|
+
return shared;
|
|
42
|
+
const mod = 'better-sqlite3';
|
|
43
|
+
return (await import(mod)).default;
|
|
44
|
+
}
|
|
45
|
+
//# sourceMappingURL=shared-sqlite.js.map
|
|
@@ -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
|
-
createdAt: string;
|
|
77
|
-
updatedAt: string;
|
|
78
|
-
schemaVersion: 1;
|
|
79
|
-
state: "completed" | "cancelled" | "failed" | "blocked" | "running" | "paused" | "queued" | "draft" | "planned" | "awaitingAuthorization" | "pauseRequested" | "verifying" | "cancelRequested";
|
|
80
|
-
plan: {
|
|
81
|
-
revision: number;
|
|
82
|
-
digest: string;
|
|
83
|
-
taskGraphRef: string;
|
|
84
|
-
};
|
|
85
76
|
objective: string;
|
|
77
|
+
schemaVersion: 1;
|
|
86
78
|
missionId: string;
|
|
87
79
|
tenantId: string;
|
|
88
80
|
workspaceId: string;
|
|
89
81
|
ownerPrincipalId: string;
|
|
90
82
|
revision: number;
|
|
83
|
+
plan: {
|
|
84
|
+
revision: number;
|
|
85
|
+
digest: string;
|
|
86
|
+
taskGraphRef: string;
|
|
87
|
+
};
|
|
91
88
|
policyRef: string;
|
|
92
89
|
budgetRef: string;
|
|
93
90
|
executionMode: "durable-executor" | "session-bound";
|
|
91
|
+
state: "draft" | "planned" | "awaitingAuthorization" | "queued" | "running" | "pauseRequested" | "paused" | "blocked" | "verifying" | "completed" | "failed" | "cancelRequested" | "cancelled";
|
|
94
92
|
evidenceRefs: string[];
|
|
95
93
|
acceptance: {
|
|
96
94
|
revision: number;
|
|
97
95
|
criteriaDigest: string;
|
|
98
96
|
};
|
|
99
97
|
lastEventSequence: number;
|
|
100
|
-
authorizationRef?: string | undefined;
|
|
101
|
-
}, {
|
|
102
98
|
createdAt: string;
|
|
103
99
|
updatedAt: string;
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
plan: {
|
|
107
|
-
revision: number;
|
|
108
|
-
digest: string;
|
|
109
|
-
taskGraphRef: string;
|
|
110
|
-
};
|
|
100
|
+
authorizationRef?: string | undefined;
|
|
101
|
+
}, {
|
|
111
102
|
objective: string;
|
|
103
|
+
schemaVersion: 1;
|
|
112
104
|
missionId: string;
|
|
113
105
|
tenantId: string;
|
|
114
106
|
workspaceId: string;
|
|
115
107
|
ownerPrincipalId: string;
|
|
116
108
|
revision: number;
|
|
109
|
+
plan: {
|
|
110
|
+
revision: number;
|
|
111
|
+
digest: string;
|
|
112
|
+
taskGraphRef: string;
|
|
113
|
+
};
|
|
117
114
|
policyRef: string;
|
|
118
115
|
budgetRef: string;
|
|
119
116
|
executionMode: "durable-executor" | "session-bound";
|
|
117
|
+
state: "draft" | "planned" | "awaitingAuthorization" | "queued" | "running" | "pauseRequested" | "paused" | "blocked" | "verifying" | "completed" | "failed" | "cancelRequested" | "cancelled";
|
|
120
118
|
evidenceRefs: string[];
|
|
121
119
|
acceptance: {
|
|
122
120
|
revision: number;
|
|
123
121
|
criteriaDigest: string;
|
|
124
122
|
};
|
|
125
123
|
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
|
-
id: string;
|
|
149
148
|
title: string;
|
|
149
|
+
id: 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
|
-
id: string;
|
|
161
160
|
title: string;
|
|
161
|
+
id: string;
|
|
162
162
|
executor: {
|
|
163
163
|
mode: "durable-executor" | "session-bound";
|
|
164
164
|
requirement: string;
|
|
165
165
|
};
|
|
166
|
-
checkpoint?: string | undefined;
|
|
167
166
|
dependsOn?: string[] | undefined;
|
|
168
167
|
capabilityCeiling?: string[] | undefined;
|
|
169
168
|
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
|
-
threshold?: string | undefined;
|
|
189
188
|
baseline?: string | undefined;
|
|
189
|
+
threshold?: string | undefined;
|
|
190
190
|
}, {
|
|
191
191
|
id: string;
|
|
192
192
|
check: string;
|
|
193
193
|
producer: string;
|
|
194
|
-
threshold?: string | undefined;
|
|
195
|
-
baseline?: string | undefined;
|
|
196
194
|
inputs?: string[] | undefined;
|
|
195
|
+
baseline?: string | undefined;
|
|
196
|
+
threshold?: 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;
|
|
211
210
|
tokens?: number | undefined;
|
|
212
211
|
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;
|
|
218
217
|
tokens?: number | undefined;
|
|
219
218
|
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
|
-
id: string;
|
|
243
242
|
title: string;
|
|
243
|
+
id: 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
|
-
id: string;
|
|
255
254
|
title: string;
|
|
255
|
+
id: string;
|
|
256
256
|
executor: {
|
|
257
257
|
mode: "durable-executor" | "session-bound";
|
|
258
258
|
requirement: string;
|
|
259
259
|
};
|
|
260
|
-
checkpoint?: string | undefined;
|
|
261
260
|
dependsOn?: string[] | undefined;
|
|
262
261
|
capabilityCeiling?: string[] | undefined;
|
|
263
262
|
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
|
-
threshold?: string | undefined;
|
|
283
282
|
baseline?: string | undefined;
|
|
283
|
+
threshold?: string | undefined;
|
|
284
284
|
}, {
|
|
285
285
|
id: string;
|
|
286
286
|
check: string;
|
|
287
287
|
producer: string;
|
|
288
|
-
threshold?: string | undefined;
|
|
289
|
-
baseline?: string | undefined;
|
|
290
288
|
inputs?: string[] | undefined;
|
|
289
|
+
baseline?: string | undefined;
|
|
290
|
+
threshold?: 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;
|
|
305
304
|
tokens?: number | undefined;
|
|
306
305
|
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;
|
|
312
311
|
tokens?: number | undefined;
|
|
313
312
|
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
|
-
id: string;
|
|
326
325
|
title: string;
|
|
326
|
+
id: string;
|
|
327
327
|
dependsOn: string[];
|
|
328
328
|
executor: {
|
|
329
329
|
mode: "durable-executor" | "session-bound";
|
|
@@ -334,17 +334,6 @@ 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
|
-
};
|
|
348
337
|
acceptance: {
|
|
349
338
|
id: string;
|
|
350
339
|
check: string;
|
|
@@ -352,41 +341,52 @@ export declare const planBodySchema: z.ZodObject<{
|
|
|
352
341
|
producer: string;
|
|
353
342
|
independent: boolean;
|
|
354
343
|
mandatory: boolean;
|
|
355
|
-
threshold?: string | undefined;
|
|
356
344
|
baseline?: string | undefined;
|
|
345
|
+
threshold?: string | undefined;
|
|
357
346
|
}[];
|
|
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
|
-
id: string;
|
|
361
360
|
title: string;
|
|
361
|
+
id: string;
|
|
362
362
|
executor: {
|
|
363
363
|
mode: "durable-executor" | "session-bound";
|
|
364
364
|
requirement: string;
|
|
365
365
|
};
|
|
366
|
-
checkpoint?: string | undefined;
|
|
367
366
|
dependsOn?: string[] | undefined;
|
|
368
367
|
capabilityCeiling?: string[] | undefined;
|
|
369
368
|
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
|
-
};
|
|
380
372
|
acceptance: {
|
|
381
373
|
id: string;
|
|
382
374
|
check: string;
|
|
383
375
|
producer: string;
|
|
384
|
-
threshold?: string | undefined;
|
|
385
|
-
baseline?: string | undefined;
|
|
386
376
|
inputs?: string[] | undefined;
|
|
377
|
+
baseline?: string | undefined;
|
|
378
|
+
threshold?: string | undefined;
|
|
387
379
|
independent?: boolean | undefined;
|
|
388
380
|
mandatory?: boolean | undefined;
|
|
389
381
|
}[];
|
|
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;
|
|
@@ -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
|
-
id: string;
|
|
431
430
|
title: string;
|
|
431
|
+
id: 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
|
-
id: string;
|
|
443
442
|
title: string;
|
|
443
|
+
id: string;
|
|
444
444
|
executor: {
|
|
445
445
|
mode: "durable-executor" | "session-bound";
|
|
446
446
|
requirement: string;
|
|
447
447
|
};
|
|
448
|
-
checkpoint?: string | undefined;
|
|
449
448
|
dependsOn?: string[] | undefined;
|
|
450
449
|
capabilityCeiling?: string[] | undefined;
|
|
451
450
|
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
|
-
threshold?: string | undefined;
|
|
471
470
|
baseline?: string | undefined;
|
|
471
|
+
threshold?: string | undefined;
|
|
472
472
|
}, {
|
|
473
473
|
id: string;
|
|
474
474
|
check: string;
|
|
475
475
|
producer: string;
|
|
476
|
-
threshold?: string | undefined;
|
|
477
|
-
baseline?: string | undefined;
|
|
478
476
|
inputs?: string[] | undefined;
|
|
477
|
+
baseline?: string | undefined;
|
|
478
|
+
threshold?: 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;
|
|
493
492
|
tokens?: number | undefined;
|
|
494
493
|
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;
|
|
500
499
|
tokens?: number | undefined;
|
|
501
500
|
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
|
-
id: string;
|
|
514
513
|
title: string;
|
|
514
|
+
id: string;
|
|
515
515
|
dependsOn: string[];
|
|
516
516
|
executor: {
|
|
517
517
|
mode: "durable-executor" | "session-bound";
|
|
@@ -522,17 +522,6 @@ 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
|
-
};
|
|
536
525
|
acceptance: {
|
|
537
526
|
id: string;
|
|
538
527
|
check: string;
|
|
@@ -540,50 +529,63 @@ export declare const planInputSchema: z.ZodObject<{
|
|
|
540
529
|
producer: string;
|
|
541
530
|
independent: boolean;
|
|
542
531
|
mandatory: boolean;
|
|
543
|
-
threshold?: string | undefined;
|
|
544
532
|
baseline?: string | undefined;
|
|
533
|
+
threshold?: string | undefined;
|
|
545
534
|
}[];
|
|
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
|
-
id: string;
|
|
549
548
|
title: string;
|
|
549
|
+
id: string;
|
|
550
550
|
executor: {
|
|
551
551
|
mode: "durable-executor" | "session-bound";
|
|
552
552
|
requirement: string;
|
|
553
553
|
};
|
|
554
|
-
checkpoint?: string | undefined;
|
|
555
554
|
dependsOn?: string[] | undefined;
|
|
556
555
|
capabilityCeiling?: string[] | undefined;
|
|
557
556
|
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
|
-
};
|
|
568
560
|
acceptance: {
|
|
569
561
|
id: string;
|
|
570
562
|
check: string;
|
|
571
563
|
producer: string;
|
|
572
|
-
threshold?: string | undefined;
|
|
573
|
-
baseline?: string | undefined;
|
|
574
564
|
inputs?: string[] | undefined;
|
|
565
|
+
baseline?: string | undefined;
|
|
566
|
+
threshold?: string | undefined;
|
|
575
567
|
independent?: boolean | undefined;
|
|
576
568
|
mandatory?: boolean | undefined;
|
|
577
569
|
}[];
|
|
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
|
+
requestId: string;
|
|
584
|
+
missionId: string;
|
|
583
585
|
plan: {
|
|
584
586
|
tasks: {
|
|
585
|
-
id: string;
|
|
586
587
|
title: string;
|
|
588
|
+
id: string;
|
|
587
589
|
dependsOn: string[];
|
|
588
590
|
executor: {
|
|
589
591
|
mode: "durable-executor" | "session-bound";
|
|
@@ -594,17 +596,6 @@ export declare const planInputSchema: z.ZodObject<{
|
|
|
594
596
|
acceptanceEvidence: string[];
|
|
595
597
|
checkpoint?: string | undefined;
|
|
596
598
|
}[];
|
|
597
|
-
scope: {
|
|
598
|
-
capabilities: string[];
|
|
599
|
-
};
|
|
600
|
-
budget: {
|
|
601
|
-
currency: string;
|
|
602
|
-
ceilingMinor: number;
|
|
603
|
-
concurrency?: number | undefined;
|
|
604
|
-
tokens?: number | undefined;
|
|
605
|
-
wallTimeSeconds?: number | undefined;
|
|
606
|
-
retries?: number | undefined;
|
|
607
|
-
};
|
|
608
599
|
acceptance: {
|
|
609
600
|
id: string;
|
|
610
601
|
check: string;
|
|
@@ -612,52 +603,61 @@ export declare const planInputSchema: z.ZodObject<{
|
|
|
612
603
|
producer: string;
|
|
613
604
|
independent: boolean;
|
|
614
605
|
mandatory: boolean;
|
|
615
|
-
threshold?: string | undefined;
|
|
616
606
|
baseline?: string | undefined;
|
|
607
|
+
threshold?: string | undefined;
|
|
617
608
|
}[];
|
|
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
|
+
};
|
|
618
620
|
};
|
|
619
|
-
requestId: string;
|
|
620
|
-
missionId: string;
|
|
621
621
|
expectedRevision: number;
|
|
622
622
|
}, {
|
|
623
|
+
requestId: string;
|
|
624
|
+
missionId: string;
|
|
623
625
|
plan: {
|
|
624
626
|
tasks: {
|
|
625
|
-
id: string;
|
|
626
627
|
title: string;
|
|
628
|
+
id: string;
|
|
627
629
|
executor: {
|
|
628
630
|
mode: "durable-executor" | "session-bound";
|
|
629
631
|
requirement: string;
|
|
630
632
|
};
|
|
631
|
-
checkpoint?: string | undefined;
|
|
632
633
|
dependsOn?: string[] | undefined;
|
|
633
634
|
capabilityCeiling?: string[] | undefined;
|
|
634
635
|
estimatedCostMinor?: number | undefined;
|
|
636
|
+
checkpoint?: string | undefined;
|
|
635
637
|
acceptanceEvidence?: string[] | undefined;
|
|
636
638
|
}[];
|
|
637
|
-
budget: {
|
|
638
|
-
currency: string;
|
|
639
|
-
ceilingMinor: number;
|
|
640
|
-
concurrency?: number | undefined;
|
|
641
|
-
tokens?: number | undefined;
|
|
642
|
-
wallTimeSeconds?: number | undefined;
|
|
643
|
-
retries?: number | undefined;
|
|
644
|
-
};
|
|
645
639
|
acceptance: {
|
|
646
640
|
id: string;
|
|
647
641
|
check: string;
|
|
648
642
|
producer: string;
|
|
649
|
-
threshold?: string | undefined;
|
|
650
|
-
baseline?: string | undefined;
|
|
651
643
|
inputs?: string[] | undefined;
|
|
644
|
+
baseline?: string | undefined;
|
|
645
|
+
threshold?: string | undefined;
|
|
652
646
|
independent?: boolean | undefined;
|
|
653
647
|
mandatory?: boolean | undefined;
|
|
654
648
|
}[];
|
|
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
|
+
};
|
|
655
657
|
scope?: {
|
|
656
658
|
capabilities?: string[] | undefined;
|
|
657
659
|
} | undefined;
|
|
658
660
|
};
|
|
659
|
-
requestId: string;
|
|
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;
|
|
676
675
|
missionId: string;
|
|
677
676
|
afterSequence: number;
|
|
677
|
+
limit: number;
|
|
678
678
|
}, {
|
|
679
679
|
missionId: string;
|
|
680
|
-
limit?: number | undefined;
|
|
681
680
|
afterSequence?: number | undefined;
|
|
681
|
+
limit?: 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";
|
|
691
690
|
requestId: string;
|
|
692
691
|
missionId: string;
|
|
693
692
|
expectedRevision: number;
|
|
693
|
+
action: "pause" | "resume" | "cancel" | "requestAuthorization" | "admit";
|
|
694
694
|
reason?: string | undefined;
|
|
695
695
|
}, {
|
|
696
|
-
action: "pause" | "resume" | "cancel" | "requestAuthorization" | "admit";
|
|
697
696
|
requestId: string;
|
|
698
697
|
missionId: string;
|
|
699
698
|
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>;
|