cc-codeconductor 1.7.0 → 1.7.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (29) hide show
  1. package/README.md +11 -10
  2. package/dist/index.d.ts +1 -0
  3. package/dist/index.js +2689 -528
  4. package/dist/library.js +859 -715
  5. package/dist/validation/schemas.d.ts +784 -138
  6. package/dist/validation/scoped-context-schemas.d.ts +1074 -0
  7. package/package.json +3 -2
  8. package/presets/agy/skills/database-migrations/SKILL.md +64 -0
  9. package/presets/agy/skills/rust-async/SKILL.md +64 -0
  10. package/presets/agy/skills/rust-engineering/SKILL.md +69 -0
  11. package/presets/agy/skills/rust-sqlx/SKILL.md +64 -0
  12. package/presets/claude/settings.json +1 -8
  13. package/presets/claude/skills/database-migrations/SKILL.md +64 -0
  14. package/presets/claude/skills/rust-async/SKILL.md +64 -0
  15. package/presets/claude/skills/rust-engineering/SKILL.md +69 -0
  16. package/presets/claude/skills/rust-sqlx/SKILL.md +64 -0
  17. package/presets/codex/skills/database-migrations/SKILL.md +64 -0
  18. package/presets/codex/skills/rust-async/SKILL.md +64 -0
  19. package/presets/codex/skills/rust-engineering/SKILL.md +69 -0
  20. package/presets/codex/skills/rust-sqlx/SKILL.md +64 -0
  21. package/presets/cursor/skills/database-migrations/SKILL.md +64 -0
  22. package/presets/cursor/skills/rust-async/SKILL.md +64 -0
  23. package/presets/cursor/skills/rust-engineering/SKILL.md +69 -0
  24. package/presets/cursor/skills/rust-sqlx/SKILL.md +64 -0
  25. package/presets/opencode/skills/database-migrations/SKILL.md +64 -0
  26. package/presets/opencode/skills/rust-async/SKILL.md +64 -0
  27. package/presets/opencode/skills/rust-engineering/SKILL.md +69 -0
  28. package/presets/opencode/skills/rust-sqlx/SKILL.md +64 -0
  29. package/src/presets/shared-skills.yml +8 -0
