vigiles 33.2.0 → 34.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/install-reader.js

@@ -30,6 +30,18 @@ function readOrNull(absolute) {
         return null;
     }
 }
+/** A symlink's stored target, or null when it is not a link. Never throws. */
+function linkOrNull(absolute) {
+    try {
+        return (0, node_fs_1.lstatSync)(absolute, { throwIfNoEntry: false })?.isSymbolicLink() ===
+            true
+            ? (0, node_fs_1.readlinkSync)(absolute)
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** Directory names directly under `dir`, or [] when it is not readable. */
 function dirNames(dir) {
     try {
@@ -80,6 +92,9 @@ function buildInstallReader(adapter, root, opts = {}) {
         repo: (repoRelative) => adapter.claims(repoRelative)
             ? readOrNull((0, node_path_1.resolve)(root, repoRelative))
             : null,
+        repoLink: (repoRelative) => adapter.claims(repoRelative)
+            ? linkOrNull((0, node_path_1.resolve)(root, repoRelative))
+            : null,
         home: (homeRelative) => readOrNull((0, node_path_1.join)(home, homeRelative)),
         repoDependsOnVigiles: pkgJson !== null && declaresVigilesDependency(pkgJson),
         vendoredSkillNames: dirNames((0, node_path_1.join)(root, "node_modules", "vigiles", "skills")),

package/dist/core/layout.d.ts

@@ -241,6 +241,16 @@ export declare function executableSourceDirs(layout: PluginLayout): readonly str
  * written a layout where they differed.
  */
 export declare function materializePrefix(layout: PluginLayout): string;
+/**
+ * Where a REPOSITORY keeps its skills for this harness, repo-relative — the
+ * skill surface under {@link materializePrefix}: `.claude/skills` on Claude
+ * Code, `.agents/skills` on Codex. `null` when the layout has no skill surface.
+ *
+ * `vigiles init` links the package's shipped skills here, so it must be the
+ * directory the harness actually scans for a project; deriving it from the two
+ * fields that already say so keeps a third spelling from appearing.
+ */
+export declare function skillsHome(layout: Pick<PluginLayout, "surfaces" | "userSurfaceRoot">): string | null;
 /**
  * How DEEP a harness reads its {@link PluginLayout.agentDir} — the one statement
  * of that rule, as a RegExp source fragment matching the part of a path AFTER

package/dist/core/layout.js

@@ -4,6 +4,7 @@ exports.RULE_FILE_LEAF_RE = exports.AGENT_FILE_LEAF_RE = exports.SURFACE_KINDS =
 exports.surfaceDirs = surfaceDirs;
 exports.executableSourceDirs = executableSourceDirs;
 exports.materializePrefix = materializePrefix;
+exports.skillsHome = skillsHome;
 exports.rulesHome = rulesHome;
 exports.ruleFileRe = ruleFileRe;
 exports.agentSurfaceName = agentSurfaceName;
@@ -46,6 +47,22 @@ function executableSourceDirs(layout) {
 function materializePrefix(layout) {
     return layout.userSurfaceRoot ?? "";
 }
+/**
+ * Where a REPOSITORY keeps its skills for this harness, repo-relative — the
+ * skill surface under {@link materializePrefix}: `.claude/skills` on Claude
+ * Code, `.agents/skills` on Codex. `null` when the layout has no skill surface.
+ *
+ * `vigiles init` links the package's shipped skills here, so it must be the
+ * directory the harness actually scans for a project; deriving it from the two
+ * fields that already say so keeps a third spelling from appearing.
+ */
+function skillsHome(layout) {
+    const skill = layout.surfaces.skill;
+    if (skill === undefined || skill === "")
+        return null;
+    const root = layout.userSurfaceRoot;
+    return root === undefined || root === "" ? skill : `${root}/${skill}`;
+}
 /**
  * How DEEP a harness reads its {@link PluginLayout.agentDir} — the one statement
  * of that rule, as a RegExp source fragment matching the part of a path AFTER

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/run-env.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The environment a child agent run inherits — the one place the runners turn
+ * a caller's `process.env` into a spawn env.
+ *
+ * Two shapes, both driven by the harness's declared {@link RunEnvPolicy}:
+ *
+ * - SCRUBBED (`scrubbedRunEnv`): a throwaway HOME/TMPDIR, the OS essentials, the
+ *   harness's declared auth, and the caller's own named extras. Everything else
+ *   is dropped. The eval tier's `ephemeralEnv` and the harness-tier preflight of
+ *   `experimental_outputStyleArms` use it.
+ * - INHERITED (`withoutSessionIdentity`): the caller's env as-is, minus the
+ *   harness's declared session identity. The default spawn of both tiers.
+ *
+ * In both, the parent session's identity never reaches the child. The core
+ * names no harness: which variables are auth and which are identity is the
+ * adapter's declaration.
+ *
+ * Pure — no fs, no spawn.
+ */
+import type { RunEnvPolicy } from "./runtime.js";
+type EnvLike = Readonly<Record<string, string | undefined>>;
+/**
+ * What ANY spawned process needs to function, whatever the harness: resolve
+ * binaries (`PATH`) and keep the locale and terminal (`LANG`, `LC_*`, `TERM`).
+ * Mirrors what `bwrapArgs` sets back after `--clearenv` in `src/sandbox.ts`.
+ */
+export declare const OS_ESSENTIAL_ENV: readonly string[];
+/**
+ * Build a SCRUBBED run environment: a NEW env with `HOME`/`TMPDIR` set to the
+ * throwaway `opts.home`, the {@link OS_ESSENTIAL_ENV}, the harness's
+ * `policy.keep`, and the caller's `opts.allow`, taken from `base`. Everything
+ * else is dropped, and `policy.sessionIdentity` is dropped even when listed in
+ * `keep` or `allow`.
+ *
+ * Without a policy only the essentials pass: right for a run against a scripted
+ * mock, which needs no auth.
+ */
+export declare function scrubbedRunEnv(base: EnvLike, opts: {
+    readonly home: string;
+    readonly policy?: RunEnvPolicy;
+    readonly allow?: readonly string[];
+}): Readonly<Record<string, string>>;
+/**
+ * The caller's env with the harness's declared session identity removed — the
+ * INHERITED shape. Unset (`undefined`) values are dropped too, so the result is
+ * a plain spawn env. Without a policy nothing is removed.
+ */
+export declare function withoutSessionIdentity(base: EnvLike, policy?: RunEnvPolicy): Readonly<Record<string, string>>;
+export {};
+//# sourceMappingURL=run-env.d.ts.map

package/dist/core/run-env.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OS_ESSENTIAL_ENV = void 0;
+exports.scrubbedRunEnv = scrubbedRunEnv;
+exports.withoutSessionIdentity = withoutSessionIdentity;
+/**
+ * What ANY spawned process needs to function, whatever the harness: resolve
+ * binaries (`PATH`) and keep the locale and terminal (`LANG`, `LC_*`, `TERM`).
+ * Mirrors what `bwrapArgs` sets back after `--clearenv` in `src/sandbox.ts`.
+ */
+exports.OS_ESSENTIAL_ENV = ["PATH", "LANG", "TERM"];
+const OS_ESSENTIAL_PREFIXES = ["LC_"];
+/**
+ * Build a SCRUBBED run environment: a NEW env with `HOME`/`TMPDIR` set to the
+ * throwaway `opts.home`, the {@link OS_ESSENTIAL_ENV}, the harness's
+ * `policy.keep`, and the caller's `opts.allow`, taken from `base`. Everything
+ * else is dropped, and `policy.sessionIdentity` is dropped even when listed in
+ * `keep` or `allow`.
+ *
+ * Without a policy only the essentials pass: right for a run against a scripted
+ * mock, which needs no auth.
+ */
+function scrubbedRunEnv(base, opts) {
+    const identity = new Set(opts.policy?.sessionIdentity ?? []);
+    const exact = new Set([
+        ...exports.OS_ESSENTIAL_ENV,
+        ...(opts.policy?.keep ?? []),
+        ...(opts.allow ?? []),
+    ]);
+    const passes = (k) => !identity.has(k) &&
+        (exact.has(k) || OS_ESSENTIAL_PREFIXES.some((p) => k.startsWith(p)));
+    return {
+        ...defined(base, passes),
+        // Last, so they win over anything passed through.
+        HOME: opts.home,
+        TMPDIR: opts.home,
+    };
+}
+/**
+ * The caller's env with the harness's declared session identity removed — the
+ * INHERITED shape. Unset (`undefined`) values are dropped too, so the result is
+ * a plain spawn env. Without a policy nothing is removed.
+ */
+function withoutSessionIdentity(base, policy) {
+    const identity = new Set(policy?.sessionIdentity ?? []);
+    return defined(base, (k) => !identity.has(k));
+}
+function defined(base, keep) {
+    return Object.fromEntries(Object.entries(base).filter((e) => e[1] !== undefined && keep(e[0])));
+}
+//# sourceMappingURL=run-env.js.map

package/dist/core/runtime.d.ts

@@ -54,5 +54,49 @@ export interface HarnessRuntime {
      * caller resolves the raw string via `agentBinary --version`); unit-testable.
      */
     versionKey(raw: string): string;
+    /**
+     * Which of the caller's environment a child run may inherit — see
+     * {@link RunEnvPolicy}. Absent: a scrubbed run inherits no harness variable,
+     * and nothing is removed from an inherited env.
+     */
+    readonly runEnv?: RunEnvPolicy;
+}
+/**
+ * Which of the caller's environment a CHILD run of this harness may inherit.
+ *
+ * A run spawned from inside a live session of the same harness (an eval started
+ * by an agent, a harness test run from a hook) inherits that session's process
+ * environment, and a harness marks its own session there. Measured on Claude
+ * Code 2.1.292 (2026-10-07): a child `claude -p` started with the parent's
+ * session variables ran AS the parent session — a task it created landed in the
+ * parent's live task list. Which variables are identity and which are auth is a
+ * fact about one harness, so the adapter declares it and the runners apply it
+ * (`src/core/run-env.ts`) without spelling a single name.
+ *
+ * Optional, so an adapter written before this field still type-checks. An
+ * adapter without one gets the strict reading: a scrubbed run inherits no
+ * harness variable at all, and an inherited one has nothing removed.
+ */
+export interface RunEnvPolicy {
+    /**
+     * Exact names a SCRUBBED run (fresh HOME, cleared env) inherits: the
+     * harness's auth and backend selection, nothing else. An allowlist on purpose —
+     * a harness's session variables are open-ended (the Claude Code 2.1.292
+     * binary references several dozen `*SESSION*` / `*SOCKET*` / `*TOKEN*` names),
+     * so a prefix with a few exceptions would keep passing whichever ones nobody
+     * listed.
+     */
+    readonly keep: readonly string[];
+    /**
+     * Auth FILES under HOME (relative paths) that a scrubbed run's throwaway HOME
+     * is seeded with, by copy. The file half of `keep`.
+     */
+    readonly keepHomeFiles: readonly string[];
+    /**
+     * The PARENT session's identity: names no child run ever inherits — not a
+     * scrubbed run, and not a run that otherwise inherits the whole caller env.
+     * Wins over `keep` and over any name a caller allows.
+     */
+    readonly sessionIdentity: readonly string[];
 }
 //# sourceMappingURL=runtime.d.ts.map

package/dist/core/skill-link-target.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Is a symlink's stored target one that `vigiles init` writes — a path ending
+ * in `node_modules/vigiles/skills/<name>`, for the SAME skill name?
+ *
+ * Two readers ask, and must agree, so the answer lives here once:
+ *
+ * - `init` (`../skill-links.ts`): an existing link of this shape that points
+ *   somewhere other than where `init` would link now was made by an earlier
+ *   `init` (for example before a workspace install hoisted the package), so it
+ *   is replaced instead of being refused as the user's;
+ * - `audit` (`../adapters/claude-code/skill-reachability.ts`): only a dangling
+ *   link of this shape is "vigiles's link, run npm install". A dangling link
+ *   that merely shares a skill's NAME is the user's, and the advice would send
+ *   them to fix the wrong thing.
+ *
+ * The test is on path SEGMENTS (either separator, so a link written on Windows
+ * reads the same), not on a substring: `my-node_modules/vigiles/...` is not it.
+ */
+export declare function isVigilesSkillTarget(target: string, name: string): boolean;
+//# sourceMappingURL=skill-link-target.d.ts.map