audit-tools 0.28.0

package/dist/audit/types/analyzerCapability.d.ts

@@ -0,0 +1,17 @@
+import type { AnalyzerSetting } from "audit-tools/shared";
+import type { AnalyzerResolution } from "../extractors/analyzers/types.js";
+export type AnalyzerCapabilityStatus = "applied" | "omitted";
+export interface AnalyzerCapabilityEntry {
+    id: string;
+    resolution: AnalyzerResolution;
+    setting: AnalyzerSetting;
+    edges_added: number;
+    routes_added: number;
+    note?: string;
+}
+export interface AnalyzerCapabilityRecord {
+    /** `applied` when ≥1 analyzer contributed edges/routes; `omitted` otherwise. */
+    status: AnalyzerCapabilityStatus;
+    analyzers: AnalyzerCapabilityEntry[];
+}
+//# sourceMappingURL=analyzerCapability.d.ts.map

package/dist/audit/types/analyzerCapability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzerCapability.d.ts","sourceRoot":"","sources":["../../../src/audit/types/analyzerCapability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAO3E,MAAM,MAAM,wBAAwB,GAAG,SAAS,GAAG,SAAS,CAAC;AAE7D,MAAM,WAAW,uBAAuB;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,kBAAkB,CAAC;IAC/B,OAAO,EAAE,eAAe,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,wBAAwB;IACvC,gFAAgF;IAChF,MAAM,EAAE,wBAAwB,CAAC;IACjC,SAAS,EAAE,uBAAuB,EAAE,CAAC;CACtC"}

package/dist/audit/types/analyzerCapability.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=analyzerCapability.js.map

package/dist/audit/types/analyzerCapability.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzerCapability.js","sourceRoot":"","sources":["../../../src/audit/types/analyzerCapability.ts"],"names":[],"mappings":""}

package/dist/audit/types/artifactMetadata.d.ts

@@ -0,0 +1,9 @@
+export interface ArtifactMetadataEntry {
+    revision: number;
+    content_hash: string;
+    dependency_revisions: Record<string, number>;
+}
+export interface ArtifactMetadataManifest {
+    artifacts: Record<string, ArtifactMetadataEntry>;
+}
+//# sourceMappingURL=artifactMetadata.d.ts.map

package/dist/audit/types/artifactMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifactMetadata.d.ts","sourceRoot":"","sources":["../../../src/audit/types/artifactMetadata.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9C;AAED,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;CAClD"}

package/dist/audit/types/artifactMetadata.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=artifactMetadata.js.map

package/dist/audit/types/artifactMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifactMetadata.js","sourceRoot":"","sources":["../../../src/audit/types/artifactMetadata.ts"],"names":[],"mappings":""}

package/dist/audit/types/auditScope.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Phase 3 — `--since` delta scope.
+ *
+ * `scope.json` records how the audit was scoped for a given run: a full audit
+ * (the default), or a delta audit measured against a git ref. In delta mode the
+ * orchestrator audits only the changed files (`seed_files`) and their nearest
+ * graph neighbours (`expanded_files`); every other auditable file inherits its
+ * prior completion or is excluded from this run. The artifact is a deterministic
+ * function of the inputs (the ref, the changed files, the graph) so the same
+ * inputs always yield the same scope, and it is recorded honestly in the report
+ * header and the run log. It sits upstream of `coverage_matrix.json` in the
+ * staleness DAG.
+ */
+export interface AuditScopeBudget {
+    /**
+     * Upper bound on the number of in-scope files (seeds + expanded). Seeds are
+     * always retained; expansion stops once this cap is reached.
+     */
+    max_files: number;
+}
+export interface AuditScopeManifest {
+    /**
+     * `full` audits every auditable file; `delta` scopes to a changed
+     * neighbourhood; `budget` dispatches only the top-K review packets under a
+     * `max_packets` cap and defers the rest.
+     */
+    mode: "full" | "delta" | "budget";
+    /** Git ref/SHA the delta was measured against; `null` in full mode. */
+    since: string | null;
+    /**
+     * Changed auditable files (relative to `since`) that exist in the repo
+     * manifest. Empty in full mode. Sorted for determinism.
+     */
+    seed_files: string[];
+    /**
+     * Auditable files pulled in by deterministic priority-frontier expansion over
+     * the dependency graph (graph neighbours of the seeds). Sorted for determinism.
+     */
+    expanded_files: string[];
+    /** The budget applied during expansion. */
+    budget: AuditScopeBudget;
+    /**
+     * Human-readable note when the scope was truncated by the budget, or when a
+     * requested `--since` could not be honoured and the run fell back to full.
+     */
+    dropped_note?: string;
+    /**
+     * When `mode === 'budget'`: the number of review packets that were NOT
+     * dispatched due to the `max_packets` cap. Present only in budget mode.
+     */
+    deferred_packet_count?: number;
+    /**
+     * When `mode === 'budget'`: the task_ids skipped due to the budget cap.
+     * Present only in budget mode.
+     */
+    deferred_task_ids?: string[];
+}
+//# sourceMappingURL=auditScope.d.ts.map