@@ -0,0 +1,1074 @@
1
+ import { z } from 'zod';
2
+ export declare const RuleKindSchema: z.ZodEnum<["default", "invariant"]>;
3
+ /** Origin class is assigned by the registry, never by the rule itself (strict). */
4
+ export declare const OriginClassSchema: z.ZodEnum<["engine", "stack", "repository", "task"]>;
5
+ export declare const ScopedRuleSchema: z.ZodObject<{
6
+ id: z.ZodString;
7
+ kind: z.ZodEnum<["default", "invariant"]>;
8
+ scopeRoot: z.ZodUnion<[z.ZodLiteral<".">, z.ZodEffects<z.ZodString, string, string>]>;
9
+ paths: z.ZodDefault<z.ZodObject<{
10
+ files: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
11
+ subtrees: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
12
+ }, "strict", z.ZodTypeAny, {
13
+ files: string[];
14
+ subtrees: string[];
15
+ }, {
16
+ files?: string[] | undefined;
17
+ subtrees?: string[] | undefined;
18
+ }>>;
19
+ when: z.ZodDefault<z.ZodObject<{
20
+ languages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
21
+ roles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
22
+ }, "strict", z.ZodTypeAny, {
23
+ languages?: string[] | undefined;
24
+ roles?: string[] | undefined;
25
+ }, {
26
+ languages?: string[] | undefined;
27
+ roles?: string[] | undefined;
28
+ }>>;
29
+ trigger: z.ZodString;
30
+ action: z.ZodString;
31
+ reason: z.ZodString;
32
+ exceptions: z.ZodString;
33
+ verification: z.ZodObject<{
34
+ recipeIds: z.ZodArray<z.ZodString, "many">;
35
+ }, "strict", z.ZodTypeAny, {
36
+ recipeIds: string[];
37
+ }, {
38
+ recipeIds: string[];
39
+ }>;
40
+ references: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
41
+ }, "strict", z.ZodTypeAny, {
42
+ id: string;
43
+ kind: "default" | "invariant";
44
+ scopeRoot: string;
45
+ paths: {
46
+ files: string[];
47
+ subtrees: string[];
48
+ };
49
+ when: {
50
+ languages?: string[] | undefined;
51
+ roles?: string[] | undefined;
52
+ };
53
+ trigger: string;
54
+ action: string;
55
+ reason: string;
56
+ exceptions: string;
57
+ verification: {
58
+ recipeIds: string[];
59
+ };
60
+ references: string[];
61
+ }, {
62
+ id: string;
63
+ kind: "default" | "invariant";
64
+ scopeRoot: string;
65
+ trigger: string;
66
+ action: string;
67
+ reason: string;
68
+ exceptions: string;
69
+ verification: {
70
+ recipeIds: string[];
71
+ };
72
+ paths?: {
73
+ files?: string[] | undefined;
74
+ subtrees?: string[] | undefined;
75
+ } | undefined;
76
+ when?: {
77
+ languages?: string[] | undefined;
78
+ roles?: string[] | undefined;
79
+ } | undefined;
80
+ references?: string[] | undefined;
81
+ }>;
82
+ export declare const ScopedRuleFileSchema: z.ZodObject<{
83
+ schemaVersion: z.ZodLiteral<1>;
84
+ rules: z.ZodArray<z.ZodObject<{
85
+ id: z.ZodString;
86
+ kind: z.ZodEnum<["default", "invariant"]>;
87
+ scopeRoot: z.ZodUnion<[z.ZodLiteral<".">, z.ZodEffects<z.ZodString, string, string>]>;
88
+ paths: z.ZodDefault<z.ZodObject<{
89
+ files: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
90
+ subtrees: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
91
+ }, "strict", z.ZodTypeAny, {
92
+ files: string[];
93
+ subtrees: string[];
94
+ }, {
95
+ files?: string[] | undefined;
96
+ subtrees?: string[] | undefined;
97
+ }>>;
98
+ when: z.ZodDefault<z.ZodObject<{
99
+ languages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
100
+ roles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
101
+ }, "strict", z.ZodTypeAny, {
102
+ languages?: string[] | undefined;
103
+ roles?: string[] | undefined;
104
+ }, {
105
+ languages?: string[] | undefined;
106
+ roles?: string[] | undefined;
107
+ }>>;
108
+ trigger: z.ZodString;
109
+ action: z.ZodString;
110
+ reason: z.ZodString;
111
+ exceptions: z.ZodString;
112
+ verification: z.ZodObject<{
113
+ recipeIds: z.ZodArray<z.ZodString, "many">;
114
+ }, "strict", z.ZodTypeAny, {
115
+ recipeIds: string[];
116
+ }, {
117
+ recipeIds: string[];
118
+ }>;
119
+ references: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
120
+ }, "strict", z.ZodTypeAny, {
121
+ id: string;
122
+ kind: "default" | "invariant";
123
+ scopeRoot: string;
124
+ paths: {
125
+ files: string[];
126
+ subtrees: string[];
127
+ };
128
+ when: {
129
+ languages?: string[] | undefined;
130
+ roles?: string[] | undefined;
131
+ };
132
+ trigger: string;
133
+ action: string;
134
+ reason: string;
135
+ exceptions: string;
136
+ verification: {
137
+ recipeIds: string[];
138
+ };
139
+ references: string[];
140
+ }, {
141
+ id: string;
142
+ kind: "default" | "invariant";
143
+ scopeRoot: string;
144
+ trigger: string;
145
+ action: string;
146
+ reason: string;
147
+ exceptions: string;
148
+ verification: {
149
+ recipeIds: string[];
150
+ };
151
+ paths?: {
152
+ files?: string[] | undefined;
153
+ subtrees?: string[] | undefined;
154
+ } | undefined;
155
+ when?: {
156
+ languages?: string[] | undefined;
157
+ roles?: string[] | undefined;
158
+ } | undefined;
159
+ references?: string[] | undefined;
160
+ }>, "many">;
161
+ }, "strict", z.ZodTypeAny, {
162
+ schemaVersion: 1;
163
+ rules: {
164
+ id: string;
165
+ kind: "default" | "invariant";
166
+ scopeRoot: string;
167
+ paths: {
168
+ files: string[];
169
+ subtrees: string[];
170
+ };
171
+ when: {
172
+ languages?: string[] | undefined;
173
+ roles?: string[] | undefined;
174
+ };
175
+ trigger: string;
176
+ action: string;
177
+ reason: string;
178
+ exceptions: string;
179
+ verification: {
180
+ recipeIds: string[];
181
+ };
182
+ references: string[];
183
+ }[];
184
+ }, {
185
+ schemaVersion: 1;
186
+ rules: {
187
+ id: string;
188
+ kind: "default" | "invariant";
189
+ scopeRoot: string;
190
+ trigger: string;
191
+ action: string;
192
+ reason: string;
193
+ exceptions: string;
194
+ verification: {
195
+ recipeIds: string[];
196
+ };
197
+ paths?: {
198
+ files?: string[] | undefined;
199
+ subtrees?: string[] | undefined;
200
+ } | undefined;
201
+ when?: {
202
+ languages?: string[] | undefined;
203
+ roles?: string[] | undefined;
204
+ } | undefined;
205
+ references?: string[] | undefined;
206
+ }[];
207
+ }>;
208
+ export declare const RecipeStatusSchema: z.ZodEnum<["PASS", "FAIL", "BLOCKED", "SKIPPED"]>;
209
+ export declare const RecipeStepSchema: z.ZodObject<{
210
+ executable: z.ZodString;
211
+ argv: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
212
+ cwd: z.ZodUnion<[z.ZodLiteral<".">, z.ZodEffects<z.ZodString, string, string>]>;
213
+ timeoutSeconds: z.ZodNumber;
214
+ expectedExitCodes: z.ZodArray<z.ZodNumber, "many">;
215
+ environment: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
216
+ }, "strict", z.ZodTypeAny, {
217
+ executable: string;
218
+ argv: string[];
219
+ cwd: string;
220
+ timeoutSeconds: number;
221
+ expectedExitCodes: number[];
222
+ environment: Record<string, string>;
223
+ }, {
224
+ executable: string;
225
+ argv: string[];
226
+ cwd: string;
227
+ timeoutSeconds: number;
228
+ expectedExitCodes: number[];
229
+ environment?: Record<string, string> | undefined;
230
+ }>;
231
+ export declare const VerificationRecipeSchema: z.ZodObject<{
232
+ schemaVersion: z.ZodLiteral<1>;
233
+ id: z.ZodString;
234
+ version: z.ZodNumber;
235
+ scope: z.ZodObject<{
236
+ workspaceRoot: z.ZodUnion<[z.ZodLiteral<".">, z.ZodEffects<z.ZodString, string, string>]>;
237
+ manifest: z.ZodEffects<z.ZodString, string, string>;
238
+ package: z.ZodOptional<z.ZodString>;
239
+ }, "strict", z.ZodTypeAny, {
240
+ workspaceRoot: string;
241
+ manifest: string;
242
+ package?: string | undefined;
243
+ }, {
244
+ workspaceRoot: string;
245
+ manifest: string;
246
+ package?: string | undefined;
247
+ }>;
248
+ prerequisites: z.ZodObject<{
249
+ tools: z.ZodArray<z.ZodString, "many">;
250
+ lockfileRequired: z.ZodBoolean;
251
+ dependencyCacheRequired: z.ZodBoolean;
252
+ }, "strict", z.ZodTypeAny, {
253
+ tools: string[];
254
+ lockfileRequired: boolean;
255
+ dependencyCacheRequired: boolean;
256
+ }, {
257
+ tools: string[];
258
+ lockfileRequired: boolean;
259
+ dependencyCacheRequired: boolean;
260
+ }>;
261
+ steps: z.ZodArray<z.ZodObject<{
262
+ executable: z.ZodString;
263
+ argv: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
264
+ cwd: z.ZodUnion<[z.ZodLiteral<".">, z.ZodEffects<z.ZodString, string, string>]>;
265
+ timeoutSeconds: z.ZodNumber;
266
+ expectedExitCodes: z.ZodArray<z.ZodNumber, "many">;
267
+ environment: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
268
+ }, "strict", z.ZodTypeAny, {
269
+ executable: string;
270
+ argv: string[];
271
+ cwd: string;
272
+ timeoutSeconds: number;
273
+ expectedExitCodes: number[];
274
+ environment: Record<string, string>;
275
+ }, {
276
+ executable: string;
277
+ argv: string[];
278
+ cwd: string;
279
+ timeoutSeconds: number;
280
+ expectedExitCodes: number[];
281
+ environment?: Record<string, string> | undefined;
282
+ }>, "many">;
283
+ evidence: z.ZodObject<{
284
+ requireObservedExecution: z.ZodLiteral<true>;
285
+ requireCandidateUnchanged: z.ZodBoolean;
286
+ }, "strict", z.ZodTypeAny, {
287
+ requireObservedExecution: true;
288
+ requireCandidateUnchanged: boolean;
289
+ }, {
290
+ requireObservedExecution: true;
291
+ requireCandidateUnchanged: boolean;
292
+ }>;
293
+ }, "strict", z.ZodTypeAny, {
294
+ id: string;
295
+ schemaVersion: 1;
296
+ version: number;
297
+ scope: {
298
+ workspaceRoot: string;
299
+ manifest: string;
300
+ package?: string | undefined;
301
+ };
302
+ prerequisites: {
303
+ tools: string[];
304
+ lockfileRequired: boolean;
305
+ dependencyCacheRequired: boolean;
306
+ };
307
+ steps: {
308
+ executable: string;
309
+ argv: string[];
310
+ cwd: string;
311
+ timeoutSeconds: number;
312
+ expectedExitCodes: number[];
313
+ environment: Record<string, string>;
314
+ }[];
315
+ evidence: {
316
+ requireObservedExecution: true;
317
+ requireCandidateUnchanged: boolean;
318
+ };
319
+ }, {
320
+ id: string;
321
+ schemaVersion: 1;
322
+ version: number;
323
+ scope: {
324
+ workspaceRoot: string;
325
+ manifest: string;
326
+ package?: string | undefined;
327
+ };
328
+ prerequisites: {
329
+ tools: string[];
330
+ lockfileRequired: boolean;
331
+ dependencyCacheRequired: boolean;
332
+ };
333
+ steps: {
334
+ executable: string;
335
+ argv: string[];
336
+ cwd: string;
337
+ timeoutSeconds: number;
338
+ expectedExitCodes: number[];
339
+ environment?: Record<string, string> | undefined;
340
+ }[];
341
+ evidence: {
342
+ requireObservedExecution: true;
343
+ requireCandidateUnchanged: boolean;
344
+ };
345
+ }>;
346
+ export declare const ContextManifestSchema: z.ZodObject<{
347
+ schemaVersion: z.ZodLiteral<1>;
348
+ scope: z.ZodObject<{
349
+ files: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
350
+ role: z.ZodString;
351
+ }, "strict", z.ZodTypeAny, {
352
+ files: string[];
353
+ role: string;
354
+ }, {
355
+ files: string[];
356
+ role: string;
357
+ }>;
358
+ profiles: z.ZodArray<z.ZodUnknown, "many">;
359
+ skills: z.ZodArray<z.ZodObject<{
360
+ id: z.ZodString;
361
+ version: z.ZodString;
362
+ }, "strict", z.ZodTypeAny, {
363
+ id: string;
364
+ version: string;
365
+ }, {
366
+ id: string;
367
+ version: string;
368
+ }>, "many">;
369
+ rules: z.ZodArray<z.ZodObject<{
370
+ id: z.ZodString;
371
+ kind: z.ZodEnum<["default", "invariant"]>;
372
+ originClass: z.ZodEnum<["engine", "stack", "repository", "task"]>;
373
+ scopeRoot: z.ZodString;
374
+ depth: z.ZodNumber;
375
+ sourcePath: z.ZodString;
376
+ contentHash: z.ZodString;
377
+ appliesTo: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
378
+ }, "strict", z.ZodTypeAny, {
379
+ id: string;
380
+ kind: "default" | "invariant";
381
+ scopeRoot: string;
382
+ originClass: "engine" | "stack" | "repository" | "task";
383
+ depth: number;
384
+ sourcePath: string;
385
+ contentHash: string;
386
+ appliesTo: string[];
387
+ }, {
388
+ id: string;
389
+ kind: "default" | "invariant";
390
+ scopeRoot: string;
391
+ originClass: "engine" | "stack" | "repository" | "task";
392
+ depth: number;
393
+ sourcePath: string;
394
+ contentHash: string;
395
+ appliesTo: string[];
396
+ }>, "many">;
397
+ overrides: z.ZodArray<z.ZodObject<{
398
+ id: z.ZodString;
399
+ winner: z.ZodString;
400
+ loser: z.ZodString;
401
+ }, "strict", z.ZodTypeAny, {
402
+ id: string;
403
+ winner: string;
404
+ loser: string;
405
+ }, {
406
+ id: string;
407
+ winner: string;
408
+ loser: string;
409
+ }>, "many">;
410
+ omittedReferences: z.ZodArray<z.ZodObject<{
411
+ ref: z.ZodString;
412
+ reason: z.ZodString;
413
+ }, "strict", z.ZodTypeAny, {
414
+ reason: string;
415
+ ref: string;
416
+ }, {
417
+ reason: string;
418
+ ref: string;
419
+ }>, "many">;
420
+ diagnostics: z.ZodArray<z.ZodObject<{
421
+ code: z.ZodString;
422
+ severity: z.ZodEnum<["info", "warning", "blocking"]>;
423
+ message: z.ZodString;
424
+ }, "strict", z.ZodTypeAny, {
425
+ code: string;
426
+ message: string;
427
+ severity: "info" | "warning" | "blocking";
428
+ }, {
429
+ code: string;
430
+ message: string;
431
+ severity: "info" | "warning" | "blocking";
432
+ }>, "many">;
433
+ budget: z.ZodObject<{
434
+ maxBytes: z.ZodNumber;
435
+ usedBytes: z.ZodNumber;
436
+ }, "strict", z.ZodTypeAny, {
437
+ maxBytes: number;
438
+ usedBytes: number;
439
+ }, {
440
+ maxBytes: number;
441
+ usedBytes: number;
442
+ }>;
443
+ hash: z.ZodString;
444
+ }, "strict", z.ZodTypeAny, {
445
+ schemaVersion: 1;
446
+ rules: {
447
+ id: string;
448
+ kind: "default" | "invariant";
449
+ scopeRoot: string;
450
+ originClass: "engine" | "stack" | "repository" | "task";
451
+ depth: number;
452
+ sourcePath: string;
453
+ contentHash: string;
454
+ appliesTo: string[];
455
+ }[];
456
+ scope: {
457
+ files: string[];
458
+ role: string;
459
+ };
460
+ profiles: unknown[];
461
+ skills: {
462
+ id: string;
463
+ version: string;
464
+ }[];
465
+ overrides: {
466
+ id: string;
467
+ winner: string;
468
+ loser: string;
469
+ }[];
470
+ omittedReferences: {
471
+ reason: string;
472
+ ref: string;
473
+ }[];
474
+ diagnostics: {
475
+ code: string;
476
+ message: string;
477
+ severity: "info" | "warning" | "blocking";
478
+ }[];
479
+ budget: {
480
+ maxBytes: number;
481
+ usedBytes: number;
482
+ };
483
+ hash: string;
484
+ }, {
485
+ schemaVersion: 1;
486
+ rules: {
487
+ id: string;
488
+ kind: "default" | "invariant";
489
+ scopeRoot: string;
490
+ originClass: "engine" | "stack" | "repository" | "task";
491
+ depth: number;
492
+ sourcePath: string;
493
+ contentHash: string;
494
+ appliesTo: string[];
495
+ }[];
496
+ scope: {
497
+ files: string[];
498
+ role: string;
499
+ };
500
+ profiles: unknown[];
501
+ skills: {
502
+ id: string;
503
+ version: string;
504
+ }[];
505
+ overrides: {
506
+ id: string;
507
+ winner: string;
508
+ loser: string;
509
+ }[];
510
+ omittedReferences: {
511
+ reason: string;
512
+ ref: string;
513
+ }[];
514
+ diagnostics: {
515
+ code: string;
516
+ message: string;
517
+ severity: "info" | "warning" | "blocking";
518
+ }[];
519
+ budget: {
520
+ maxBytes: number;
521
+ usedBytes: number;
522
+ };
523
+ hash: string;
524
+ }>;
525
+ /** Compact, role-filtered rules as they reach the prompt; `hash` covers exactly this view. */
526
+ export declare const RuleViewSchema: z.ZodObject<{
527
+ id: z.ZodString;
528
+ kind: z.ZodEnum<["default", "invariant"]>;
529
+ trigger: z.ZodString;
530
+ action: z.ZodString;
531
+ exceptions: z.ZodString;
532
+ verify: z.ZodArray<z.ZodString, "many">;
533
+ appliesTo: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
534
+ source: z.ZodString;
535
+ }, "strict", z.ZodTypeAny, {
536
+ id: string;
537
+ kind: "default" | "invariant";
538
+ trigger: string;
539
+ action: string;
540
+ exceptions: string;
541
+ appliesTo: string[];
542
+ verify: string[];
543
+ source: string;
544
+ }, {
545
+ id: string;
546
+ kind: "default" | "invariant";
547
+ trigger: string;
548
+ action: string;
549
+ exceptions: string;
550
+ appliesTo: string[];
551
+ verify: string[];
552
+ source: string;
553
+ }>;
554
+ export declare const ScopedContextSchema: z.ZodObject<{
555
+ manifest: z.ZodObject<{
556
+ schemaVersion: z.ZodLiteral<1>;
557
+ scope: z.ZodObject<{
558
+ files: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
559
+ role: z.ZodString;
560
+ }, "strict", z.ZodTypeAny, {
561
+ files: string[];
562
+ role: string;
563
+ }, {
564
+ files: string[];
565
+ role: string;
566
+ }>;
567
+ profiles: z.ZodArray<z.ZodUnknown, "many">;
568
+ skills: z.ZodArray<z.ZodObject<{
569
+ id: z.ZodString;
570
+ version: z.ZodString;
571
+ }, "strict", z.ZodTypeAny, {
572
+ id: string;
573
+ version: string;
574
+ }, {
575
+ id: string;
576
+ version: string;
577
+ }>, "many">;
578
+ rules: z.ZodArray<z.ZodObject<{
579
+ id: z.ZodString;
580
+ kind: z.ZodEnum<["default", "invariant"]>;
581
+ originClass: z.ZodEnum<["engine", "stack", "repository", "task"]>;
582
+ scopeRoot: z.ZodString;
583
+ depth: z.ZodNumber;
584
+ sourcePath: z.ZodString;
585
+ contentHash: z.ZodString;
586
+ appliesTo: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
587
+ }, "strict", z.ZodTypeAny, {
588
+ id: string;
589
+ kind: "default" | "invariant";
590
+ scopeRoot: string;
591
+ originClass: "engine" | "stack" | "repository" | "task";
592
+ depth: number;
593
+ sourcePath: string;
594
+ contentHash: string;
595
+ appliesTo: string[];
596
+ }, {
597
+ id: string;
598
+ kind: "default" | "invariant";
599
+ scopeRoot: string;
600
+ originClass: "engine" | "stack" | "repository" | "task";
601
+ depth: number;
602
+ sourcePath: string;
603
+ contentHash: string;
604
+ appliesTo: string[];
605
+ }>, "many">;
606
+ overrides: z.ZodArray<z.ZodObject<{
607
+ id: z.ZodString;
608
+ winner: z.ZodString;
609
+ loser: z.ZodString;
610
+ }, "strict", z.ZodTypeAny, {
611
+ id: string;
612
+ winner: string;
613
+ loser: string;
614
+ }, {
615
+ id: string;
616
+ winner: string;
617
+ loser: string;
618
+ }>, "many">;
619
+ omittedReferences: z.ZodArray<z.ZodObject<{
620
+ ref: z.ZodString;
621
+ reason: z.ZodString;
622
+ }, "strict", z.ZodTypeAny, {
623
+ reason: string;
624
+ ref: string;
625
+ }, {
626
+ reason: string;
627
+ ref: string;
628
+ }>, "many">;
629
+ diagnostics: z.ZodArray<z.ZodObject<{
630
+ code: z.ZodString;
631
+ severity: z.ZodEnum<["info", "warning", "blocking"]>;
632
+ message: z.ZodString;
633
+ }, "strict", z.ZodTypeAny, {
634
+ code: string;
635
+ message: string;
636
+ severity: "info" | "warning" | "blocking";
637
+ }, {
638
+ code: string;
639
+ message: string;
640
+ severity: "info" | "warning" | "blocking";
641
+ }>, "many">;
642
+ budget: z.ZodObject<{
643
+ maxBytes: z.ZodNumber;
644
+ usedBytes: z.ZodNumber;
645
+ }, "strict", z.ZodTypeAny, {
646
+ maxBytes: number;
647
+ usedBytes: number;
648
+ }, {
649
+ maxBytes: number;
650
+ usedBytes: number;
651
+ }>;
652
+ hash: z.ZodString;
653
+ }, "strict", z.ZodTypeAny, {
654
+ schemaVersion: 1;
655
+ rules: {
656
+ id: string;
657
+ kind: "default" | "invariant";
658
+ scopeRoot: string;
659
+ originClass: "engine" | "stack" | "repository" | "task";
660
+ depth: number;
661
+ sourcePath: string;
662
+ contentHash: string;
663
+ appliesTo: string[];
664
+ }[];
665
+ scope: {
666
+ files: string[];
667
+ role: string;
668
+ };
669
+ profiles: unknown[];
670
+ skills: {
671
+ id: string;
672
+ version: string;
673
+ }[];
674
+ overrides: {
675
+ id: string;
676
+ winner: string;
677
+ loser: string;
678
+ }[];
679
+ omittedReferences: {
680
+ reason: string;
681
+ ref: string;
682
+ }[];
683
+ diagnostics: {
684
+ code: string;
685
+ message: string;
686
+ severity: "info" | "warning" | "blocking";
687
+ }[];
688
+ budget: {
689
+ maxBytes: number;
690
+ usedBytes: number;
691
+ };
692
+ hash: string;
693
+ }, {
694
+ schemaVersion: 1;
695
+ rules: {
696
+ id: string;
697
+ kind: "default" | "invariant";
698
+ scopeRoot: string;
699
+ originClass: "engine" | "stack" | "repository" | "task";
700
+ depth: number;
701
+ sourcePath: string;
702
+ contentHash: string;
703
+ appliesTo: string[];
704
+ }[];
705
+ scope: {
706
+ files: string[];
707
+ role: string;
708
+ };
709
+ profiles: unknown[];
710
+ skills: {
711
+ id: string;
712
+ version: string;
713
+ }[];
714
+ overrides: {
715
+ id: string;
716
+ winner: string;
717
+ loser: string;
718
+ }[];
719
+ omittedReferences: {
720
+ reason: string;
721
+ ref: string;
722
+ }[];
723
+ diagnostics: {
724
+ code: string;
725
+ message: string;
726
+ severity: "info" | "warning" | "blocking";
727
+ }[];
728
+ budget: {
729
+ maxBytes: number;
730
+ usedBytes: number;
731
+ };
732
+ hash: string;
733
+ }>;
734
+ view: z.ZodObject<{
735
+ hash: z.ZodString;
736
+ rules: z.ZodArray<z.ZodObject<{
737
+ id: z.ZodString;
738
+ kind: z.ZodEnum<["default", "invariant"]>;
739
+ trigger: z.ZodString;
740
+ action: z.ZodString;
741
+ exceptions: z.ZodString;
742
+ verify: z.ZodArray<z.ZodString, "many">;
743
+ appliesTo: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
744
+ source: z.ZodString;
745
+ }, "strict", z.ZodTypeAny, {
746
+ id: string;
747
+ kind: "default" | "invariant";
748
+ trigger: string;
749
+ action: string;
750
+ exceptions: string;
751
+ appliesTo: string[];
752
+ verify: string[];
753
+ source: string;
754
+ }, {
755
+ id: string;
756
+ kind: "default" | "invariant";
757
+ trigger: string;
758
+ action: string;
759
+ exceptions: string;
760
+ appliesTo: string[];
761
+ verify: string[];
762
+ source: string;
763
+ }>, "many">;
764
+ }, "strict", z.ZodTypeAny, {
765
+ rules: {
766
+ id: string;
767
+ kind: "default" | "invariant";
768
+ trigger: string;
769
+ action: string;
770
+ exceptions: string;
771
+ appliesTo: string[];
772
+ verify: string[];
773
+ source: string;
774
+ }[];
775
+ hash: string;
776
+ }, {
777
+ rules: {
778
+ id: string;
779
+ kind: "default" | "invariant";
780
+ trigger: string;
781
+ action: string;
782
+ exceptions: string;
783
+ appliesTo: string[];
784
+ verify: string[];
785
+ source: string;
786
+ }[];
787
+ hash: string;
788
+ }>;
789
+ }, "strict", z.ZodTypeAny, {
790
+ manifest: {
791
+ schemaVersion: 1;
792
+ rules: {
793
+ id: string;
794
+ kind: "default" | "invariant";
795
+ scopeRoot: string;
796
+ originClass: "engine" | "stack" | "repository" | "task";
797
+ depth: number;
798
+ sourcePath: string;
799
+ contentHash: string;
800
+ appliesTo: string[];
801
+ }[];
802
+ scope: {
803
+ files: string[];
804
+ role: string;
805
+ };
806
+ profiles: unknown[];
807
+ skills: {
808
+ id: string;
809
+ version: string;
810
+ }[];
811
+ overrides: {
812
+ id: string;
813
+ winner: string;
814
+ loser: string;
815
+ }[];
816
+ omittedReferences: {
817
+ reason: string;
818
+ ref: string;
819
+ }[];
820
+ diagnostics: {
821
+ code: string;
822
+ message: string;
823
+ severity: "info" | "warning" | "blocking";
824
+ }[];
825
+ budget: {
826
+ maxBytes: number;
827
+ usedBytes: number;
828
+ };
829
+ hash: string;
830
+ };
831
+ view: {
832
+ rules: {
833
+ id: string;
834
+ kind: "default" | "invariant";
835
+ trigger: string;
836
+ action: string;
837
+ exceptions: string;
838
+ appliesTo: string[];
839
+ verify: string[];
840
+ source: string;
841
+ }[];
842
+ hash: string;
843
+ };
844
+ }, {
845
+ manifest: {
846
+ schemaVersion: 1;
847
+ rules: {
848
+ id: string;
849
+ kind: "default" | "invariant";
850
+ scopeRoot: string;
851
+ originClass: "engine" | "stack" | "repository" | "task";
852
+ depth: number;
853
+ sourcePath: string;
854
+ contentHash: string;
855
+ appliesTo: string[];
856
+ }[];
857
+ scope: {
858
+ files: string[];
859
+ role: string;
860
+ };
861
+ profiles: unknown[];
862
+ skills: {
863
+ id: string;
864
+ version: string;
865
+ }[];
866
+ overrides: {
867
+ id: string;
868
+ winner: string;
869
+ loser: string;
870
+ }[];
871
+ omittedReferences: {
872
+ reason: string;
873
+ ref: string;
874
+ }[];
875
+ diagnostics: {
876
+ code: string;
877
+ message: string;
878
+ severity: "info" | "warning" | "blocking";
879
+ }[];
880
+ budget: {
881
+ maxBytes: number;
882
+ usedBytes: number;
883
+ };
884
+ hash: string;
885
+ };
886
+ view: {
887
+ rules: {
888
+ id: string;
889
+ kind: "default" | "invariant";
890
+ trigger: string;
891
+ action: string;
892
+ exceptions: string;
893
+ appliesTo: string[];
894
+ verify: string[];
895
+ source: string;
896
+ }[];
897
+ hash: string;
898
+ };
899
+ }>;
900
+ export declare const DetectionStatusSchema: z.ZodEnum<["confirmed", "indicative", "inconclusive", "absent"]>;
901
+ export declare const DependencyEvidenceSchema: z.ZodObject<{
902
+ file: z.ZodString;
903
+ section: z.ZodString;
904
+ key: z.ZodString;
905
+ name: z.ZodString;
906
+ alias: z.ZodOptional<z.ZodString>;
907
+ category: z.ZodEnum<["normal", "dev", "build"]>;
908
+ optional: z.ZodBoolean;
909
+ features: z.ZodArray<z.ZodString, "many">;
910
+ defaultFeatures: z.ZodBoolean;
911
+ target: z.ZodOptional<z.ZodString>;
912
+ owner: z.ZodString;
913
+ resolution: z.ZodEnum<["declared", "workspace-inherited", "unresolved"]>;
914
+ }, "strict", z.ZodTypeAny, {
915
+ file: string;
916
+ section: string;
917
+ key: string;
918
+ name: string;
919
+ category: "normal" | "dev" | "build";
920
+ optional: boolean;
921
+ features: string[];
922
+ defaultFeatures: boolean;
923
+ owner: string;
924
+ resolution: "declared" | "workspace-inherited" | "unresolved";
925
+ alias?: string | undefined;
926
+ target?: string | undefined;
927
+ }, {
928
+ file: string;
929
+ section: string;
930
+ key: string;
931
+ name: string;
932
+ category: "normal" | "dev" | "build";
933
+ optional: boolean;
934
+ features: string[];
935
+ defaultFeatures: boolean;
936
+ owner: string;
937
+ resolution: "declared" | "workspace-inherited" | "unresolved";
938
+ alias?: string | undefined;
939
+ target?: string | undefined;
940
+ }>;
941
+ export declare const ProjectScopeProfileSchema: z.ZodObject<{
942
+ root: z.ZodString;
943
+ language: z.ZodString;
944
+ status: z.ZodEnum<["confirmed", "indicative", "inconclusive", "absent"]>;
945
+ packages: z.ZodArray<z.ZodObject<{
946
+ name: z.ZodString;
947
+ manifest: z.ZodString;
948
+ workspaceRoot: z.ZodOptional<z.ZodString>;
949
+ }, "strict", z.ZodTypeAny, {
950
+ manifest: string;
951
+ name: string;
952
+ workspaceRoot?: string | undefined;
953
+ }, {
954
+ manifest: string;
955
+ name: string;
956
+ workspaceRoot?: string | undefined;
957
+ }>, "many">;
958
+ capabilities: z.ZodArray<z.ZodString, "many">;
959
+ declaredDatabaseBackends: z.ZodArray<z.ZodString, "many">;
960
+ dependencyEvidence: z.ZodArray<z.ZodObject<{
961
+ file: z.ZodString;
962
+ section: z.ZodString;
963
+ key: z.ZodString;
964
+ name: z.ZodString;
965
+ alias: z.ZodOptional<z.ZodString>;
966
+ category: z.ZodEnum<["normal", "dev", "build"]>;
967
+ optional: z.ZodBoolean;
968
+ features: z.ZodArray<z.ZodString, "many">;
969
+ defaultFeatures: z.ZodBoolean;
970
+ target: z.ZodOptional<z.ZodString>;
971
+ owner: z.ZodString;
972
+ resolution: z.ZodEnum<["declared", "workspace-inherited", "unresolved"]>;
973
+ }, "strict", z.ZodTypeAny, {
974
+ file: string;
975
+ section: string;
976
+ key: string;
977
+ name: string;
978
+ category: "normal" | "dev" | "build";
979
+ optional: boolean;
980
+ features: string[];
981
+ defaultFeatures: boolean;
982
+ owner: string;
983
+ resolution: "declared" | "workspace-inherited" | "unresolved";
984
+ alias?: string | undefined;
985
+ target?: string | undefined;
986
+ }, {
987
+ file: string;
988
+ section: string;
989
+ key: string;
990
+ name: string;
991
+ category: "normal" | "dev" | "build";
992
+ optional: boolean;
993
+ features: string[];
994
+ defaultFeatures: boolean;
995
+ owner: string;
996
+ resolution: "declared" | "workspace-inherited" | "unresolved";
997
+ alias?: string | undefined;
998
+ target?: string | undefined;
999
+ }>, "many">;
1000
+ diagnostics: z.ZodArray<z.ZodObject<{
1001
+ code: z.ZodString;
1002
+ message: z.ZodString;
1003
+ }, "strict", z.ZodTypeAny, {
1004
+ code: string;
1005
+ message: string;
1006
+ }, {
1007
+ code: string;
1008
+ message: string;
1009
+ }>, "many">;
1010
+ }, "strict", z.ZodTypeAny, {
1011
+ status: "confirmed" | "indicative" | "inconclusive" | "absent";
1012
+ diagnostics: {
1013
+ code: string;
1014
+ message: string;
1015
+ }[];
1016
+ root: string;
1017
+ language: string;
1018
+ packages: {
1019
+ manifest: string;
1020
+ name: string;
1021
+ workspaceRoot?: string | undefined;
1022
+ }[];
1023
+ capabilities: string[];
1024
+ declaredDatabaseBackends: string[];
1025
+ dependencyEvidence: {
1026
+ file: string;
1027
+ section: string;
1028
+ key: string;
1029
+ name: string;
1030
+ category: "normal" | "dev" | "build";
1031
+ optional: boolean;
1032
+ features: string[];
1033
+ defaultFeatures: boolean;
1034
+ owner: string;
1035
+ resolution: "declared" | "workspace-inherited" | "unresolved";
1036
+ alias?: string | undefined;
1037
+ target?: string | undefined;
1038
+ }[];
1039
+ }, {
1040
+ status: "confirmed" | "indicative" | "inconclusive" | "absent";
1041
+ diagnostics: {
1042
+ code: string;
1043
+ message: string;
1044
+ }[];
1045
+ root: string;
1046
+ language: string;
1047
+ packages: {
1048
+ manifest: string;
1049
+ name: string;
1050
+ workspaceRoot?: string | undefined;
1051
+ }[];
1052
+ capabilities: string[];
1053
+ declaredDatabaseBackends: string[];
1054
+ dependencyEvidence: {
1055
+ file: string;
1056
+ section: string;
1057
+ key: string;
1058
+ name: string;
1059
+ category: "normal" | "dev" | "build";
1060
+ optional: boolean;
1061
+ features: string[];
1062
+ defaultFeatures: boolean;
1063
+ owner: string;
1064
+ resolution: "declared" | "workspace-inherited" | "unresolved";
1065
+ alias?: string | undefined;
1066
+ target?: string | undefined;
1067
+ }[];
1068
+ }>;
1069
+ export type ScopedRule = z.infer<typeof ScopedRuleSchema>;
1070
+ export type VerificationRecipe = z.infer<typeof VerificationRecipeSchema>;
1071
+ export type RecipeStatus = z.infer<typeof RecipeStatusSchema>;
1072
+ export type ContextManifest = z.infer<typeof ContextManifestSchema>;
1073
+ export type ScopedContext = z.infer<typeof ScopedContextSchema>;
1074
+ export type ProjectScopeProfile = z.infer<typeof ProjectScopeProfileSchema>;