audit-tools 0.40.1 → 0.41.1

package/dist/shared/io/auditToolsPaths.js.map

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

package/dist/shared/io/schemaVersion.d.ts

@@ -3,10 +3,11 @@
  * unmissable at the call site.
  *
  * State written by an older version of the tool is read back under the CURRENT
- * version's semantics. A reader that never compares the stamped
- * `schema_version` silently reinterprets old bytes as new-shape data. Stamping
- * a version on WRITE and not comparing it on READ is therefore not "versioned"
- * at all — it is an unchecked cast wearing a version field.
+ * version's semantics. A reader that never compares the stamped version (spelled
+ * `schema_version` on artifacts, `contract_version` on contracts — both are read
+ * here) silently reinterprets old bytes as new-shape data. Stamping a version on
+ * WRITE and not comparing it on READ is therefore not "versioned" at all — it is
+ * an unchecked cast wearing a version field.
  *
  * There are exactly two correct policies, and which one applies is a property
  * of the STATE, not of the module:

package/dist/shared/io/schemaVersion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemaVersion.d.ts","sourceRoot":"","sources":["../../../src/shared/io/schemaVersion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;GAIG;AACH,qBAAa,0BAA2B,SAAQ,KAAK;aAEjC,YAAY,EAAE,MAAM;aACpB,QAAQ,EAAE,MAAM;aAChB,MAAM,EAAE,MAAM;gBAFd,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM;CASjC;AASD;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAAC,CAAC,SAAS,MAAM,EAC7D,KAAK,EAAE,CAAC,GAAG,SAAS,GAAG,IAAI,EAC3B,QAAQ,EAAE,MAAM,GACf,CAAC,GAAG,SAAS,CAGf;AAED;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,EAChC,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,GACf,IAAI,CASN"}
+{"version":3,"file":"schemaVersion.d.ts","sourceRoot":"","sources":["../../../src/shared/io/schemaVersion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;GAIG;AACH,qBAAa,0BAA2B,SAAQ,KAAK;aAEjC,YAAY,EAAE,MAAM;aACpB,QAAQ,EAAE,MAAM;aAChB,MAAM,EAAE,MAAM;gBAFd,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM;CASjC;AAoBD;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAAC,CAAC,SAAS,MAAM,EAC7D,KAAK,EAAE,CAAC,GAAG,SAAS,GAAG,IAAI,EAC3B,QAAQ,EAAE,MAAM,GACf,CAAC,GAAG,SAAS,CAGf;AAED;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,EAChC,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,GACf,IAAI,CASN"}

package/dist/shared/io/schemaVersion.js

@@ -3,10 +3,11 @@
  * unmissable at the call site.
  *
  * State written by an older version of the tool is read back under the CURRENT
- * version's semantics. A reader that never compares the stamped
- * `schema_version` silently reinterprets old bytes as new-shape data. Stamping
- * a version on WRITE and not comparing it on READ is therefore not "versioned"
- * at all — it is an unchecked cast wearing a version field.
+ * version's semantics. A reader that never compares the stamped version (spelled
+ * `schema_version` on artifacts, `contract_version` on contracts — both are read
+ * here) silently reinterprets old bytes as new-shape data. Stamping a version on
+ * WRITE and not comparing it on READ is therefore not "versioned" at all — it is
+ * an unchecked cast wearing a version field.
  *
  * There are exactly two correct policies, and which one applies is a property
  * of the STATE, not of the module:
