audit-tools 0.40.1 → 0.41.0

package/dist/audit/cli/fanoutLanes.d.ts

@@ -1,54 +1,90 @@
+import { type LaneSubmissionShortfall } from "./laneSubmissions.js";
 /**
  * Always-materialized fan-out lanes (design resolution 2, 2026-08-05).
  *
  * A fan-out step never inlines lane work into its step prompt and never
  * branches on host capability: every lane's prompt is a FILE on disk and every
- * lane's result is a FILE on disk, identical across IDEs/providers, so a run is
- * resumable and parallelizable regardless of who executes the lanes. Lane
+ * lane's submission is a FILE on disk, identical across IDEs/providers, so a run
+ * is resumable and parallelizable regardless of who executes the lanes. Lane
  * prompt files are ADVANCE-FREE — the continue-command lives in the step
  * prompt, never inside a lane file, so no lane executor can become a second
  * orchestrator driver (the same property `prepareContractDispatch` pins for
  * design review).
  *
- * K-of-N resume: a lane whose RESULT file already exists under `incoming/` is
+ * This is also the MINTING CHOKEPOINT: a lane declares an id and a prompt, and
+ * the tool derives where the answer goes. A lane spec cannot name its own
+ * result file, so a host-typed filename is not expressible here or in any
+ * caller.
+ *
+ * K-of-N resume: a lane whose submission already exists at its bound path is
  * complete — its prompt is not rewritten and it is excluded from the pending
  * set, so a re-emitted step instructs only the missing lanes and never
  * regenerates or overwrites completed lane results.
  */
 export interface FanoutLaneSpec {
-    /** Stable lane id — becomes the `artifact_paths` key prefix. */
+    /**
+     * Stable lane id — the `artifact_paths` key prefix AND the identity the
+     * lane's submission path is derived from, so it must be unique across the
+     * whole audit and stable across re-emissions of the same lane.
+     */
     id: string;
     /** Human label rendered into the step's lane list. */
     label: string;
-    /** Lane prompt filename under `incoming/`. */
+    /** Lane prompt filename under the tool-owned lane-asset dir. */
     promptFilename: string;
-    /** Lane result filename under `incoming/`. */
-    resultFilename: string;
     /** Advance-free lane prompt body (no continue-command). */
     promptText: string;
+    /**
+     * False for a lane whose submission the TOOL never reads — a host-side
+     * intermediate another lane consumes (the conceptual perspectives, which
+     * only the judge reads). Its bound path is still minted, declared, and
+     * rendered so the worker has a tool-named place to write; but nothing is
+     * ever owed to the tool, so it is not an expected submission, appears in no
+     * expected set, and produces no ledger expectation the run can never
+     * satisfy. Defaults to true — a lane owes the tool a submission unless it
+     * says otherwise.
+     */
+    expected?: boolean;
 }
 export interface MaterializedFanoutLane {
     id: string;
     label: string;
     promptPath: string;
+    /** Tool-computed bound path this lane's submission must land at. */
     resultPath: string;
-    /** True when the lane's result file already exists (K-of-N resume). */
+    /** True when the lane's submission already exists (K-of-N resume). */
     resultExists: boolean;
 }
 export interface MaterializedFanout {
     lanes: MaterializedFanoutLane[];
-    /** Lanes still owed a result — the only lanes the step instructs. */
+    /** Lanes still owed a submission — the only lanes the step instructs. */
     pendingLanes: MaterializedFanoutLane[];
     /** `<id>_prompt` / `<id>_results` entries for the step contract. */
     artifactPaths: Record<string, string>;
     /** Pending lanes' prompt paths (step `access.read_paths`). */
     readPaths: string[];
-    /** Pending lanes' result paths (step `access.write_paths`). */
+    /** Pending lanes' bound submission paths (step `access.write_paths`). */
     writePaths: string[];
+    /**
+     * What a PREVIOUS emission of these lanes is still owed — empty on a first
+     * emission. Rendered into the re-emitted step prompt and persisted on the
+     * step contract so a dropped lane is reported by name instead of showing up
+     * as the same step arriving twice.
+     */
+    shortfall: LaneSubmissionShortfall;
 }
-/** Write the pending lanes' prompt files and describe the whole fan-out. */
+/**
+ * Write the pending lanes' prompt files, record what the emission owes, and
+ * describe the whole fan-out.
+ */
 export declare function materializeFanoutLanes(params: {
     artifactsDir: string;
+    /**
+     * The scope the lane submissions belong to. Audit gate emitters pass
+     * `AUDIT_GATE_SUBMISSION_SCOPE` — see `laneSubmissions.ts` for why the gates
+     * have no run id of their own.
+     */
+    runId: string;
     lanes: FanoutLaneSpec[];
 }): Promise<MaterializedFanout>;
 //# sourceMappingURL=fanoutLanes.d.ts.map

