audit-tools 0.36.2 → 0.38.1

package/dist/shared/analyzers/provenance.d.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+/**
+ * Content-anchored identity of one analyzer lead — the join key that lets
+ * remediation's close-verify draw ask "does this exact lead still fire?"
+ * mechanically (item C of `spec/mechanical-analyzer-layer-design.md`).
+ *
+ * Anchored on the NORMALIZED flagged snippet, never line numbers: edits shift
+ * lines, but an untouched clone/violation re-hashes identically wherever it
+ * moves within its file. Optional everywhere it is carried — a lead whose
+ * snippet cannot be read simply carries no provenance and is exempt from
+ * mechanical verification.
+ */
+export declare const AnalyzerLeadProvenanceSchema: z.ZodObject<{
+    /** Candidate id that produced the lead (e.g. "jscpd", "gitleaks"). */
+    analyzer_id: z.ZodString;
+    /** Analyzer-native rule id, when the tool reports one. */
+    rule: z.ZodOptional<z.ZodString>;
+    /** Repo-relative path of the flagged file. */
+    path: z.ZodString;
+    /** `hashAnalyzerSnippet` digest of the normalized flagged span. */
+    snippet_hash: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    analyzer_id: string;
+    snippet_hash: string;
+    rule?: string | undefined;
+}, {
+    path: string;
+    analyzer_id: string;
+    snippet_hash: string;
+    rule?: string | undefined;
+}>;
+export type AnalyzerLeadProvenance = z.infer<typeof AnalyzerLeadProvenanceSchema>;
+/**
+ * Normalize a flagged source span so the hash survives cosmetic movement:
+ * per-line trim, internal whitespace runs collapsed to one space, empty lines
+ * dropped. A whitespace-only reformat therefore re-hashes identically (the
+ * lead's identity is its content, not its layout), while any real edit to the
+ * flagged code changes the digest.
+ */
+export declare function normalizeAnalyzerSnippet(snippet: string): string;
+/**
+ * Hash the 1-based inclusive line span `[lineStart, lineEnd ?? lineStart]` of
+ * `source` after {@link normalizeAnalyzerSnippet}. Returns undefined when the
+ * span is empty after normalization or lies wholly outside the file — callers
+ * then attach no provenance rather than a meaningless digest.
+ */
+export declare function hashAnalyzerSnippet(source: string, lineStart: number, lineEnd?: number): string | undefined;
+/**
+ * Stable string key of a provenance identity, for set membership at the
+ * close-verify draw (`analyzer_id`+`rule`+`path`+`snippet_hash`; `rule` folds
+ * in as "" when absent so the same lead keys identically on both sides).
+ */
+export declare function analyzerProvenanceKey(p: AnalyzerLeadProvenance): string;
+//# sourceMappingURL=provenance.d.ts.map

package/dist/shared/analyzers/provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.d.ts","sourceRoot":"","sources":["../../../src/shared/analyzers/provenance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B;IAErC,sEAAsE;;IAEtE,0DAA0D;;IAE1D,8CAA8C;;IAE9C,mEAAmE;;;;;;;;;;;;EAG5D,CAAC;AACZ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAKlF;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAMhE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,MAAM,GAAG,SAAS,CAUpB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAEvE"}

