audit-tools 0.51.6 → 0.51.9

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

@@ -54,23 +54,43 @@ export declare function mechanismContradictsOutcome(outcome: RemediationOutcomeS
  * `executed`   — the command list ran; `passed` is a real verdict.
  * `scoped_out` — the suite does not apply to this target; zero commands ran.
  * `disabled`   — a gate was DUE but did not run.
+ * `history`    — a verdict for this exact tree content was already recorded, so
+ *                the floor was NOT re-spawned; `passed` is that recorded verdict
+ *                and `commands_run` counts the commands the RECORD held, never
+ *                commands this evaluation ran. A fourth kind rather than a
+ *                flavour of `executed`, because "the judge ran just now" and
+ *                "a judge already ruled on this unchanged tree" are different
+ *                facts about the same verdict — and a reader that cannot tell
+ *                them apart cannot tell whether the floor is still being
+ *                exercised at all.
  */
-export declare const FinalGateOutcomeKindSchema: z.ZodEnum<["executed", "scoped_out", "disabled"]>;
+export declare const FinalGateOutcomeKindSchema: z.ZodEnum<["executed", "scoped_out", "disabled", "history"]>;
 export type FinalGateOutcomeKind = z.infer<typeof FinalGateOutcomeKindSchema>;
+/**
+ * Which outcomes carry a REAL verdict. `executed` because a judge just ran;
+ * `history` because a judge ran on this identical tree content and the answer
+ * cannot have changed. Every other outcome — the not-run kinds AND the report's
+ * own `absent` — has no verdict to report.
+ *
+ * Accepts `absent` as well as the gate kinds so the REPORT reader can ask this
+ * one question rather than restating the list: a second hand-written list is
+ * exactly how the next verdict-bearing kind comes back to read as absent.
+ */
+export declare function carriesGateVerdict(outcome: FinalGateOutcomeKind | "absent"): boolean;
 /**
  * What the outcomes contract says about the run's tool-owned gate.
  *
- * `outcome` widens the three gate kinds with `absent` — which is NOT a fourth
- * gate kind but the report's own statement that no gate record existed for this
- * run. It is stated rather than inferred: the alternative is silence, and
- * silence about a gate reads as "fine".
+ * `outcome` widens the gate kinds with `absent` — which is NOT a gate kind but
+ * the report's own statement that no gate record existed for this run. It is
+ * stated rather than inferred: the alternative is silence, and silence about a
+ * gate reads as "fine".
  *
- * `passed` is `boolean | null`. Only an `executed` gate carries a verdict; the
- * other three carry `null`, so no consumer of this contract can read a gate
- * that did not run as a green floor.
+ * `passed` is `boolean | null`. Only a verdict-bearing kind ({@link
+ * carriesGateVerdict}) carries one; every other kind carries `null`, so no
+ * consumer of this contract can read a gate that did not run as a green floor.
  */
 export declare const FinalGateReportSchema: z.ZodObject<{
-    outcome: z.ZodUnion<[z.ZodEnum<["executed", "scoped_out", "disabled"]>, z.ZodLiteral<"absent">]>;
+    outcome: z.ZodUnion<[z.ZodEnum<["executed", "scoped_out", "disabled", "history"]>, z.ZodLiteral<"absent">]>;
     passed: z.ZodNullable<z.ZodBoolean>;
     commands_run: z.ZodNumber;
     /** Which gate produced it — a phase boundary, or the all-terminal funnel. */
@@ -79,14 +99,14 @@ export declare const FinalGateReportSchema: z.ZodObject<{
     reason: z.ZodOptional<z.ZodString>;
     recorded_at: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
-    outcome: "executed" | "scoped_out" | "disabled" | "absent";
+    outcome: "absent" | "executed" | "scoped_out" | "disabled" | "history";
     passed: boolean | null;
     commands_run: number;
     reason?: string | undefined;
     scope?: string | undefined;
     recorded_at?: string | undefined;
 }, {
-    outcome: "executed" | "scoped_out" | "disabled" | "absent";
+    outcome: "absent" | "executed" | "scoped_out" | "disabled" | "history";
     passed: boolean | null;
     commands_run: number;
     reason?: string | undefined;
@@ -100,6 +120,136 @@ export type FinalGateReport = z.infer<typeof FinalGateReportSchema>;
  * a green-shaped default.
  */
 export declare const ABSENT_FINAL_GATE_REPORT: FinalGateReport;
+/**
+ * One submission the run READMITTED, and through which verb.
+ *
+ * `kind` is the submission ledger's own event kind — declared as the two
+ * recovery members rather than a boolean, because the two are not the same act:
+ * `recovered_by_hand` re-lands a payload the normal lane's validator still
+ * fully accepts, while `accepted_via_recovery` relaxed one of its corroboration
+ * checks. A surface that collapsed them would erase exactly the difference that
+ * makes a run's evidence bar legible.
+ */
+export declare const RecoveryMarkSchema: z.ZodObject<{
+    kind: z.ZodEnum<["recovered_by_hand", "accepted_via_recovery"]>;
+    submission_id: z.ZodString;
+    lane: z.ZodString;
+    issue_code: z.ZodOptional<z.ZodString>;
+    recorded_at: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "recovered_by_hand" | "accepted_via_recovery";
+    lane: string;
+    recorded_at: string;
+    submission_id: string;
+    issue_code?: string | undefined;
+}, {
+    kind: "recovered_by_hand" | "accepted_via_recovery";
+    lane: string;
+    recorded_at: string;
+    submission_id: string;
+    issue_code?: string | undefined;
+}>;
+export type RecoveryMark = z.infer<typeof RecoveryMarkSchema>;
+/**
+ * How the run's work was READMITTED, as read from the submission ledger at
+ * close time.
+ *
+ * REQUIRED on the outcomes contract and never omitted: like {@link
+ * FinalGateReport}, the clean case is written as an empty array rather than
+ * left out, so a reader can distinguish "this run recovered nothing" from "this
+ * release did not record the fact". The three-shape collapse the outcomes
+ * contract exists to prevent — clean, repaired, unknown — was previously
+ * expressible for the gate and not for recovery, so a run whose submission had
+ * to be re-landed through a LOWER evidence bar produced a completion contract
+ * byte-identical to a run that got it right first try.
+ *
+ * A recovery record is a monotone ACCUMULATOR over the run's ledger events: two
+ * marks for one submission (say a hand re-land followed by a relaxed
+ * acceptance) are two facts, and neither subsumes the other.
+ */
+export declare const RunRecoverySchema: z.ZodObject<{
+    recovered_by_hand: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["recovered_by_hand", "accepted_via_recovery"]>;
+        submission_id: z.ZodString;
+        lane: z.ZodString;
+        issue_code: z.ZodOptional<z.ZodString>;
+        recorded_at: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "recovered_by_hand" | "accepted_via_recovery";
+        lane: string;
+        recorded_at: string;
+        submission_id: string;
+        issue_code?: string | undefined;
+    }, {
+        kind: "recovered_by_hand" | "accepted_via_recovery";
+        lane: string;
+        recorded_at: string;
+        submission_id: string;
+        issue_code?: string | undefined;
+    }>, "many">;
+    accepted_via_recovery: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["recovered_by_hand", "accepted_via_recovery"]>;
+        submission_id: z.ZodString;
+        lane: z.ZodString;
+        issue_code: z.ZodOptional<z.ZodString>;
+        recorded_at: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "recovered_by_hand" | "accepted_via_recovery";
+        lane: string;
+        recorded_at: string;
+        submission_id: string;
+        issue_code?: string | undefined;
+    }, {
+        kind: "recovered_by_hand" | "accepted_via_recovery";
+        lane: string;
+        recorded_at: string;
+        submission_id: string;
+        issue_code?: string | undefined;
+    }>, "many">;
+    /** Ledger lines the close-phase read could not parse. See the writer. */
+    dropped_lines: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    recovered_by_hand: {
+        kind: "recovered_by_hand" | "accepted_via_recovery";
+        lane: string;
+        recorded_at: string;
+        submission_id: string;
+        issue_code?: string | undefined;
+    }[];
+    accepted_via_recovery: {
+        kind: "recovered_by_hand" | "accepted_via_recovery";
+        lane: string;
+        recorded_at: string;
+        submission_id: string;
+        issue_code?: string | undefined;
+    }[];
+    dropped_lines: number;
+}, {
+    recovered_by_hand: {
+        kind: "recovered_by_hand" | "accepted_via_recovery";
+        lane: string;
+        recorded_at: string;
+        submission_id: string;
+        issue_code?: string | undefined;
+    }[];
+    accepted_via_recovery: {
+        kind: "recovered_by_hand" | "accepted_via_recovery";
+        lane: string;
+        recorded_at: string;
+        submission_id: string;
+        issue_code?: string | undefined;
+    }[];
+    dropped_lines: number;
+}>;
+export type RunRecovery = z.infer<typeof RunRecoverySchema>;
+/**
+ * The report's statement when the close-phase read found no recovery at all.
+ * NOT the same as "the ledger could not be read": a read failure is reported by
+ * the close phase itself rather than laundered into a clean-looking empty set.
+ */
+export declare const NO_RECOVERY: RunRecovery;
+/** True when the run's ledger recorded any readmission. */
+export declare function wasRecovered(recovery: RunRecovery): boolean;
 /**
  * Item C — result of the close-gate mechanical re-verify of an analyzer-born
  * finding. `verified_mechanically`: the finding's content-anchored lead
@@ -194,8 +344,8 @@ export declare const RemediationOutcomeSchema: z.ZodObject<{
      */
     recorded_by_module: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
-    outcome: "blocked" | "refuted" | "resolved" | "verified_no_change" | "inappropriate" | "ignored" | "verified_already_fixed";
     lens: string;
+    outcome: "refuted" | "resolved" | "verified_no_change" | "inappropriate" | "ignored" | "blocked" | "verified_already_fixed";
     finding_id: string;
     file_exts: string[];
     rework_count: number;
@@ -218,8 +368,8 @@ export declare const RemediationOutcomeSchema: z.ZodObject<{
     } | undefined;
     recorded_by_module?: string | undefined;
 }, {
-    outcome: "blocked" | "refuted" | "resolved" | "verified_no_change" | "inappropriate" | "ignored" | "verified_already_fixed";
     lens: string;
+    outcome: "refuted" | "resolved" | "verified_no_change" | "inappropriate" | "ignored" | "blocked" | "verified_already_fixed";
     finding_id: string;
     file_exts: string[];
     rework_count: number;
@@ -255,20 +405,20 @@ export declare const RemediationOutcomesReportSchema: z.ZodObject<{
         verified_already_fixed: z.ZodNumber;
         refuted: z.ZodNumber;
     }, "strict", z.ZodTypeAny, {
-        blocked: number;
         refuted: number;
         resolved: number;
         verified_no_change: number;
         inappropriate: number;
         ignored: number;
+        blocked: number;
         verified_already_fixed: number;
     }, {
-        blocked: number;
         refuted: number;
         resolved: number;
         verified_no_change: number;
         inappropriate: number;
         ignored: number;
+        blocked: number;
         verified_already_fixed: number;
     }>;
     by_lens: z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -280,20 +430,20 @@ export declare const RemediationOutcomesReportSchema: z.ZodObject<{
         verified_already_fixed: z.ZodOptional<z.ZodNumber>;
         refuted: z.ZodOptional<z.ZodNumber>;
     }, "strict", z.ZodTypeAny, {
-        blocked?: number | undefined;
         refuted?: number | undefined;
         resolved?: number | undefined;
         verified_no_change?: number | undefined;
         inappropriate?: number | undefined;
         ignored?: number | undefined;
+        blocked?: number | undefined;
         verified_already_fixed?: number | undefined;
     }, {
-        blocked?: number | undefined;
         refuted?: number | undefined;
         resolved?: number | undefined;
         verified_no_change?: number | undefined;
         inappropriate?: number | undefined;
         ignored?: number | undefined;
+        blocked?: number | undefined;
         verified_already_fixed?: number | undefined;
     }>>;
     /** Earliest item started_at across all outcomes. */
@@ -311,7 +461,7 @@ export declare const RemediationOutcomesReportSchema: z.ZodObject<{
      * executed-green one.
      */
     final_gate: z.ZodObject<{
-        outcome: z.ZodUnion<[z.ZodEnum<["executed", "scoped_out", "disabled"]>, z.ZodLiteral<"absent">]>;
+        outcome: z.ZodUnion<[z.ZodEnum<["executed", "scoped_out", "disabled", "history"]>, z.ZodLiteral<"absent">]>;
         passed: z.ZodNullable<z.ZodBoolean>;
         commands_run: z.ZodNumber;
         /** Which gate produced it — a phase boundary, or the all-terminal funnel. */
@@ -320,20 +470,100 @@ export declare const RemediationOutcomesReportSchema: z.ZodObject<{
         reason: z.ZodOptional<z.ZodString>;
         recorded_at: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
-        outcome: "executed" | "scoped_out" | "disabled" | "absent";
+        outcome: "absent" | "executed" | "scoped_out" | "disabled" | "history";
         passed: boolean | null;
         commands_run: number;
         reason?: string | undefined;
         scope?: string | undefined;
         recorded_at?: string | undefined;
     }, {
-        outcome: "executed" | "scoped_out" | "disabled" | "absent";
+        outcome: "absent" | "executed" | "scoped_out" | "disabled" | "history";
         passed: boolean | null;
         commands_run: number;
         reason?: string | undefined;
         scope?: string | undefined;
         recorded_at?: string | undefined;
     }>;
+    /**
+     * How the run's work was READMITTED. REQUIRED, same shape as `final_gate`:
+     * the clean case is `NO_RECOVERY` (empty sets), never an omitted key, so a
+     * recovered run cannot render as a clean one and a pre-recovery release's
+     * artifact cannot read as clean either.
+     */
+    recovery: z.ZodObject<{
+        recovered_by_hand: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<["recovered_by_hand", "accepted_via_recovery"]>;
+            submission_id: z.ZodString;
+            lane: z.ZodString;
+            issue_code: z.ZodOptional<z.ZodString>;
+            recorded_at: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            kind: "recovered_by_hand" | "accepted_via_recovery";
+            lane: string;
+            recorded_at: string;
+            submission_id: string;
+            issue_code?: string | undefined;
+        }, {
+            kind: "recovered_by_hand" | "accepted_via_recovery";
+            lane: string;
+            recorded_at: string;
+            submission_id: string;
+            issue_code?: string | undefined;
+        }>, "many">;
+        accepted_via_recovery: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<["recovered_by_hand", "accepted_via_recovery"]>;
+            submission_id: z.ZodString;
+            lane: z.ZodString;
+            issue_code: z.ZodOptional<z.ZodString>;
+            recorded_at: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            kind: "recovered_by_hand" | "accepted_via_recovery";
+            lane: string;
+            recorded_at: string;
+            submission_id: string;
+            issue_code?: string | undefined;
+        }, {
+            kind: "recovered_by_hand" | "accepted_via_recovery";
+            lane: string;
+            recorded_at: string;
+            submission_id: string;
+            issue_code?: string | undefined;
+        }>, "many">;
+        /** Ledger lines the close-phase read could not parse. See the writer. */
+        dropped_lines: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        recovered_by_hand: {
+            kind: "recovered_by_hand" | "accepted_via_recovery";
+            lane: string;
+            recorded_at: string;
+            submission_id: string;
+            issue_code?: string | undefined;
+        }[];
+        accepted_via_recovery: {
+            kind: "recovered_by_hand" | "accepted_via_recovery";
+            lane: string;
+            recorded_at: string;
+            submission_id: string;
+            issue_code?: string | undefined;
+        }[];
+        dropped_lines: number;
+    }, {
+        recovered_by_hand: {
+            kind: "recovered_by_hand" | "accepted_via_recovery";
+            lane: string;
+            recorded_at: string;
+            submission_id: string;
+            issue_code?: string | undefined;
+        }[];
+        accepted_via_recovery: {
+            kind: "recovered_by_hand" | "accepted_via_recovery";
+            lane: string;
+            recorded_at: string;
+            submission_id: string;
+            issue_code?: string | undefined;
+        }[];
+        dropped_lines: number;
+    }>;
     outcomes: z.ZodArray<z.ZodObject<{
         finding_id: z.ZodString;
         /** Audit lens the finding came from (free string in the wire contract). */
@@ -406,8 +636,8 @@ export declare const RemediationOutcomesReportSchema: z.ZodObject<{
          */
         recorded_by_module: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
-        outcome: "blocked" | "refuted" | "resolved" | "verified_no_change" | "inappropriate" | "ignored" | "verified_already_fixed";
         lens: string;
+        outcome: "refuted" | "resolved" | "verified_no_change" | "inappropriate" | "ignored" | "blocked" | "verified_already_fixed";
         finding_id: string;
         file_exts: string[];
         rework_count: number;
@@ -430,8 +660,8 @@ export declare const RemediationOutcomesReportSchema: z.ZodObject<{
         } | undefined;
         recorded_by_module?: string | undefined;
     }, {
-        outcome: "blocked" | "refuted" | "resolved" | "verified_no_change" | "inappropriate" | "ignored" | "verified_already_fixed";
         lens: string;
+        outcome: "refuted" | "resolved" | "verified_no_change" | "inappropriate" | "ignored" | "blocked" | "verified_already_fixed";
         finding_id: string;
         file_exts: string[];
         rework_count: number;
@@ -458,34 +688,51 @@ export declare const RemediationOutcomesReportSchema: z.ZodObject<{
     contract_version: string;
     total: number;
     by_outcome: {
-        blocked: number;
         refuted: number;
         resolved: number;
         verified_no_change: number;
         inappropriate: number;
         ignored: number;
+        blocked: number;
         verified_already_fixed: number;
     };
     by_lens: Record<string, {
-        blocked?: number | undefined;
         refuted?: number | undefined;
         resolved?: number | undefined;
         verified_no_change?: number | undefined;
         inappropriate?: number | undefined;
         ignored?: number | undefined;
+        blocked?: number | undefined;
         verified_already_fixed?: number | undefined;
     }>;
     final_gate: {
-        outcome: "executed" | "scoped_out" | "disabled" | "absent";
+        outcome: "absent" | "executed" | "scoped_out" | "disabled" | "history";
         passed: boolean | null;
         commands_run: number;
         reason?: string | undefined;
         scope?: string | undefined;
         recorded_at?: string | undefined;
     };
+    recovery: {
+        recovered_by_hand: {
+            kind: "recovered_by_hand" | "accepted_via_recovery";
+            lane: string;
+            recorded_at: string;
+            submission_id: string;
+            issue_code?: string | undefined;
+        }[];
+        accepted_via_recovery: {
+            kind: "recovered_by_hand" | "accepted_via_recovery";
+            lane: string;
+            recorded_at: string;
+            submission_id: string;
+            issue_code?: string | undefined;
+        }[];
+        dropped_lines: number;
+    };
     outcomes: {
-        outcome: "blocked" | "refuted" | "resolved" | "verified_no_change" | "inappropriate" | "ignored" | "verified_already_fixed";
         lens: string;
+        outcome: "refuted" | "resolved" | "verified_no_change" | "inappropriate" | "ignored" | "blocked" | "verified_already_fixed";
         finding_id: string;
         file_exts: string[];
         rework_count: number;
@@ -515,34 +762,51 @@ export declare const RemediationOutcomesReportSchema: z.ZodObject<{
     contract_version: string;
     total: number;
     by_outcome: {
-        blocked: number;
         refuted: number;
         resolved: number;
         verified_no_change: number;
         inappropriate: number;
         ignored: number;
+        blocked: number;
         verified_already_fixed: number;
     };
     by_lens: Record<string, {
-        blocked?: number | undefined;
         refuted?: number | undefined;
         resolved?: number | undefined;
         verified_no_change?: number | undefined;
         inappropriate?: number | undefined;
         ignored?: number | undefined;
+        blocked?: number | undefined;
         verified_already_fixed?: number | undefined;
     }>;
     final_gate: {
-        outcome: "executed" | "scoped_out" | "disabled" | "absent";
+        outcome: "absent" | "executed" | "scoped_out" | "disabled" | "history";
         passed: boolean | null;
         commands_run: number;
         reason?: string | undefined;
         scope?: string | undefined;
         recorded_at?: string | undefined;
     };
+    recovery: {
+        recovered_by_hand: {
+            kind: "recovered_by_hand" | "accepted_via_recovery";
+            lane: string;
+            recorded_at: string;
+            submission_id: string;
+            issue_code?: string | undefined;
+        }[];
+        accepted_via_recovery: {
+            kind: "recovered_by_hand" | "accepted_via_recovery";
+            lane: string;
+            recorded_at: string;
+            submission_id: string;
+            issue_code?: string | undefined;
+        }[];
+        dropped_lines: number;
+    };
     outcomes: {
-        outcome: "blocked" | "refuted" | "resolved" | "verified_no_change" | "inappropriate" | "ignored" | "verified_already_fixed";
         lens: string;
+        outcome: "refuted" | "resolved" | "verified_no_change" | "inappropriate" | "ignored" | "blocked" | "verified_already_fixed";
         finding_id: string;
         file_exts: string[];
         rework_count: number;

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

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

package/dist/shared/types/remediationOutcome.js

@@ -116,23 +116,46 @@ export function mechanismContradictsOutcome(outcome, mechanism) {
  * `executed`   — the command list ran; `passed` is a real verdict.
  * `scoped_out` — the suite does not apply to this target; zero commands ran.
  * `disabled`   — a gate was DUE but did not run.
+ * `history`    — a verdict for this exact tree content was already recorded, so
+ *                the floor was NOT re-spawned; `passed` is that recorded verdict
+ *                and `commands_run` counts the commands the RECORD held, never
+ *                commands this evaluation ran. A fourth kind rather than a
+ *                flavour of `executed`, because "the judge ran just now" and
+ *                "a judge already ruled on this unchanged tree" are different
+ *                facts about the same verdict — and a reader that cannot tell
+ *                them apart cannot tell whether the floor is still being
+ *                exercised at all.
  */
 export const FinalGateOutcomeKindSchema = z.enum([
     "executed",
     "scoped_out",
     "disabled",
+    "history",
 ]);
+/**
+ * Which outcomes carry a REAL verdict. `executed` because a judge just ran;
+ * `history` because a judge ran on this identical tree content and the answer
+ * cannot have changed. Every other outcome — the not-run kinds AND the report's
+ * own `absent` — has no verdict to report.
+ *
+ * Accepts `absent` as well as the gate kinds so the REPORT reader can ask this
+ * one question rather than restating the list: a second hand-written list is
+ * exactly how the next verdict-bearing kind comes back to read as absent.
+ */
+export function carriesGateVerdict(outcome) {
+    return outcome === "executed" || outcome === "history";
+}
 /**
  * What the outcomes contract says about the run's tool-owned gate.
  *
- * `outcome` widens the three gate kinds with `absent` — which is NOT a fourth
- * gate kind but the report's own statement that no gate record existed for this
- * run. It is stated rather than inferred: the alternative is silence, and
- * silence about a gate reads as "fine".
+ * `outcome` widens the gate kinds with `absent` — which is NOT a gate kind but
+ * the report's own statement that no gate record existed for this run. It is
+ * stated rather than inferred: the alternative is silence, and silence about a
+ * gate reads as "fine".
  *
- * `passed` is `boolean | null`. Only an `executed` gate carries a verdict; the
- * other three carry `null`, so no consumer of this contract can read a gate
- * that did not run as a green floor.
+ * `passed` is `boolean | null`. Only a verdict-bearing kind ({@link
+ * carriesGateVerdict}) carries one; every other kind carries `null`, so no
+ * consumer of this contract can read a gate that did not run as a green floor.
  */
 export const FinalGateReportSchema = z
     .object({
@@ -157,6 +180,65 @@ export const ABSENT_FINAL_GATE_REPORT = {
     commands_run: 0,
     reason: "no tool-owned gate outcome was recorded for this run",
 };
+/**
+ * One submission the run READMITTED, and through which verb.
+ *
+ * `kind` is the submission ledger's own event kind — declared as the two
+ * recovery members rather than a boolean, because the two are not the same act:
+ * `recovered_by_hand` re-lands a payload the normal lane's validator still
+ * fully accepts, while `accepted_via_recovery` relaxed one of its corroboration
+ * checks. A surface that collapsed them would erase exactly the difference that
+ * makes a run's evidence bar legible.
+ */
+export const RecoveryMarkSchema = z
+    .object({
+    kind: z.enum(["recovered_by_hand", "accepted_via_recovery"]),
+    submission_id: z.string(),
+    lane: z.string(),
+    issue_code: z.string().optional(),
+    recorded_at: z.string(),
+})
+    .strict();
+/**
+ * How the run's work was READMITTED, as read from the submission ledger at
+ * close time.
+ *
+ * REQUIRED on the outcomes contract and never omitted: like {@link
+ * FinalGateReport}, the clean case is written as an empty array rather than
+ * left out, so a reader can distinguish "this run recovered nothing" from "this
+ * release did not record the fact". The three-shape collapse the outcomes
+ * contract exists to prevent — clean, repaired, unknown — was previously
+ * expressible for the gate and not for recovery, so a run whose submission had
+ * to be re-landed through a LOWER evidence bar produced a completion contract
+ * byte-identical to a run that got it right first try.
+ *
+ * A recovery record is a monotone ACCUMULATOR over the run's ledger events: two
+ * marks for one submission (say a hand re-land followed by a relaxed
+ * acceptance) are two facts, and neither subsumes the other.
+ */
+export const RunRecoverySchema = z
+    .object({
+    recovered_by_hand: z.array(RecoveryMarkSchema),
+    accepted_via_recovery: z.array(RecoveryMarkSchema),
+    /** Ledger lines the close-phase read could not parse. See the writer. */
+    dropped_lines: z.number(),
+})
+    .strict();
+/**
+ * The report's statement when the close-phase read found no recovery at all.
+ * NOT the same as "the ledger could not be read": a read failure is reported by
+ * the close phase itself rather than laundered into a clean-looking empty set.
+ */
+export const NO_RECOVERY = {
+    recovered_by_hand: [],
+    accepted_via_recovery: [],
+    dropped_lines: 0,
+};
+/** True when the run's ledger recorded any readmission. */
+export function wasRecovered(recovery) {
+    return (recovery.recovered_by_hand.length > 0 ||
+        recovery.accepted_via_recovery.length > 0);
+}
 /**
  * Item C — result of the close-gate mechanical re-verify of an analyzer-born
  * finding. `verified_mechanically`: the finding's content-anchored lead
@@ -256,6 +338,13 @@ export const RemediationOutcomesReportSchema = z.object({
      * executed-green one.
      */
     final_gate: FinalGateReportSchema,
+    /**
+     * How the run's work was READMITTED. REQUIRED, same shape as `final_gate`:
+     * the clean case is `NO_RECOVERY` (empty sets), never an omitted key, so a
+     * recovered run cannot render as a clean one and a pre-recovery release's
+     * artifact cannot read as clean either.
+     */
+    recovery: RunRecoverySchema,
     outcomes: z.array(RemediationOutcomeSchema),
 });
 //# sourceMappingURL=remediationOutcome.js.map