vigiles 33.3.0 → 35.0.0

package/dist/core/config-schema.d.ts

@@ -69,20 +69,20 @@ export declare const vigilesConfigSchema: z.ZodObject<{
         checkboxes: "checkboxes";
     }>>>;
     rules: z.ZodPrefault<z.ZodObject<{
-        "spec-refs": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "orphan-docs": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "duplicate-rules": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "require-instructions-spec": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "require-skill-spec": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        integrity: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        coverage: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>, z.ZodTuple<[z.ZodLiteral<"warn">, z.ZodObject<{
+        "spec-refs": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "orphan-docs": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "duplicate-rules": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "require-instructions-spec": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "require-skill-spec": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        integrity: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        coverage: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>, z.ZodTuple<[z.ZodLiteral<"warn">, z.ZodObject<{
             linterRules: z.ZodOptional<z.ZodNumber>;
             scripts: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>], null>, z.ZodTuple<[z.ZodLiteral<"error">, z.ZodObject<{
             linterRules: z.ZodOptional<z.ZodNumber>;
             scripts: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>], null>]>>;
-        "untested-skill": z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>, z.ZodTuple<[z.ZodLiteral<"warn">, z.ZodObject<{
+        "untested-skill": z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>, z.ZodTuple<[z.ZodLiteral<"warn">, z.ZodObject<{
             include: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
             exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
             testExtension: z.ZodOptional<z.ZodString>;
@@ -91,7 +91,7 @@ export declare const vigilesConfigSchema: z.ZodObject<{
             exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
             testExtension: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>], null>]>>;
-        "untested-subagent": z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>, z.ZodTuple<[z.ZodLiteral<"warn">, z.ZodObject<{
+        "untested-subagent": z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>, z.ZodTuple<[z.ZodLiteral<"warn">, z.ZodObject<{
             include: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
             exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
             testExtension: z.ZodOptional<z.ZodString>;
@@ -100,7 +100,7 @@ export declare const vigilesConfigSchema: z.ZodObject<{
             exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
             testExtension: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>], null>]>>;
-        "untested-hook": z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>, z.ZodTuple<[z.ZodLiteral<"warn">, z.ZodObject<{
+        "untested-hook": z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>, z.ZodTuple<[z.ZodLiteral<"warn">, z.ZodObject<{
             include: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
             exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
             testExtension: z.ZodOptional<z.ZodString>;
@@ -109,7 +109,7 @@ export declare const vigilesConfigSchema: z.ZodObject<{
             exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
             testExtension: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>], null>]>>;
-        "untested-output-style": z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>, z.ZodTuple<[z.ZodLiteral<"warn">, z.ZodObject<{
+        "untested-output-style": z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>, z.ZodTuple<[z.ZodLiteral<"warn">, z.ZodObject<{
             include: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
             exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
             testExtension: z.ZodOptional<z.ZodString>;
@@ -118,29 +118,29 @@ export declare const vigilesConfigSchema: z.ZodObject<{
             exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
             testExtension: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>], null>]>>;
-        "unmarked-refs": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "subagent-tool-contract": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "hook-events": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "subagent-frontmatter": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "mcp-config": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "skill-frontmatter": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "mcp-tool-resolves": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "hook-script-exists": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "prefer-compiled-hooks": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "disallowed-tools-contract": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "description-overlap": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "skill-description-budget": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "frontmatter-valid": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "mcp-hook-target-resolves": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "lethal-trifecta": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "skill-resource-resolves": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "skill-missing-fence": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "plugin-dir-layout": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "delegation-trifecta": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "hook-block-ineffective": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "hook-matcher": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "doc-refs": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
-        "instruction-weight": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
+        "unmarked-refs": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "subagent-tool-contract": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "hook-events": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "subagent-frontmatter": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "mcp-config": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "skill-frontmatter": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "mcp-tool-resolves": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "hook-script-exists": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "prefer-compiled-hooks": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "disallowed-tools-contract": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "description-overlap": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "skill-description-budget": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "frontmatter-valid": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "mcp-hook-target-resolves": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "lethal-trifecta": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "skill-resource-resolves": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "skill-missing-fence": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "plugin-dir-layout": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "delegation-trifecta": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "hook-block-ineffective": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "hook-matcher": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "doc-refs": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
+        "instruction-weight": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "error" | "warn", boolean | 0 | 1 | 2 | "error" | "warn" | "off">>>;
     }, z.core.$strict>>;
     files: z.ZodDefault<z.ZodArray<z.ZodString>>;
     maxRules: z.ZodOptional<z.ZodNumber>;
@@ -170,8 +170,27 @@ export declare const vigilesConfigSchema: z.ZodObject<{
         apiVersion: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
     nudge: z.ZodOptional<z.ZodLiteral<"dismissed">>;
+    extends: z.ZodOptional<z.ZodEnum<{
+        "vigiles:recommended": "vigiles:recommended";
+    }>>;
     $schema: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+/**
+ * Parse a raw `.vigilesrc.json` value — THE one entry point every reader uses.
+ *
+ * 🔴 THE PRESET IS MERGED INTO THE RAW INPUT, BEFORE THE SCHEMA, for one reason:
+ * after parsing, every rule carries a value (the schema fills each default), so
+ * "the user wrote `hook-events: warn`" and "nobody wrote it" are the same
+ * output, and an explicit downgrade could not win over the preset. Before
+ * parsing, the user's own `rules` keys are exactly what they wrote. So the
+ * preset's severities go UNDER them, and the schema then normalizes and
+ * validates the result as if the user had typed both.
+ *
+ * Only a recognized preset with an object (or absent) `rules` is expanded;
+ * anything else is passed through untouched for the schema to refuse with its
+ * own message, so a typo in `extends` is reported, never silently ignored.
+ */
+export declare function parseVigilesConfig(raw: unknown): Readonly<ReturnType<typeof vigilesConfigSchema.safeParse>>;
 /**
  * A `.vigilesrc.json` that cannot be honoured as written.
  *

package/dist/core/config-schema.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REPLACED_KEYS = exports.VigilesConfigError = exports.vigilesConfigSchema = exports.RULE_NAMES = void 0;
+exports.parseVigilesConfig = parseVigilesConfig;
 exports.replacedKeyMessage = replacedKeyMessage;
 exports.formatConfigIssues = formatConfigIssues;
 /**
@@ -48,6 +49,7 @@ exports.formatConfigIssues = formatConfigIssues;
  */
 const zod_1 = require("zod");
 const edit_distance_js_1 = require("./edit-distance.js");
+const presets_js_1 = require("./presets.js");
 // ---------------------------------------------------------------------------
 // Primitives
 // ---------------------------------------------------------------------------
@@ -232,6 +234,14 @@ exports.vigilesConfigSchema = zod_1.z
     audit: zod_1.z.object({ measure: zod_1.z.boolean().optional() }).strict().optional(),
     eval: zod_1.z.object({ apiVersion: zod_1.z.number().optional() }).strict().optional(),
     nudge: zod_1.z.literal("dismissed").optional(),
+    /**
+     * A named preset whose rule severities apply UNDER `rules` — ESLint's
+     * `extends`. `"vigiles:recommended"` gates the structural group (see
+     * `./presets.ts`); an explicit `rules` entry overrides it. Applied by
+     * {@link parseVigilesConfig}, which is why this key is only VALIDATED here.
+     * Placed after the keys people misspell most: the "Known:" list is capped.
+     */
+    extends: zod_1.z.enum(presets_js_1.PRESET_NAMES).optional(),
     /**
      * The editor's pointer at the published JSON Schema. Accepted, never read.
      *
@@ -262,6 +272,38 @@ exports.vigilesConfigSchema = zod_1.z
     $schema: zod_1.z.string().optional(),
 })
     .strict();
+/**
+ * Parse a raw `.vigilesrc.json` value — THE one entry point every reader uses.
+ *
+ * 🔴 THE PRESET IS MERGED INTO THE RAW INPUT, BEFORE THE SCHEMA, for one reason:
+ * after parsing, every rule carries a value (the schema fills each default), so
+ * "the user wrote `hook-events: warn`" and "nobody wrote it" are the same
+ * output, and an explicit downgrade could not win over the preset. Before
+ * parsing, the user's own `rules` keys are exactly what they wrote. So the
+ * preset's severities go UNDER them, and the schema then normalizes and
+ * validates the result as if the user had typed both.
+ *
+ * Only a recognized preset with an object (or absent) `rules` is expanded;
+ * anything else is passed through untouched for the schema to refuse with its
+ * own message, so a typo in `extends` is reported, never silently ignored.
+ */
+function parseVigilesConfig(raw) {
+    return exports.vigilesConfigSchema.safeParse(withPresetRules(raw));
+}
+/** `raw` with its `extends` preset's rules placed under its own `rules`. */
+function withPresetRules(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return raw;
+    const preset = "extends" in raw ? raw.extends : undefined;
+    const rules = "rules" in raw ? raw.rules : undefined;
+    if (!(0, presets_js_1.isPresetName)(preset))
+        return raw;
+    if (rules === undefined)
+        return { ...raw, rules: { ...(0, presets_js_1.presetRules)(preset) } };
+    if (typeof rules !== "object" || rules === null || Array.isArray(rules))
+        return raw;
+    return { ...raw, rules: { ...(0, presets_js_1.presetRules)(preset), ...rules } };
+}
 /**
  * A `.vigilesrc.json` that cannot be honoured as written.
  *

package/dist/core/harness-driver.d.ts

@@ -107,8 +107,11 @@ export interface HarnessDriverContext {
     readonly cwd: string;
     /** Whether a settings file was written (CC: pass `--settings`). */
     readonly hasSettings: boolean;
-    /** Tools the agent may use. */
-    readonly tools: readonly string[];
+    /**
+     * The ONLY tools the agent has, when the spec lists them; undefined = no
+     * restriction (every tool is offered, the default four are pre-approved).
+     */
+    readonly tools?: readonly string[];
     /** Capture the full event transcript instead of just the final result. */
     readonly transcript: boolean;
     /** Path to a plugin dir to install natively, if any. */

package/dist/core/presets.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Named rule PRESETS a `.vigilesrc.json` can `extends` — the ESLint
+ * `recommended` model, stored as data.
+ *
+ * 🔴 WHY A PRESET READ AT LOAD TIME, NOT RULE LINES WRITTEN AT SETUP TIME. Every
+ * rule's built-in default stays `warn` (`config-schema.ts`); the structural rules
+ * gate only because `init` turns them up. It used to do that by WRITING nine
+ * `"<rule>": "error"` lines into the new repo's config — a snapshot of the group
+ * on the day `init` ran. A repo adopted before a rule joined the group never got
+ * it from an upgrade, and re-running `init` to fetch it rewrote far more than
+ * the rule (#338). `"extends": "vigiles:recommended"` is resolved by the loader
+ * on every run, so the repo follows the group as the installed vigiles ships it,
+ * and an explicit `rules` entry still overrides it.
+ *
+ * ⚠️ ADDING A RULE HERE IS A BREAKING CHANGE (a `!` commit, a semver major): it
+ * can turn a consumer's CI red with no edit on their side. Removing one is not.
+ * ESLint treats `eslint:recommended` the same way.
+ *
+ * Harness-agnostic data: rule names only, no adapter fact.
+ */
+import type { RulesConfig } from "./types.js";
+/**
+ * The rules `vigiles:recommended` raises to `error` — the FP-safe structural
+ * group: each one fires only on a genuine defect (a never-available or typo'd
+ * tool, a subagent missing `name`/`description`, a typo'd hook event, a dead hook
+ * script, a broken MCP reference, two skills that collide in the selector), so a
+ * well-formed harness stays green.
+ *
+ * Deliberately EXCLUDES the workflow rules (`require-instructions-spec`,
+ * `untested-*`): a clean repo fails those until the work is done, so they stay
+ * an explicit opt-in (`init --strict`).
+ */
+export declare const RECOMMENDED_RULES: readonly ["subagent-tool-contract", "subagent-frontmatter", "hook-events", "hook-script-exists", "mcp-config", "mcp-tool-resolves", "mcp-hook-target-resolves", "disallowed-tools-contract", "description-overlap"];
+/** The preset names `extends` accepts. One today; the tuple is the enum. */
+export declare const PRESET_NAMES: readonly ["vigiles:recommended"];
+/** A preset name `extends` accepts. */
+export type PresetName = (typeof PRESET_NAMES)[number];
+/** The preset `init` writes. */
+export declare const RECOMMENDED_PRESET: PresetName;
+/** Whether a raw value names a preset. */
+export declare function isPresetName(value: unknown): value is PresetName;
+/** The rule severities a preset sets, in the config's raw spelling. */
+export declare function presetRules(name: PresetName): Readonly<Partial<Record<keyof RulesConfig, "error">>>;
+//# sourceMappingURL=presets.d.ts.map

package/dist/core/presets.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECOMMENDED_PRESET = exports.PRESET_NAMES = exports.RECOMMENDED_RULES = void 0;
+exports.isPresetName = isPresetName;
+exports.presetRules = presetRules;
+/**
+ * The rules `vigiles:recommended` raises to `error` — the FP-safe structural
+ * group: each one fires only on a genuine defect (a never-available or typo'd
+ * tool, a subagent missing `name`/`description`, a typo'd hook event, a dead hook
+ * script, a broken MCP reference, two skills that collide in the selector), so a
+ * well-formed harness stays green.
+ *
+ * Deliberately EXCLUDES the workflow rules (`require-instructions-spec`,
+ * `untested-*`): a clean repo fails those until the work is done, so they stay
+ * an explicit opt-in (`init --strict`).
+ */
+exports.RECOMMENDED_RULES = [
+    "subagent-tool-contract",
+    "subagent-frontmatter",
+    "hook-events",
+    "hook-script-exists",
+    "mcp-config",
+    "mcp-tool-resolves",
+    "mcp-hook-target-resolves",
+    "disallowed-tools-contract",
+    "description-overlap",
+];
+/** The preset names `extends` accepts. One today; the tuple is the enum. */
+exports.PRESET_NAMES = ["vigiles:recommended"];
+/** The preset `init` writes. */
+exports.RECOMMENDED_PRESET = "vigiles:recommended";
+/** What each preset sets, as the config would spell it. */
+const PRESETS = {
+    "vigiles:recommended": Object.fromEntries(exports.RECOMMENDED_RULES.map((r) => [r, "error"])),
+};
+/** Whether a raw value names a preset. */
+function isPresetName(value) {
+    return exports.PRESET_NAMES.some((n) => n === value);
+}
+/** The rule severities a preset sets, in the config's raw spelling. */
+function presetRules(name) {
+    return PRESETS[name];
+}
+//# sourceMappingURL=presets.js.map

package/dist/core/script-overrun.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Running past the end of a scripted model is an error.
+ *
+ * A harness test scripts the turns the agent should take, then asserts on what
+ * happened. When the agent asks for more turns than the script has, the mock
+ * used to answer with a copy of the LAST turn: a looping agent (a Stop hook
+ * that keeps blocking, a retry, a reaction to a tool result) then ran on turns
+ * nobody scripted, a final `{ tool }` re-ran its side effect, and the test went
+ * green over a run it never described (#340). Pure and shared by both mocks
+ * (Anthropic Messages, OpenAI Responses) and the runner that fails the test.
+ */
+import type { ModelRequest } from "./harness-driver.js";
+/** The first request the script could not answer. */
+export interface ScriptOverrun {
+    /** How many turns the script had. */
+    readonly scripted: number;
+    /** 1-based number of the agent request that had no turn left. */
+    readonly request: number;
+    /** The last message that request carried (what the agent was reacting to). */
+    readonly lastMessage: string;
+}
+/** Why a test failed because the agent outran its script. */
+export declare function scriptOverrunMessage(o: ScriptOverrun): string;
+/**
+ * The first agent request past the end of a script of `scripted` turns, read
+ * off the recorded requests (side-channel calls never consume a turn, so they
+ * do not count). Undefined when the agent stayed inside the script.
+ */
+export declare function findScriptOverrun(scripted: number, requests: readonly ModelRequest[]): ScriptOverrun | undefined;
+/** {@link findScriptOverrun} and {@link scriptOverrunMessage} in one: the message, or undefined. */
+export declare function overrunMessageFor(scripted: number, requests: readonly ModelRequest[]): string | undefined;
+//# sourceMappingURL=script-overrun.d.ts.map

package/dist/core/script-overrun.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scriptOverrunMessage = scriptOverrunMessage;
+exports.findScriptOverrun = findScriptOverrun;
+exports.overrunMessageFor = overrunMessageFor;
+const MAX_QUOTED = 160;
+const quote = (text) => {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > MAX_QUOTED ? `${flat.slice(0, MAX_QUOTED)}...` : flat;
+};
+/** Why a test failed because the agent outran its script. */
+function scriptOverrunMessage(o) {
+    const last = o.lastMessage.trim() === ""
+        ? ""
+        : ` The request carried this last message: "${quote(o.lastMessage)}".`;
+    return (`the agent asked for more model turns than the script has: ${String(o.scripted)} turn(s) scripted, ` +
+        `and agent request #${String(o.request)} had none left.${last} ` +
+        "The mock does not repeat the last turn, because a looping agent would then pass on turns nobody scripted. " +
+        "Script every turn the agent should take.");
+}
+/**
+ * The first agent request past the end of a script of `scripted` turns, read
+ * off the recorded requests (side-channel calls never consume a turn, so they
+ * do not count). Undefined when the agent stayed inside the script.
+ */
+function findScriptOverrun(scripted, requests) {
+    const agent = requests.filter((r) => r.sideChannel !== true);
+    const first = agent[scripted];
+    if (first === undefined)
+        return undefined;
+    return {
+        scripted,
+        request: scripted + 1,
+        lastMessage: first.messages.at(-1)?.text ?? "",
+    };
+}
+/** {@link findScriptOverrun} and {@link scriptOverrunMessage} in one: the message, or undefined. */
+function overrunMessageFor(scripted, requests) {
+    const overrun = findScriptOverrun(scripted, requests);
+    return overrun === undefined ? undefined : scriptOverrunMessage(overrun);
+}
+//# sourceMappingURL=script-overrun.js.map

package/dist/core/validate.js

@@ -147,7 +147,7 @@ function loadConfig(searchFrom, { onInvalid = "throw" } = {}) {
         }
     }
     if (problems.length === 0) {
-        const parsed = config_schema_js_1.vigilesConfigSchema.safeParse(raw);
+        const parsed = (0, config_schema_js_1.parseVigilesConfig)(raw);
         if (parsed.success)
             return parsed.data;
         problems.push(...(0, config_schema_js_1.formatConfigIssues)(parsed.error.issues));

package/dist/doc-test-script-coverage.d.ts

@@ -20,7 +20,7 @@
  * anywhere in the prose counts, because a name like `test:harness` cannot
  * collide with an English word the way `test` and `audit` do. The only thing the
  * lookarounds buy is that a LONGER script name is never read as a shorter one
- * (`test:cli-e2e` does not document `test:e2e`).
+ * (`test:unit-extra` does not document `test:unit`).
  *
  * Scope is the `test:` PREFIX, deliberately. Bare `npm test` is the vitest
  * suite, named in the map as prose; every other script (`build`, `lint`,

package/dist/doc-test-script-coverage.js

@@ -21,7 +21,7 @@
  * anywhere in the prose counts, because a name like `test:harness` cannot
  * collide with an English word the way `test` and `audit` do. The only thing the
  * lookarounds buy is that a LONGER script name is never read as a shorter one
- * (`test:cli-e2e` does not document `test:e2e`).
+ * (`test:unit-extra` does not document `test:unit`).
  *
  * Scope is the `test:` PREFIX, deliberately. Bare `npm test` is the vitest
  * suite, named in the map as prose; every other script (`build`, `lint`,

package/dist/eval-lock.d.ts

@@ -116,12 +116,11 @@ export declare function lockPath(dir: string, name: string): string;
  */
 export declare function readLock(dir: string, name: string): EvalLock | null;
 /**
- * Whether ANY lock has been committed under `dir`. The CI staleness gate
- * (`eval --check`) uses this to stay a NO-OP until the feature is in use: a repo
- * that has never run `eval --update` has no locks, so there is nothing to verify
- * and CI passes green. Once the first lock is committed, every named eval is held
- * to having a fresh one (a new unlocked eval then reads as stale). The graduated,
- * opt-in-by-committing behavior that keeps a fresh `init` from going red.
+ * Whether ANY lock has been committed under `dir`. `eval --check` fails when none
+ * is (#197): with no lock there is no recorded result to verify the current inputs
+ * against, so a pass would mean nothing was checked. Once the first lock is
+ * committed, every named eval is held to having a fresh one (a new unlocked eval
+ * then reads as stale). The edit-time nudge also stays silent until then.
  */
 export declare function anyLocksCommitted(dir: string): boolean;
 /**

package/dist/eval-lock.js

@@ -130,12 +130,11 @@ function readLock(dir, name) {
     return obj;
 }
 /**
- * Whether ANY lock has been committed under `dir`. The CI staleness gate
- * (`eval --check`) uses this to stay a NO-OP until the feature is in use: a repo
- * that has never run `eval --update` has no locks, so there is nothing to verify
- * and CI passes green. Once the first lock is committed, every named eval is held
- * to having a fresh one (a new unlocked eval then reads as stale). The graduated,
- * opt-in-by-committing behavior that keeps a fresh `init` from going red.
+ * Whether ANY lock has been committed under `dir`. `eval --check` fails when none
+ * is (#197): with no lock there is no recorded result to verify the current inputs
+ * against, so a pass would mean nothing was checked. Once the first lock is
+ * committed, every named eval is held to having a fresh one (a new unlocked eval
+ * then reads as stale). The edit-time nudge also stays silent until then.
  */
 function anyLocksCommitted(dir) {
     return countLocks(dir) > 0;

package/dist/harness-test.d.ts

@@ -52,7 +52,18 @@ export interface HarnessTestSpec {
     readonly model: readonly ModelTurn[];
     /** The user prompt. Default: "go". */
     readonly prompt?: string;
-    /** Tools the agent may use. Default: Read Edit Write Bash. */
+    /**
+     * The ONLY tools the agent has, when you list them: a tool left out is not
+     * offered (`claude --tools`, Claude Code 2.0.31+), `[]` is refused, and a
+     * scripted call to a tool the list leaves out throws before the run starts.
+     * Omitted, nothing is withheld: every tool is offered and Read, Edit, Write and
+     * Bash are pre-approved. Each listed tool is also pre-approved
+     * (`--allowedTools`), so it does not stop on a permission prompt; a permission
+     * rule such as `Bash(git *)` keeps its specifier for the approval and is
+     * offered as plain `Bash`. An MCP tool is not a built-in: left out, it is still
+     * offered but not approved, so a call to it is refused for permission rather
+     * than as "No such tool".
+     */
     readonly allowedTools?: readonly string[];
     /**
      * Capture the full event transcript (`--output-format stream-json`) into
@@ -119,6 +130,27 @@ export declare function parseResultEvent(stdout: string): Record<string, unknown
 /** The agent's final answer text from a transcript / result object, or "". */
 export declare function parseOutput(stdout: string): string;
 export declare function parseHooks(stdout: string): HookFire[];
+/**
+ * The names `--tools` should offer for an `allowedTools` list. `--allowedTools`
+ * takes permission rules (`Bash(git *)`); `--tools` takes tool NAMES, and a rule
+ * with a specifier there makes the CLI offer no tools at all. So the specifier is
+ * dropped (`Bash(git *)` → `Bash`) and repeats collapse. Pure.
+ */
+export declare function toolAvailabilityList(allowed: readonly string[]): readonly string[];
+/**
+ * A scripted call to a tool an EXPLICIT `allowedTools` does not offer. The CLI
+ * answers it with "No such tool available" and the run goes on, so a test that
+ * scripts the call and then asserts on something else passes over a step that
+ * never happened. Returns the message to throw, or undefined. MCP tools are not
+ * built-ins, so `--tools` does not withhold them and they are skipped. Pure.
+ */
+export declare function unofferedScriptedTool(model: readonly ModelTurn[], allowed: readonly string[] | undefined): string | undefined;
+/**
+ * A run on a `claude` that predates `--tools` exits at argument parsing, and
+ * commander's "unknown option" says nothing about WHY vigiles passed it. Returns
+ * the message to throw, or undefined when the run did not die that way. Pure.
+ */
+export declare function unsupportedToolsFlag(stderr: string): string | undefined;
 /**
  * The `claude` CLI argv for a harness run (shared by the direct and sandboxed
  * paths). `ANTHROPIC_BASE_URL` is set by the caller's environment / wrapper, not
@@ -170,6 +202,8 @@ export interface RunHarnessTestOptions {
      */
     readonly adapter?: HarnessAdapter;
 }
+/** Say so on stderr when side-channel calls arrived and no script turn was served. */
+export declare function warnUnconsumed(count: number, sideChannelCount: number): void;
 /**
  * Run the real agent CLI against a scripted mock model, with the given fixture
  * and settings (hooks). Deterministic — same script, same result. Adapter-driven