package/dist/shared/analyzers/provenance.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { hashContent } from "../hash.js";
+/**
+ * Content-anchored identity of one analyzer lead — the join key that lets
+ * remediation's close-verify draw ask "does this exact lead still fire?"
+ * mechanically (item C of `spec/mechanical-analyzer-layer-design.md`).
+ *
+ * Anchored on the NORMALIZED flagged snippet, never line numbers: edits shift
+ * lines, but an untouched clone/violation re-hashes identically wherever it
+ * moves within its file. Optional everywhere it is carried — a lead whose
+ * snippet cannot be read simply carries no provenance and is exempt from
+ * mechanical verification.
+ */
+export const AnalyzerLeadProvenanceSchema = z
+    .object({
+    /** Candidate id that produced the lead (e.g. "jscpd", "gitleaks"). */
+    analyzer_id: z.string(),
+    /** Analyzer-native rule id, when the tool reports one. */
+    rule: z.string().optional(),
+    /** Repo-relative path of the flagged file. */
+    path: z.string(),
+    /** `hashAnalyzerSnippet` digest of the normalized flagged span. */
+    snippet_hash: z.string(),
+})
+    .strict();
+/** Truncated-digest length: 16 hex chars — ample for per-file span identity. */
+const SNIPPET_HASH_LENGTH = 16;
+/**
+ * Normalize a flagged source span so the hash survives cosmetic movement:
+ * per-line trim, internal whitespace runs collapsed to one space, empty lines
+ * dropped. A whitespace-only reformat therefore re-hashes identically (the
+ * lead's identity is its content, not its layout), while any real edit to the
+ * flagged code changes the digest.
+ */
+export function normalizeAnalyzerSnippet(snippet) {
+    return snippet
+        .split(/\r?\n/)
+        .map((line) => line.trim().replace(/\s+/g, " "))
+        .filter((line) => line.length > 0)
+        .join("\n");
+}
+/**
+ * Hash the 1-based inclusive line span `[lineStart, lineEnd ?? lineStart]` of
+ * `source` after {@link normalizeAnalyzerSnippet}. Returns undefined when the
+ * span is empty after normalization or lies wholly outside the file — callers
+ * then attach no provenance rather than a meaningless digest.
+ */
+export function hashAnalyzerSnippet(source, lineStart, lineEnd) {
+    if (!Number.isInteger(lineStart) || lineStart < 1)
+        return undefined;
+    const last = lineEnd !== undefined && Number.isInteger(lineEnd) && lineEnd >= lineStart
+        ? lineEnd
+        : lineStart;
+    const lines = source.split(/\r?\n/).slice(lineStart - 1, last);
+    if (lines.length === 0)
+        return undefined;
+    const normalized = normalizeAnalyzerSnippet(lines.join("\n"));
+    if (normalized.length === 0)
+        return undefined;
+    return hashContent(normalized, { length: SNIPPET_HASH_LENGTH });
+}
+/**
+ * Stable string key of a provenance identity, for set membership at the
+ * close-verify draw (`analyzer_id`+`rule`+`path`+`snippet_hash`; `rule` folds
+ * in as "" when absent so the same lead keys identically on both sides).
+ */
+export function analyzerProvenanceKey(p) {
+    return [p.analyzer_id, p.rule ?? "", p.path, p.snippet_hash].join("\0");
+}
+//# sourceMappingURL=provenance.js.map

package/dist/shared/analyzers/provenance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.js","sourceRoot":"","sources":["../../../src/shared/analyzers/provenance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC;KAC1C,MAAM,CAAC;IACN,sEAAsE;IACtE,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,0DAA0D;IAC1D,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,8CAA8C;IAC9C,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,mEAAmE;IACnE,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;CACzB,CAAC;KACD,MAAM,EAAE,CAAC;AAGZ,gFAAgF;AAChF,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAE/B;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CAAC,OAAe;IACtD,OAAO,OAAO;SACX,KAAK,CAAC,OAAO,CAAC;SACd,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;SAC/C,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;SACjC,IAAI,CAAC,IAAI,CAAC,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CACjC,MAAc,EACd,SAAiB,EACjB,OAAgB;IAEhB,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,SAAS,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IACpE,MAAM,IAAI,GAAG,OAAO,KAAK,SAAS,IAAI,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,OAAO,IAAI,SAAS;QACrF,CAAC,CAAC,OAAO;QACT,CAAC,CAAC,SAAS,CAAC;IACd,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,SAAS,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC;IAC/D,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IACzC,MAAM,UAAU,GAAG,wBAAwB,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAC9D,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAC9C,OAAO,WAAW,CAAC,UAAU,EAAE,EAAE,MAAM,EAAE,mBAAmB,EAAE,CAAC,CAAC;AAClE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,CAAyB;IAC7D,OAAO,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,IAAI,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1E,CAAC"}

package/dist/{audit/adapters → shared/analyzers}/rubocop.d.ts