package/dist/audit/types/auditScope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auditScope.d.ts","sourceRoot":"","sources":["../../../src/audit/types/auditScope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;IAClC,uEAAuE;IACvE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB;;;OAGG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB;;;OAGG;IACH,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,2CAA2C;IAC3C,MAAM,EAAE,gBAAgB,CAAC;IACzB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B"}

package/dist/audit/types/auditScope.js

@@ -0,0 +1,15 @@
+/**
+ * Phase 3 — `--since` delta scope.
+ *
+ * `scope.json` records how the audit was scoped for a given run: a full audit
+ * (the default), or a delta audit measured against a git ref. In delta mode the
+ * orchestrator audits only the changed files (`seed_files`) and their nearest
+ * graph neighbours (`expanded_files`); every other auditable file inherits its
+ * prior completion or is excluded from this run. The artifact is a deterministic
+ * function of the inputs (the ref, the changed files, the graph) so the same
+ * inputs always yield the same scope, and it is recorded honestly in the report
+ * header and the run log. It sits upstream of `coverage_matrix.json` in the
+ * staleness DAG.
+ */
+export {};
+//# sourceMappingURL=auditScope.js.map

package/dist/audit/types/auditScope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auditScope.js","sourceRoot":"","sources":["../../../src/audit/types/auditScope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}

package/dist/audit/types/auditState.d.ts

@@ -0,0 +1,18 @@
+import type { Obligation } from "audit-tools/shared";
+export type AuditTopLevelStatus = "not_started" | "active" | "blocked" | "complete";
+export type { ObligationState } from "audit-tools/shared";
+export type AuditObligation = Obligation;
+export interface AuditState {
+    status: AuditTopLevelStatus;
+    last_executor?: string;
+    last_obligation?: string;
+    blockers?: string[];
+    obligations: AuditObligation[];
+    /**
+     * Set when the rolling dispatch engine fires a partial-completion terminal
+     * (empty pool or livelock). Allows synthesis to proceed on partial coverage
+     * without hard-gating on `audit_tasks_completed`.
+     */
+    partial_coverage_terminal?: boolean;
+}
+//# sourceMappingURL=auditState.d.ts.map

package/dist/audit/types/auditState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auditState.d.ts","sourceRoot":"","sources":["../../../src/audit/types/auditState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,MAAM,MAAM,mBAAmB,GAC3B,aAAa,GACb,QAAQ,GACR,SAAS,GACT,UAAU,CAAC;AAMf,YAAY,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC;AAEzC,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B;;;;OAIG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC"}

package/dist/audit/types/auditState.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=auditState.js.map

package/dist/audit/types/auditState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auditState.js","sourceRoot":"","sources":["../../../src/audit/types/auditState.ts"],"names":[],"mappings":""}

package/dist/audit/types/designAssessment.d.ts

