@vibe-agent-toolkit/cli 0.2.0-rc.11 → 0.2.0-rc.12

package/dist/commands/audit-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-schema.d.ts","sourceRoot":"","sources":["../../src/commands/audit-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAErE,uHAAuH;AACvH,eAAO,MAAM,cAAc,EAAE,mBAG5B,CAAC;AA6HF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;IA9B9B;;;;;OAKG;;IAEH,0DAA0D;;QAxG1D,wCAAwC;;QAExC,gCAAgC;;QAEhC,6CAA6C;;;;;;;;;;;;;;IAsG7C,0IAA0I;;;;;;;;;;;;;;;;;;QA3C1I,kEAAkE;;;QAGlE,6DAA6D;;QAE7D,wCAAwC;;;;;;;;;;;;;;QAExC,wDAAwD;;;;;;;;;;;;;;YA9CxD,sCAAsC;;;;;;;;;;;;;;YAKtC,mFAAmF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA2CnF,mEAAmE;;YAlBnE,yEAAyE;;;;;;;;;;;;;;;;;;;;;;;;YAGzE,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAyDnC,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;oBAhCnD,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAA7D,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAA7D,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAA7D,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CgB,CAAC"}

package/dist/commands/audit-schema.js

@@ -0,0 +1,139 @@
+/**
+ * The document `vat audit` publishes, apart from the command.
+ *
+ * A sibling module because the published-shape registry imports it and the
+ * command imports the writer that imports the registry: a schema declared in
+ * the command module itself would be an import cycle, read before it is
+ * initialised.
+ *
+ * 🔑 **One meaning of `summary`.** The document used to carry two: a header
+ * `summary` counting FILES beside a per-file `summary` counting FINDINGS. The
+ * envelope's `summary` counts findings; the file counts are `data.counts`,
+ * and the number of files read is the envelope's `examined`.
+ */
+import { FindingSchema, reportSchema, SeverityCountsSchema } from '@vibe-agent-toolkit/schema';
+import { z } from 'zod';
+/** What `examined` counts for `vat audit` (and the corpus scan's per-plugin audit), and the remedy when it is zero. */
+export const AUDIT_EXAMINED = {
+    unit: 'files',
+    whenZero: 'The scan root holds nothing auditable — check the path and skills.include.',
+};
+/** Where a URL audit's tree came from — the base its paths are relative to. */
+const ProvenanceSchema = z.object({
+    /** The URL as the operator typed it. */
+    url: z.string(),
+    /** The branch or tag cloned. */
+    ref: z.string(),
+    /** The full commit SHA of the cloned ref. */
+    commit: z.string(),
+    subpath: z.string().optional(),
+}).strict();
+/** A path a lane enumerated and could not read, root-relative, and why. */
+const UncheckedPathSchema = z.object({ path: z.string(), reason: z.string() }).strict();
+/**
+ * One record the compatibility analyzer produced (evidence, observation,
+ * verdict). Their shapes are `@vibe-agent-toolkit/claude-marketplace`'s
+ * exported types, published verbatim; this document owns the block around them.
+ */
+const AnalyzerRecordSchema = z.record(z.string(), z.unknown());
+/** The analyzer's result for one plugin. */
+const CompatibilityResultSchema = z.object({
+    plugin: z.string(),
+    version: z.string().optional(),
+    declaredTargets: z.array(z.string()).optional(),
+    /** Present only under `--verbose`. */
+    evidence: z.array(AnalyzerRecordSchema).optional(),
+    observations: z.array(AnalyzerRecordSchema),
+    verdicts: z.array(AnalyzerRecordSchema),
+    unchecked: z.array(UncheckedPathSchema),
+    /** FILES the analysis walked, by kind — never `summary`, which counts findings. */
+    fileCounts: z.object({
+        totalFiles: z.number().int().nonnegative(),
+        skillFiles: z.number().int().nonnegative(),
+        scriptFiles: z.number().int().nonnegative(),
+        hookFiles: z.number().int().nonnegative(),
+        mcpConfigs: z.number().int().nonnegative(),
+    }).strict(),
+}).strict();
+/** The block when the analyzer could not run for the plugin at all — said, never omitted. */
+const CompatibilityUnavailableSchema = z.object({ analyzed: z.literal(false), reason: z.string() }).strict();
+/** One settings conflict, as `checkSettingsCompatibility` found it. */
+const SettingsConflictSchema = z.object({
+    type: z.string(),
+    detail: z.string(),
+    blockedBy: z.string(),
+    value: z.string(),
+    settingsFile: z.string(),
+    settingsLevel: z.string(),
+}).strict();
+/** The `settings:` block under `--compat --settings`. */
+const SettingsBlockSchema = z.object({
+    /** `false` when a conflict was found OR when anything went unchecked. */
+    compatible: z.boolean(),
+    conflicts: z.array(SettingsConflictSchema),
+    /** Present only when non-empty. */
+    unchecked: z.array(UncheckedPathSchema).optional(),
+}).strict();
+/** One audited file (or refused path): what it is and how its findings are distributed. Its findings are the envelope's. */
+const AuditFileSchema = z.object({
+    /** Relative to `data.root` — or to the clone, for a URL audit. */
+    path: z.string(),
+    type: z.enum(['agent-skill', 'vat-agent', 'claude-plugin', 'marketplace', 'registry', 'unknown']),
+    /** Literal: `findings` iff this file carries any finding. */
+    status: z.enum(['ok', 'findings']),
+    /** This file's findings by severity. */
+    summary: SeverityCountsSchema,
+    /** Under `--compat`, on every `claude-plugin` entry. */
+    compatibility: z.union([CompatibilityUnavailableSchema, CompatibilityResultSchema]).optional(),
+    /** Under `--compat --settings`, on every `claude-plugin` entry. */
+    settings: SettingsBlockSchema.optional(),
+}).strict();
+/** One skill in the `--user` view. */
+const HierarchicalSkillSchema = z.object({
+    name: z.string(),
+    path: z.string(),
+    status: z.enum(['ok', 'findings']),
+    summary: SeverityCountsSchema,
+    /** A cached copy's standing against its installed source. */
+    cacheStatus: z.enum(['stale', 'orphaned', 'fresh']).optional(),
+}).strict();
+const HierarchicalPluginSchema = z.object({ name: z.string(), skills: z.array(HierarchicalSkillSchema) }).strict();
+/** `--user` only: the skills grouped by where Claude Code installed them. */
+const HierarchicalSchema = z.object({
+    marketplaces: z.array(z.object({ name: z.string(), plugins: z.array(HierarchicalPluginSchema) }).strict()),
+    cachedPlugins: z.array(HierarchicalPluginSchema),
+    standalonePlugins: z.array(HierarchicalPluginSchema),
+    standaloneSkills: z.array(HierarchicalSkillSchema),
+}).strict();
+const AuditDataSchema = z.object({
+    /**
+     * The invocation scan root — the ONE absolute path in the document, and the
+     * base every `path` and finding `location` is relative to. `null` for a URL
+     * audit, and only then: the clone lives in a random tempdir nothing
+     * downstream can resolve, so `provenance` names the base instead.
+     */
+    root: z.string().nullable(),
+    /** A URL audit's source; `null` for every other audit. */
+    provenance: ProvenanceSchema.nullable(),
+    /** FILES by their worst actionable severity. The files read are `examined`; a refused path is in `pathsUnreadable` and no other count. */
+    counts: z.object({
+        filesPassed: z.number().int().nonnegative(),
+        filesWithWarnings: z.number().int().nonnegative(),
+        filesWithErrors: z.number().int().nonnegative(),
+        pathsUnreadable: z.number().int().nonnegative(),
+    }).strict(),
+    files: z.array(AuditFileSchema),
+    /** `--user` only; `null` for every other audit. */
+    hierarchical: HierarchicalSchema.nullable(),
+}).strict().refine((data) => (data.root === null) === (data.provenance !== null), {
+    message: 'root is null exactly when the audit is a URL audit (provenance names the base instead)',
+    path: ['root'],
+});
+/**
+ * The document this command publishes. Every finding about a FILE names it in
+ * `location` (a validator's finding without one inherits its row's path); the
+ * one finding with no file is the run's own `RESOURCE_CHECK_BROKEN` over zero
+ * files, which is about the run.
+ */
+export const AUDIT_REPORT_SCHEMA = reportSchema(AuditDataSchema, FindingSchema);
+//# sourceMappingURL=audit-schema.js.map