@@ -1,4 +1,4 @@
-import type { ExternalAnalyzerResults } from "../types/externalAnalyzer.js";
+import type { ExternalAnalyzerResults } from "./types.js";
 /**
  * Parse rubocop's `--format json` stdout into the generic item shape. Degrades
  * to `[]` on empty/malformed input or a missing `files` array.

package/dist/{audit/adapters → shared/analyzers}/rubocop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rubocop.d.ts","sourceRoot":"","sources":["../../../src/audit/adapters/rubocop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAgD5E;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC;IAClD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC,CAsDD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,uBAAuB,CAE5E"}
+{"version":3,"file":"rubocop.d.ts","sourceRoot":"","sources":["../../../src/shared/analyzers/rubocop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAgD1D;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC;IAClD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC,CAsDD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,uBAAuB,CAE5E"}

package/dist/shared/analyzers/rubocop.js.map

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

package/dist/{audit/types/externalAnalyzer.d.ts → shared/analyzers/types.d.ts}

@@ -11,15 +11,38 @@ export declare const ExternalAnalyzerResultItemSchema: z.ZodObject<{
     rule: z.ZodOptional<z.ZodString>;
     /** Preserves the analyzer-native payload when consumers need original detail. */
     raw: z.ZodOptional<z.ZodUnknown>;