@@ -0,0 +1,22 @@
+import type { Finding } from "../types.js";
+export interface DesignAssessment {
+    generated_at: string;
+    findings: Finding[];
+    /** @deprecated Use contract_findings instead */
+    review_findings?: Finding[];
+    /** @deprecated Derived from contract_reviewed && conceptual_reviewed */
+    reviewed?: boolean;
+    /** Contract-assessment pass (adversarial): inferred_contract_gap, trust_boundary_gap, invariant_counterexample, critical_invariant_coverage_gap */
+    contract_findings?: Finding[];
+    /** Conceptual-design pass (generative): tool_opportunity, architecture_pattern, design_simplification, integration, missing_capability */
+    conceptual_findings?: Finding[];
+    /** True when the contract review pass has been completed */
+    contract_reviewed?: boolean;
+    /** True when the conceptual review pass has been completed */
+    conceptual_reviewed?: boolean;
+}
+/**
+ * Derived backward-compat alias: true only when both passes are done.
+ */
+export declare function isDesignReviewed(assessment: DesignAssessment): boolean;
+//# sourceMappingURL=designAssessment.d.ts.map

package/dist/audit/types/designAssessment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"designAssessment.d.ts","sourceRoot":"","sources":["../../../src/audit/types/designAssessment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,gDAAgD;IAChD,eAAe,CAAC,EAAE,OAAO,EAAE,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,mJAAmJ;IACnJ,iBAAiB,CAAC,EAAE,OAAO,EAAE,CAAC;IAC9B,0IAA0I;IAC1I,mBAAmB,CAAC,EAAE,OAAO,EAAE,CAAC;IAChC,4DAA4D;IAC5D,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,8DAA8D;IAC9D,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAKtE"}

package/dist/audit/types/designAssessment.js

@@ -0,0 +1,8 @@
+/**
+ * Derived backward-compat alias: true only when both passes are done.
+ */
+export function isDesignReviewed(assessment) {
+    return (assessment.contract_reviewed === true &&
+        assessment.conceptual_reviewed === true);
+}
+//# sourceMappingURL=designAssessment.js.map

package/dist/audit/types/designAssessment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"designAssessment.js","sourceRoot":"","sources":["../../../src/audit/types/designAssessment.ts"],"names":[],"mappings":"AAmBA;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,UAA4B;IAC3D,OAAO,CACL,UAAU,CAAC,iBAAiB,KAAK,IAAI;QACrC,UAAU,CAAC,mBAAmB,KAAK,IAAI,CACxC,CAAC;AACJ,CAAC"}

package/dist/audit/types/externalAnalyzer.d.ts

