@openspecui/core 10.0.0 → 11.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/dist/{active-root-config-N3lOotoq.d.mts → active-root-config-CsFtntHf.d.mts} +15 -15
- package/dist/active-root-config.d.mts +5 -5
- package/dist/app-daemon-control.d.mts +14 -14
- package/dist/{cli-projection-bB650ru4.d.mts → cli-projection-Dd5Gdqa2.d.mts} +17 -17
- package/dist/cli-projection.d.mts +5 -5
- package/dist/{dashboard-summary-transport-DcyVID8z.d.mts → dashboard-summary-transport-wRH7oVWM.d.mts} +3294 -3294
- package/dist/dashboard-summary-transport.d.mts +17 -17
- package/dist/{document-translation-DM2eydNr.d.mts → document-translation-OvsFNs-H.d.mts} +100 -100
- package/dist/document-translation.d.mts +1 -1
- package/dist/hosted-app.d.mts +17 -17
- package/dist/hosted-contract.d.mts +17 -17
- package/dist/{index-CW5hcqKC.d.mts → index-jbHV-sxg.d.mts} +46 -46
- package/dist/index.d.mts +17 -17
- package/dist/{local-download-profiles-DXmw0Zs3.d.mts → local-download-profiles-DXNExauZ.d.mts} +1 -1
- package/dist/local-download-profiles.d.mts +2 -2
- package/dist/{notifications-BQhnmovr.d.mts → notifications-B8Ael_hq.d.mts} +13 -13
- package/dist/notifications.d.mts +2 -2
- package/dist/openspec-compat.d.mts +4 -4
- package/dist/{openspec-projection-FKuNsfBp.d.mts → openspec-projection-xOnjhQ7v.d.mts} +1 -1
- package/dist/openspec-projection.d.mts +2 -2
- package/dist/{opsx-entity-CulylXeK.d.mts → opsx-entity-Dc4XotlR.d.mts} +2 -2
- package/dist/opsx-entity.d.mts +7 -7
- package/dist/{opsx-schema-detail-C9kNWQmO.d.mts → opsx-schema-detail-BJ6wzYhq.d.mts} +2 -2
- package/dist/opsx-schema-detail.d.mts +8 -8
- package/dist/{opsx-types-BeQJ4Le_.d.mts → opsx-types-CnZ4dsxb.d.mts} +189 -189
- package/dist/planning-cli-projection.d.mts +17 -17
- package/dist/{schemas-BIaPbul1.d.mts → schemas-pfpqDlAd.d.mts} +153 -153
- package/dist/{sounds-CxSkCgKh.d.mts → sounds-B0GiWqBN.d.mts} +8 -8
- package/dist/sounds.d.mts +1 -1
- package/dist/spec-catalog.d.mts +17 -17
- package/dist/{store-types-TDbmbvPx.d.mts → store-types-BLW7QE7W.d.mts} +1 -1
- package/dist/store-types.d.mts +5 -5
- package/dist/task-progress.d.mts +6 -6
- package/dist/{terminal-audio-R-3VBy0x.d.mts → terminal-audio-BpfUW_eB.d.mts} +1 -1
- package/dist/terminal-audio.d.mts +2 -2
- package/dist/terminal-control.d.mts +2 -2
- package/dist/{terminal-invocation-C8mSioBZ.d.mts → terminal-invocation-DROo1wu_.d.mts} +105 -105
- package/dist/terminal-invocation.d.mts +1 -1
- package/dist/{translator-CVkc7MHh.d.mts → translator-C5z6a5C4.d.mts} +236 -236
- package/dist/translator.d.mts +1 -1
- package/dist/workspace-directory-catalog.d.mts +2 -2
- package/package.json +1 -1
|
@@ -1,5 +1,5 @@
|
|
|
1
|
-
import { vt as CliJsonValue } from "./index-
|
|
2
|
-
import { n as ChangeFile, v as Task } from "./schemas-
|
|
1
|
+
import { vt as CliJsonValue } from "./index-jbHV-sxg.mjs";
|
|
2
|
+
import { n as ChangeFile, v as Task } from "./schemas-pfpqDlAd.mjs";
|
|
3
3
|
import { z } from "zod";
|
|
4
4
|
|
|
5
5
|
//#region src/task-progress.d.ts
|
|
@@ -406,15 +406,15 @@ declare const ArtifactStatusSchema: z.ZodObject<{
|
|
|
406
406
|
missingDeps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
407
407
|
relativePath: z.ZodOptional<z.ZodString>;
|
|
408
408
|
}, "strip", z.ZodTypeAny, {
|
|
409
|
-
id: string;
|
|
410
409
|
status: "ready" | "done" | "skipped" | "blocked";
|
|
410
|
+
id: string;
|
|
411
411
|
outputPath: string;
|
|
412
412
|
requires: string[];
|
|
413
413
|
missingDeps?: string[] | undefined;
|
|
414
414
|
relativePath?: string | undefined;
|
|
415
415
|
}, {
|
|
416
|
-
id: string;
|
|
417
416
|
status: "ready" | "done" | "skipped" | "blocked";
|
|
417
|
+
id: string;
|
|
418
418
|
outputPath: string;
|
|
419
419
|
requires: string[];
|
|
420
420
|
missingDeps?: string[] | undefined;
|
|
@@ -435,15 +435,15 @@ declare const ChangeStatusSchema: z.ZodObject<{
|
|
|
435
435
|
missingDeps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
436
436
|
relativePath: z.ZodOptional<z.ZodString>;
|
|
437
437
|
}, "strip", z.ZodTypeAny, {
|
|
438
|
-
id: string;
|
|
439
438
|
status: "ready" | "done" | "skipped" | "blocked";
|
|
439
|
+
id: string;
|
|
440
440
|
outputPath: string;
|
|
441
441
|
requires: string[];
|
|
442
442
|
missingDeps?: string[] | undefined;
|
|
443
443
|
relativePath?: string | undefined;
|
|
444
444
|
}, {
|
|
445
|
-
id: string;
|
|
446
445
|
status: "ready" | "done" | "skipped" | "blocked";
|
|
446
|
+
id: string;
|
|
447
447
|
outputPath: string;
|
|
448
448
|
requires: string[];
|
|
449
449
|
missingDeps?: string[] | undefined;
|
|
@@ -693,7 +693,6 @@ declare const ChangeStatusSchema: z.ZodObject<{
|
|
|
693
693
|
[k: string]: unknown;
|
|
694
694
|
};
|
|
695
695
|
evidence: {
|
|
696
|
-
command: "status";
|
|
697
696
|
success: boolean;
|
|
698
697
|
stdout: string;
|
|
699
698
|
stderr: string;
|
|
@@ -706,15 +705,16 @@ declare const ChangeStatusSchema: z.ZodObject<{
|
|
|
706
705
|
target: z.ZodOptional<z.ZodString>;
|
|
707
706
|
fix: z.ZodOptional<z.ZodString>;
|
|
708
707
|
}, z.ZodTypeAny, "passthrough">[];
|
|
708
|
+
command: "status";
|
|
709
709
|
selector: {
|
|
710
710
|
store?: string | undefined;
|
|
711
711
|
};
|
|
712
|
+
contractError?: string | undefined;
|
|
712
713
|
root?: z.objectOutputType<{
|
|
713
714
|
path: z.ZodString;
|
|
714
715
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
715
716
|
store_id: z.ZodOptional<z.ZodString>;
|
|
716
717
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
717
|
-
contractError?: string | undefined;
|
|
718
718
|
} & {
|
|
719
719
|
[k: string]: unknown;
|
|
720
720
|
};
|
|
@@ -756,7 +756,6 @@ declare const ChangeStatusSchema: z.ZodObject<{
|
|
|
756
756
|
[k: string]: unknown;
|
|
757
757
|
};
|
|
758
758
|
evidence: {
|
|
759
|
-
command: "status";
|
|
760
759
|
success: boolean;
|
|
761
760
|
stdout: string;
|
|
762
761
|
stderr: string;
|
|
@@ -769,15 +768,16 @@ declare const ChangeStatusSchema: z.ZodObject<{
|
|
|
769
768
|
target: z.ZodOptional<z.ZodString>;
|
|
770
769
|
fix: z.ZodOptional<z.ZodString>;
|
|
771
770
|
}, z.ZodTypeAny, "passthrough">[];
|
|
771
|
+
command: "status";
|
|
772
772
|
selector: {
|
|
773
773
|
store?: string | undefined;
|
|
774
774
|
};
|
|
775
|
+
contractError?: string | undefined;
|
|
775
776
|
root?: z.objectInputType<{
|
|
776
777
|
path: z.ZodString;
|
|
777
778
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
778
779
|
store_id: z.ZodOptional<z.ZodString>;
|
|
779
780
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
780
|
-
contractError?: string | undefined;
|
|
781
781
|
} & {
|
|
782
782
|
[k: string]: unknown;
|
|
783
783
|
};
|
|
@@ -822,8 +822,8 @@ declare const ChangeStatusSchema: z.ZodObject<{
|
|
|
822
822
|
isPlanningComplete: boolean;
|
|
823
823
|
applyRequires: string[];
|
|
824
824
|
artifacts: {
|
|
825
|
-
id: string;
|
|
826
825
|
status: "ready" | "done" | "skipped" | "blocked";
|
|
826
|
+
id: string;
|
|
827
827
|
outputPath: string;
|
|
828
828
|
requires: string[];
|
|
829
829
|
missingDeps?: string[] | undefined;
|
|
@@ -839,7 +839,6 @@ declare const ChangeStatusSchema: z.ZodObject<{
|
|
|
839
839
|
[k: string]: unknown;
|
|
840
840
|
};
|
|
841
841
|
evidence: {
|
|
842
|
-
command: "status";
|
|
843
842
|
success: boolean;
|
|
844
843
|
stdout: string;
|
|
845
844
|
stderr: string;
|
|
@@ -852,15 +851,16 @@ declare const ChangeStatusSchema: z.ZodObject<{
|
|
|
852
851
|
target: z.ZodOptional<z.ZodString>;
|
|
853
852
|
fix: z.ZodOptional<z.ZodString>;
|
|
854
853
|
}, z.ZodTypeAny, "passthrough">[];
|
|
854
|
+
command: "status";
|
|
855
855
|
selector: {
|
|
856
856
|
store?: string | undefined;
|
|
857
857
|
};
|
|
858
|
+
contractError?: string | undefined;
|
|
858
859
|
root?: z.objectOutputType<{
|
|
859
860
|
path: z.ZodString;
|
|
860
861
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
861
862
|
store_id: z.ZodOptional<z.ZodString>;
|
|
862
863
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
863
|
-
contractError?: string | undefined;
|
|
864
864
|
} & {
|
|
865
865
|
[k: string]: unknown;
|
|
866
866
|
};
|
|
@@ -901,8 +901,8 @@ declare const ChangeStatusSchema: z.ZodObject<{
|
|
|
901
901
|
isPlanningComplete: boolean;
|
|
902
902
|
applyRequires: string[];
|
|
903
903
|
artifacts: {
|
|
904
|
-
id: string;
|
|
905
904
|
status: "ready" | "done" | "skipped" | "blocked";
|
|
905
|
+
id: string;
|
|
906
906
|
outputPath: string;
|
|
907
907
|
requires: string[];
|
|
908
908
|
missingDeps?: string[] | undefined;
|
|
@@ -918,7 +918,6 @@ declare const ChangeStatusSchema: z.ZodObject<{
|
|
|
918
918
|
[k: string]: unknown;
|
|
919
919
|
};
|
|
920
920
|
evidence: {
|
|
921
|
-
command: "status";
|
|
922
921
|
success: boolean;
|
|
923
922
|
stdout: string;
|
|
924
923
|
stderr: string;
|
|
@@ -931,15 +930,16 @@ declare const ChangeStatusSchema: z.ZodObject<{
|
|
|
931
930
|
target: z.ZodOptional<z.ZodString>;
|
|
932
931
|
fix: z.ZodOptional<z.ZodString>;
|
|
933
932
|
}, z.ZodTypeAny, "passthrough">[];
|
|
933
|
+
command: "status";
|
|
934
934
|
selector: {
|
|
935
935
|
store?: string | undefined;
|
|
936
936
|
};
|
|
937
|
+
contractError?: string | undefined;
|
|
937
938
|
root?: z.objectInputType<{
|
|
938
939
|
path: z.ZodString;
|
|
939
940
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
940
941
|
store_id: z.ZodOptional<z.ZodString>;
|
|
941
942
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
942
|
-
contractError?: string | undefined;
|
|
943
943
|
} & {
|
|
944
944
|
[k: string]: unknown;
|
|
945
945
|
};
|
|
@@ -983,16 +983,16 @@ declare const DependencyInfoSchema: z.ZodObject<{
|
|
|
983
983
|
description: z.ZodString;
|
|
984
984
|
skipped: z.ZodOptional<z.ZodBoolean>;
|
|
985
985
|
}, "strip", z.ZodTypeAny, {
|
|
986
|
-
id: string;
|
|
987
986
|
path: string;
|
|
988
|
-
|
|
987
|
+
id: string;
|
|
989
988
|
done: boolean;
|
|
989
|
+
description: string;
|
|
990
990
|
skipped?: boolean | undefined;
|
|
991
991
|
}, {
|
|
992
|
-
id: string;
|
|
993
992
|
path: string;
|
|
994
|
-
|
|
993
|
+
id: string;
|
|
995
994
|
done: boolean;
|
|
995
|
+
description: string;
|
|
996
996
|
skipped?: boolean | undefined;
|
|
997
997
|
}>;
|
|
998
998
|
type DependencyInfo = z.infer<typeof DependencyInfoSchema>;
|
|
@@ -1002,12 +1002,12 @@ declare const ApplyTaskSchema: z.ZodObject<{
|
|
|
1002
1002
|
done: z.ZodBoolean;
|
|
1003
1003
|
}, "strip", z.ZodTypeAny, {
|
|
1004
1004
|
id: string;
|
|
1005
|
-
description: string;
|
|
1006
1005
|
done: boolean;
|
|
1006
|
+
description: string;
|
|
1007
1007
|
}, {
|
|
1008
1008
|
id: string;
|
|
1009
|
-
description: string;
|
|
1010
1009
|
done: boolean;
|
|
1010
|
+
description: string;
|
|
1011
1011
|
}>;
|
|
1012
1012
|
type ApplyTask = z.infer<typeof ApplyTaskSchema>;
|
|
1013
1013
|
declare const ApplyInstructionsContextFilesSchema: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, string[], string | string[]>>;
|
|
@@ -1023,12 +1023,12 @@ declare const ApplyInstructionsProjectionSchema: z.ZodObject<{
|
|
|
1023
1023
|
done: z.ZodBoolean;
|
|
1024
1024
|
}, "strip", z.ZodTypeAny, {
|
|
1025
1025
|
id: string;
|
|
1026
|
-
description: string;
|
|
1027
1026
|
done: boolean;
|
|
1027
|
+
description: string;
|
|
1028
1028
|
}, {
|
|
1029
1029
|
id: string;
|
|
1030
|
-
description: string;
|
|
1031
1030
|
done: boolean;
|
|
1031
|
+
description: string;
|
|
1032
1032
|
}>, "many">;
|
|
1033
1033
|
state: z.ZodEnum<["blocked", "all_done", "ready"]>;
|
|
1034
1034
|
missingArtifacts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
@@ -1311,15 +1311,15 @@ declare const ApplyInstructionsProjectionSchema: z.ZodObject<{
|
|
|
1311
1311
|
remaining: z.ZodNumber;
|
|
1312
1312
|
phase: z.ZodEnum<["no-tasks", "in-progress", "complete"]>;
|
|
1313
1313
|
}, "strip", z.ZodTypeAny, {
|
|
1314
|
+
completed: number;
|
|
1314
1315
|
total: number;
|
|
1315
1316
|
remaining: number;
|
|
1316
|
-
|
|
1317
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
1317
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
1318
1318
|
}, {
|
|
1319
|
+
completed: number;
|
|
1319
1320
|
total: number;
|
|
1320
1321
|
remaining: number;
|
|
1321
|
-
|
|
1322
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
1322
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
1323
1323
|
}>;
|
|
1324
1324
|
}, "strip", z.ZodTypeAny, {
|
|
1325
1325
|
message: string;
|
|
@@ -1330,10 +1330,10 @@ declare const ApplyInstructionsProjectionSchema: z.ZodObject<{
|
|
|
1330
1330
|
remaining: number;
|
|
1331
1331
|
};
|
|
1332
1332
|
tracked: {
|
|
1333
|
+
completed: number;
|
|
1333
1334
|
total: number;
|
|
1334
1335
|
remaining: number;
|
|
1335
|
-
|
|
1336
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
1336
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
1337
1337
|
};
|
|
1338
1338
|
}, {
|
|
1339
1339
|
message: string;
|
|
@@ -1344,18 +1344,18 @@ declare const ApplyInstructionsProjectionSchema: z.ZodObject<{
|
|
|
1344
1344
|
remaining: number;
|
|
1345
1345
|
};
|
|
1346
1346
|
tracked: {
|
|
1347
|
+
completed: number;
|
|
1347
1348
|
total: number;
|
|
1348
1349
|
remaining: number;
|
|
1349
|
-
|
|
1350
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
1350
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
1351
1351
|
};
|
|
1352
1352
|
}>>;
|
|
1353
1353
|
}, "strip", z.ZodTypeAny, {
|
|
1354
|
-
source: "openspec-instructions-apply";
|
|
1355
1354
|
state: "ready" | "blocked" | "all_done";
|
|
1356
1355
|
complete: number;
|
|
1357
1356
|
total: number;
|
|
1358
1357
|
remaining: number;
|
|
1358
|
+
source: "openspec-instructions-apply";
|
|
1359
1359
|
divergence: {
|
|
1360
1360
|
message: string;
|
|
1361
1361
|
kind: "tracked-task-mismatch";
|
|
@@ -1365,18 +1365,18 @@ declare const ApplyInstructionsProjectionSchema: z.ZodObject<{
|
|
|
1365
1365
|
remaining: number;
|
|
1366
1366
|
};
|
|
1367
1367
|
tracked: {
|
|
1368
|
+
completed: number;
|
|
1368
1369
|
total: number;
|
|
1369
1370
|
remaining: number;
|
|
1370
|
-
|
|
1371
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
1371
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
1372
1372
|
};
|
|
1373
1373
|
} | null;
|
|
1374
1374
|
}, {
|
|
1375
|
-
source: "openspec-instructions-apply";
|
|
1376
1375
|
state: "ready" | "blocked" | "all_done";
|
|
1377
1376
|
complete: number;
|
|
1378
1377
|
total: number;
|
|
1379
1378
|
remaining: number;
|
|
1379
|
+
source: "openspec-instructions-apply";
|
|
1380
1380
|
divergence: {
|
|
1381
1381
|
message: string;
|
|
1382
1382
|
kind: "tracked-task-mismatch";
|
|
@@ -1386,16 +1386,21 @@ declare const ApplyInstructionsProjectionSchema: z.ZodObject<{
|
|
|
1386
1386
|
remaining: number;
|
|
1387
1387
|
};
|
|
1388
1388
|
tracked: {
|
|
1389
|
+
completed: number;
|
|
1389
1390
|
total: number;
|
|
1390
1391
|
remaining: number;
|
|
1391
|
-
|
|
1392
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
1392
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
1393
1393
|
};
|
|
1394
1394
|
} | null;
|
|
1395
1395
|
}>;
|
|
1396
1396
|
}, "strip", z.ZodTypeAny, {
|
|
1397
|
+
state: "ready" | "blocked" | "all_done";
|
|
1398
|
+
tasks: {
|
|
1399
|
+
id: string;
|
|
1400
|
+
done: boolean;
|
|
1401
|
+
description: string;
|
|
1402
|
+
}[];
|
|
1397
1403
|
evidence: {
|
|
1398
|
-
command: "instructions apply";
|
|
1399
1404
|
success: boolean;
|
|
1400
1405
|
stdout: string;
|
|
1401
1406
|
stderr: string;
|
|
@@ -1408,35 +1413,30 @@ declare const ApplyInstructionsProjectionSchema: z.ZodObject<{
|
|
|
1408
1413
|
target: z.ZodOptional<z.ZodString>;
|
|
1409
1414
|
fix: z.ZodOptional<z.ZodString>;
|
|
1410
1415
|
}, z.ZodTypeAny, "passthrough">[];
|
|
1416
|
+
command: "instructions apply";
|
|
1411
1417
|
selector: {
|
|
1412
1418
|
store?: string | undefined;
|
|
1413
1419
|
};
|
|
1420
|
+
contractError?: string | undefined;
|
|
1414
1421
|
root?: z.objectOutputType<{
|
|
1415
1422
|
path: z.ZodString;
|
|
1416
1423
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
1417
1424
|
store_id: z.ZodOptional<z.ZodString>;
|
|
1418
1425
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
1419
|
-
contractError?: string | undefined;
|
|
1420
1426
|
} & {
|
|
1421
1427
|
[k: string]: unknown;
|
|
1422
1428
|
};
|
|
1423
|
-
state: "ready" | "blocked" | "all_done";
|
|
1424
1429
|
changeName: string;
|
|
1425
1430
|
schemaName: string;
|
|
1426
1431
|
changeDir: string;
|
|
1427
1432
|
instruction: string;
|
|
1428
1433
|
contextFiles: Record<string, string[]>;
|
|
1429
|
-
tasks: {
|
|
1430
|
-
id: string;
|
|
1431
|
-
description: string;
|
|
1432
|
-
done: boolean;
|
|
1433
|
-
}[];
|
|
1434
1434
|
applyInstructionProgress: {
|
|
1435
|
-
source: "openspec-instructions-apply";
|
|
1436
1435
|
state: "ready" | "blocked" | "all_done";
|
|
1437
1436
|
complete: number;
|
|
1438
1437
|
total: number;
|
|
1439
1438
|
remaining: number;
|
|
1439
|
+
source: "openspec-instructions-apply";
|
|
1440
1440
|
divergence: {
|
|
1441
1441
|
message: string;
|
|
1442
1442
|
kind: "tracked-task-mismatch";
|
|
@@ -1446,10 +1446,10 @@ declare const ApplyInstructionsProjectionSchema: z.ZodObject<{
|
|
|
1446
1446
|
remaining: number;
|
|
1447
1447
|
};
|
|
1448
1448
|
tracked: {
|
|
1449
|
+
completed: number;
|
|
1449
1450
|
total: number;
|
|
1450
1451
|
remaining: number;
|
|
1451
|
-
|
|
1452
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
1452
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
1453
1453
|
};
|
|
1454
1454
|
} | null;
|
|
1455
1455
|
};
|
|
@@ -1492,8 +1492,13 @@ declare const ApplyInstructionsProjectionSchema: z.ZodObject<{
|
|
|
1492
1492
|
missingArtifacts?: string[] | undefined;
|
|
1493
1493
|
operationGuidance?: string[] | undefined;
|
|
1494
1494
|
}, {
|
|
1495
|
+
state: "ready" | "blocked" | "all_done";
|
|
1496
|
+
tasks: {
|
|
1497
|
+
id: string;
|
|
1498
|
+
done: boolean;
|
|
1499
|
+
description: string;
|
|
1500
|
+
}[];
|
|
1495
1501
|
evidence: {
|
|
1496
|
-
command: "instructions apply";
|
|
1497
1502
|
success: boolean;
|
|
1498
1503
|
stdout: string;
|
|
1499
1504
|
stderr: string;
|
|
@@ -1506,35 +1511,30 @@ declare const ApplyInstructionsProjectionSchema: z.ZodObject<{
|
|
|
1506
1511
|
target: z.ZodOptional<z.ZodString>;
|
|
1507
1512
|
fix: z.ZodOptional<z.ZodString>;
|
|
1508
1513
|
}, z.ZodTypeAny, "passthrough">[];
|
|
1514
|
+
command: "instructions apply";
|
|
1509
1515
|
selector: {
|
|
1510
1516
|
store?: string | undefined;
|
|
1511
1517
|
};
|
|
1518
|
+
contractError?: string | undefined;
|
|
1512
1519
|
root?: z.objectInputType<{
|
|
1513
1520
|
path: z.ZodString;
|
|
1514
1521
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
1515
1522
|
store_id: z.ZodOptional<z.ZodString>;
|
|
1516
1523
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
1517
|
-
contractError?: string | undefined;
|
|
1518
1524
|
} & {
|
|
1519
1525
|
[k: string]: unknown;
|
|
1520
1526
|
};
|
|
1521
|
-
state: "ready" | "blocked" | "all_done";
|
|
1522
1527
|
changeName: string;
|
|
1523
1528
|
schemaName: string;
|
|
1524
1529
|
changeDir: string;
|
|
1525
1530
|
instruction: string;
|
|
1526
1531
|
contextFiles: Record<string, string | string[]>;
|
|
1527
|
-
tasks: {
|
|
1528
|
-
id: string;
|
|
1529
|
-
description: string;
|
|
1530
|
-
done: boolean;
|
|
1531
|
-
}[];
|
|
1532
1532
|
applyInstructionProgress: {
|
|
1533
|
-
source: "openspec-instructions-apply";
|
|
1534
1533
|
state: "ready" | "blocked" | "all_done";
|
|
1535
1534
|
complete: number;
|
|
1536
1535
|
total: number;
|
|
1537
1536
|
remaining: number;
|
|
1537
|
+
source: "openspec-instructions-apply";
|
|
1538
1538
|
divergence: {
|
|
1539
1539
|
message: string;
|
|
1540
1540
|
kind: "tracked-task-mismatch";
|
|
@@ -1544,10 +1544,10 @@ declare const ApplyInstructionsProjectionSchema: z.ZodObject<{
|
|
|
1544
1544
|
remaining: number;
|
|
1545
1545
|
};
|
|
1546
1546
|
tracked: {
|
|
1547
|
+
completed: number;
|
|
1547
1548
|
total: number;
|
|
1548
1549
|
remaining: number;
|
|
1549
|
-
|
|
1550
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
1550
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
1551
1551
|
};
|
|
1552
1552
|
} | null;
|
|
1553
1553
|
};
|
|
@@ -1614,12 +1614,12 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
1614
1614
|
done: z.ZodBoolean;
|
|
1615
1615
|
}, "strip", z.ZodTypeAny, {
|
|
1616
1616
|
id: string;
|
|
1617
|
-
description: string;
|
|
1618
1617
|
done: boolean;
|
|
1618
|
+
description: string;
|
|
1619
1619
|
}, {
|
|
1620
1620
|
id: string;
|
|
1621
|
-
description: string;
|
|
1622
1621
|
done: boolean;
|
|
1622
|
+
description: string;
|
|
1623
1623
|
}>, "many">;
|
|
1624
1624
|
state: z.ZodEnum<["blocked", "all_done", "ready"]>;
|
|
1625
1625
|
missingArtifacts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
@@ -1875,8 +1875,13 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
1875
1875
|
command: z.ZodLiteral<"instructions apply">;
|
|
1876
1876
|
}, z.ZodTypeAny, "passthrough">>;
|
|
1877
1877
|
}, "strip", z.ZodTypeAny, {
|
|
1878
|
+
state: "ready" | "blocked" | "all_done";
|
|
1879
|
+
tasks: {
|
|
1880
|
+
id: string;
|
|
1881
|
+
done: boolean;
|
|
1882
|
+
description: string;
|
|
1883
|
+
}[];
|
|
1878
1884
|
evidence: {
|
|
1879
|
-
command: "instructions apply";
|
|
1880
1885
|
success: boolean;
|
|
1881
1886
|
stdout: string;
|
|
1882
1887
|
stderr: string;
|
|
@@ -1889,34 +1894,29 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
1889
1894
|
target: z.ZodOptional<z.ZodString>;
|
|
1890
1895
|
fix: z.ZodOptional<z.ZodString>;
|
|
1891
1896
|
}, z.ZodTypeAny, "passthrough">[];
|
|
1897
|
+
command: "instructions apply";
|
|
1892
1898
|
selector: {
|
|
1893
1899
|
store?: string | undefined;
|
|
1894
1900
|
};
|
|
1901
|
+
contractError?: string | undefined;
|
|
1895
1902
|
root?: z.objectOutputType<{
|
|
1896
1903
|
path: z.ZodString;
|
|
1897
1904
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
1898
1905
|
store_id: z.ZodOptional<z.ZodString>;
|
|
1899
1906
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
1900
|
-
contractError?: string | undefined;
|
|
1901
1907
|
} & {
|
|
1902
1908
|
[k: string]: unknown;
|
|
1903
1909
|
};
|
|
1904
|
-
state: "ready" | "blocked" | "all_done";
|
|
1905
|
-
progress: {
|
|
1906
|
-
complete: number;
|
|
1907
|
-
total: number;
|
|
1908
|
-
remaining: number;
|
|
1909
|
-
};
|
|
1910
1910
|
changeName: string;
|
|
1911
1911
|
schemaName: string;
|
|
1912
1912
|
changeDir: string;
|
|
1913
1913
|
instruction: string;
|
|
1914
1914
|
contextFiles: Record<string, string[]>;
|
|
1915
|
-
|
|
1916
|
-
|
|
1917
|
-
|
|
1918
|
-
|
|
1919
|
-
}
|
|
1915
|
+
progress: {
|
|
1916
|
+
complete: number;
|
|
1917
|
+
total: number;
|
|
1918
|
+
remaining: number;
|
|
1919
|
+
};
|
|
1920
1920
|
references?: z.objectOutputType<{
|
|
1921
1921
|
store_id: z.ZodString;
|
|
1922
1922
|
root: z.ZodOptional<z.ZodString>;
|
|
@@ -1956,8 +1956,13 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
1956
1956
|
missingArtifacts?: string[] | undefined;
|
|
1957
1957
|
operationGuidance?: string[] | undefined;
|
|
1958
1958
|
}, {
|
|
1959
|
+
state: "ready" | "blocked" | "all_done";
|
|
1960
|
+
tasks: {
|
|
1961
|
+
id: string;
|
|
1962
|
+
done: boolean;
|
|
1963
|
+
description: string;
|
|
1964
|
+
}[];
|
|
1959
1965
|
evidence: {
|
|
1960
|
-
command: "instructions apply";
|
|
1961
1966
|
success: boolean;
|
|
1962
1967
|
stdout: string;
|
|
1963
1968
|
stderr: string;
|
|
@@ -1970,34 +1975,29 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
1970
1975
|
target: z.ZodOptional<z.ZodString>;
|
|
1971
1976
|
fix: z.ZodOptional<z.ZodString>;
|
|
1972
1977
|
}, z.ZodTypeAny, "passthrough">[];
|
|
1978
|
+
command: "instructions apply";
|
|
1973
1979
|
selector: {
|
|
1974
1980
|
store?: string | undefined;
|
|
1975
1981
|
};
|
|
1982
|
+
contractError?: string | undefined;
|
|
1976
1983
|
root?: z.objectInputType<{
|
|
1977
1984
|
path: z.ZodString;
|
|
1978
1985
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
1979
1986
|
store_id: z.ZodOptional<z.ZodString>;
|
|
1980
1987
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
1981
|
-
contractError?: string | undefined;
|
|
1982
1988
|
} & {
|
|
1983
1989
|
[k: string]: unknown;
|
|
1984
1990
|
};
|
|
1985
|
-
state: "ready" | "blocked" | "all_done";
|
|
1986
|
-
progress: {
|
|
1987
|
-
complete: number;
|
|
1988
|
-
total: number;
|
|
1989
|
-
remaining: number;
|
|
1990
|
-
};
|
|
1991
1991
|
changeName: string;
|
|
1992
1992
|
schemaName: string;
|
|
1993
1993
|
changeDir: string;
|
|
1994
1994
|
instruction: string;
|
|
1995
1995
|
contextFiles: Record<string, string | string[]>;
|
|
1996
|
-
|
|
1997
|
-
|
|
1998
|
-
|
|
1999
|
-
|
|
2000
|
-
}
|
|
1996
|
+
progress: {
|
|
1997
|
+
complete: number;
|
|
1998
|
+
total: number;
|
|
1999
|
+
remaining: number;
|
|
2000
|
+
};
|
|
2001
2001
|
references?: z.objectInputType<{
|
|
2002
2002
|
store_id: z.ZodString;
|
|
2003
2003
|
root: z.ZodOptional<z.ZodString>;
|
|
@@ -2038,8 +2038,13 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
2038
2038
|
operationGuidance?: string[] | undefined;
|
|
2039
2039
|
}>, {
|
|
2040
2040
|
applyInstructionProgress: ApplyInstructionProgress;
|
|
2041
|
+
state: "ready" | "blocked" | "all_done";
|
|
2042
|
+
tasks: {
|
|
2043
|
+
id: string;
|
|
2044
|
+
done: boolean;
|
|
2045
|
+
description: string;
|
|
2046
|
+
}[];
|
|
2041
2047
|
evidence: {
|
|
2042
|
-
command: "instructions apply";
|
|
2043
2048
|
success: boolean;
|
|
2044
2049
|
stdout: string;
|
|
2045
2050
|
stderr: string;
|
|
@@ -2052,29 +2057,24 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
2052
2057
|
target: z.ZodOptional<z.ZodString>;
|
|
2053
2058
|
fix: z.ZodOptional<z.ZodString>;
|
|
2054
2059
|
}, z.ZodTypeAny, "passthrough">[];
|
|
2060
|
+
command: "instructions apply";
|
|
2055
2061
|
selector: {
|
|
2056
2062
|
store?: string | undefined;
|
|
2057
2063
|
};
|
|
2064
|
+
contractError?: string | undefined;
|
|
2058
2065
|
root?: z.objectOutputType<{
|
|
2059
2066
|
path: z.ZodString;
|
|
2060
2067
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
2061
2068
|
store_id: z.ZodOptional<z.ZodString>;
|
|
2062
2069
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
2063
|
-
contractError?: string | undefined;
|
|
2064
2070
|
} & {
|
|
2065
2071
|
[k: string]: unknown;
|
|
2066
2072
|
};
|
|
2067
|
-
state: "ready" | "blocked" | "all_done";
|
|
2068
2073
|
changeName: string;
|
|
2069
2074
|
schemaName: string;
|
|
2070
2075
|
changeDir: string;
|
|
2071
2076
|
instruction: string;
|
|
2072
2077
|
contextFiles: Record<string, string[]>;
|
|
2073
|
-
tasks: {
|
|
2074
|
-
id: string;
|
|
2075
|
-
description: string;
|
|
2076
|
-
done: boolean;
|
|
2077
|
-
}[];
|
|
2078
2078
|
references?: z.objectOutputType<{
|
|
2079
2079
|
store_id: z.ZodString;
|
|
2080
2080
|
root: z.ZodOptional<z.ZodString>;
|
|
@@ -2114,8 +2114,13 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
2114
2114
|
missingArtifacts?: string[] | undefined;
|
|
2115
2115
|
operationGuidance?: string[] | undefined;
|
|
2116
2116
|
}, {
|
|
2117
|
+
state: "ready" | "blocked" | "all_done";
|
|
2118
|
+
tasks: {
|
|
2119
|
+
id: string;
|
|
2120
|
+
done: boolean;
|
|
2121
|
+
description: string;
|
|
2122
|
+
}[];
|
|
2117
2123
|
evidence: {
|
|
2118
|
-
command: "instructions apply";
|
|
2119
2124
|
success: boolean;
|
|
2120
2125
|
stdout: string;
|
|
2121
2126
|
stderr: string;
|
|
@@ -2128,34 +2133,29 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
2128
2133
|
target: z.ZodOptional<z.ZodString>;
|
|
2129
2134
|
fix: z.ZodOptional<z.ZodString>;
|
|
2130
2135
|
}, z.ZodTypeAny, "passthrough">[];
|
|
2136
|
+
command: "instructions apply";
|
|
2131
2137
|
selector: {
|
|
2132
2138
|
store?: string | undefined;
|
|
2133
2139
|
};
|
|
2140
|
+
contractError?: string | undefined;
|
|
2134
2141
|
root?: z.objectInputType<{
|
|
2135
2142
|
path: z.ZodString;
|
|
2136
2143
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
2137
2144
|
store_id: z.ZodOptional<z.ZodString>;
|
|
2138
2145
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
2139
|
-
contractError?: string | undefined;
|
|
2140
2146
|
} & {
|
|
2141
2147
|
[k: string]: unknown;
|
|
2142
2148
|
};
|
|
2143
|
-
state: "ready" | "blocked" | "all_done";
|
|
2144
|
-
progress: {
|
|
2145
|
-
complete: number;
|
|
2146
|
-
total: number;
|
|
2147
|
-
remaining: number;
|
|
2148
|
-
};
|
|
2149
2149
|
changeName: string;
|
|
2150
2150
|
schemaName: string;
|
|
2151
2151
|
changeDir: string;
|
|
2152
2152
|
instruction: string;
|
|
2153
2153
|
contextFiles: Record<string, string | string[]>;
|
|
2154
|
-
|
|
2155
|
-
|
|
2156
|
-
|
|
2157
|
-
|
|
2158
|
-
}
|
|
2154
|
+
progress: {
|
|
2155
|
+
complete: number;
|
|
2156
|
+
total: number;
|
|
2157
|
+
remaining: number;
|
|
2158
|
+
};
|
|
2159
2159
|
references?: z.objectInputType<{
|
|
2160
2160
|
store_id: z.ZodString;
|
|
2161
2161
|
root: z.ZodOptional<z.ZodString>;
|
|
@@ -2205,12 +2205,12 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
2205
2205
|
done: z.ZodBoolean;
|
|
2206
2206
|
}, "strip", z.ZodTypeAny, {
|
|
2207
2207
|
id: string;
|
|
2208
|
-
description: string;
|
|
2209
2208
|
done: boolean;
|
|
2209
|
+
description: string;
|
|
2210
2210
|
}, {
|
|
2211
2211
|
id: string;
|
|
2212
|
-
description: string;
|
|
2213
2212
|
done: boolean;
|
|
2213
|
+
description: string;
|
|
2214
2214
|
}>, "many">;
|
|
2215
2215
|
state: z.ZodEnum<["blocked", "all_done", "ready"]>;
|
|
2216
2216
|
missingArtifacts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
@@ -2493,15 +2493,15 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
2493
2493
|
remaining: z.ZodNumber;
|
|
2494
2494
|
phase: z.ZodEnum<["no-tasks", "in-progress", "complete"]>;
|
|
2495
2495
|
}, "strip", z.ZodTypeAny, {
|
|
2496
|
+
completed: number;
|
|
2496
2497
|
total: number;
|
|
2497
2498
|
remaining: number;
|
|
2498
|
-
|
|
2499
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
2499
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
2500
2500
|
}, {
|
|
2501
|
+
completed: number;
|
|
2501
2502
|
total: number;
|
|
2502
2503
|
remaining: number;
|
|
2503
|
-
|
|
2504
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
2504
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
2505
2505
|
}>;
|
|
2506
2506
|
}, "strip", z.ZodTypeAny, {
|
|
2507
2507
|
message: string;
|
|
@@ -2512,10 +2512,10 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
2512
2512
|
remaining: number;
|
|
2513
2513
|
};
|
|
2514
2514
|
tracked: {
|
|
2515
|
+
completed: number;
|
|
2515
2516
|
total: number;
|
|
2516
2517
|
remaining: number;
|
|
2517
|
-
|
|
2518
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
2518
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
2519
2519
|
};
|
|
2520
2520
|
}, {
|
|
2521
2521
|
message: string;
|
|
@@ -2526,18 +2526,18 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
2526
2526
|
remaining: number;
|
|
2527
2527
|
};
|
|
2528
2528
|
tracked: {
|
|
2529
|
+
completed: number;
|
|
2529
2530
|
total: number;
|
|
2530
2531
|
remaining: number;
|
|
2531
|
-
|
|
2532
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
2532
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
2533
2533
|
};
|
|
2534
2534
|
}>>;
|
|
2535
2535
|
}, "strip", z.ZodTypeAny, {
|
|
2536
|
-
source: "openspec-instructions-apply";
|
|
2537
2536
|
state: "ready" | "blocked" | "all_done";
|
|
2538
2537
|
complete: number;
|
|
2539
2538
|
total: number;
|
|
2540
2539
|
remaining: number;
|
|
2540
|
+
source: "openspec-instructions-apply";
|
|
2541
2541
|
divergence: {
|
|
2542
2542
|
message: string;
|
|
2543
2543
|
kind: "tracked-task-mismatch";
|
|
@@ -2547,18 +2547,18 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
2547
2547
|
remaining: number;
|
|
2548
2548
|
};
|
|
2549
2549
|
tracked: {
|
|
2550
|
+
completed: number;
|
|
2550
2551
|
total: number;
|
|
2551
2552
|
remaining: number;
|
|
2552
|
-
|
|
2553
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
2553
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
2554
2554
|
};
|
|
2555
2555
|
} | null;
|
|
2556
2556
|
}, {
|
|
2557
|
-
source: "openspec-instructions-apply";
|
|
2558
2557
|
state: "ready" | "blocked" | "all_done";
|
|
2559
2558
|
complete: number;
|
|
2560
2559
|
total: number;
|
|
2561
2560
|
remaining: number;
|
|
2561
|
+
source: "openspec-instructions-apply";
|
|
2562
2562
|
divergence: {
|
|
2563
2563
|
message: string;
|
|
2564
2564
|
kind: "tracked-task-mismatch";
|
|
@@ -2568,16 +2568,21 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
2568
2568
|
remaining: number;
|
|
2569
2569
|
};
|
|
2570
2570
|
tracked: {
|
|
2571
|
+
completed: number;
|
|
2571
2572
|
total: number;
|
|
2572
2573
|
remaining: number;
|
|
2573
|
-
|
|
2574
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
2574
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
2575
2575
|
};
|
|
2576
2576
|
} | null;
|
|
2577
2577
|
}>;
|
|
2578
2578
|
}, "strip", z.ZodTypeAny, {
|
|
2579
|
+
state: "ready" | "blocked" | "all_done";
|
|
2580
|
+
tasks: {
|
|
2581
|
+
id: string;
|
|
2582
|
+
done: boolean;
|
|
2583
|
+
description: string;
|
|
2584
|
+
}[];
|
|
2579
2585
|
evidence: {
|
|
2580
|
-
command: "instructions apply";
|
|
2581
2586
|
success: boolean;
|
|
2582
2587
|
stdout: string;
|
|
2583
2588
|
stderr: string;
|
|
@@ -2590,35 +2595,30 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
2590
2595
|
target: z.ZodOptional<z.ZodString>;
|
|
2591
2596
|
fix: z.ZodOptional<z.ZodString>;
|
|
2592
2597
|
}, z.ZodTypeAny, "passthrough">[];
|
|
2598
|
+
command: "instructions apply";
|
|
2593
2599
|
selector: {
|
|
2594
2600
|
store?: string | undefined;
|
|
2595
2601
|
};
|
|
2602
|
+
contractError?: string | undefined;
|
|
2596
2603
|
root?: z.objectOutputType<{
|
|
2597
2604
|
path: z.ZodString;
|
|
2598
2605
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
2599
2606
|
store_id: z.ZodOptional<z.ZodString>;
|
|
2600
2607
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
2601
|
-
contractError?: string | undefined;
|
|
2602
2608
|
} & {
|
|
2603
2609
|
[k: string]: unknown;
|
|
2604
2610
|
};
|
|
2605
|
-
state: "ready" | "blocked" | "all_done";
|
|
2606
2611
|
changeName: string;
|
|
2607
2612
|
schemaName: string;
|
|
2608
2613
|
changeDir: string;
|
|
2609
2614
|
instruction: string;
|
|
2610
2615
|
contextFiles: Record<string, string[]>;
|
|
2611
|
-
tasks: {
|
|
2612
|
-
id: string;
|
|
2613
|
-
description: string;
|
|
2614
|
-
done: boolean;
|
|
2615
|
-
}[];
|
|
2616
2616
|
applyInstructionProgress: {
|
|
2617
|
-
source: "openspec-instructions-apply";
|
|
2618
2617
|
state: "ready" | "blocked" | "all_done";
|
|
2619
2618
|
complete: number;
|
|
2620
2619
|
total: number;
|
|
2621
2620
|
remaining: number;
|
|
2621
|
+
source: "openspec-instructions-apply";
|
|
2622
2622
|
divergence: {
|
|
2623
2623
|
message: string;
|
|
2624
2624
|
kind: "tracked-task-mismatch";
|
|
@@ -2628,10 +2628,10 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
2628
2628
|
remaining: number;
|
|
2629
2629
|
};
|
|
2630
2630
|
tracked: {
|
|
2631
|
+
completed: number;
|
|
2631
2632
|
total: number;
|
|
2632
2633
|
remaining: number;
|
|
2633
|
-
|
|
2634
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
2634
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
2635
2635
|
};
|
|
2636
2636
|
} | null;
|
|
2637
2637
|
};
|
|
@@ -2674,8 +2674,13 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
2674
2674
|
missingArtifacts?: string[] | undefined;
|
|
2675
2675
|
operationGuidance?: string[] | undefined;
|
|
2676
2676
|
}, {
|
|
2677
|
+
state: "ready" | "blocked" | "all_done";
|
|
2678
|
+
tasks: {
|
|
2679
|
+
id: string;
|
|
2680
|
+
done: boolean;
|
|
2681
|
+
description: string;
|
|
2682
|
+
}[];
|
|
2677
2683
|
evidence: {
|
|
2678
|
-
command: "instructions apply";
|
|
2679
2684
|
success: boolean;
|
|
2680
2685
|
stdout: string;
|
|
2681
2686
|
stderr: string;
|
|
@@ -2688,35 +2693,30 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
2688
2693
|
target: z.ZodOptional<z.ZodString>;
|
|
2689
2694
|
fix: z.ZodOptional<z.ZodString>;
|
|
2690
2695
|
}, z.ZodTypeAny, "passthrough">[];
|
|
2696
|
+
command: "instructions apply";
|
|
2691
2697
|
selector: {
|
|
2692
2698
|
store?: string | undefined;
|
|
2693
2699
|
};
|
|
2700
|
+
contractError?: string | undefined;
|
|
2694
2701
|
root?: z.objectInputType<{
|
|
2695
2702
|
path: z.ZodString;
|
|
2696
2703
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
2697
2704
|
store_id: z.ZodOptional<z.ZodString>;
|
|
2698
2705
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
2699
|
-
contractError?: string | undefined;
|
|
2700
2706
|
} & {
|
|
2701
2707
|
[k: string]: unknown;
|
|
2702
2708
|
};
|
|
2703
|
-
state: "ready" | "blocked" | "all_done";
|
|
2704
2709
|
changeName: string;
|
|
2705
2710
|
schemaName: string;
|
|
2706
2711
|
changeDir: string;
|
|
2707
2712
|
instruction: string;
|
|
2708
2713
|
contextFiles: Record<string, string | string[]>;
|
|
2709
|
-
tasks: {
|
|
2710
|
-
id: string;
|
|
2711
|
-
description: string;
|
|
2712
|
-
done: boolean;
|
|
2713
|
-
}[];
|
|
2714
2714
|
applyInstructionProgress: {
|
|
2715
|
-
source: "openspec-instructions-apply";
|
|
2716
2715
|
state: "ready" | "blocked" | "all_done";
|
|
2717
2716
|
complete: number;
|
|
2718
2717
|
total: number;
|
|
2719
2718
|
remaining: number;
|
|
2719
|
+
source: "openspec-instructions-apply";
|
|
2720
2720
|
divergence: {
|
|
2721
2721
|
message: string;
|
|
2722
2722
|
kind: "tracked-task-mismatch";
|
|
@@ -2726,10 +2726,10 @@ declare const ApplyInstructionsSchema: z.ZodPipeline<z.ZodEffects<z.ZodObject<{
|
|
|
2726
2726
|
remaining: number;
|
|
2727
2727
|
};
|
|
2728
2728
|
tracked: {
|
|
2729
|
+
completed: number;
|
|
2729
2730
|
total: number;
|
|
2730
2731
|
remaining: number;
|
|
2731
|
-
|
|
2732
|
-
phase: "no-tasks" | "complete" | "in-progress";
|
|
2732
|
+
phase: "no-tasks" | "in-progress" | "complete";
|
|
2733
2733
|
};
|
|
2734
2734
|
} | null;
|
|
2735
2735
|
};
|
|
@@ -2924,7 +2924,6 @@ declare const ArchiveInstructionsSchema: z.ZodObject<{
|
|
|
2924
2924
|
}, z.ZodTypeAny, "passthrough">>;
|
|
2925
2925
|
}, "strip", z.ZodTypeAny, {
|
|
2926
2926
|
evidence: {
|
|
2927
|
-
command: "instructions archive";
|
|
2928
2927
|
success: boolean;
|
|
2929
2928
|
stdout: string;
|
|
2930
2929
|
stderr: string;
|
|
@@ -2937,15 +2936,16 @@ declare const ArchiveInstructionsSchema: z.ZodObject<{
|
|
|
2937
2936
|
target: z.ZodOptional<z.ZodString>;
|
|
2938
2937
|
fix: z.ZodOptional<z.ZodString>;
|
|
2939
2938
|
}, z.ZodTypeAny, "passthrough">[];
|
|
2939
|
+
command: "instructions archive";
|
|
2940
2940
|
selector: {
|
|
2941
2941
|
store?: string | undefined;
|
|
2942
2942
|
};
|
|
2943
|
+
contractError?: string | undefined;
|
|
2943
2944
|
root?: z.objectOutputType<{
|
|
2944
2945
|
path: z.ZodString;
|
|
2945
2946
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
2946
2947
|
store_id: z.ZodOptional<z.ZodString>;
|
|
2947
2948
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
2948
|
-
contractError?: string | undefined;
|
|
2949
2949
|
} & {
|
|
2950
2950
|
[k: string]: unknown;
|
|
2951
2951
|
};
|
|
@@ -2954,7 +2954,6 @@ declare const ArchiveInstructionsSchema: z.ZodObject<{
|
|
|
2954
2954
|
operationGuidance?: string[] | undefined;
|
|
2955
2955
|
}, {
|
|
2956
2956
|
evidence: {
|
|
2957
|
-
command: "instructions archive";
|
|
2958
2957
|
success: boolean;
|
|
2959
2958
|
stdout: string;
|
|
2960
2959
|
stderr: string;
|
|
@@ -2967,15 +2966,16 @@ declare const ArchiveInstructionsSchema: z.ZodObject<{
|
|
|
2967
2966
|
target: z.ZodOptional<z.ZodString>;
|
|
2968
2967
|
fix: z.ZodOptional<z.ZodString>;
|
|
2969
2968
|
}, z.ZodTypeAny, "passthrough">[];
|
|
2969
|
+
command: "instructions archive";
|
|
2970
2970
|
selector: {
|
|
2971
2971
|
store?: string | undefined;
|
|
2972
2972
|
};
|
|
2973
|
+
contractError?: string | undefined;
|
|
2973
2974
|
root?: z.objectInputType<{
|
|
2974
2975
|
path: z.ZodString;
|
|
2975
2976
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
2976
2977
|
store_id: z.ZodOptional<z.ZodString>;
|
|
2977
2978
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
2978
|
-
contractError?: string | undefined;
|
|
2979
2979
|
} & {
|
|
2980
2980
|
[k: string]: unknown;
|
|
2981
2981
|
};
|
|
@@ -3002,16 +3002,16 @@ declare const ArtifactInstructionsSchema: z.ZodObject<{
|
|
|
3002
3002
|
description: z.ZodString;
|
|
3003
3003
|
skipped: z.ZodOptional<z.ZodBoolean>;
|
|
3004
3004
|
}, "strip", z.ZodTypeAny, {
|
|
3005
|
-
id: string;
|
|
3006
3005
|
path: string;
|
|
3007
|
-
|
|
3006
|
+
id: string;
|
|
3008
3007
|
done: boolean;
|
|
3008
|
+
description: string;
|
|
3009
3009
|
skipped?: boolean | undefined;
|
|
3010
3010
|
}, {
|
|
3011
|
-
id: string;
|
|
3012
3011
|
path: string;
|
|
3013
|
-
|
|
3012
|
+
id: string;
|
|
3014
3013
|
done: boolean;
|
|
3014
|
+
description: string;
|
|
3015
3015
|
skipped?: boolean | undefined;
|
|
3016
3016
|
}>, "many">;
|
|
3017
3017
|
unlocks: z.ZodArray<z.ZodString, "many">;
|
|
@@ -3264,10 +3264,9 @@ declare const ArtifactInstructionsSchema: z.ZodObject<{
|
|
|
3264
3264
|
command: z.ZodLiteral<"instructions">;
|
|
3265
3265
|
}, z.ZodTypeAny, "passthrough">>;
|
|
3266
3266
|
}, "strip", z.ZodTypeAny, {
|
|
3267
|
-
|
|
3268
|
-
|
|
3267
|
+
artifactId: string;
|
|
3268
|
+
outputPath: string;
|
|
3269
3269
|
evidence: {
|
|
3270
|
-
command: "instructions";
|
|
3271
3270
|
success: boolean;
|
|
3272
3271
|
stdout: string;
|
|
3273
3272
|
stderr: string;
|
|
@@ -3280,28 +3279,29 @@ declare const ArtifactInstructionsSchema: z.ZodObject<{
|
|
|
3280
3279
|
target: z.ZodOptional<z.ZodString>;
|
|
3281
3280
|
fix: z.ZodOptional<z.ZodString>;
|
|
3282
3281
|
}, z.ZodTypeAny, "passthrough">[];
|
|
3282
|
+
command: "instructions";
|
|
3283
3283
|
selector: {
|
|
3284
3284
|
store?: string | undefined;
|
|
3285
3285
|
};
|
|
3286
|
+
contractError?: string | undefined;
|
|
3286
3287
|
root?: z.objectOutputType<{
|
|
3287
3288
|
path: z.ZodString;
|
|
3288
3289
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
3289
3290
|
store_id: z.ZodOptional<z.ZodString>;
|
|
3290
3291
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
3291
|
-
contractError?: string | undefined;
|
|
3292
3292
|
} & {
|
|
3293
3293
|
[k: string]: unknown;
|
|
3294
3294
|
};
|
|
3295
3295
|
changeName: string;
|
|
3296
3296
|
schemaName: string;
|
|
3297
|
-
outputPath: string;
|
|
3298
|
-
artifactId: string;
|
|
3299
3297
|
changeDir: string;
|
|
3298
|
+
description: string;
|
|
3299
|
+
template: string;
|
|
3300
3300
|
dependencies: {
|
|
3301
|
-
id: string;
|
|
3302
3301
|
path: string;
|
|
3303
|
-
|
|
3302
|
+
id: string;
|
|
3304
3303
|
done: boolean;
|
|
3304
|
+
description: string;
|
|
3305
3305
|
skipped?: boolean | undefined;
|
|
3306
3306
|
}[];
|
|
3307
3307
|
unlocks: string[];
|
|
@@ -3344,10 +3344,9 @@ declare const ArtifactInstructionsSchema: z.ZodObject<{
|
|
|
3344
3344
|
instruction?: string | null | undefined;
|
|
3345
3345
|
rules?: string[] | null | undefined;
|
|
3346
3346
|
}, {
|
|
3347
|
-
|
|
3348
|
-
|
|
3347
|
+
artifactId: string;
|
|
3348
|
+
outputPath: string;
|
|
3349
3349
|
evidence: {
|
|
3350
|
-
command: "instructions";
|
|
3351
3350
|
success: boolean;
|
|
3352
3351
|
stdout: string;
|
|
3353
3352
|
stderr: string;
|
|
@@ -3360,28 +3359,29 @@ declare const ArtifactInstructionsSchema: z.ZodObject<{
|
|
|
3360
3359
|
target: z.ZodOptional<z.ZodString>;
|
|
3361
3360
|
fix: z.ZodOptional<z.ZodString>;
|
|
3362
3361
|
}, z.ZodTypeAny, "passthrough">[];
|
|
3362
|
+
command: "instructions";
|
|
3363
3363
|
selector: {
|
|
3364
3364
|
store?: string | undefined;
|
|
3365
3365
|
};
|
|
3366
|
+
contractError?: string | undefined;
|
|
3366
3367
|
root?: z.objectInputType<{
|
|
3367
3368
|
path: z.ZodString;
|
|
3368
3369
|
source: z.ZodEnum<["store", "declared", "nearest", "global_default", "implicit"]>;
|
|
3369
3370
|
store_id: z.ZodOptional<z.ZodString>;
|
|
3370
3371
|
}, z.ZodTypeAny, "passthrough"> | undefined;
|
|
3371
|
-
contractError?: string | undefined;
|
|
3372
3372
|
} & {
|
|
3373
3373
|
[k: string]: unknown;
|
|
3374
3374
|
};
|
|
3375
3375
|
changeName: string;
|
|
3376
3376
|
schemaName: string;
|
|
3377
|
-
outputPath: string;
|
|
3378
|
-
artifactId: string;
|
|
3379
3377
|
changeDir: string;
|
|
3378
|
+
description: string;
|
|
3379
|
+
template: string;
|
|
3380
3380
|
dependencies: {
|
|
3381
|
-
id: string;
|
|
3382
3381
|
path: string;
|
|
3383
|
-
|
|
3382
|
+
id: string;
|
|
3384
3383
|
done: boolean;
|
|
3384
|
+
description: string;
|
|
3385
3385
|
skipped?: boolean | undefined;
|
|
3386
3386
|
}[];
|
|
3387
3387
|
unlocks: string[];
|
|
@@ -3542,15 +3542,15 @@ declare const SchemaArtifactSchema: z.ZodObject<{
|
|
|
3542
3542
|
outputPath: string;
|
|
3543
3543
|
requires: string[];
|
|
3544
3544
|
description?: string | undefined;
|
|
3545
|
-
template?: string | undefined;
|
|
3546
3545
|
instruction?: string | undefined;
|
|
3546
|
+
template?: string | undefined;
|
|
3547
3547
|
}, {
|
|
3548
3548
|
id: string;
|
|
3549
3549
|
outputPath: string;
|
|
3550
3550
|
requires: string[];
|
|
3551
3551
|
description?: string | undefined;
|
|
3552
|
-
template?: string | undefined;
|
|
3553
3552
|
instruction?: string | undefined;
|
|
3553
|
+
template?: string | undefined;
|
|
3554
3554
|
}>;
|
|
3555
3555
|
type SchemaArtifact = z.infer<typeof SchemaArtifactSchema>;
|
|
3556
3556
|
declare const SchemaDetailSchema: z.ZodObject<{
|
|
@@ -3569,15 +3569,15 @@ declare const SchemaDetailSchema: z.ZodObject<{
|
|
|
3569
3569
|
outputPath: string;
|
|
3570
3570
|
requires: string[];
|
|
3571
3571
|
description?: string | undefined;
|
|
3572
|
-
template?: string | undefined;
|
|
3573
3572
|
instruction?: string | undefined;
|
|
3573
|
+
template?: string | undefined;
|
|
3574
3574
|
}, {
|
|
3575
3575
|
id: string;
|
|
3576
3576
|
outputPath: string;
|
|
3577
3577
|
requires: string[];
|
|
3578
3578
|
description?: string | undefined;
|
|
3579
|
-
template?: string | undefined;
|
|
3580
3579
|
instruction?: string | undefined;
|
|
3580
|
+
template?: string | undefined;
|
|
3581
3581
|
}>, "many">;
|
|
3582
3582
|
applyRequires: z.ZodArray<z.ZodString, "many">;
|
|
3583
3583
|
applyTracks: z.ZodOptional<z.ZodString>;
|
|
@@ -3590,11 +3590,11 @@ declare const SchemaDetailSchema: z.ZodObject<{
|
|
|
3590
3590
|
outputPath: string;
|
|
3591
3591
|
requires: string[];
|
|
3592
3592
|
description?: string | undefined;
|
|
3593
|
-
template?: string | undefined;
|
|
3594
3593
|
instruction?: string | undefined;
|
|
3594
|
+
template?: string | undefined;
|
|
3595
3595
|
}[];
|
|
3596
|
-
description?: string | undefined;
|
|
3597
3596
|
version?: string | number | undefined;
|
|
3597
|
+
description?: string | undefined;
|
|
3598
3598
|
applyTracks?: string | undefined;
|
|
3599
3599
|
applyInstruction?: string | undefined;
|
|
3600
3600
|
}, {
|
|
@@ -3605,11 +3605,11 @@ declare const SchemaDetailSchema: z.ZodObject<{
|
|
|
3605
3605
|
outputPath: string;
|
|
3606
3606
|
requires: string[];
|
|
3607
3607
|
description?: string | undefined;
|
|
3608
|
-
template?: string | undefined;
|
|
3609
3608
|
instruction?: string | undefined;
|
|
3609
|
+
template?: string | undefined;
|
|
3610
3610
|
}[];
|
|
3611
|
-
description?: string | undefined;
|
|
3612
3611
|
version?: string | number | undefined;
|
|
3612
|
+
description?: string | undefined;
|
|
3613
3613
|
applyTracks?: string | undefined;
|
|
3614
3614
|
applyInstruction?: string | undefined;
|
|
3615
3615
|
}>;
|
|
@@ -3648,15 +3648,15 @@ declare const OpsxConfigBundleSchema: z.ZodObject<{
|
|
|
3648
3648
|
outputPath: string;
|
|
3649
3649
|
requires: string[];
|
|
3650
3650
|
description?: string | undefined;
|
|
3651
|
-
template?: string | undefined;
|
|
3652
3651
|
instruction?: string | undefined;
|
|
3652
|
+
template?: string | undefined;
|
|
3653
3653
|
}, {
|
|
3654
3654
|
id: string;
|
|
3655
3655
|
outputPath: string;
|
|
3656
3656
|
requires: string[];
|
|
3657
3657
|
description?: string | undefined;
|
|
3658
|
-
template?: string | undefined;
|
|
3659
3658
|
instruction?: string | undefined;
|
|
3659
|
+
template?: string | undefined;
|
|
3660
3660
|
}>, "many">;
|
|
3661
3661
|
applyRequires: z.ZodArray<z.ZodString, "many">;
|
|
3662
3662
|
applyTracks: z.ZodOptional<z.ZodString>;
|
|
@@ -3669,11 +3669,11 @@ declare const OpsxConfigBundleSchema: z.ZodObject<{
|
|
|
3669
3669
|
outputPath: string;
|
|
3670
3670
|
requires: string[];
|
|
3671
3671
|
description?: string | undefined;
|
|
3672
|
-
template?: string | undefined;
|
|
3673
3672
|
instruction?: string | undefined;
|
|
3673
|
+
template?: string | undefined;
|
|
3674
3674
|
}[];
|
|
3675
|
-
description?: string | undefined;
|
|
3676
3675
|
version?: string | number | undefined;
|
|
3676
|
+
description?: string | undefined;
|
|
3677
3677
|
applyTracks?: string | undefined;
|
|
3678
3678
|
applyInstruction?: string | undefined;
|
|
3679
3679
|
}, {
|
|
@@ -3684,11 +3684,11 @@ declare const OpsxConfigBundleSchema: z.ZodObject<{
|
|
|
3684
3684
|
outputPath: string;
|
|
3685
3685
|
requires: string[];
|
|
3686
3686
|
description?: string | undefined;
|
|
3687
|
-
template?: string | undefined;
|
|
3688
3687
|
instruction?: string | undefined;
|
|
3688
|
+
template?: string | undefined;
|
|
3689
3689
|
}[];
|
|
3690
|
-
description?: string | undefined;
|
|
3691
3690
|
version?: string | number | undefined;
|
|
3691
|
+
description?: string | undefined;
|
|
3692
3692
|
applyTracks?: string | undefined;
|
|
3693
3693
|
applyInstruction?: string | undefined;
|
|
3694
3694
|
}>>>;
|
|
@@ -3774,11 +3774,11 @@ declare const OpsxConfigBundleSchema: z.ZodObject<{
|
|
|
3774
3774
|
outputPath: string;
|
|
3775
3775
|
requires: string[];
|
|
3776
3776
|
description?: string | undefined;
|
|
3777
|
-
template?: string | undefined;
|
|
3778
3777
|
instruction?: string | undefined;
|
|
3778
|
+
template?: string | undefined;
|
|
3779
3779
|
}[];
|
|
3780
|
-
description?: string | undefined;
|
|
3781
3780
|
version?: string | number | undefined;
|
|
3781
|
+
description?: string | undefined;
|
|
3782
3782
|
applyTracks?: string | undefined;
|
|
3783
3783
|
applyInstruction?: string | undefined;
|
|
3784
3784
|
} | null>;
|
|
@@ -3820,11 +3820,11 @@ declare const OpsxConfigBundleSchema: z.ZodObject<{
|
|
|
3820
3820
|
outputPath: string;
|
|
3821
3821
|
requires: string[];
|
|
3822
3822
|
description?: string | undefined;
|
|
3823
|
-
template?: string | undefined;
|
|
3824
3823
|
instruction?: string | undefined;
|
|
3824
|
+
template?: string | undefined;
|
|
3825
3825
|
}[];
|
|
3826
|
-
description?: string | undefined;
|
|
3827
3826
|
version?: string | number | undefined;
|
|
3827
|
+
description?: string | undefined;
|
|
3828
3828
|
applyTracks?: string | undefined;
|
|
3829
3829
|
applyInstruction?: string | undefined;
|
|
3830
3830
|
} | null>;
|