package/dist/audit/cli/fanoutLanes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fanoutLanes.d.ts","sourceRoot":"","sources":["../../../src/audit/cli/fanoutLanes.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,cAAc;IAC7B,gEAAgE;IAChE,EAAE,EAAE,MAAM,CAAC;IACX,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,cAAc,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,cAAc,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAChC,qEAAqE;IACrE,YAAY,EAAE,sBAAsB,EAAE,CAAC;IACvC,oEAAoE;IACpE,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,8DAA8D;IAC9D,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,+DAA+D;IAC/D,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAWD,4EAA4E;AAC5E,wBAAsB,sBAAsB,CAAC,MAAM,EAAE;IACnD,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,cAAc,EAAE,CAAC;CACzB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAsC9B"}
+{"version":3,"file":"fanoutLanes.d.ts","sourceRoot":"","sources":["../../../src/audit/cli/fanoutLanes.ts"],"names":[],"mappings":"AAKA,OAAO,EAGL,KAAK,uBAAuB,EAC7B,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,cAAc,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,oEAAoE;IACpE,UAAU,EAAE,MAAM,CAAC;IACnB,sEAAsE;IACtE,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAChC,yEAAyE;IACzE,YAAY,EAAE,sBAAsB,EAAE,CAAC;IACvC,oEAAoE;IACpE,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,8DAA8D;IAC9D,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,yEAAyE;IACzE,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB;;;;;OAKG;IACH,SAAS,EAAE,uBAAuB,CAAC;CACpC;AAWD;;;GAGG;AACH,wBAAsB,sBAAsB,CAAC,MAAM,EAAE;IACnD,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,cAAc,EAAE,CAAC;CACzB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAmD9B"}

package/dist/audit/cli/fanoutLanes.js