+    /** Content-anchored lead identity for the close-verify draw (item C). */
+    provenance: z.ZodOptional<z.ZodObject<{
+        analyzer_id: z.ZodString;
+        rule: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        snippet_hash: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        analyzer_id: string;
+        snippet_hash: string;
+        rule?: string | undefined;
+    }, {
+        path: string;
+        analyzer_id: string;
+        snippet_hash: string;
+        rule?: string | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     path: string;
     id: string;
     category: string;
     severity: string;
     summary: string;
+    rule?: string | undefined;
     line_start?: number | undefined;
     line_end?: number | undefined;
-    rule?: string | undefined;
+    provenance?: {
+        path: string;
+        analyzer_id: string;
+        snippet_hash: string;
+        rule?: string | undefined;
+    } | undefined;
     raw?: unknown;
 }, {
     path: string;
@@ -27,9 +50,15 @@ export declare const ExternalAnalyzerResultItemSchema: z.ZodObject<{
     category: string;
     severity: string;
     summary: string;
+    rule?: string | undefined;
     line_start?: number | undefined;
     line_end?: number | undefined;
-    rule?: string | undefined;
+    provenance?: {
+        path: string;
+        analyzer_id: string;
+        snippet_hash: string;
+        rule?: string | undefined;
+    } | undefined;
     raw?: unknown;
 }>;
 export type ExternalAnalyzerResultItem = z.infer<typeof ExternalAnalyzerResultItemSchema>;
@@ -90,20 +119,23 @@ export declare const ExternalAnalyzerToolStatusSchema: z.ZodObject<{
     exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     error: z.ZodOptional<z.ZodString>;
     output_snippet: z.ZodOptional<z.ZodString>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
-    status: "failed" | "findings" | "success" | "spawn_error" | "skipped" | "not_resolved" | "parse_error";
+    status: "failed" | "findings" | "skipped" | "success" | "spawn_error" | "not_resolved" | "parse_error";
     resolved: boolean;
     tool: string;
     error?: string | undefined;
     command?: string | undefined;
+    duration_ms?: number | undefined;
     exit_code?: number | null | undefined;
     output_snippet?: string | undefined;
 }, {
-    status: "failed" | "findings" | "success" | "spawn_error" | "skipped" | "not_resolved" | "parse_error";
+    status: "failed" | "findings" | "skipped" | "success" | "spawn_error" | "not_resolved" | "parse_error";
     resolved: boolean;
     tool: string;
     error?: string | undefined;
     command?: string | undefined;
+    duration_ms?: number | undefined;
     exit_code?: number | null | undefined;
     output_snippet?: string | undefined;
 }>;
@@ -162,20 +194,23 @@ export declare const ExternalAnalyzerResultsSchema: z.ZodObject<{
         exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         error: z.ZodOptional<z.ZodString>;
         output_snippet: z.ZodOptional<z.ZodString>;
+        duration_ms: z.ZodOptional<z.ZodNumber>;
     }, "strict", z.ZodTypeAny, {
-        status: "failed" | "findings" | "success" | "spawn_error" | "skipped" | "not_resolved" | "parse_error";
+        status: "failed" | "findings" | "skipped" | "success" | "spawn_error" | "not_resolved" | "parse_error";
         resolved: boolean;
         tool: string;
         error?: string | undefined;
         command?: string | undefined;
+        duration_ms?: number | undefined;
         exit_code?: number | null | undefined;
         output_snippet?: string | undefined;
     }, {
-        status: "failed" | "findings" | "success" | "spawn_error" | "skipped" | "not_resolved" | "parse_error";
+        status: "failed" | "findings" | "skipped" | "success" | "spawn_error" | "not_resolved" | "parse_error";
         resolved: boolean;
         tool: string;
         error?: string | undefined;
         command?: string | undefined;
+        duration_ms?: number | undefined;
         exit_code?: number | null | undefined;
         output_snippet?: string | undefined;
     }>, "many">>;
@@ -190,15 +225,38 @@ export declare const ExternalAnalyzerResultsSchema: z.ZodObject<{
         rule: z.ZodOptional<z.ZodString>;
         /** Preserves the analyzer-native payload when consumers need original detail. */
         raw: z.ZodOptional<z.ZodUnknown>;
+        /** Content-anchored lead identity for the close-verify draw (item C). */
+        provenance: z.ZodOptional<z.ZodObject<{
+            analyzer_id: z.ZodString;
+            rule: z.ZodOptional<z.ZodString>;
+            path: z.ZodString;
+            snippet_hash: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            path: string;
+            analyzer_id: string;
+            snippet_hash: string;
+            rule?: string | undefined;
+        }, {
+            path: string;
+            analyzer_id: string;
+            snippet_hash: string;
+            rule?: string | undefined;
+        }>>;
     }, "strict", z.ZodTypeAny, {
         path: string;
         id: string;
         category: string;
         severity: string;
         summary: string;
+        rule?: string | undefined;
         line_start?: number | undefined;
         line_end?: number | undefined;
-        rule?: string | undefined;
+        provenance?: {
+            path: string;
+            analyzer_id: string;
+            snippet_hash: string;
+            rule?: string | undefined;
+        } | undefined;
         raw?: unknown;
     }, {
         path: string;
@@ -206,9 +264,15 @@ export declare const ExternalAnalyzerResultsSchema: z.ZodObject<{
         category: string;
         severity: string;
         summary: string;
+        rule?: string | undefined;
         line_start?: number | undefined;
         line_end?: number | undefined;
-        rule?: string | undefined;
+        provenance?: {
+            path: string;
+            analyzer_id: string;
+            snippet_hash: string;
+            rule?: string | undefined;
+        } | undefined;
         raw?: unknown;
     }>, "many">;
 }, "strict", z.ZodTypeAny, {
@@ -219,9 +283,15 @@ export declare const ExternalAnalyzerResultsSchema: z.ZodObject<{
         category: string;
         severity: string;
         summary: string;
+        rule?: string | undefined;
         line_start?: number | undefined;
         line_end?: number | undefined;
-        rule?: string | undefined;
+        provenance?: {
+            path: string;
+            analyzer_id: string;
+            snippet_hash: string;
+            rule?: string | undefined;
+        } | undefined;
         raw?: unknown;
     }[];
     generated_at?: string | undefined;
@@ -240,11 +310,12 @@ export declare const ExternalAnalyzerResultsSchema: z.ZodObject<{
         kind?: string | undefined;
     }[] | undefined;
     tool_statuses?: {
-        status: "failed" | "findings" | "success" | "spawn_error" | "skipped" | "not_resolved" | "parse_error";
+        status: "failed" | "findings" | "skipped" | "success" | "spawn_error" | "not_resolved" | "parse_error";
         resolved: boolean;
         tool: string;
         error?: string | undefined;
         command?: string | undefined;
+        duration_ms?: number | undefined;
         exit_code?: number | null | undefined;
         output_snippet?: string | undefined;
     }[] | undefined;
@@ -256,9 +327,15 @@ export declare const ExternalAnalyzerResultsSchema: z.ZodObject<{
         category: string;
         severity: string;
         summary: string;
+        rule?: string | undefined;
         line_start?: number | undefined;
         line_end?: number | undefined;
-        rule?: string | undefined;
+        provenance?: {
+            path: string;
+            analyzer_id: string;
+            snippet_hash: string;
+            rule?: string | undefined;
+        } | undefined;
         raw?: unknown;
     }[];
     generated_at?: string | undefined;
@@ -277,11 +354,12 @@ export declare const ExternalAnalyzerResultsSchema: z.ZodObject<{
         kind?: string | undefined;
     }[] | undefined;
     tool_statuses?: {
-        status: "failed" | "findings" | "success" | "spawn_error" | "skipped" | "not_resolved" | "parse_error";
+        status: "failed" | "findings" | "skipped" | "success" | "spawn_error" | "not_resolved" | "parse_error";
         resolved: boolean;
         tool: string;
         error?: string | undefined;
         command?: string | undefined;
+        duration_ms?: number | undefined;
         exit_code?: number | null | undefined;
         output_snippet?: string | undefined;
     }[] | undefined;
@@ -310,31 +388,35 @@ export declare const ExternalAnalyzerAcquisitionMarkerSchema: z.ZodObject<{
         exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         error: z.ZodOptional<z.ZodString>;
         output_snippet: z.ZodOptional<z.ZodString>;
+        duration_ms: z.ZodOptional<z.ZodNumber>;
     }, "strict", z.ZodTypeAny, {
-        status: "failed" | "findings" | "success" | "spawn_error" | "skipped" | "not_resolved" | "parse_error";
+        status: "failed" | "findings" | "skipped" | "success" | "spawn_error" | "not_resolved" | "parse_error";
         resolved: boolean;
         tool: string;
         error?: string | undefined;
         command?: string | undefined;
+        duration_ms?: number | undefined;
         exit_code?: number | null | undefined;
         output_snippet?: string | undefined;
     }, {
-        status: "failed" | "findings" | "success" | "spawn_error" | "skipped" | "not_resolved" | "parse_error";
+        status: "failed" | "findings" | "skipped" | "success" | "spawn_error" | "not_resolved" | "parse_error";
         resolved: boolean;
         tool: string;
         error?: string | undefined;
         command?: string | undefined;
+        duration_ms?: number | undefined;
         exit_code?: number | null | undefined;
         output_snippet?: string | undefined;
     }>, "many">;
 }, "strict", z.ZodTypeAny, {
     enabled: boolean;
     tool_statuses: {
-        status: "failed" | "findings" | "success" | "spawn_error" | "skipped" | "not_resolved" | "parse_error";
+        status: "failed" | "findings" | "skipped" | "success" | "spawn_error" | "not_resolved" | "parse_error";
         resolved: boolean;
         tool: string;
         error?: string | undefined;
         command?: string | undefined;
+        duration_ms?: number | undefined;
         exit_code?: number | null | undefined;
         output_snippet?: string | undefined;
     }[];
@@ -342,11 +424,12 @@ export declare const ExternalAnalyzerAcquisitionMarkerSchema: z.ZodObject<{
 }, {
     enabled: boolean;
     tool_statuses: {
-        status: "failed" | "findings" | "success" | "spawn_error" | "skipped" | "not_resolved" | "parse_error";
+        status: "failed" | "findings" | "skipped" | "success" | "spawn_error" | "not_resolved" | "parse_error";
         resolved: boolean;
         tool: string;
         error?: string | undefined;
         command?: string | undefined;
+        duration_ms?: number | undefined;
         exit_code?: number | null | undefined;
         output_snippet?: string | undefined;
     }[];
@@ -361,4 +444,4 @@ export type ExternalAnalyzerAcquisitionMarker = z.infer<typeof ExternalAnalyzerA
  * the others. Returns a new array sorted by `tool` for deterministic output.
  */
 export declare function upsertExternalToolResults(existing: ExternalAnalyzerResults[] | undefined, incoming: ExternalAnalyzerResults): ExternalAnalyzerResults[];
-//# sourceMappingURL=externalAnalyzer.d.ts.map
+//# sourceMappingURL=types.d.ts.map

package/dist/shared/analyzers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/shared/analyzers/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,sFAAsF;AACtF,eAAO,MAAM,gCAAgC;;;;;;;;;IAUzC,iFAAiF;;IAEjF,yEAAyE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlE,CAAC;AACZ,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;EAQjC,CAAC;AACZ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;EAQrC,CAAC;AAEZ,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBlC,CAAC;AACZ,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;IAKtC;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA5EH,iFAAiF;;QAEjF,yEAAyE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+ElE,CAAC;AACZ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMzC,CAAC;AACZ,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,uBAAuB,EAAE,GAAG,SAAS,EAC/C,QAAQ,EAAE,uBAAuB,GAChC,uBAAuB,EAAE,CAI3B"}

package/dist/{audit/types/externalAnalyzer.js → shared/analyzers/types.js}

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { AnalyzerLeadProvenanceSchema } from "./provenance.js";
 /** One normalized result imported from an external analyzer such as eslint or tsc. */
 export const ExternalAnalyzerResultItemSchema = z
     .object({
@@ -12,6 +13,8 @@ export const ExternalAnalyzerResultItemSchema = z
     rule: z.string().optional(),
     /** Preserves the analyzer-native payload when consumers need original detail. */
     raw: z.unknown().optional(),
+    /** Content-anchored lead identity for the close-verify draw (item C). */
+    provenance: AnalyzerLeadProvenanceSchema.optional(),
 })
     .strict();
 /**
@@ -59,6 +62,7 @@ export const ExternalAnalyzerToolStatusSchema = z
     exit_code: z.number().nullable().optional(),
     error: z.string().optional(),
     output_snippet: z.string().optional(),
+    duration_ms: z.number().optional(),
 })
     .strict();
 /** Imported analyzer output captured at a single generation time. */
@@ -107,4 +111,4 @@ export function upsertExternalToolResults(existing, incoming) {
     next.push(incoming);
     return next.sort((a, b) => a.tool.localeCompare(b.tool));
 }
-//# sourceMappingURL=externalAnalyzer.js.map
+//# sourceMappingURL=types.js.map

package/dist/shared/analyzers/types.js.map

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

package/dist/shared/decompose/systemicChallenge.d.ts

@@ -124,6 +124,22 @@ export declare const SystemicChallengeSubmissionSchema: z.ZodObject<{
         contract_obligation_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         verification_obligation_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         targeted_commands: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        analyzer_provenance: z.ZodOptional<z.ZodObject<{
+            analyzer_id: z.ZodString;
+            rule: z.ZodOptional<z.ZodString>;
+            path: z.ZodString;
+            snippet_hash: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            path: string;
+            analyzer_id: string;
+            snippet_hash: string;
+            rule?: string | undefined;
+        }, {
+            path: string;
+            analyzer_id: string;
+            snippet_hash: string;
+            rule?: string | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         id: string;
         confidence: "high" | "low" | "medium";
@@ -172,6 +188,12 @@ export declare const SystemicChallengeSubmissionSchema: z.ZodObject<{
         contract_obligation_ids?: string[] | undefined;
         verification_obligation_ids?: string[] | undefined;
         targeted_commands?: string[] | undefined;
+        analyzer_provenance?: {
+            path: string;
+            analyzer_id: string;
+            snippet_hash: string;
+            rule?: string | undefined;
+        } | undefined;
     }, {
         id: string;
         confidence: "high" | "low" | "medium";
@@ -220,6 +242,12 @@ export declare const SystemicChallengeSubmissionSchema: z.ZodObject<{
         contract_obligation_ids?: string[] | undefined;
         verification_obligation_ids?: string[] | undefined;
         targeted_commands?: string[] | undefined;
+        analyzer_provenance?: {
+            path: string;
+            analyzer_id: string;
+            snippet_hash: string;
+            rule?: string | undefined;
+        } | undefined;
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
     findings: {
@@ -270,6 +298,12 @@ export declare const SystemicChallengeSubmissionSchema: z.ZodObject<{
         contract_obligation_ids?: string[] | undefined;
         verification_obligation_ids?: string[] | undefined;
         targeted_commands?: string[] | undefined;
+        analyzer_provenance?: {
+            path: string;
+            analyzer_id: string;
+            snippet_hash: string;
+            rule?: string | undefined;
+        } | undefined;
     }[];
 }, {
     findings?: {
@@ -320,6 +354,12 @@ export declare const SystemicChallengeSubmissionSchema: z.ZodObject<{
         contract_obligation_ids?: string[] | undefined;
         verification_obligation_ids?: string[] | undefined;
         targeted_commands?: string[] | undefined;
+        analyzer_provenance?: {
+            path: string;
+            analyzer_id: string;
+            snippet_hash: string;
+            rule?: string | undefined;
+        } | undefined;
     }[] | undefined;
 }>;
 export type SystemicChallengeSubmission = z.infer<typeof SystemicChallengeSubmissionSchema>;

package/dist/shared/decompose/systemicChallenge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"systemicChallenge.d.ts","sourceRoot":"","sources":["../../../src/shared/decompose/systemicChallenge.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;GAOG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAInC,CAAC;AACZ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC"}
+{"version":3,"file":"systemicChallenge.d.ts","sourceRoot":"","sources":["../../../src/shared/decompose/systemicChallenge.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;GAOG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAInC,CAAC;AACZ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC"}

package/dist/shared/dispatch/dispatchQuotaContract.d.ts

@@ -501,7 +501,7 @@ export declare const DispatchQuotaContractSchema: z.ZodObject<{
     }, "strict", z.ZodTypeAny, {
         confidence: "high" | "low" | "medium";
         model: string | null;
-        source: "explicit_config" | "discovered_capability" | "static_metadata" | "cli_flags" | "provider_default" | "learned" | "default";
+        source: "default" | "explicit_config" | "discovered_capability" | "static_metadata" | "cli_flags" | "provider_default" | "learned";
         cooldown_until: string | null;
         pool_id: string;
         slots: number;
@@ -562,7 +562,7 @@ export declare const DispatchQuotaContractSchema: z.ZodObject<{
     }, {
         confidence: "high" | "low" | "medium";
         model: string | null;
-        source: "explicit_config" | "discovered_capability" | "static_metadata" | "cli_flags" | "provider_default" | "learned" | "default";
+        source: "default" | "explicit_config" | "discovered_capability" | "static_metadata" | "cli_flags" | "provider_default" | "learned";
         cooldown_until: string | null;
         pool_id: string;
         slots: number;
@@ -714,7 +714,7 @@ export declare const DispatchQuotaContractSchema: z.ZodObject<{
     run_id: string;
     contract_version: "dispatch-quota/v1";
     model: string | null;
-    source: "explicit_config" | "discovered_capability" | "static_metadata" | "cli_flags" | "provider_default" | "learned" | "default";
+    source: "default" | "explicit_config" | "discovered_capability" | "static_metadata" | "cli_flags" | "provider_default" | "learned";
     cooldown_until: string | null;
     resolved_limits: {
         context_tokens: number | null;
@@ -797,7 +797,7 @@ export declare const DispatchQuotaContractSchema: z.ZodObject<{
     capacity_pools?: {
         confidence: "high" | "low" | "medium";
         model: string | null;
-        source: "explicit_config" | "discovered_capability" | "static_metadata" | "cli_flags" | "provider_default" | "learned" | "default";
+        source: "default" | "explicit_config" | "discovered_capability" | "static_metadata" | "cli_flags" | "provider_default" | "learned";
         cooldown_until: string | null;
         pool_id: string;
         slots: number;
@@ -873,7 +873,7 @@ export declare const DispatchQuotaContractSchema: z.ZodObject<{
     run_id: string;
     contract_version: "dispatch-quota/v1";
     model: string | null;
-    source: "explicit_config" | "discovered_capability" | "static_metadata" | "cli_flags" | "provider_default" | "learned" | "default";
+    source: "default" | "explicit_config" | "discovered_capability" | "static_metadata" | "cli_flags" | "provider_default" | "learned";
     cooldown_until: string | null;
     resolved_limits: {
         context_tokens: number | null;
@@ -956,7 +956,7 @@ export declare const DispatchQuotaContractSchema: z.ZodObject<{
     capacity_pools?: {
         confidence: "high" | "low" | "medium";
         model: string | null;
-        source: "explicit_config" | "discovered_capability" | "static_metadata" | "cli_flags" | "provider_default" | "learned" | "default";
+        source: "default" | "explicit_config" | "discovered_capability" | "static_metadata" | "cli_flags" | "provider_default" | "learned";
         cooldown_until: string | null;
         pool_id: string;
         slots: number;