@@ -49,8 +50,19 @@ export class SchemaVersionMismatchError extends Error {
 // Both directions accept ANY object — an unstamped payload is a defined input
 // (discard: stale; throw: mismatch), and the parameter types state that real
 // contract rather than requiring a `schema_version`-bearing shape.
+//
+// TWO spellings are recognized, because the repo stamps both: `schema_version`
+// on artifacts and `contract_version` on contracts (the version-gate scan's own
+// version-key family). That is a naming convention of the payload FAMILY, not a
+// difference in policy — and a helper that knew only one spelling would return
+// `undefined` for every payload of the other, i.e. discard a current file as if
+// it were never written, or throw on a correctly-stamped one. A silent
+// always-discard is indistinguishable from a working guard in review, so the
+// helper resolves the key rather than making each call site remember it.
+// `schema_version` wins when a payload carries both.
 function stampedVersion(value) {
-    return value.schema_version;
+    const record = value;
+    return "schema_version" in record ? record.schema_version : record.contract_version;
 }
 /**
  * REGENERABLE state: return the payload only when its stamped `schema_version`

package/dist/shared/io/schemaVersion.js.map

@@ -1 +1 @@
-{"version":3,"file":"schemaVersion.js","sourceRoot":"","sources":["../../../src/shared/io/schemaVersion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;GAIG;AACH,MAAM,OAAO,0BAA2B,SAAQ,KAAK;IAEjC;IACA;IACA;IAHlB,YACkB,YAAoB,EACpB,QAAgB,EAChB,MAAc;QAE9B,KAAK,CACH,aAAa,YAAY,yBAAyB,MAAM,mBAAmB,QAAQ,KAAK;YACtF,uFAAuF;YACvF,UAAU,YAAY,iDAAiD,CAC1E,CAAC;QARc,iBAAY,GAAZ,YAAY,CAAQ;QACpB,aAAQ,GAAR,QAAQ,CAAQ;QAChB,WAAM,GAAN,MAAM,CAAQ;QAO9B,IAAI,CAAC,IAAI,GAAG,4BAA4B,CAAC;IAC3C,CAAC;CACF;AAED,8EAA8E;AAC9E,6EAA6E;AAC7E,mEAAmE;AACnE,SAAS,cAAc,CAAC,KAAa;IACnC,OAAQ,KAAiC,CAAC,cAAc,CAAC;AAC3D,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,8BAA8B,CAC5C,KAA2B,EAC3B,QAAgB;IAEhB,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,SAAS,CAAC;IAC5D,OAAO,cAAc,CAAC,KAAK,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;AAChE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,4BAA4B,CAC1C,KAAgC,EAChC,YAAoB,EACpB,QAAgB;IAEhB,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO;IAClD,MAAM,MAAM,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IACrC,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC/B,MAAM,IAAI,0BAA0B,CAAC,YAAY,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/E,CAAC;IACD,IAAI,MAAM,KAAK,QAAQ,EAAE,CAAC;QACxB,MAAM,IAAI,0BAA0B,CAAC,YAAY,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;IACvE,CAAC;AACH,CAAC"}
+{"version":3,"file":"schemaVersion.js","sourceRoot":"","sources":["../../../src/shared/io/schemaVersion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;GAIG;AACH,MAAM,OAAO,0BAA2B,SAAQ,KAAK;IAEjC;IACA;IACA;IAHlB,YACkB,YAAoB,EACpB,QAAgB,EAChB,MAAc;QAE9B,KAAK,CACH,aAAa,YAAY,yBAAyB,MAAM,mBAAmB,QAAQ,KAAK;YACtF,uFAAuF;YACvF,UAAU,YAAY,iDAAiD,CAC1E,CAAC;QARc,iBAAY,GAAZ,YAAY,CAAQ;QACpB,aAAQ,GAAR,QAAQ,CAAQ;QAChB,WAAM,GAAN,MAAM,CAAQ;QAO9B,IAAI,CAAC,IAAI,GAAG,4BAA4B,CAAC;IAC3C,CAAC;CACF;AAED,8EAA8E;AAC9E,6EAA6E;AAC7E,mEAAmE;AACnE,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,gFAAgF;AAChF,+EAA+E;AAC/E,gFAAgF;AAChF,uEAAuE;AACvE,6EAA6E;AAC7E,yEAAyE;AACzE,qDAAqD;AACrD,SAAS,cAAc,CAAC,KAAa;IACnC,MAAM,MAAM,GAAG,KAAgC,CAAC;IAChD,OAAO,gBAAgB,IAAI,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC;AACtF,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,8BAA8B,CAC5C,KAA2B,EAC3B,QAAgB;IAEhB,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,SAAS,CAAC;IAC5D,OAAO,cAAc,CAAC,KAAK,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;AAChE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,4BAA4B,CAC1C,KAAgC,EAChC,YAAoB,EACpB,QAAgB;IAEhB,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO;IAClD,MAAM,MAAM,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IACrC,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC/B,MAAM,IAAI,0BAA0B,CAAC,YAAY,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/E,CAAC;IACD,IAAI,MAAM,KAAK,QAAQ,EAAE,CAAC;QACxB,MAAM,IAAI,0BAA0B,CAAC,YAAY,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;IACvE,CAAC;AACH,CAAC"}

package/dist/shared/loopCorePaths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loopCorePaths.d.ts","sourceRoot":"","sources":["../../src/shared/loopCorePaths.ts"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,MAAM,EAc/C,CAAC;AAOF;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAUpD"}
+{"version":3,"file":"loopCorePaths.d.ts","sourceRoot":"","sources":["../../src/shared/loopCorePaths.ts"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,MAAM,EAoB/C,CAAC;AAOF;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAUpD"}

package/dist/shared/loopCorePaths.js

@@ -25,17 +25,23 @@
 export const LOOP_CORE_PATTERNS = [
     // Path-sorted (JS default string order) so the serialized order is stable and
     // the hook-parity comparison is deterministic. Groups, for the reader:
-    //   • audit orchestrator step machine + host-handoff boundary
+    //   • audit orchestrator step machine + host-handoff boundary + gate ingest
+    //     (the lane modules carry the bound-path rule and the lane validators —
+    //     the audit draw of the submission core, not a helper beside it)
     //   • remediate step machine + host-handoff/landing + risk/pipeline core
-    //   • shared obligation engine
+    //   • shared obligation engine + submission core
     "src/audit/cli/dispatch.ts",
     "src/audit/cli/dispatch/",
+    "src/audit/cli/laneSubmissions.ts",
+    "src/audit/cli/laneValidators.ts",
+    "src/audit/cli/nextStepHelpers.ts",
     "src/audit/orchestrator/",
     "src/remediate/riskSignal.ts",
     "src/remediate/steps/contractPipeline.ts",
     "src/remediate/steps/dispatch/",
     "src/remediate/steps/nextStep.ts",
     "src/shared/engine/",
+    "src/shared/submission/",
 ];
 /** Normalize a repo-relative path to forward slashes, no leading "./". */
 function normalizeRepoRelPath(path) {

package/dist/shared/loopCorePaths.js.map

@@ -1 +1 @@
-{"version":3,"file":"loopCorePaths.js","sourceRoot":"","sources":["../../src/shared/loopCorePaths.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,kFAAkF;AAClF,oFAAoF;AACpF,EAAE;AACF,8EAA8E;AAC9E,+EAA+E;AAC/E,4EAA4E;AAC5E,wEAAwE;AACxE,mBAAmB;AACnB,EAAE;AACF,4EAA4E;AAC5E,2EAA2E;AAC3E,iFAAiF;AACjF,kFAAkF;AAClF,iDAAiD;AACjD,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,+EAA+E;AAE/E;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAsB;IACnD,8EAA8E;IAC9E,uEAAuE;IACvE,8DAA8D;IAC9D,yEAAyE;IACzE,+BAA+B;IAC/B,2BAA2B;IAC3B,yBAAyB;IACzB,yBAAyB;IACzB,6BAA6B;IAC7B,yCAAyC;IACzC,+BAA+B;IAC/B,iCAAiC;IACjC,oBAAoB;CACrB,CAAC;AAEF,0EAA0E;AAC1E,SAAS,oBAAoB,CAAC,IAAY;IACxC,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;AACvD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,MAAM,CAAC,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC;IACrC,KAAK,MAAM,OAAO,IAAI,kBAAkB,EAAE,CAAC;QACzC,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC1B,IAAI,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC;gBAAE,OAAO,IAAI,CAAC;QACzC,CAAC;aAAM,IAAI,CAAC,KAAK,OAAO,EAAE,CAAC;YACzB,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}
+{"version":3,"file":"loopCorePaths.js","sourceRoot":"","sources":["../../src/shared/loopCorePaths.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,kFAAkF;AAClF,oFAAoF;AACpF,EAAE;AACF,8EAA8E;AAC9E,+EAA+E;AAC/E,4EAA4E;AAC5E,wEAAwE;AACxE,mBAAmB;AACnB,EAAE;AACF,4EAA4E;AAC5E,2EAA2E;AAC3E,iFAAiF;AACjF,kFAAkF;AAClF,iDAAiD;AACjD,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,+EAA+E;AAE/E;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAsB;IACnD,8EAA8E;IAC9E,uEAAuE;IACvE,4EAA4E;IAC5E,4EAA4E;IAC5E,qEAAqE;IACrE,yEAAyE;IACzE,iDAAiD;IACjD,2BAA2B;IAC3B,yBAAyB;IACzB,kCAAkC;IAClC,iCAAiC;IACjC,kCAAkC;IAClC,yBAAyB;IACzB,6BAA6B;IAC7B,yCAAyC;IACzC,+BAA+B;IAC/B,iCAAiC;IACjC,oBAAoB;IACpB,wBAAwB;CACzB,CAAC;AAEF,0EAA0E;AAC1E,SAAS,oBAAoB,CAAC,IAAY;IACxC,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;AACvD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,MAAM,CAAC,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC;IACrC,KAAK,MAAM,OAAO,IAAI,kBAAkB,EAAE,CAAC;QACzC,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC1B,IAAI,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC;gBAAE,OAAO,IAAI,CAAC;QACzC,CAAC;aAAM,IAAI,CAAC,KAAK,OAAO,EAAE,CAAC;YACzB,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/shared/submission/expectedSubmissions.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The expected-submission set: what a step emission OWES, stated by name.
+ *
+ * A fan-out emission used to be implicit — it wrote N lane prompts and, on the
+ * next turn, simply looked to see which result files happened to be there. An
+ * absent lane was a `continue`, so a lane that was never delivered was
+ * indistinguishable from a lane that was merely slow, and the run reported
+ * neither the shortfall nor its cause. Recording the set at emit turns that
+ * into "expected 3, accepted 2, lane `revealed` is missing".
+ *
+ * The set is a COHERENCE grouping, never a fit claim: a member is a
+ * content-coherent lane, and the diff counts lanes. Nothing here describes a
+ * backend, a window, or a partition sized to one — that is the host's business
+ * and this package does not own it.
+ *
+ * Storage-neutral by construction (one core, two draws): the core says what the
+ * set IS; the audit draw persists it as a file beside the submissions, the
+ * remediate draw carries its equivalent inside `RemediationState`.
+ */
+import type { SubmissionIssue, SubmissionReadOutcome } from "./submissionClassifier.js";
+import type { SubmissionRoots } from "./submissionIdentity.js";
+export declare const EXPECTED_SET_CONTRACT_VERSION: "submission-expected-set/v1alpha1";
+export interface ExpectedSubmission {
+    readonly submission_id: string;
+    /** The content-coherent lane this member answers. */
+    readonly lane: string;
+    /** Digest of the prompt the lane was given — binds the answer to the ask. */
+    readonly prompt_sha256: string;
+    /** The tool-computed bound path, repository-relative and forward-slashed. */
+    readonly submission_path: string;
+}
+export interface ExpectedSubmissionSet {
+    readonly contract_version: typeof EXPECTED_SET_CONTRACT_VERSION;
+    readonly run_id: string;
+    readonly entries: readonly ExpectedSubmission[];
+}
+/** One lane's declaration, as the emitter knows it. */
+export interface ExpectedSubmissionLane {
+    readonly lane: string;
+    readonly submissionId: string;
+    readonly promptSha256: string;
+}
+/** Per-member verdict of a diff. */
+export type SubmissionClassification = {
+    readonly status: "accepted";
+    readonly submission_id: string;
+} | {
+    readonly status: "issue";
+    readonly submission_id: string;
+    readonly issue: SubmissionIssue;
+};
+export interface ExpectedSetDiff {
+    /** How many lanes were owed. */
+    readonly expected: number;
+    /** How many of them arrived. */
+    readonly accepted: number;
+    readonly members: readonly SubmissionClassification[];
+}
+/**
+ * Build the set one emission owes. Entries are ordered by `submission_id` — a
+ * content-derived key, never emission or filesystem order, so re-recording an
+ * unchanged set produces byte-identical content.
+ */
+export declare function buildExpectedSubmissionSet(params: {
+    readonly runId: string;
+    readonly paths: SubmissionRoots;
+    readonly lanes: readonly ExpectedSubmissionLane[];
+}): ExpectedSubmissionSet;
+/**
+ * Merge `additional` into `base`, keyed by `submission_id`. A re-emitted lane
+ * re-declares the identical member (the id is deterministic), and a step that
+ * materializes several lane groups accumulates them into one statement of what
+ * is currently owed. Returns the merged set plus the ids that are NEW, so a
+ * caller records an `expected` event once per lane rather than on every
+ * re-emission.
+ */
+export declare function mergeExpectedSets(base: ExpectedSubmissionSet | undefined, additional: ExpectedSubmissionSet): {
+    readonly set: ExpectedSubmissionSet;
+    readonly addedIds: readonly string[];
+};
+/** Drop members that are no longer owed (they were accepted and applied). */
+export declare function withoutExpectedSubmissions(set: ExpectedSubmissionSet, submissionIds: readonly string[]): ExpectedSubmissionSet;
+/**
+ * Diff what was owed against what is on disk. Every member is classified by its
+ * own id: arrived, or named with the reason it did not.
+ */
+export declare function diffExpectedSet(set: ExpectedSubmissionSet, observed: ReadonlyMap<string, SubmissionReadOutcome>): ExpectedSetDiff;
+//# sourceMappingURL=expectedSubmissions.d.ts.map

package/dist/shared/submission/expectedSubmissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expectedSubmissions.d.ts","sourceRoot":"","sources":["../../../src/shared/submission/expectedSubmissions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EACV,eAAe,EACf,qBAAqB,EACtB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAG/D,eAAO,MAAM,6BAA6B,EACxC,kCAA2C,CAAC;AAE9C,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,qDAAqD;IACrD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,6EAA6E;IAC7E,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,gBAAgB,EAAE,OAAO,6BAA6B,CAAC;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACjD;AAED,uDAAuD;AACvD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,oCAAoC;AACpC,MAAM,MAAM,wBAAwB,GAChC;IAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAC/D;IACE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;CACjC,CAAC;AAEN,MAAM,WAAW,eAAe;IAC9B,gCAAgC;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,gCAAgC;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,wBAAwB,EAAE,CAAC;CACvD;AAMD;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,SAAS,sBAAsB,EAAE,CAAC;CACnD,GAAG,qBAAqB,CAcxB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,qBAAqB,GAAG,SAAS,EACvC,UAAU,EAAE,qBAAqB,GAChC;IAAE,QAAQ,CAAC,GAAG,EAAE,qBAAqB,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAkB/E;AAED,6EAA6E;AAC7E,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,qBAAqB,EAC1B,aAAa,EAAE,SAAS,MAAM,EAAE,GAC/B,qBAAqB,CAOvB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,qBAAqB,EAC1B,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,qBAAqB,CAAC,GACnD,eAAe,CAkBjB"}

package/dist/shared/submission/expectedSubmissions.js

@@ -0,0 +1,84 @@
+import { classifyRead } from "./submissionClassifier.js";
+import { submissionPathFor } from "./submissionIdentity.js";
+export const EXPECTED_SET_CONTRACT_VERSION = "submission-expected-set/v1alpha1";
+function compareIds(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+/**
+ * Build the set one emission owes. Entries are ordered by `submission_id` — a
+ * content-derived key, never emission or filesystem order, so re-recording an
+ * unchanged set produces byte-identical content.
+ */
+export function buildExpectedSubmissionSet(params) {
+    const entries = params.lanes.map((lane) => ({
+        submission_id: lane.submissionId,
+        lane: lane.lane,
+        prompt_sha256: lane.promptSha256,
+        submission_path: submissionPathFor(params.paths, lane.submissionId),
+    }));
+    return {
+        contract_version: EXPECTED_SET_CONTRACT_VERSION,
+        run_id: params.runId,
+        entries: entries.sort((left, right) => compareIds(left.submission_id, right.submission_id)),
+    };
+}
+/**
+ * Merge `additional` into `base`, keyed by `submission_id`. A re-emitted lane
+ * re-declares the identical member (the id is deterministic), and a step that
+ * materializes several lane groups accumulates them into one statement of what
+ * is currently owed. Returns the merged set plus the ids that are NEW, so a
+ * caller records an `expected` event once per lane rather than on every
+ * re-emission.
+ */
+export function mergeExpectedSets(base, additional) {
+    const merged = new Map();
+    for (const entry of base?.entries ?? [])
+        merged.set(entry.submission_id, entry);
+    const addedIds = [];
+    for (const entry of additional.entries) {
+        if (!merged.has(entry.submission_id))
+            addedIds.push(entry.submission_id);
+        merged.set(entry.submission_id, entry);
+    }
+    return {
+        set: {
+            contract_version: EXPECTED_SET_CONTRACT_VERSION,
+            run_id: additional.run_id,
+            entries: [...merged.values()].sort((left, right) => compareIds(left.submission_id, right.submission_id)),
+        },
+        addedIds: addedIds.sort(compareIds),
+    };
+}
+/** Drop members that are no longer owed (they were accepted and applied). */
+export function withoutExpectedSubmissions(set, submissionIds) {
+    const dropped = new Set(submissionIds);
+    return {
+        contract_version: EXPECTED_SET_CONTRACT_VERSION,
+        run_id: set.run_id,
+        entries: set.entries.filter((entry) => !dropped.has(entry.submission_id)),
+    };
+}
+/**
+ * Diff what was owed against what is on disk. Every member is classified by its
+ * own id: arrived, or named with the reason it did not.
+ */
+export function diffExpectedSet(set, observed) {
+    const members = [];
+    let accepted = 0;
+    for (const entry of set.entries) {
+        const outcome = observed.get(entry.submission_id) ?? { kind: "missing" };
+        const issue = classifyRead(outcome, {
+            submissionId: entry.submission_id,
+            lane: entry.lane,
+            submissionPath: entry.submission_path,
+        });
+        if (issue === null) {
+            accepted += 1;
+            members.push({ status: "accepted", submission_id: entry.submission_id });
+            continue;
+        }
+        members.push({ status: "issue", submission_id: entry.submission_id, issue });
+    }
+    return { expected: set.entries.length, accepted, members };
+}
+//# sourceMappingURL=expectedSubmissions.js.map

package/dist/shared/submission/expectedSubmissions.js.map

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

package/dist/shared/submission/handRecovery.d.ts

@@ -0,0 +1,37 @@
+import type { SubmissionIssue } from "./submissionClassifier.js";
+export interface HandRecoveryRequest {
+    readonly root: string;
+    readonly artifactsDir: string;
+    readonly runId: string;
+    readonly submissionId: string;
+    /** Where the operator's corrected payload currently sits. */
+    readonly fromPath: string;
+    /**
+     * The lane this submission answers, when the caller knows it. Recorded on
+     * the ledger so the repair reads in lane vocabulary; absent, it is looked up
+     * from the recorded expectation and only then falls back to the raw id.
+     */
+    readonly lane?: string;
+    /**
+     * The DRAW's submission home, when it is not the artifacts dir's
+     * `submissions/`. Declared by the calling bin, never by the operator — the
+     * remediate draw binds its work-item submissions under the run directory,
+     * and the core stays storage-neutral rather than picking one for both.
+     */
+    readonly submissionDir?: string;
+}
+export type HandRecoveryOutcome = {
+    readonly ok: true;
+    readonly submission_path: string;
+} | {
+    readonly ok: false;
+    readonly issue: SubmissionIssue;
+};
+/**
+ * Validate the operator's payload with the normal lane's validator and, only
+ * if it passes, land it at the tool-owned path. A refusal writes nothing and
+ * records nothing — a run must never look hand-repaired because a repair was
+ * ATTEMPTED.
+ */
+export declare function recoverSubmission(request: HandRecoveryRequest, validate: (value: unknown) => SubmissionIssue | null): Promise<HandRecoveryOutcome>;
+//# sourceMappingURL=handRecovery.d.ts.map

package/dist/shared/submission/handRecovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handRecovery.d.ts","sourceRoot":"","sources":["../../../src/shared/submission/handRecovery.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAWjE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,6DAA6D;IAC7D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;CAAE,CAAC;AA6B5D;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,mBAAmB,EAC5B,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,eAAe,GAAG,IAAI,GACnD,OAAO,CAAC,mBAAmB,CAAC,CAsF9B"}

package/dist/shared/submission/handRecovery.js

@@ -0,0 +1,123 @@
+/**
+ * Hand recovery — the ONLY place a human hand may re-land a submission.
+ *
+ * An operator sometimes has to rescue a submission a host mangled. The danger
+ * is that the rescue becomes a second, weaker door into the tool: a path that
+ * skips the schema the normal lane enforces, or that lets the operator choose
+ * where the payload lands. Both are closed here by construction — the caller
+ * hands in the NORMAL lane's validator (there is no other validator to pass),
+ * and the destination is derived from the submission id, so `--from` says what
+ * to land and never where.
+ *
+ * The third property is that the rescue is not erased: a successful recovery
+ * appends `recovered_by_hand`, so a run repaired by an operator stays
+ * distinguishable from one the host got right.
+ */
+import { unlink } from "node:fs/promises";
+import { readOptionalJsonFile, writeJsonFile } from "../io/json.js";
+import { discardOnSchemaVersionMismatch } from "../io/schemaVersion.js";
+import { expectedSubmissionsPath, submissionsDir, } from "../io/auditToolsPaths.js";
+import { EXPECTED_SET_CONTRACT_VERSION } from "./expectedSubmissions.js";
+import { readSubmissionDocument } from "./submissionClassifier.js";
+import { absoluteSubmissionPath, submissionPathFor, } from "./submissionIdentity.js";
+import { SUBMISSION_LEDGER_EVENT_CONTRACT_VERSION, appendSubmissionEvent, } from "./submissionLedger.js";
+/**
+ * Resolve which lane the id belongs to from the recorded expectation, so the
+ * ledger entry reads in lane vocabulary. Best-effort: a draw that keeps its
+ * expected set somewhere other than the artifacts dir simply records the id.
+ *
+ * The set is REGENERABLE bookkeeping (rewritten at every emit), so one left by
+ * another release is discarded rather than read under this release's field
+ * semantics — a lane name is a label on the record, and a wrong one taken from
+ * a foreign contract is worse than the raw id this function already falls back
+ * to. Discarding lands on exactly that existing degrade path.
+ */
+async function resolveLane(artifactsDir, submissionId) {
+    const set = discardOnSchemaVersionMismatch(await readOptionalJsonFile(expectedSubmissionsPath(artifactsDir)).catch(() => undefined), EXPECTED_SET_CONTRACT_VERSION);
+    return (set?.entries?.find((entry) => entry.submission_id === submissionId)?.lane ??
+        submissionId);
+}
+/**
+ * Validate the operator's payload with the normal lane's validator and, only
+ * if it passes, land it at the tool-owned path. A refusal writes nothing and
+ * records nothing — a run must never look hand-repaired because a repair was
+ * ATTEMPTED.
+ */
+export async function recoverSubmission(request, validate) {
+    const paths = {
+        root: request.root,
+        submissionDir: request.submissionDir ?? submissionsDir(request.artifactsDir),
+    };
+    // BOTH destinations are resolved first, because both can refuse: the
+    // repo-relative form runs the containment check, and a submission directory
+    // that escapes the declared root throws. Computed after the write, that
+    // refusal arrived with the payload already landed and `recovered_by_hand`
+    // already appended — a rescue reported as failed that a re-run would then
+    // record twice. Resolved here, a refusal is what the rejection path already
+    // guarantees: nothing written, nothing recorded.
+    const landingPath = absoluteSubmissionPath(paths, request.submissionId);
+    const boundPath = submissionPathFor(paths, request.submissionId);
+    const read = await readSubmissionDocument(request.fromPath);
+    if (read.kind === "missing") {
+        return {
+            ok: false,
+            issue: {
+                code: "submission_missing",
+                message: `nothing to recover at ${request.fromPath}`,
+                submission_id: request.submissionId,
+            },
+        };
+    }
+    if (read.kind === "malformed") {
+        return {
+            ok: false,
+            issue: {
+                code: "submission_malformed",
+                message: `the payload at ${request.fromPath} is not JSON: ${read.detail}`,
+                submission_id: request.submissionId,
+            },
+        };
+    }
+    const issue = validate(read.value);
+    if (issue !== null) {
+        return { ok: false, issue };
+    }
+    const lane = request.lane ?? (await resolveLane(request.artifactsDir, request.submissionId));
+    await writeJsonFile(landingPath, read.value);
+    try {
+        await appendSubmissionEvent(request.artifactsDir, {
+            contract_version: SUBMISSION_LEDGER_EVENT_CONTRACT_VERSION,
+            run_id: request.runId,
+            submission_id: request.submissionId,
+            lane,
+            kind: "recovered_by_hand",
+            message: `re-landed by hand from ${request.fromPath}`,
+            recorded_at: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        // The payload is landed but the repair is unrecorded — the single state
+        // this verb must never leave behind, because the next `next-step` would
+        // consume it as a clean first-try submission and the run would read as one
+        // that never drifted. That is precisely the distinguishability the ledger
+        // exists to guarantee, so the write is rolled back and the operator keeps a
+        // failed rescue they can retry rather than a silent falsification.
+        const detail = error instanceof Error ? error.message : String(error);
+        try {
+            await unlink(landingPath);
+        }
+        catch (rollbackError) {
+            const rollbackDetail = rollbackError instanceof Error
+                ? rollbackError.message
+                : String(rollbackError);
+            throw new Error(`hand recovery for '${request.submissionId}' could not record the ledger event ` +
+                `(${detail}), and the landed payload could NOT be rolled back (${rollbackDetail}). ` +
+                `The payload IS on disk at ${boundPath} with no recovered_by_hand record — ` +
+                "remove it or retry the recovery before the next next-step consumes it.", { cause: error });
+        }
+        throw new Error(`hand recovery for '${request.submissionId}' could not record the ledger event: ` +
+            `${detail}. The payload was NOT landed (rolled back) — retry the recovery.`, { cause: error });
+    }
+    return { ok: true, submission_path: boundPath };
+}
+//# sourceMappingURL=handRecovery.js.map

package/dist/shared/submission/handRecovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handRecovery.js","sourceRoot":"","sources":["../../../src/shared/submission/handRecovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,8BAA8B,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EACL,uBAAuB,EACvB,cAAc,GACf,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,6BAA6B,EAAE,MAAM,0BAA0B,CAAC;AAGzE,OAAO,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,EACL,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,wCAAwC,EACxC,qBAAqB,GACtB,MAAM,uBAAuB,CAAC;AA4B/B;;;;;;;;;;GAUG;AACH,KAAK,UAAU,WAAW,CACxB,YAAoB,EACpB,YAAoB;IAEpB,MAAM,GAAG,GAAG,8BAA8B,CACxC,MAAM,oBAAoB,CACxB,uBAAuB,CAAC,YAAY,CAAC,CACtC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,EACxB,6BAA6B,CAC9B,CAAC;IACF,OAAO,CACL,GAAG,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,aAAa,KAAK,YAAY,CAAC,EAAE,IAAI;QACzE,YAAY,CACb,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,OAA4B,EAC5B,QAAoD;IAEpD,MAAM,KAAK,GAAG;QACZ,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,aAAa,EAAE,OAAO,CAAC,aAAa,IAAI,cAAc,CAAC,OAAO,CAAC,YAAY,CAAC;KAC7E,CAAC;IACF,qEAAqE;IACrE,4EAA4E;IAC5E,wEAAwE;IACxE,0EAA0E;IAC1E,0EAA0E;IAC1E,4EAA4E;IAC5E,iDAAiD;IACjD,MAAM,WAAW,GAAG,sBAAsB,CAAC,KAAK,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;IACxE,MAAM,SAAS,GAAG,iBAAiB,CAAC,KAAK,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;IACjE,MAAM,IAAI,GAAG,MAAM,sBAAsB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC5D,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC5B,OAAO;YACL,EAAE,EAAE,KAAK;YACT,KAAK,EAAE;gBACL,IAAI,EAAE,oBAAoB;gBAC1B,OAAO,EAAE,yBAAyB,OAAO,CAAC,QAAQ,EAAE;gBACpD,aAAa,EAAE,OAAO,CAAC,YAAY;aACpC;SACF,CAAC;IACJ,CAAC;IACD,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;QAC9B,OAAO;YACL,EAAE,EAAE,KAAK;YACT,KAAK,EAAE;gBACL,IAAI,EAAE,sBAAsB;gBAC5B,OAAO,EAAE,kBAAkB,OAAO,CAAC,QAAQ,iBAAiB,IAAI,CAAC,MAAM,EAAE;gBACzE,aAAa,EAAE,OAAO,CAAC,YAAY;aACpC;SACF,CAAC;IACJ,CAAC;IAED,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACnC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IAC9B,CAAC;IAED,MAAM,IAAI,GACR,OAAO,CAAC,IAAI,IAAI,CAAC,MAAM,WAAW,CAAC,OAAO,CAAC,YAAY,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;IAClF,MAAM,aAAa,CAAC,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAE7C,IAAI,CAAC;QACH,MAAM,qBAAqB,CAAC,OAAO,CAAC,YAAY,EAAE;YAChD,gBAAgB,EAAE,wCAAwC;YAC1D,MAAM,EAAE,OAAO,CAAC,KAAK;YACrB,aAAa,EAAE,OAAO,CAAC,YAAY;YACnC,IAAI;YACJ,IAAI,EAAE,mBAAmB;YACzB,OAAO,EAAE,0BAA0B,OAAO,CAAC,QAAQ,EAAE;YACrD,WAAW,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SACtC,CAAC,CAAC;IACL,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,wEAAwE;QACxE,wEAAwE;QACxE,2EAA2E;QAC3E,0EAA0E;QAC1E,4EAA4E;QAC5E,mEAAmE;QACnE,MAAM,MAAM,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACtE,IAAI,CAAC;YACH,MAAM,MAAM,CAAC,WAAW,CAAC,CAAC;QAC5B,CAAC;QAAC,OAAO,aAAa,EAAE,CAAC;YACvB,MAAM,cAAc,GAClB,aAAa,YAAY,KAAK;gBAC5B,CAAC,CAAC,aAAa,CAAC,OAAO;gBACvB,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;YAC5B,MAAM,IAAI,KAAK,CACb,sBAAsB,OAAO,CAAC,YAAY,sCAAsC;gBAC9E,IAAI,MAAM,uDAAuD,cAAc,KAAK;gBACpF,6BAA6B,SAAS,sCAAsC;gBAC5E,wEAAwE,EAC1E,EAAE,KAAK,EAAE,KAAK,EAAE,CACjB,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,KAAK,CACb,sBAAsB,OAAO,CAAC,YAAY,uCAAuC;YAC/E,GAAG,MAAM,kEAAkE,EAC7E,EAAE,KAAK,EAAE,KAAK,EAAE,CACjB,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,CAAC;AAClD,CAAC"}

package/dist/shared/submission/submissionClassifier.d.ts

@@ -0,0 +1,48 @@
+export declare const SUBMISSION_ISSUE_CODES: readonly ["submission_missing", "submission_malformed", "submission_contract_invalid", "submission_rejected", "duplicate_submission_id"];
+export type SubmissionIssueCode = (typeof SUBMISSION_ISSUE_CODES)[number];
+/**
+ * One classified failure. `TCode` widens for a draw that adds its own domain
+ * codes; the base parameterization is the shared vocabulary above.
+ *
+ * Two optional locators, because a submission is identified differently on the
+ * two lanes it can arrive through: an expected-set member is named by
+ * `submission_id` + `submission_path`, and a host work item by `work_item_id` +
+ * `result_path` (the field name its own persisted contract already uses).
+ */
+export interface SubmissionIssue<TCode extends string = SubmissionIssueCode> {
+    readonly code: TCode;
+    readonly message: string;
+    readonly submission_id?: string;
+    readonly submission_path?: string;
+    readonly work_item_id?: string;
+    readonly result_path?: string;
+}
+/** The three-way read every gate narrows on — never a throw out of one lane. */
+export type SubmissionReadOutcome = {
+    readonly kind: "missing";
+} | {
+    readonly kind: "malformed";
+    readonly detail: string;
+} | {
+    readonly kind: "value";
+    readonly value: unknown;
+};
+/**
+ * Read the bytes at a bound path and classify the outcome. A file that is not
+ * there and a file that will not parse are DIFFERENT answers; every other IO
+ * failure reads as malformed rather than escaping, so one unreadable lane can
+ * never destroy a sibling lane's already-consumed work.
+ */
+export declare function readSubmissionDocument(absolutePath: string): Promise<SubmissionReadOutcome>;
+/** Where a classified read came from, for the issue's message and locators. */
+export interface SubmissionReadContext {
+    readonly submissionId: string;
+    readonly lane: string;
+    readonly submissionPath: string;
+}
+/**
+ * Turn a non-`value` read into the issue that names it, or `null` when the
+ * submission arrived. Lane vocabulary throughout: a member is a lane.
+ */
+export declare function classifyRead(outcome: SubmissionReadOutcome, context: SubmissionReadContext): SubmissionIssue | null;
+//# sourceMappingURL=submissionClassifier.d.ts.map

package/dist/shared/submission/submissionClassifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"submissionClassifier.d.ts","sourceRoot":"","sources":["../../../src/shared/submission/submissionClassifier.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,sBAAsB,0IAWzB,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1E;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe,CAAC,KAAK,SAAS,MAAM,GAAG,mBAAmB;IACzE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,gFAAgF;AAChF,MAAM,MAAM,qBAAqB,GAC7B;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAExD;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,qBAAqB,CAAC,CAqBhC;AAED,+EAA+E;AAC/E,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,qBAAqB,EAC9B,OAAO,EAAE,qBAAqB,GAC7B,eAAe,GAAG,IAAI,CAkBxB"}

package/dist/shared/submission/submissionClassifier.js

@@ -0,0 +1,83 @@
+/**
+ * The ONE failure vocabulary for a host submission both orchestrators read.
+ *
+ * Before this module the two draws had drifted: remediate classified a failed
+ * read into a named issue code, while the audit ingest collapsed a missing
+ * file, unparseable bytes, a contract-invalid body and a failed conversion into
+ * the same bare `null` — so a host that never wrote its submission and a host
+ * that wrote garbage were indistinguishable to every caller. One union, two
+ * thin draws.
+ *
+ * The vocabulary is deliberately narrow: it names what happened to a
+ * SUBMISSION. Domain corroboration a single draw performs (git ancestry, write
+ * scope, a required test rerun) extends this union on that draw's side rather
+ * than pulling its vocabulary in here — see `RemediationIssueCode`.
+ */
+import { readFile } from "node:fs/promises";
+export const SUBMISSION_ISSUE_CODES = [
+    /** Nothing exists at the bound path. */
+    "submission_missing",
+    /** Something exists at the bound path but is not JSON. */
+    "submission_malformed",
+    /** Valid JSON that fails the lane's schema / binding contract. */
+    "submission_contract_invalid",
+    /** Well-formed and valid, but refused for a stated reason. */
+    "submission_rejected",
+    /** A second submission re-uses an identity already accepted this run. */
+    "duplicate_submission_id",
+];
+/**
+ * Read the bytes at a bound path and classify the outcome. A file that is not
+ * there and a file that will not parse are DIFFERENT answers; every other IO
+ * failure reads as malformed rather than escaping, so one unreadable lane can
+ * never destroy a sibling lane's already-consumed work.
+ */
+export async function readSubmissionDocument(absolutePath) {
+    let source;
+    try {
+        source = await readFile(absolutePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { kind: "missing" };
+        }
+        return {
+            kind: "malformed",
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+    try {
+        return { kind: "value", value: JSON.parse(source) };
+    }
+    catch (error) {
+        return {
+            kind: "malformed",
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Turn a non-`value` read into the issue that names it, or `null` when the
+ * submission arrived. Lane vocabulary throughout: a member is a lane.
+ */
+export function classifyRead(outcome, context) {
+    if (outcome.kind === "value")
+        return null;
+    const locators = {
+        submission_id: context.submissionId,
+        submission_path: context.submissionPath,
+    };
+    if (outcome.kind === "missing") {
+        return {
+            code: "submission_missing",
+            message: `lane '${context.lane}' submitted nothing at its bound path`,
+            ...locators,
+        };
+    }
+    return {
+        code: "submission_malformed",
+        message: `lane '${context.lane}' submitted bytes that are not JSON: ${outcome.detail}`,
+        ...locators,
+    };
+}
+//# sourceMappingURL=submissionClassifier.js.map

package/dist/shared/submission/submissionClassifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"submissionClassifier.js","sourceRoot":"","sources":["../../../src/shared/submission/submissionClassifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,wCAAwC;IACxC,oBAAoB;IACpB,0DAA0D;IAC1D,sBAAsB;IACtB,kEAAkE;IAClE,6BAA6B;IAC7B,8DAA8D;IAC9D,qBAAqB;IACrB,yEAAyE;IACzE,yBAAyB;CACjB,CAAC;AA4BX;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAC1C,YAAoB;IAEpB,IAAI,MAAc,CAAC;IACnB,IAAI,CAAC;QACH,MAAM,GAAG,MAAM,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAChD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAK,KAA+B,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YACvD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;QAC7B,CAAC;QACD,OAAO;YACL,IAAI,EAAE,WAAW;YACjB,MAAM,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;SAC/D,CAAC;IACJ,CAAC;IACD,IAAI,CAAC;QACH,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAY,EAAE,CAAC;IACjE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO;YACL,IAAI,EAAE,WAAW;YACjB,MAAM,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;SAC/D,CAAC;IACJ,CAAC;AACH,CAAC;AASD;;;GAGG;AACH,MAAM,UAAU,YAAY,CAC1B,OAA8B,EAC9B,OAA8B;IAE9B,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO;QAAE,OAAO,IAAI,CAAC;IAC1C,MAAM,QAAQ,GAAG;QACf,aAAa,EAAE,OAAO,CAAC,YAAY;QACnC,eAAe,EAAE,OAAO,CAAC,cAAc;KAC/B,CAAC;IACX,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC/B,OAAO;YACL,IAAI,EAAE,oBAAoB;YAC1B,OAAO,EAAE,SAAS,OAAO,CAAC,IAAI,uCAAuC;YACrE,GAAG,QAAQ;SACZ,CAAC;IACJ,CAAC;IACD,OAAO;QACL,IAAI,EAAE,sBAAsB;QAC5B,OAAO,EAAE,SAAS,OAAO,CAAC,IAAI,wCAAwC,OAAO,CAAC,MAAM,EAAE;QACtF,GAAG,QAAQ;KACZ,CAAC;AACJ,CAAC"}