@@ -0,0 +1,225 @@
+import { z } from "zod";
+/** One normalized result imported from an external analyzer such as eslint or tsc. */
+export declare const ExternalAnalyzerResultItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    category: z.ZodString;
+    severity: z.ZodString;
+    path: z.ZodString;
+    line_start: z.ZodOptional<z.ZodNumber>;
+    line_end: z.ZodOptional<z.ZodNumber>;
+    summary: z.ZodString;
+    rule: z.ZodOptional<z.ZodString>;
+    /** Preserves the analyzer-native payload when consumers need original detail. */
+    raw: z.ZodOptional<z.ZodUnknown>;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    id: string;
+    category: string;
+    severity: string;
+    summary: string;
+    line_start?: number | undefined;
+    line_end?: number | undefined;
+    rule?: string | undefined;
+    raw?: unknown;
+}, {
+    path: string;
+    id: string;
+    category: string;
+    severity: string;
+    summary: string;
+    line_start?: number | undefined;
+    line_end?: number | undefined;
+    rule?: string | undefined;
+    raw?: unknown;
+}>;
+export type ExternalAnalyzerResultItem = z.infer<typeof ExternalAnalyzerResultItemSchema>;
+/** A normalized analyzer hint that a bounded set of files belongs to a root. */
+export declare const ExternalAnalyzerOwnershipRootSchema: z.ZodObject<{
+    root: z.ZodString;
+    paths: z.ZodArray<z.ZodString, "many">;
+    kind: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    paths: string[];
+    root: string;
+    reason?: string | undefined;
+    confidence?: number | undefined;
+    kind?: string | undefined;
+}, {
+    paths: string[];
+    root: string;
+    reason?: string | undefined;
+    confidence?: number | undefined;
+    kind?: string | undefined;
+}>;
+export type ExternalAnalyzerOwnershipRoot = z.infer<typeof ExternalAnalyzerOwnershipRootSchema>;
+export declare const ExternalAnalyzerToolStatusSchema: z.ZodObject<{
+    tool: z.ZodString;
+    command: z.ZodOptional<z.ZodString>;
+    resolved: z.ZodBoolean;
+    status: z.ZodEnum<["skipped", "success", "findings", "not_resolved", "spawn_error", "parse_error", "failed"]>;
+    exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    error: z.ZodOptional<z.ZodString>;
+    output_snippet: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    status: "failed" | "findings" | "spawn_error" | "success" | "skipped" | "not_resolved" | "parse_error";
+    resolved: boolean;
+    tool: string;
+    command?: string | undefined;
+    error?: string | undefined;
+    exit_code?: number | null | undefined;
+    output_snippet?: string | undefined;
+}, {
+    status: "failed" | "findings" | "spawn_error" | "success" | "skipped" | "not_resolved" | "parse_error";
+    resolved: boolean;
+    tool: string;
+    command?: string | undefined;
+    error?: string | undefined;
+    exit_code?: number | null | undefined;
+    output_snippet?: string | undefined;
+}>;
+export type ExternalAnalyzerToolStatus = z.infer<typeof ExternalAnalyzerToolStatusSchema>;
+/** Imported analyzer output captured at a single generation time. */
+export declare const ExternalAnalyzerResultsSchema: z.ZodObject<{
+    tool: z.ZodString;
+    generated_at: z.ZodOptional<z.ZodString>;
+    ownership_roots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        root: z.ZodString;
+        paths: z.ZodArray<z.ZodString, "many">;
+        kind: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        paths: string[];
+        root: string;
+        reason?: string | undefined;
+        confidence?: number | undefined;
+        kind?: string | undefined;
+    }, {
+        paths: string[];
+        root: string;
+        reason?: string | undefined;
+        confidence?: number | undefined;
+        kind?: string | undefined;
+    }>, "many">>;
+    tool_statuses: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        tool: z.ZodString;
+        command: z.ZodOptional<z.ZodString>;
+        resolved: z.ZodBoolean;
+        status: z.ZodEnum<["skipped", "success", "findings", "not_resolved", "spawn_error", "parse_error", "failed"]>;
+        exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        error: z.ZodOptional<z.ZodString>;
+        output_snippet: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        status: "failed" | "findings" | "spawn_error" | "success" | "skipped" | "not_resolved" | "parse_error";
+        resolved: boolean;
+        tool: string;
+        command?: string | undefined;
+        error?: string | undefined;
+        exit_code?: number | null | undefined;
+        output_snippet?: string | undefined;
+    }, {
+        status: "failed" | "findings" | "spawn_error" | "success" | "skipped" | "not_resolved" | "parse_error";
+        resolved: boolean;
+        tool: string;
+        command?: string | undefined;
+        error?: string | undefined;
+        exit_code?: number | null | undefined;
+        output_snippet?: string | undefined;
+    }>, "many">>;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        category: z.ZodString;
+        severity: z.ZodString;
+        path: z.ZodString;
+        line_start: z.ZodOptional<z.ZodNumber>;
+        line_end: z.ZodOptional<z.ZodNumber>;
+        summary: z.ZodString;
+        rule: z.ZodOptional<z.ZodString>;
+        /** Preserves the analyzer-native payload when consumers need original detail. */
+        raw: z.ZodOptional<z.ZodUnknown>;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        id: string;
+        category: string;
+        severity: string;
+        summary: string;
+        line_start?: number | undefined;
+        line_end?: number | undefined;
+        rule?: string | undefined;
+        raw?: unknown;
+    }, {
+        path: string;
+        id: string;
+        category: string;
+        severity: string;
+        summary: string;
+        line_start?: number | undefined;
+        line_end?: number | undefined;
+        rule?: string | undefined;
+        raw?: unknown;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    results: {
+        path: string;
+        id: string;
+        category: string;
+        severity: string;
+        summary: string;
+        line_start?: number | undefined;
+        line_end?: number | undefined;
+        rule?: string | undefined;
+        raw?: unknown;
+    }[];
+    tool: string;
+    generated_at?: string | undefined;
+    ownership_roots?: {
+        paths: string[];
+        root: string;
+        reason?: string | undefined;
+        confidence?: number | undefined;
+        kind?: string | undefined;
+    }[] | undefined;
+    tool_statuses?: {
+        status: "failed" | "findings" | "spawn_error" | "success" | "skipped" | "not_resolved" | "parse_error";
+        resolved: boolean;
+        tool: string;
+        command?: string | undefined;
+        error?: string | undefined;
+        exit_code?: number | null | undefined;
+        output_snippet?: string | undefined;
+    }[] | undefined;
+}, {
+    results: {
+        path: string;
+        id: string;
+        category: string;
+        severity: string;
+        summary: string;
+        line_start?: number | undefined;
+        line_end?: number | undefined;
+        rule?: string | undefined;
+        raw?: unknown;
+    }[];
+    tool: string;
+    generated_at?: string | undefined;
+    ownership_roots?: {
+        paths: string[];
+        root: string;
+        reason?: string | undefined;
+        confidence?: number | undefined;
+        kind?: string | undefined;
+    }[] | undefined;
+    tool_statuses?: {
+        status: "failed" | "findings" | "spawn_error" | "success" | "skipped" | "not_resolved" | "parse_error";
+        resolved: boolean;
+        tool: string;
+        command?: string | undefined;
+        error?: string | undefined;
+        exit_code?: number | null | undefined;
+        output_snippet?: string | undefined;
+    }[] | undefined;
+}>;
+export type ExternalAnalyzerResults = z.infer<typeof ExternalAnalyzerResultsSchema>;
+//# sourceMappingURL=externalAnalyzer.d.ts.map

