audit-tools 0.28.0

package/dist/shared/types/graph.d.ts

@@ -0,0 +1,359 @@
+import { z } from "zod";
+export declare const GraphEdgeSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    kind: z.ZodOptional<z.ZodString>;
+    direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    from: string;
+    to: string;
+    reason?: string | undefined;
+    confidence?: number | undefined;
+    kind?: string | undefined;
+    direction?: "directed" | "undirected" | undefined;
+}, {
+    from: string;
+    to: string;
+    reason?: string | undefined;
+    confidence?: number | undefined;
+    kind?: string | undefined;
+    direction?: "directed" | "undirected" | undefined;
+}>;
+export type GraphEdge = z.infer<typeof GraphEdgeSchema>;
+export declare const RouteEdgeSchema: z.ZodObject<{
+    path: z.ZodString;
+    handler: z.ZodString;
+    method: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    handler: string;
+    method?: string | undefined;
+}, {
+    path: string;
+    handler: string;
+    method?: string | undefined;
+}>;
+export type RouteEdge = z.infer<typeof RouteEdgeSchema>;
+export declare const GraphBundleSchema: z.ZodObject<{
+    graphs: z.ZodObject<{
+        imports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            kind: z.ZodOptional<z.ZodString>;
+            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }>, "many">>;
+        calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            kind: z.ZodOptional<z.ZodString>;
+            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }>, "many">>;
+        references: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            kind: z.ZodOptional<z.ZodString>;
+            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }>, "many">>;
+        routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            handler: z.ZodString;
+            method: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            path: string;
+            handler: string;
+            method?: string | undefined;
+        }, {
+            path: string;
+            handler: string;
+            method?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        imports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            kind: z.ZodOptional<z.ZodString>;
+            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }>, "many">>;
+        calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            kind: z.ZodOptional<z.ZodString>;
+            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }>, "many">>;
+        references: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            kind: z.ZodOptional<z.ZodString>;
+            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }>, "many">>;
+        routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            handler: z.ZodString;
+            method: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            path: string;
+            handler: string;
+            method?: string | undefined;
+        }, {
+            path: string;
+            handler: string;
+            method?: string | undefined;
+        }>, "many">>;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        imports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            kind: z.ZodOptional<z.ZodString>;
+            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }>, "many">>;
+        calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            kind: z.ZodOptional<z.ZodString>;
+            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }>, "many">>;
+        references: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            kind: z.ZodOptional<z.ZodString>;
+            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }, {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }>, "many">>;
+        routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            handler: z.ZodString;
+            method: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            path: string;
+            handler: string;
+            method?: string | undefined;
+        }, {
+            path: string;
+            handler: string;
+            method?: string | undefined;
+        }>, "many">>;
+    }, z.ZodUnknown, "strip">>;
+    /**
+     * Provenance for the optional graph-enrichment pass: the ids of the language
+     * analyzers whose edges were merged into this bundle (empty/absent when only
+     * the deterministic regex floor was used). See Phase 5 analyzer seam.
+     */
+    analyzers_used: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    graphs: {
+        imports?: {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }[] | undefined;
+        calls?: {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }[] | undefined;
+        references?: {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }[] | undefined;
+        routes?: {
+            path: string;
+            handler: string;
+            method?: string | undefined;
+        }[] | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    analyzers_used?: string[] | undefined;
+}, {
+    graphs: {
+        imports?: {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }[] | undefined;
+        calls?: {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }[] | undefined;
+        references?: {
+            from: string;
+            to: string;
+            reason?: string | undefined;
+            confidence?: number | undefined;
+            kind?: string | undefined;
+            direction?: "directed" | "undirected" | undefined;
+        }[] | undefined;
+        routes?: {
+            path: string;
+            handler: string;
+            method?: string | undefined;
+        }[] | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    analyzers_used?: string[] | undefined;
+}>;
+export type GraphBundle = z.infer<typeof GraphBundleSchema>;
+//# sourceMappingURL=graph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../../src/shared/types/graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;EASjB,CAAC;AACZ,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,eAAe;;;;;;;;;;;;EAMjB,CAAC;AACZ,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAW1B;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGI,CAAC;AACZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/shared/types/graph.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export const GraphEdgeSchema = z
+    .object({
+    from: z.string(),
+    to: z.string(),
+    kind: z.string().optional(),
+    direction: z.enum(["directed", "undirected"]).optional(),
+    confidence: z.number().min(0).max(1).optional(),
+    reason: z.string().optional(),
+})
+    .strict();
+export const RouteEdgeSchema = z
+    .object({
+    path: z.string(),
+    handler: z.string(),
+    method: z.string().optional(),
+})
+    .strict();
+export const GraphBundleSchema = z
+    .object({
+    graphs: z
+        .object({
+        imports: z.array(GraphEdgeSchema).optional(),
+        calls: z.array(GraphEdgeSchema).optional(),
+        references: z.array(GraphEdgeSchema).optional(),
+        routes: z.array(RouteEdgeSchema).optional(),
+    })
+        // Graph categories are open-ended: new analyzers may add edge sets.
+        .catchall(z.unknown()),
+    /**
+     * Provenance for the optional graph-enrichment pass: the ids of the language
+     * analyzers whose edges were merged into this bundle (empty/absent when only
+     * the deterministic regex floor was used). See Phase 5 analyzer seam.
+     */
+    analyzers_used: z.array(z.string()).optional(),
+})
+    .strict();
+//# sourceMappingURL=graph.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph.js","sourceRoot":"","sources":["../../../src/shared/types/graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC;KAC7B,MAAM,CAAC;IACN,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,SAAS,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC,CAAC,QAAQ,EAAE;IACxD,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC/C,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC9B,CAAC;KACD,MAAM,EAAE,CAAC;AAGZ,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC;KAC7B,MAAM,CAAC;IACN,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC9B,CAAC;KACD,MAAM,EAAE,CAAC;AAGZ,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC;KAC/B,MAAM,CAAC;IACN,MAAM,EAAE,CAAC;SACN,MAAM,CAAC;QACN,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,QAAQ,EAAE;QAC5C,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,QAAQ,EAAE;QAC1C,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,QAAQ,EAAE;QAC/C,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,QAAQ,EAAE;KAC5C,CAAC;QACF,oEAAoE;SACnE,QAAQ,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;IACxB;;;;OAIG;IACH,cAAc,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;CAC/C,CAAC;KACD,MAAM,EAAE,CAAC"}

package/dist/shared/types/intentCheckpoint.d.ts

@@ -0,0 +1,95 @@
+import type { FileDispositionStatus } from "./disposition.js";
+/**
+ * The accepted scope and intent for a run, confirmed by the host before
+ * planning. Single-sourced so both orchestrators share one shape: audit-code
+ * uses `excluded_scope`/`must_not_touch`/`free_form_intent`; remediate-code
+ * additionally uses `filters` to narrow findings. `scope_summary`/
+ * `intent_summary` are human renders; the structured fields are what downstream
+ * planning, worker prompts, and reports actually consume.
+ */
+export interface IntentCheckpoint {
+    schema_version: "intent-checkpoint/v1";
+    confirmed_at: string;
+    /**
+     * `"host"` — checkpoint has been reviewed and confirmed by the host agent.
+     * `"draft"` — preliminary checkpoint pre-populated by synthesize_intake worker;
+     *   not yet confirmed; planning must not begin and filtering must not apply.
+     */
+    confirmed_by: "host" | "draft";
+    /** Human-readable description of the confirmed scope. */
+    scope_summary: string;
+    /** Human-readable description of the goal (e.g. full-audit / delta). */
+    intent_summary: string;
+    /**
+     * Free-form intent; interpreted into priority/lens/scope signals at planning
+     * time via freeFormIntentInterpreter. Never threaded verbatim into worker or
+     * dispatch prompts (see freeFormIntentInterpreter, INV-S04).
+     */
+    free_form_intent?: string;
+    /** Paths intentionally excluded from the run, each with a reason. */
+    excluded_scope?: Array<{
+        path: string;
+        reason: string;
+    }>;
+    /** Path globs that must never be written to. */
+    must_not_touch?: string[];
+    /** Remediate-only finding filters; audit-code ignores these. */
+    filters?: {
+        severity?: string[];
+        lenses?: string[];
+        packages?: string[];
+        themes?: string[];
+    };
+    /**
+     * Clauses from free_form_intent that could not be encoded as lens-weight,
+     * priority, or scope signals. Each entry carries the original clause text,
+     * the blocking checkpoint question raised for it, and the optional host
+     * answer once resolved. These survive as explicit machine-checkable
+     * contract constraints threaded into planning and worker prompts.
+     */
+    constraint_clauses?: Array<{
+        /** The original unencodable clause text. */
+        text: string;
+        /** The blocking checkpoint question generated for this clause. */
+        checkpoint_question: string;
+        /** The host's answer to the checkpoint question once resolved. */
+        host_answer?: string;
+    }>;
+    /**
+     * Per-file or per-prefix status corrections accepted by the host. Applied
+     * before coverage initialization so overridden files never become audit
+     * tasks. Typically sourced from `disposition_override_proposals` in the
+     * scope pre-digest shown during the `confirm_intent` step.
+     */
+    disposition_overrides?: Array<{
+        path: string;
+        status: FileDispositionStatus;
+        reason: string;
+    }>;
+    /**
+     * Accepted or modified lens set from the host, derived from the
+     * `lens_proposals` in the scope pre-digest. `include` is additive (always
+     * merged with mandatory lenses); `exclude` removes non-mandatory lenses.
+     */
+    lens_selection?: {
+        include?: string[];
+        exclude?: string[];
+    };
+    /**
+     * Conceptual design-review depth, confirmed by the host during
+     * `confirm_intent`. Provider-neutral: it records *how much* conceptual review
+     * to do, never *which model* runs it (model choice is resolved JIT at dispatch
+     * against the active provider's discovered roster).
+     * - `conceptual_depth: "shallow"` (default when omitted) — a single conceptual
+     *   reviewer.
+     * - `conceptual_depth: "deep"` — fan out `perspectives` independent reviewers
+     *   with maximally dissimilar perspectives, then compile via an independent
+     *   judge.
+     * `perspectives` bounds the deep fan-out count; ignored when shallow.
+     */
+    design_review?: {
+        conceptual_depth?: "shallow" | "deep";
+        perspectives?: number;
+    };
+}
+//# sourceMappingURL=intentCheckpoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intentCheckpoint.d.ts","sourceRoot":"","sources":["../../../src/shared/types/intentCheckpoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAE9D;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,cAAc,EAAE,sBAAsB,CAAC;IACvC,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,yDAAyD;IACzD,aAAa,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,cAAc,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qEAAqE;IACrE,cAAc,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACzD,gDAAgD;IAChD,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,gEAAgE;IAChE,OAAO,CAAC,EAAE;QACR,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;QAClB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC;IACF;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,KAAK,CAAC;QACzB,4CAA4C;QAC5C,IAAI,EAAE,MAAM,CAAC;QACb,kEAAkE;QAClE,mBAAmB,EAAE,MAAM,CAAC;QAC5B,kEAAkE;QAClE,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC,CAAC;IACH;;;;;OAKG;IACH,qBAAqB,CAAC,EAAE,KAAK,CAAC;QAC5B,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,qBAAqB,CAAC;QAC9B,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;IACH;;;;OAIG;IACH,cAAc,CAAC,EAAE;QACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;IACF;;;;;;;;;;;OAWG;IACH,aAAa,CAAC,EAAE;QACd,gBAAgB,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;QACtC,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;CACH"}

package/dist/shared/types/intentCheckpoint.js

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

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

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

package/dist/shared/types/intentInterpretation.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Versioned seam contract for the free_form_intent Interpreter (N-X06).
+ *
+ * Pins the output shape of the intent interpretation step so that consumers
+ * (audit-code, remediate-code) can be validated against a single,
+ * version-stamped result interface.
+ *
+ * The implementing function lives in src/intent/clauseInterpreter.ts (interpretIntent)
+ * and src/intent/freeFormIntentInterpreter.ts (interpretFreeFormIntent).
+ * This file ONLY declares the contract types and the version constant.
+ */
+import type { Lens } from "./lens.js";
+/**
+ * Version string for the FreeFormIntentInterpretation contract.
+ * Increment when any breaking interface change lands.
+ */
+export declare const FREE_FORM_INTENT_INTERPRETATION_VERSION: "1.0.0";
+/** A single encoded clause with its signal kind and detail. */
+export interface EncodedClause {
+    /** Original clause text (trimmed, never the verbatim free_form_intent). */
+    text: string;
+    /** The signal kind this clause encoded to. */
+    kind: "lens_weight" | "priority_signal" | "scope_emphasis";
+    /**
+     * Human-readable detail describing what was encoded.
+     * e.g. "Matches lens(es): security" or "Contains urgency/priority keyword".
+     */
+    detail: string;
+    /**
+     * Lens name, present only when kind === "lens_weight".
+     * Enables callers to correlate encoded clauses with lens-weighting logic.
+     */
+    lens?: Lens;
+}
+/**
+ * Structured output of the free-form intent interpreter.
+ *
+ * INV-S04: The verbatim free_form_intent string MUST NOT appear in any field
+ * of this type. All output is derived signal, never the raw input.
+ */
+export interface FreeFormIntentInterpretation {
+    /** Schema version — must equal FREE_FORM_INTENT_INTERPRETATION_VERSION. */
+    schema_version: typeof FREE_FORM_INTENT_INTERPRETATION_VERSION;
+    /**
+     * Clauses that were successfully encoded as planning signals
+     * (lens weights, priority signals, scope emphases).
+     */
+    encoded_clauses: EncodedClause[];
+    /**
+     * Blocking checkpoint questions generated from clauses that could not be
+     * encoded. Each question must be answered before planning proceeds.
+     */
+    checkpoint_questions: string[];
+    /** True when at least one clause produced a checkpoint question. */
+    has_unencodable: boolean;
+}
+//# sourceMappingURL=intentInterpretation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intentInterpretation.d.ts","sourceRoot":"","sources":["../../../src/shared/types/intentInterpretation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAMtC;;;GAGG;AACH,eAAO,MAAM,uCAAuC,EAAG,OAAgB,CAAC;AAMxE,+DAA+D;AAC/D,MAAM,WAAW,aAAa;IAC5B,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,IAAI,EAAE,aAAa,GAAG,iBAAiB,GAAG,gBAAgB,CAAC;IAC3D;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,IAAI,CAAC,EAAE,IAAI,CAAC;CACb;AAED;;;;;GAKG;AACH,MAAM,WAAW,4BAA4B;IAC3C,2EAA2E;IAC3E,cAAc,EAAE,OAAO,uCAAuC,CAAC;IAC/D;;;OAGG;IACH,eAAe,EAAE,aAAa,EAAE,CAAC;IACjC;;;OAGG;IACH,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,oEAAoE;IACpE,eAAe,EAAE,OAAO,CAAC;CAC1B"}

package/dist/shared/types/intentInterpretation.js

@@ -0,0 +1,20 @@
+/**
+ * Versioned seam contract for the free_form_intent Interpreter (N-X06).
+ *
+ * Pins the output shape of the intent interpretation step so that consumers
+ * (audit-code, remediate-code) can be validated against a single,
+ * version-stamped result interface.
+ *
+ * The implementing function lives in src/intent/clauseInterpreter.ts (interpretIntent)
+ * and src/intent/freeFormIntentInterpreter.ts (interpretFreeFormIntent).
+ * This file ONLY declares the contract types and the version constant.
+ */
+// ---------------------------------------------------------------------------
+// Version constant
+// ---------------------------------------------------------------------------
+/**
+ * Version string for the FreeFormIntentInterpretation contract.
+ * Increment when any breaking interface change lands.
+ */
+export const FREE_FORM_INTENT_INTERPRETATION_VERSION = "1.0.0";
+//# sourceMappingURL=intentInterpretation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intentInterpretation.js","sourceRoot":"","sources":["../../../src/shared/types/intentInterpretation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,8EAA8E;AAC9E,mBAAmB;AACnB,8EAA8E;AAE9E;;;GAGG;AACH,MAAM,CAAC,MAAM,uCAAuC,GAAG,OAAgB,CAAC"}

package/dist/shared/types/lens.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import type { FindingSeverity, FindingConfidence } from "./finding.js";
+/** The canonical zod enum every other lens artifact derives from. */
+export declare const LensSchema: z.ZodEnum<["correctness", "architecture", "maintainability", "security", "reliability", "performance", "data_integrity", "tests", "operability", "config_deployment", "observability"]>;
+/** The canonical ordered tuple of lenses. */
+export declare const LENSES: ["correctness", "architecture", "maintainability", "security", "reliability", "performance", "data_integrity", "tests", "operability", "config_deployment", "observability"];
+/** Audit lens: one analytical perspective an audit task covers a unit under. */
+export type Lens = z.infer<typeof LensSchema>;
+/** Runtime membership test set for {@link Lens}. */
+export declare const VALID_LENSES: ReadonlySet<string>;
+export declare function isLens(value: unknown): value is Lens;
+/** The canonical ordered tuple of finding severities. */
+export declare const SEVERITIES: readonly FindingSeverity[];
+/** Runtime membership test set for {@link FindingSeverity}. */
+export declare const VALID_SEVERITIES: ReadonlySet<string>;
+/** The canonical ordered tuple of finding confidence levels. */
+export declare const CONFIDENCES: readonly FindingConfidence[];
+/** Runtime membership test set for {@link FindingConfidence}. */
+export declare const VALID_CONFIDENCES: ReadonlySet<string>;
+/**
+ * Numeric severity rank: `critical`=5, `high`=4, `medium`=3, `low`=2, `info`=1.
+ * Higher == more severe. Derived from {@link SEVERITIES} so it never drifts.
+ */
+export declare function severityRank(severity: FindingSeverity): number;
+/**
+ * Numeric confidence rank: `high`=3, `medium`=2, `low`=1. Higher == more
+ * confident. Derived from {@link CONFIDENCES} so it never drifts.
+ */
+export declare function confidenceRank(confidence: FindingConfidence): number;
+/**
+ * Comparator that orders severities **most-severe-first** (`critical` before
+ * `info`). Returns a negative number when `a` is more severe than `b`, so
+ * `findings.sort((x, y) => severityCompare(x.severity, y.severity))` puts the
+ * most-severe finding first. Single-sources the "critical-first" sort direction
+ * that intake previously open-coded with an inverted ad-hoc table.
+ */
+export declare function severityCompare(a: FindingSeverity, b: FindingSeverity): number;
+//# sourceMappingURL=lens.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lens.d.ts","sourceRoot":"","sources":["../../../src/shared/types/lens.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAGvE,qEAAqE;AACrE,eAAO,MAAM,UAAU,yLAYrB,CAAC;AAEH,6CAA6C;AAC7C,eAAO,MAAM,MAAM,8KAAqB,CAAC;AAEzC,gFAAgF;AAChF,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAE9C,oDAAoD;AACpD,eAAO,MAAM,YAAY,EAAE,WAAW,CAAC,MAAM,CAAmB,CAAC;AAEjE,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,CAEpD;AAED,yDAAyD;AACzD,eAAO,MAAM,UAAU,EAAE,SAAS,eAAe,EAAkC,CAAC;AAEpF,+DAA+D;AAC/D,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAuB,CAAC;AAEzE,gEAAgE;AAChE,eAAO,MAAM,WAAW,EAAE,SAAS,iBAAiB,EAAoC,CAAC;AAEzF,iEAAiE;AACjE,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAwB,CAAC;AAiB3E;;;GAGG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,CAI9D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,iBAAiB,GAAG,MAAM,CAEpE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,GAAG,MAAM,CAE9E"}