package/dist/commands/audit-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-schema.js","sourceRoot":"","sources":["../../src/commands/audit-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAC/F,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,uHAAuH;AACvH,MAAM,CAAC,MAAM,cAAc,GAAwB;IACjD,IAAI,EAAE,OAAO;IACb,QAAQ,EAAE,4EAA4E;CACvF,CAAC;AAEF,+EAA+E;AAC/E,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChC,wCAAwC;IACxC,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;IACf,gCAAgC;IAChC,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;IACf,6CAA6C;IAC7C,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC,MAAM,EAAE,CAAC;AAEZ,2EAA2E;AAC3E,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;AAExF;;;;GAIG;AACH,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;AAE/D,4CAA4C;AAC5C,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IAC/C,sCAAsC;IACtC,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,QAAQ,EAAE;IAClD,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC;IAC3C,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC;IACvC,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC;IACvC,mFAAmF;IACnF,UAAU,EAAE,CAAC,CAAC,MAAM,CAAC;QACnB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;QAC1C,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;QAC1C,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;QAC3C,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;QACzC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;KAC3C,CAAC,CAAC,MAAM,EAAE;CACZ,CAAC,CAAC,MAAM,EAAE,CAAC;AAEZ,6FAA6F;AAC7F,MAAM,8BAA8B,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;AAE7G,uEAAuE;AACvE,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;IACxB,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;CAC1B,CAAC,CAAC,MAAM,EAAE,CAAC;AAEZ,yDAAyD;AACzD,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,yEAAyE;IACzE,UAAU,EAAE,CAAC,CAAC,OAAO,EAAE;IACvB,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,sBAAsB,CAAC;IAC1C,mCAAmC;IACnC,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC,QAAQ,EAAE;CACnD,CAAC,CAAC,MAAM,EAAE,CAAC;AAEZ,4HAA4H;AAC5H,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/B,kEAAkE;IAClE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,WAAW,EAAE,eAAe,EAAE,aAAa,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;IACjG,6DAA6D;IAC7D,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAClC,wCAAwC;IACxC,OAAO,EAAE,oBAAoB;IAC7B,wDAAwD;IACxD,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,8BAA8B,EAAE,yBAAyB,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC9F,mEAAmE;IACnE,QAAQ,EAAE,mBAAmB,CAAC,QAAQ,EAAE;CACzC,CAAC,CAAC,MAAM,EAAE,CAAC;AAEZ,sCAAsC;AACtC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAClC,OAAO,EAAE,oBAAoB;IAC7B,6DAA6D;IAC7D,WAAW,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,QAAQ,EAAE;CAC/D,CAAC,CAAC,MAAM,EAAE,CAAC;AAEZ,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;AAEnH,6EAA6E;AAC7E,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;IAC1G,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC;IAChD,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC;IACpD,gBAAgB,EAAE,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC;CACnD,CAAC,CAAC,MAAM,EAAE,CAAC;AAEZ,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/B;;;;;OAKG;IACH,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,0DAA0D;IAC1D,UAAU,EAAE,gBAAgB,CAAC,QAAQ,EAAE;IACvC,0IAA0I;IAC1I,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC;QACf,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;QAC3C,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;QACjD,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;QAC/C,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;KAChD,CAAC,CAAC,MAAM,EAAE;IACX,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC;IAC/B,mDAAmD;IACnD,YAAY,EAAE,kBAAkB,CAAC,QAAQ,EAAE;CAC5C,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,KAAK,IAAI,CAAC,EAAE;IAChF,OAAO,EAAE,wFAAwF;IACjG,IAAI,EAAE,CAAC,MAAM,CAAC;CACf,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,YAAY,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC"}