@@ -1,6 +1,7 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { access } from "node:fs/promises";
+import { access, mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { laneAssetsDir } from "audit-tools/shared";
+import { laneSubmissionPath, recordExpectedLanes, } from "./laneSubmissions.js";
 async function fileExists(path) {
     try {
         await access(path);
@@ -10,14 +11,17 @@ async function fileExists(path) {
         return false;
     }
 }
-/** Write the pending lanes' prompt files and describe the whole fan-out. */
+/**
+ * Write the pending lanes' prompt files, record what the emission owes, and
+ * describe the whole fan-out.
+ */
 export async function materializeFanoutLanes(params) {
-    const incoming = join(params.artifactsDir, "incoming");
-    await mkdir(incoming, { recursive: true });
+    const promptDir = laneAssetsDir(params.artifactsDir);
+    await mkdir(promptDir, { recursive: true });
     const lanes = [];
     for (const spec of params.lanes) {
-        const promptPath = join(incoming, spec.promptFilename);
-        const resultPath = join(incoming, spec.resultFilename);
+        const promptPath = join(promptDir, spec.promptFilename);
+        const resultPath = laneSubmissionPath(params.artifactsDir, spec.id, params.runId);
         const resultExists = await fileExists(resultPath);
         // Pending lanes always get a fresh prompt. A COMPLETED lane's prompt is
         // left untouched (its content matches the result that was produced) —
@@ -34,6 +38,9 @@ export async function materializeFanoutLanes(params) {
             resultExists,
         });
     }
+    const shortfall = await recordExpectedLanes(params.artifactsDir, params.runId, params.lanes
+        .filter((spec) => spec.expected !== false)
+        .map((spec) => ({ lane: spec.id, promptText: spec.promptText })));
     const pendingLanes = lanes.filter((lane) => !lane.resultExists);
     const artifactPaths = {};
     for (const lane of lanes) {
@@ -46,6 +53,7 @@ export async function materializeFanoutLanes(params) {
         artifactPaths,
         readPaths: pendingLanes.map((lane) => lane.promptPath),
         writePaths: pendingLanes.map((lane) => lane.resultPath),
+        shortfall,
     };
 }
 //# sourceMappingURL=fanoutLanes.js.map

package/dist/audit/cli/fanoutLanes.js.map

@@ -1 +1 @@
-{"version":3,"file":"fanoutLanes.js","sourceRoot":"","sources":["../../../src/audit/cli/fanoutLanes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAqDjC,KAAK,UAAU,UAAU,CAAC,IAAY;IACpC,IAAI,CAAC;QACH,MAAM,MAAM,CAAC,IAAI,CAAC,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,4EAA4E;AAC5E,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAAC,MAG5C;IACC,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;IACvD,MAAM,KAAK,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAE3C,MAAM,KAAK,GAA6B,EAAE,CAAC;IAC3C,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;QAChC,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QACvD,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QACvD,MAAM,YAAY,GAAG,MAAM,UAAU,CAAC,UAAU,CAAC,CAAC;QAClD,wEAAwE;QACxE,sEAAsE;QACtE,qEAAqE;QACrE,mEAAmE;QACnE,IAAI,CAAC,YAAY,IAAI,CAAC,CAAC,MAAM,UAAU,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC;YACrD,MAAM,SAAS,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;QACvD,CAAC;QACD,KAAK,CAAC,IAAI,CAAC;YACT,EAAE,EAAE,IAAI,CAAC,EAAE;YACX,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,UAAU;YACV,UAAU;YACV,YAAY;SACb,CAAC,CAAC;IACL,CAAC;IAED,MAAM,YAAY,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAChE,MAAM,aAAa,GAA2B,EAAE,CAAC;IACjD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,aAAa,CAAC,GAAG,IAAI,CAAC,EAAE,SAAS,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC;QACrD,aAAa,CAAC,GAAG,IAAI,CAAC,EAAE,UAAU,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC;IACxD,CAAC;IACD,OAAO;QACL,KAAK;QACL,YAAY;QACZ,aAAa;QACb,SAAS,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC;QACtD,UAAU,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC;KACxD,CAAC;AACJ,CAAC"}
+{"version":3,"file":"fanoutLanes.js","sourceRoot":"","sources":["../../../src/audit/cli/fanoutLanes.ts"],"names":[],"mappings":"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"}

package/dist/audit/cli/laneSubmissions.d.ts

@@ -0,0 +1,241 @@
+/**
+ * The audit draw of the shared submission core: how a GATE lane's bound path is
+ * computed, and where the expected-set / ledger for those lanes are persisted.
+ *
+ * Two facts about the audit gates shape everything here:
+ *
+ * 1. **They carry no run id.** `NextStepParams` has none, and threading one
+ *    into every gate would change ten signatures to carry a value the gates
+ *    never use. Their submissions are therefore ARTIFACTS-DIR-scoped: the
+ *    constant `AUDIT_GATE_SUBMISSION_SCOPE` stands in for run identity, so the
+ *    same gate lane in the same artifacts dir denotes the same submission
+ *    across `next-step` calls. That is not a shortcut — it is exactly the
+ *    K-of-N resume property, which requires a re-emitted step to re-declare
+ *    the identical bound path rather than mint a new one and re-ask for work
+ *    the host already delivered.
+ *
+ * 2. **The lane id is the only join key.** The emitter and the gate reader
+ *    never meet; they agree because both derive the id from the lane id
+ *    through this module. A lane id is declared once in
+ *    `HOST_GATE_DESCRIPTORS` and used verbatim on both sides.
+ *
+ * The bound path is DERIVED, not looked up. The persisted expected set states
+ * what is owed (and feeds the diff and the ledger), but a gate that could only
+ * read a submission when a bookkeeping file happened to exist would lose a
+ * valid submission the first time that file was absent — so derivation is the
+ * mechanism and the record is the record.
+ */
+import { z } from "zod";
+import { type CharterKind, type SubmissionIssue, type SubmissionIssueCode, type SubmissionRoots } from "audit-tools/shared";
+/**
+ * Gate lane ids — the single join key between an emitter and its gate reader.
+ *
+ * The two never meet: an emitter writes a lane's prompt and declares where the
+ * answer goes, and (possibly several `next-step` calls later) the gate reader
+ * looks for it. They agree because both derive the bound path from the lane id
+ * through this module. Declared once, here, so no site can spell a lane one way
+ * on the emit side and another on the read side.
+ */
+export declare const GATE_LANES: {
+    readonly analyzer_consent: "analyzer_consent";
+    readonly analyzer_decisions: "analyzer_decisions";
+    readonly edge_reasoning: "edge_reasoning";
+    readonly design_review_legacy: "design_review_legacy";
+    readonly design_review_contract: "design_review_contract";
+    readonly design_review_conceptual: "design_review_conceptual";
+    readonly critical_flow_fallback: "critical_flow_fallback";
+    readonly intent_equivalence: "intent_equivalence";
+    readonly synthesis_narrative: "synthesis_narrative";
+    readonly charter_delta: "charter_delta";
+    readonly charter_clarification: "charter_clarification";
+    readonly systemic_challenge: "systemic_challenge";
+};
+/** The blind per-kind charter lanes (one per estimator channel). */
+export declare function charterExtractionLane(kind: CharterKind): string;
+/** Recover the charter kind a `charter_extraction_*` lane id denotes. */
+export declare function charterKindForLane(lane: string): CharterKind | undefined;
+export declare const CONCEPTUAL_PERSPECTIVE_LANE_PREFIX = "design_review_conceptual_p";
+/**
+ * The deep conceptual pass's independent perspective lanes. Their COUNT is
+ * resolved at emit from confirmed intent, so the ids are generated rather than
+ * enumerated.
+ *
+ * The id carries the ROUND — a digest of the upstream content the round asks
+ * about — because a perspective is the one lane class whose reuse is WRONG.
+ * Every other lane's identity is deliberately stable so a re-emitted step
+ * re-declares the same bound path (K-of-N resume); a perspective, though, is a
+ * fresh independent reading of the artifacts as they now stand. Keyed on the
+ * index alone, a re-review after staleness would find the PREVIOUS round's
+ * submission at the bound path, skip the lane, leave its prompt unrewritten,
+ * and hand the judge the old round's findings as if they were this round's.
+ * Same round, same digest, same id — so resume WITHIN a round still works.
+ */
+export declare function conceptualPerspectiveLane(index: number, roundToken: string): string;
+/**
+ * The round token every perspective lane in one deep conceptual emission
+ * shares: a digest of exactly what this round asks. Deterministic in its inputs
+ * — never a timestamp or a counter, which would mint new ids (and re-ask for
+ * already-delivered work) on every re-emission of an unchanged round.
+ */
+export declare function conceptualRoundToken(inputs: readonly string[]): string;
+/**
+ * The per-kind evidence packet a charter lane reads. TOOL-written, so it lives
+ * under the lane-asset dir with the lane prompts — a host only ever reads it.
+ */
+export declare function charterExtractionPacketFilename(kind: CharterKind): string;
+/**
+ * The tool-side merge of the per-kind charter lanes, handed to the extraction
+ * executor by path and deleted once ingested. Tool-written, so it is a lane
+ * asset and not a submission.
+ */
+export declare const CHARTER_EXTRACTION_MERGED_FILENAME = "charter-extraction-merged.json";
+/**
+ * The submission FAMILY every audit gate lane belongs to. Distinguishes these
+ * from the host-handoff work-item submissions, which mint through the same rule
+ * under their own run id.
+ */
+export declare const AUDIT_LANE_SUBMISSION_KIND = "audit_host_lane";
+/** See the module comment: the audit gates' stand-in for run identity. */
+export declare const AUDIT_GATE_SUBMISSION_SCOPE = "audit-host-gates";
+/**
+ * Bound paths for gate lanes are expressed relative to the artifact tree root
+ * (`.audit-tools/`), not the repository root: the gates are handed an artifacts
+ * dir and nothing else, and a recorded path must be derivable from exactly what
+ * the reader has.
+ */
+export declare function laneSubmissionRoots(artifactsDir: string): SubmissionRoots;
+/** The tool-minted id for one lane. Deterministic in the lane id alone. */
+export declare function laneSubmissionId(lane: string, runId?: string): string;
+/**
+ * Absolute on-disk path a lane's submission must land at.
+ *
+ * `runId` is threaded rather than defaulted-and-forgotten: the bound path and
+ * the recorded expectation must come from ONE derivation. They were two — the
+ * path taking the module constant while the record took the caller's scope —
+ * which coincided only because every caller happened to pass the constant, i.e.
+ * the invariant held by the caller remembering.
+ */
+export declare function laneSubmissionPath(artifactsDir: string, lane: string, runId?: string): string;
+/** One lane an emission owes, as the emitter knows it. */
+export interface DeclaredLane {
+    readonly lane: string;
+    readonly promptText: string;
+}
+export declare const LaneSubmissionShortfallSchema: z.ZodObject<{
+    /** Lanes CARRIED into this emission (a prior emission already asked). */
+    expected: z.ZodNumber;
+    /** How many of those have a readable submission at their bound path. */
+    accepted: z.ZodNumber;
+    outstanding: z.ZodArray<z.ZodObject<{
+        lane: z.ZodString;
+        submission_id: z.ZodString;
+        /**
+         * The tool-computed bound path, ABSOLUTE — the same form (and the same
+         * file) as the step's `access.write_paths` entry for this lane, so the two
+         * compare directly. Deliberately NOT the expected set's recorded form:
+         * that one is relative to the artifact tree root, a base the step contract
+         * declares nowhere, so a consumer joining it against `repo_root` or
+         * `artifacts_dir` would build a path that never existed. `extraFields` ride
+         * through `writeStepContract` un-normalized (only prompt_path / repo_root /
+         * artifacts_dir / artifact_paths are), exactly as `access` does.
+         */
+        submission_path: z.ZodString;
+        issue_code: z.ZodString;
+        message: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        message: string;
+        submission_path: string;
+        lane: string;
+        submission_id: string;
+        issue_code: string;
+    }, {
+        message: string;
+        submission_path: string;
+        lane: string;
+        submission_id: string;
+        issue_code: string;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    expected: number;
+    accepted: number;
+    outstanding: {
+        message: string;
+        submission_path: string;
+        lane: string;
+        submission_id: string;
+        issue_code: string;
+    }[];
+}, {
+    expected: number;
+    accepted: number;
+    outstanding: {
+        message: string;
+        submission_path: string;
+        lane: string;
+        submission_id: string;
+        issue_code: string;
+    }[];
+}>;
+export type LaneSubmissionShortfall = z.infer<typeof LaneSubmissionShortfallSchema>;
+/**
+ * Record what this emission owes, and report what a PREVIOUS one is still owed.
+ *
+ * Merges into the current statement (a step that materializes several lane
+ * groups accumulates them) and appends one `expected` event per NEWLY declared
+ * lane, so a re-emission does not spam the arrival record.
+ *
+ * The returned shortfall diffs only the lanes CARRIED into this emission — the
+ * ones an earlier emission already asked for and that are still not on disk.
+ * Restricting it to carried lanes is what makes the report meaningful: on a
+ * first emission every lane is legitimately absent (it is being asked for right
+ * now), so counting those would make every fan-out look like a failure.
+ */
+export declare function recordExpectedLanes(artifactsDir: string, runId: string, lanes: readonly DeclaredLane[]): Promise<LaneSubmissionShortfall>;
+/** Merge the shortfalls of a step that materializes several lane groups. */
+export declare function mergeLaneShortfalls(shortfalls: readonly LaneSubmissionShortfall[]): LaneSubmissionShortfall;
+/**
+ * The host-facing statement of an unmet expectation, by lane and issue code.
+ * Empty when nothing was carried or everything carried has arrived — a clean
+ * emission says nothing, so the notice's presence is itself the signal.
+ */
+export declare function renderLaneShortfallLines(shortfall: LaneSubmissionShortfall): string[];
+/**
+ * Record the outcome of one lane. An accepted lane stops being owed; a rejected
+ * one stays owed (the host is asked again) but the refusal is on the record
+ * with its reason, which is what makes a repaired run distinguishable from a
+ * clean one.
+ */
+export declare function recordLaneOutcome(artifactsDir: string, lane: string, outcome: {
+    readonly kind: "accepted";
+    readonly message?: string;
+} | {
+    readonly kind: "rejected";
+    readonly issueCode: SubmissionIssueCode;
+    readonly message: string;
+}): Promise<void>;
+/**
+ * Record what the host-handoff ingest just decided about each work item, on the
+ * same ledger the gate lanes use — so a submission that never arrived (or
+ * arrived unreadable) is a durable fact rather than a value that died inside
+ * the call that computed it.
+ *
+ * Two rules keep the record drift-focused and arithmetically honest:
+ *
+ *   • Deduped against the LAST recorded event for each submission. Ingest runs
+ *     on every `next-step`, so a host still working through its workload would
+ *     otherwise append the same "missing" line every poll, burying the state
+ *     CHANGES the ledger exists to preserve. A changed classification still
+ *     appends, in arrival order.
+ *   • An acceptance is recorded ONLY where a refusal precedes it. A work item
+ *     the host got right first try says nothing (the ledger is not an inventory
+ *     of work), but one that was refused and later accepted must close its own
+ *     story — otherwise a run where every failure was repaired reports its
+ *     refusals with no matching repairs, and the report reads as a run that
+ *     never recovered.
+ */
+export declare function recordHostResultOutcomes(artifactsDir: string, runId: string, outcomes: {
+    readonly issues: readonly SubmissionIssue[];
+    /** Work items whose results this run has accepted (ingest's completed set). */
+    readonly acceptedIds: readonly string[];
+}): Promise<void>;
+//# sourceMappingURL=laneSubmissions.d.ts.map

package/dist/audit/cli/laneSubmissions.d.ts.map

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