package/dist/audit/types/externalAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"externalAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/audit/types/externalAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,sFAAsF;AACtF,eAAO,MAAM,gCAAgC;;;;;;;;;IAUzC,iFAAiF;;;;;;;;;;;;;;;;;;;;;;EAG1E,CAAC;AACZ,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;EAQrC,CAAC;AACZ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,mCAAmC,CAC3C,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;EAkBlC,CAAC;AACZ,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA9CtC,iFAAiF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsD1E,CAAC;AACZ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC"}

package/dist/audit/types/externalAnalyzer.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+/** One normalized result imported from an external analyzer such as eslint or tsc. */
+export const ExternalAnalyzerResultItemSchema = z
+    .object({
+    id: z.string(),
+    category: z.string(),
+    severity: z.string(),
+    path: z.string(),
+    line_start: z.number().optional(),
+    line_end: z.number().optional(),
+    summary: z.string(),
+    rule: z.string().optional(),
+    /** Preserves the analyzer-native payload when consumers need original detail. */
+    raw: z.unknown().optional(),
+})
+    .strict();
+/** A normalized analyzer hint that a bounded set of files belongs to a root. */
+export const ExternalAnalyzerOwnershipRootSchema = z
+    .object({
+    root: z.string(),
+    paths: z.array(z.string()),
+    kind: z.string().optional(),
+    confidence: z.number().optional(),
+    reason: z.string().optional(),
+})
+    .strict();
+export const ExternalAnalyzerToolStatusSchema = z
+    .object({
+    tool: z.string(),
+    command: z.string().optional(),
+    resolved: z.boolean(),
+    status: z.enum([
+        "skipped",
+        "success",
+        "findings",
+        "not_resolved",
+        "spawn_error",
+        "parse_error",
+        "failed",
+    ]),
+    exit_code: z.number().nullable().optional(),
+    error: z.string().optional(),
+    output_snippet: z.string().optional(),
+})
+    .strict();
+/** Imported analyzer output captured at a single generation time. */
+export const ExternalAnalyzerResultsSchema = z
+    .object({
+    tool: z.string(),
+    generated_at: z.string().optional(),
+    ownership_roots: z.array(ExternalAnalyzerOwnershipRootSchema).optional(),
+    tool_statuses: z.array(ExternalAnalyzerToolStatusSchema).optional(),
+    results: z.array(ExternalAnalyzerResultItemSchema),
+})
+    .strict();
+//# sourceMappingURL=externalAnalyzer.js.map