package/dist/commands/audit-settings-schema.d.ts

@@ -0,0 +1,417 @@
+/**
+ * The document `vat audit settings` publishes, apart from the command.
+ *
+ * A sibling module for the same reason as `audit-schema.ts`: the published-shape
+ * registry imports it, and the command imports the writer that imports the
+ * registry.
+ *
+ * The verb has three modes and one envelope. `data.mode` says which one ran,
+ * and each mode's `data` is what it read — the findings (a shadowed rule, an
+ * invalid field, a deprecated path) are the envelope's, never `data`'s.
+ */
+import { type Report } from '@vibe-agent-toolkit/schema';
+import { z } from 'zod';
+import type { ExaminedDeclaration } from '../utils/run-integrity.js';
+/** What `examined` counts for `vat audit settings`, and the remedy when it is zero. */
+export declare const AUDIT_SETTINGS_EXAMINED: ExaminedDeclaration;
+declare const AuditSettingsDataSchema: z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+    mode: z.ZodLiteral<"file">;
+    root: z.ZodString;
+    /** The file, relative to `root`. */
+    file: z.ZodString;
+    detectedType: z.ZodEnum<["managed", "user", "project", "unknown"]>;
+    /** How `detectedType` was arrived at: `declared` (--type), `inferred`, `ambiguous`, or `undetermined` (not JSON; an unreadable file is refused, never reported). */
+    typeConfidence: z.ZodEnum<["declared", "inferred", "ambiguous", "undetermined"]>;
+    /** `null` when the file is not a JSON object, so there are no fields to list — not the same answer as `[]`. */
+    fields: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+        count: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        key: string;
+        value?: string | undefined;
+        count?: number | undefined;
+    }, {
+        key: string;
+        value?: string | undefined;
+        count?: number | undefined;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    file: string;
+    root: string;
+    mode: "file";
+    detectedType: "unknown" | "managed" | "user" | "project";
+    typeConfidence: "declared" | "inferred" | "ambiguous" | "undetermined";
+    fields: {
+        key: string;
+        value?: string | undefined;
+        count?: number | undefined;
+    }[] | null;
+}, {
+    file: string;
+    root: string;
+    mode: "file";
+    detectedType: "unknown" | "managed" | "user" | "project";
+    typeConfidence: "declared" | "inferred" | "ambiguous" | "undetermined";
+    fields: {
+        key: string;
+        value?: string | undefined;
+        count?: number | undefined;
+    }[] | null;
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"paths">;
+    root: z.ZodString;
+    paths: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        path: z.ZodString;
+        /** `undetermined` when the probe itself failed — not the same answer as `false`. */
+        exists: z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"undetermined">]>;
+        readable: z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"undetermined">]>;
+        level: z.ZodString;
+        accessError: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        label: string;
+        exists: boolean | "undetermined";
+        readable: boolean | "undetermined";
+        level: string;
+        accessError?: string | undefined;
+    }, {
+        path: string;
+        label: string;
+        exists: boolean | "undetermined";
+        readable: boolean | "undetermined";
+        level: string;
+        accessError?: string | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    root: string;
+    mode: "paths";
+    paths: {
+        path: string;
+        label: string;
+        exists: boolean | "undetermined";
+        readable: boolean | "undetermined";
+        level: string;
+        accessError?: string | undefined;
+    }[];
+}, {
+    root: string;
+    mode: "paths";
+    paths: {
+        path: string;
+        label: string;
+        exists: boolean | "undetermined";
+        readable: boolean | "undetermined";
+        level: string;
+        accessError?: string | undefined;
+    }[];
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"effective">;
+    root: z.ZodString;
+    /** Every settings file loaded, highest precedence first. */
+    layers: z.ZodArray<z.ZodObject<{
+        level: z.ZodString;
+        file: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        file: string;
+        level: string;
+    }, {
+        file: string;
+        level: string;
+    }>, "many">;
+    /** Merged values, each with its source; keys are Claude Code's settings keys. */
+    effectiveSettings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    /** Rules that can never take effect, and what shadows each. The findings say the same thing, one per rule. */
+    conflicts: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        rule: z.ZodString;
+        ruleSource: z.ZodString;
+        ruleLevel: z.ZodString;
+        ruleList: z.ZodString;
+        shadowedBy: z.ZodString;
+        shadowedBySource: z.ZodString;
+        shadowedByLevel: z.ZodString;
+        shadowedByList: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: string;
+        rule: string;
+        ruleSource: string;
+        ruleLevel: string;
+        ruleList: string;
+        shadowedBy: string;
+        shadowedBySource: string;
+        shadowedByLevel: string;
+        shadowedByList: string;
+    }, {
+        kind: string;
+        rule: string;
+        ruleSource: string;
+        ruleLevel: string;
+        ruleList: string;
+        shadowedBy: string;
+        shadowedBySource: string;
+        shadowedByLevel: string;
+        shadowedByList: string;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    root: string;
+    conflicts: {
+        kind: string;
+        rule: string;
+        ruleSource: string;
+        ruleLevel: string;
+        ruleList: string;
+        shadowedBy: string;
+        shadowedBySource: string;
+        shadowedByLevel: string;
+        shadowedByList: string;
+    }[];
+    mode: "effective";
+    layers: {
+        file: string;
+        level: string;
+    }[];
+    effectiveSettings: Record<string, unknown>;
+}, {
+    root: string;
+    conflicts: {
+        kind: string;
+        rule: string;
+        ruleSource: string;
+        ruleLevel: string;
+        ruleList: string;
+        shadowedBy: string;
+        shadowedBySource: string;
+        shadowedByLevel: string;
+        shadowedByList: string;
+    }[];
+    mode: "effective";
+    layers: {
+        file: string;
+        level: string;
+    }[];
+    effectiveSettings: Record<string, unknown>;
+}>]>;
+export type AuditSettingsData = z.infer<typeof AuditSettingsDataSchema>;
+/** The document this command publishes. */
+export declare const AUDIT_SETTINGS_REPORT_SCHEMA: import("@vibe-agent-toolkit/schema").ReportZodSchema<z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+    mode: z.ZodLiteral<"file">;
+    root: z.ZodString;
+    /** The file, relative to `root`. */
+    file: z.ZodString;
+    detectedType: z.ZodEnum<["managed", "user", "project", "unknown"]>;
+    /** How `detectedType` was arrived at: `declared` (--type), `inferred`, `ambiguous`, or `undetermined` (not JSON; an unreadable file is refused, never reported). */
+    typeConfidence: z.ZodEnum<["declared", "inferred", "ambiguous", "undetermined"]>;
+    /** `null` when the file is not a JSON object, so there are no fields to list — not the same answer as `[]`. */
+    fields: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+        count: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        key: string;
+        value?: string | undefined;
+        count?: number | undefined;
+    }, {
+        key: string;
+        value?: string | undefined;
+        count?: number | undefined;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    file: string;
+    root: string;
+    mode: "file";
+    detectedType: "unknown" | "managed" | "user" | "project";
+    typeConfidence: "declared" | "inferred" | "ambiguous" | "undetermined";
+    fields: {
+        key: string;
+        value?: string | undefined;
+        count?: number | undefined;
+    }[] | null;
+}, {
+    file: string;
+    root: string;
+    mode: "file";
+    detectedType: "unknown" | "managed" | "user" | "project";
+    typeConfidence: "declared" | "inferred" | "ambiguous" | "undetermined";
+    fields: {
+        key: string;
+        value?: string | undefined;
+        count?: number | undefined;
+    }[] | null;
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"paths">;
+    root: z.ZodString;
+    paths: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        path: z.ZodString;
+        /** `undetermined` when the probe itself failed — not the same answer as `false`. */
+        exists: z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"undetermined">]>;
+        readable: z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"undetermined">]>;
+        level: z.ZodString;
+        accessError: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        label: string;
+        exists: boolean | "undetermined";
+        readable: boolean | "undetermined";
+        level: string;
+        accessError?: string | undefined;
+    }, {
+        path: string;
+        label: string;
+        exists: boolean | "undetermined";
+        readable: boolean | "undetermined";
+        level: string;
+        accessError?: string | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    root: string;
+    mode: "paths";
+    paths: {
+        path: string;
+        label: string;
+        exists: boolean | "undetermined";
+        readable: boolean | "undetermined";
+        level: string;
+        accessError?: string | undefined;
+    }[];
+}, {
+    root: string;
+    mode: "paths";
+    paths: {
+        path: string;
+        label: string;
+        exists: boolean | "undetermined";
+        readable: boolean | "undetermined";
+        level: string;
+        accessError?: string | undefined;
+    }[];
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"effective">;
+    root: z.ZodString;
+    /** Every settings file loaded, highest precedence first. */
+    layers: z.ZodArray<z.ZodObject<{
+        level: z.ZodString;
+        file: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        file: string;
+        level: string;
+    }, {
+        file: string;
+        level: string;
+    }>, "many">;
+    /** Merged values, each with its source; keys are Claude Code's settings keys. */
+    effectiveSettings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    /** Rules that can never take effect, and what shadows each. The findings say the same thing, one per rule. */
+    conflicts: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        rule: z.ZodString;
+        ruleSource: z.ZodString;
+        ruleLevel: z.ZodString;
+        ruleList: z.ZodString;
+        shadowedBy: z.ZodString;
+        shadowedBySource: z.ZodString;
+        shadowedByLevel: z.ZodString;
+        shadowedByList: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: string;
+        rule: string;
+        ruleSource: string;
+        ruleLevel: string;
+        ruleList: string;
+        shadowedBy: string;
+        shadowedBySource: string;
+        shadowedByLevel: string;
+        shadowedByList: string;
+    }, {
+        kind: string;
+        rule: string;
+        ruleSource: string;
+        ruleLevel: string;
+        ruleList: string;
+        shadowedBy: string;
+        shadowedBySource: string;
+        shadowedByLevel: string;
+        shadowedByList: string;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    root: string;
+    conflicts: {
+        kind: string;
+        rule: string;
+        ruleSource: string;
+        ruleLevel: string;
+        ruleList: string;
+        shadowedBy: string;
+        shadowedBySource: string;
+        shadowedByLevel: string;
+        shadowedByList: string;
+    }[];
+    mode: "effective";
+    layers: {
+        file: string;
+        level: string;
+    }[];
+    effectiveSettings: Record<string, unknown>;
+}, {
+    root: string;
+    conflicts: {
+        kind: string;
+        rule: string;
+        ruleSource: string;
+        ruleLevel: string;
+        ruleList: string;
+        shadowedBy: string;
+        shadowedBySource: string;
+        shadowedByLevel: string;
+        shadowedByList: string;
+    }[];
+    mode: "effective";
+    layers: {
+        file: string;
+        level: string;
+    }[];
+    effectiveSettings: Record<string, unknown>;
+}>]>, z.ZodObject<Omit<{
+    code: z.ZodString;
+    severity: z.ZodEnum<["error", "warning", "info", "ignore"]>;
+    message: z.ZodString;
+    location: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    line: z.ZodOptional<z.ZodNumber>;
+    field: z.ZodOptional<z.ZodString>;
+    link: z.ZodOptional<z.ZodString>;
+    fix: z.ZodOptional<z.ZodString>;
+    reference: z.ZodOptional<z.ZodString>;
+    suggestion: z.ZodOptional<z.ZodString>;
+}, "severity"> & {
+    severity: z.ZodEnum<["error", "warning", "info"]>;
+    column: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    code: string;
+    message: string;
+    severity: "error" | "warning" | "info";
+    fix?: string | undefined;
+    reference?: string | undefined;
+    location?: string | undefined;
+    line?: number | undefined;
+    field?: string | undefined;
+    link?: string | undefined;
+    suggestion?: string | undefined;
+    column?: number | undefined;
+}, {
+    code: string;
+    message: string;
+    severity: "error" | "warning" | "info";
+    fix?: string | undefined;
+    reference?: string | undefined;
+    location?: string | undefined;
+    line?: number | undefined;
+    field?: string | undefined;
+    link?: string | undefined;
+    suggestion?: string | undefined;
+    column?: number | undefined;
+}>>;
+export type AuditSettingsReport = Report<AuditSettingsData>;
+export {};
+//# sourceMappingURL=audit-settings-schema.d.ts.map

package/dist/commands/audit-settings-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-settings-schema.d.ts","sourceRoot":"","sources":["../../src/commands/audit-settings-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAA+B,KAAK,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACtF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAErE,uFAAuF;AACvF,eAAO,MAAM,uBAAuB,EAAE,mBAGrC,CAAC;AA6DF,QAAA,MAAM,uBAAuB;;;IA9C3B,oCAAoC;;;IAGpC,oKAAoK;;IAEpK,+GAA+G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAW7G,oFAAoF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAYtF,4DAA4D;;;;;;;;;;;IAE5D,iFAAiF;;IAEjF,8GAA8G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAcI,CAAC;AAErH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,2CAA2C;AAC3C,eAAO,MAAM,4BAA4B;;;IAnDvC,oCAAoC;;;IAGpC,oKAAoK;;IAEpK,+GAA+G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAW7G,oFAAoF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAYtF,4DAA4D;;;;;;;;;;;IAE5D,iFAAiF;;IAEjF,8GAA8G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmBhB,CAAC;AAEjG,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC"}

package/dist/commands/audit-settings-schema.js

@@ -0,0 +1,77 @@
+/**
+ * The document `vat audit settings` publishes, apart from the command.
+ *
+ * A sibling module for the same reason as `audit-schema.ts`: the published-shape
+ * registry imports it, and the command imports the writer that imports the
+ * registry.
+ *
+ * The verb has three modes and one envelope. `data.mode` says which one ran,
+ * and each mode's `data` is what it read — the findings (a shadowed rule, an
+ * invalid field, a deprecated path) are the envelope's, never `data`'s.
+ */
+import { FindingSchema, reportSchema } from '@vibe-agent-toolkit/schema';
+import { z } from 'zod';
+/** What `examined` counts for `vat audit settings`, and the remedy when it is zero. */
+export const AUDIT_SETTINGS_EXAMINED = {
+    unit: 'settings documents',
+    whenZero: 'No Claude settings file could be read from here — run from the project directory, or run vat audit settings --show-paths to see which settings paths exist and are readable.',
+};
+/**
+ * The directory the command ran in — the ONE absolute path in the document,
+ * and the base every other path (a finding's `location`, a layer's `file`, a
+ * rule's source, a probed `path`) is forward-slashed and relative to, as
+ * `vat audit`'s `data.root` is. A settings file on another Windows drive has no
+ * relative spelling and is the one path published absolutely.
+ */
+const root = z.string();
+/** `--file <path>`: the one settings file named. */
+const FileModeSchema = z.object({
+    mode: z.literal('file'),
+    root,
+    /** The file, relative to `root`. */
+    file: z.string(),
+    detectedType: z.enum(['managed', 'user', 'project', 'unknown']),
+    /** How `detectedType` was arrived at: `declared` (--type), `inferred`, `ambiguous`, or `undetermined` (not JSON; an unreadable file is refused, never reported). */
+    typeConfidence: z.enum(['declared', 'inferred', 'ambiguous', 'undetermined']),
+    /** `null` when the file is not a JSON object, so there are no fields to list — not the same answer as `[]`. */
+    fields: z.array(z.object({ key: z.string(), value: z.string().optional(), count: z.number().int().optional() }).strict()).nullable(),
+}).strict();
+/** `--show-paths`: every settings path Claude Code reads, probed. */
+const PathsModeSchema = z.object({
+    mode: z.literal('paths'),
+    root,
+    paths: z.array(z.object({
+        label: z.string(),
+        path: z.string(),
+        /** `undetermined` when the probe itself failed — not the same answer as `false`. */
+        exists: z.union([z.boolean(), z.literal('undetermined')]),
+        readable: z.union([z.boolean(), z.literal('undetermined')]),
+        level: z.string(),
+        accessError: z.string().optional(),
+    }).strict()),
+}).strict();
+/** The default mode: the settings the layers merge into, from the working directory. */
+const EffectiveModeSchema = z.object({
+    mode: z.literal('effective'),
+    root,
+    /** Every settings file loaded, highest precedence first. */
+    layers: z.array(z.object({ level: z.string(), file: z.string() }).strict()),
+    /** Merged values, each with its source; keys are Claude Code's settings keys. */
+    effectiveSettings: z.record(z.string(), z.unknown()),
+    /** Rules that can never take effect, and what shadows each. The findings say the same thing, one per rule. */
+    conflicts: z.array(z.object({
+        kind: z.string(),
+        rule: z.string(),
+        ruleSource: z.string(),
+        ruleLevel: z.string(),
+        ruleList: z.string(),
+        shadowedBy: z.string(),
+        shadowedBySource: z.string(),
+        shadowedByLevel: z.string(),
+        shadowedByList: z.string(),
+    }).strict()),
+}).strict();
+const AuditSettingsDataSchema = z.discriminatedUnion('mode', [FileModeSchema, PathsModeSchema, EffectiveModeSchema]);
+/** The document this command publishes. */
+export const AUDIT_SETTINGS_REPORT_SCHEMA = reportSchema(AuditSettingsDataSchema, FindingSchema);
+//# sourceMappingURL=audit-settings-schema.js.map

package/dist/commands/audit-settings-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-settings-schema.js","sourceRoot":"","sources":["../../src/commands/audit-settings-schema.ts"],"names":[],"mappings":"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"}