package/dist/audit/types/externalAnalyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"externalAnalyzer.js","sourceRoot":"","sources":["../../../src/audit/types/externalAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,sFAAsF;AACtF,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAAC;KAC9C,MAAM,CAAC;IACN,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC/B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,iFAAiF;IACjF,GAAG,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;CAC5B,CAAC;KACD,MAAM,EAAE,CAAC;AAKZ,gFAAgF;AAChF,MAAM,CAAC,MAAM,mCAAmC,GAAG,CAAC;KACjD,MAAM,CAAC;IACN,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC1B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC9B,CAAC;KACD,MAAM,EAAE,CAAC;AAKZ,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAAC;KAC9C,MAAM,CAAC;IACN,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE;IACrB,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC;QACb,SAAS;QACT,SAAS;QACT,UAAU;QACV,cAAc;QACd,aAAa;QACb,aAAa;QACb,QAAQ;KACT,CAAC;IACF,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAC3C,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC5B,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACtC,CAAC;KACD,MAAM,EAAE,CAAC;AAKZ,qEAAqE;AACrE,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC;KAC3C,MAAM,CAAC;IACN,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACnC,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,mCAAmC,CAAC,CAAC,QAAQ,EAAE;IACxE,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,gCAAgC,CAAC,CAAC,QAAQ,EAAE;IACnE,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,gCAAgC,CAAC;CACnD,CAAC;KACD,MAAM,EAAE,CAAC"}

package/dist/audit/types/flowCoverage.d.ts

@@ -0,0 +1,16 @@
+export declare const FLOW_COVERAGE_STATUSES: readonly ["pending", "partial", "complete"];
+export type FlowCoverageStatus = (typeof FLOW_COVERAGE_STATUSES)[number];
+/** Coverage for one critical flow across the lenses the audit expects to see. */
+export interface FlowCoverageRecord {
+    flow_id: string;
+    paths: string[];
+    required_lenses: string[];
+    completed_lenses: string[];
+    status: FlowCoverageStatus;
+    notes?: string[];
+}
+/** Aggregated flow coverage written beside the critical flow manifest. */
+export interface FlowCoverageManifest {
+    flows: FlowCoverageRecord[];
+}
+//# sourceMappingURL=flowCoverage.d.ts.map

package/dist/audit/types/flowCoverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowCoverage.d.ts","sourceRoot":"","sources":["../../../src/audit/types/flowCoverage.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,6CAIzB,CAAC;AACX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzE,iFAAiF;AACjF,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,MAAM,EAAE,kBAAkB,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,0EAA0E;AAC1E,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,kBAAkB,EAAE,CAAC;CAC7B"}

package/dist/audit/types/flowCoverage.js

@@ -0,0 +1,6 @@
+export const FLOW_COVERAGE_STATUSES = [
+    "pending",
+    "partial",
+    "complete",
+];
+//# sourceMappingURL=flowCoverage.js.map

package/dist/audit/types/flowCoverage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowCoverage.js","sourceRoot":"","sources":["../../../src/audit/types/flowCoverage.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,SAAS;IACT,SAAS;IACT,UAAU;CACF,CAAC"}