@tiangong-ai/cli 0.0.42 → 0.0.43

package/AGENTS.md

@@ -17,8 +17,8 @@ checkPaths:
   - .docpact/config.yaml
   - docs/agents/**
   - src/**
-lastReviewedAt: 2026-08-18
-lastReviewedCommit: 9205e1b06678ef79042bee89bd3bca3fa77af515
+lastReviewedAt: 2026-08-19
+lastReviewedCommit: cd92a737acbdfd05a36c0d0d5b14c7e531ae6ee7
 ---
 
 # Tiangong AI CLI Contract

package/README.md

@@ -13,7 +13,7 @@ checkPaths:
   - bin/**
   - src/**
 lastReviewedAt: 2026-08-18
-lastReviewedCommit: 9205e1b06678ef79042bee89bd3bca3fa77af515
+lastReviewedCommit: 34a5c2a3af26fc56e9c9dc94fcbdabd91a6dd1d8
 ---
 
 # Tiangong AI CLI
@@ -417,14 +417,17 @@ tiangong-ai research project init top-journal-paper \
   --workspace /absolute/path/to/workspace --json
 ```
 
-The base evidence lifecycle remains
-`discover -> acquire -> analyze -> synthesize -> review -> close`, authored in
-the current interactive Codex or Claude Code host. A fresh independent reviewer
+The base evidence lifecycle remains producer-authored in the current interactive
+Codex or Claude Code host, but its frozen control sequence is now
+`discover -> acquire -> typed decomposition/atoms -> content freeze -> inference freeze -> analyze -> Claim-Evidence Graph -> synthesize -> review -> close`.
+A fresh independent reviewer
 must first pass three hash-bound scientific gates: `research-design` before
 discovery, a real-record and outcome-blind `evidence-construct` canary after
-acquisition freezes the evidence snapshot, and `pilot-methods` after that
-canary and before analysis. Evidence-construct coverage may cite only frozen
-snapshot source IDs and states. Its JSON canary artifacts are promoted and
+acquisition and typed-content freeze, and `pilot-methods` after that canary and
+before analysis. Acquisition always freezes its exact result, including honest
+gaps; a stopped acquisition/content gate prevents inference without discarding
+the acquired evidence. Evidence-construct coverage may cite only frozen
+snapshot source IDs and exact content atoms. Its JSON canary artifacts are promoted and
 content-addressed through `--canary-artifacts`; reviewer prose cannot override
 an invented ID, unbound digest, or other mechanical failure.
 
@@ -457,14 +460,23 @@ audit manifest separately records the raw stored packet-file digest. This keeps
 packet identity and byte-level transfer verification explicit rather than
 overloading one hash with both meanings.
 
-After base closure, the current native host writes a final manuscript and
-schema-valid publication assessment. `research publication freeze` then
-content-addresses the Policy, scientific design and early reviews, evidence
-snapshot, base outputs, manuscript, assessment, and supplements.
+After base closure, the current native host writes a final Markdown/plain-text
+manuscript, schema-valid publication assessment, and an explicit submission
+manifest. The manuscript must contain Abstract, Introduction, Methods, Results,
+Discussion, Data availability, Code availability, and References. The
+submission manifest must bind distinct absolute files for cover letter, title
+page, reporting checklist, data availability, code availability, and source
+data; figure/table index, extended data, and supplementary methods are optional.
+`research publication freeze` then content-addresses the Policy, scientific
+design and early reviews, acquisition/content/inference snapshots, reproduced
+analysis, Claim-Evidence Graph, base outputs, manuscript, assessment,
+supplements, role-complete submission files, and reproducibility manifest.
 Exactly four fresh independent sessions review that frozen generation:
 evidence, methods/reproducibility, domain/novelty, and journal-editor. A revised
-manuscript invalidates prior reviews; reviewer-session reuse is rejected from
-the append-only journal even if mutable cache state is removed. The raw opaque
+manuscript invalidates prior reviews. Every reviewer must use the configured
+agent family that differs from the native producer; changing only the session
+ID is not independent. Reviewer-session reuse is rejected from the append-only
+journal even if mutable cache state is removed. The raw opaque
 producer/reviewer session identifiers are accepted only at the command boundary;
 generation, packet, review, journal, and closure objects persist only their
 SHA-256 bindings.
@@ -474,6 +486,7 @@ tiangong-ai research schema show publication-assessment --json
 tiangong-ai research publication freeze top-journal-paper \
   --manuscript /absolute/path/to/final-manuscript.md \
   --assessment /absolute/path/to/publication-assessment.json \
+  --submission /absolute/path/to/submission-package.json \
   --producer-agent codex --producer-session OPAQUE_NATIVE_SESSION \
   --workspace /absolute/path/to/workspace --json
 tiangong-ai research publication status top-journal-paper \
@@ -486,9 +499,13 @@ The CLI returns a mechanically bounded ceiling:
 it. None of these states predicts or guarantees editorial acceptance.
 
 Before external handoff or archival, export and independently verify a portable
-audit directory. It contains the selected project, portable copies of admitted
+audit directory. Export first revalidates the semantic acquisition, content,
+inference, graph, and publication objects; a copied but stale/tampered chain is
+rejected. Its manifest exposes their intrinsic IDs and hashes under
+`researchChain`. It contains the selected project, portable copies of admitted
 inputs, formal evidence and artifact bytes, Policy/design/review objects,
-outputs, environment fingerprints, and journal proofs. Credentials, setup
+outputs, environment fingerprints, and safe hash-preserving journal proof
+derivatives. Credentials, setup
 sources, browser profiles, native active state, capsules, unrelated projects,
 and host-specific absolute paths are excluded.
 
@@ -673,9 +690,19 @@ resume criteria. Research then stops; it does not spend more budget on
 low-yield substitutes. If no lawful remaining route exists, the user must narrow
 or abandon the unsupported scope before a new reviewed generation can resume.
 
-Successful acquisition freezes an immutable evidence snapshot before analysis.
-The reviewer and mechanical closure bind and recheck the snapshot chain,
-ledger, receipts, selected artifacts, excerpts, analysis, and report. Refresh a
+Acquisition freezes an immutable evidence snapshot even when lawful retrieval
+ends with explicit gaps. Before inference, decompose every acquired PDF,
+spreadsheet, archive, or structured file into exact lineage-bound producer-
+readable artifacts; register line-range or JSON-Pointer evidence atoms; then
+freeze `content-snapshot.json`. `research status --json` exposes acquisition,
+content, inference, and graph state under `evidencePipeline` and does not direct
+the operator to analysis while content preparation is missing or stopped.
+Only passing acquisition/content gates and required scientific reviews can
+freeze `inference-snapshot.json`. Analyze schema v2 binds that exact snapshot,
+a reproduced analysis run, source IDs, atom IDs, and design claim IDs; the CLI
+then creates `claim-evidence-graph.json` mechanically. The reviewer and
+mechanical closure bind and recheck the full chain, ledger, receipts, selected
+artifacts, excerpts, analysis, graph, and report. Refresh a
 closed result with `research project addendum SOURCE --to TARGET`; the original
 closure remains unchanged, the child snapshot records a mechanical delta, and
 default status hides the superseded project (`research status --all` shows full

package/dist/research/orchestration.js

@@ -13,6 +13,7 @@ import { fetchNativeCandidateSource } from "./workspace/broker.js";
 import { registerEvidenceArtifact } from "./workspace/artifacts.js";
 import { exportProjectAuditBundle, verifyProjectAuditBundle } from "./workspace/audit-bundle.js";
 import { loadCurrentEvidenceSnapshot } from "./workspace/acquisition.js";
+import { freezeEvidenceContentSnapshot, loadCurrentEvidenceContentSnapshot, recordArtifactDecomposition, registerEvidenceAtom, } from "./workspace/content-evidence.js";
 import { inspectDiscoveryProgress } from "./workspace/discovery-status.js";
 import { inspectEvidenceAccessStatus } from "./workspace/evidence-exhaustion.js";
 import { recordDiscoveryAssessmentBatch } from "./workspace/discovery.js";
@@ -20,6 +21,7 @@ import { bindEvidenceDownload } from "./workspace/downloads.js";
 import { registerNativeDiscoveryCandidate } from "./workspace/evidence-ledger.js";
 import { recordNativeResearchActivity } from "./workspace/native-activity.js";
 import { readAndVerifyProjectInputPlan } from "./workspace/input-plan.js";
+import { loadCurrentClaimEvidenceGraph, loadCurrentInferenceSnapshot, } from "./workspace/inference.js";
 import { addProjectInput, createProjectAddendum, initializeProject, forkProject, listProjects, loadProject, nextReadyPackage, normalizeEvidenceRequirements, refreshProject, retryProjectPackage, setProjectDisposition, } from "./workspace/projects.js";
 import { evaluateProjectPreflight } from "./workspace/preflight.js";
 import { closePublication, freezePublicationManuscript, inspectPublicationStatus, preparePublicationReview, publicationAssessmentSchema, publicationReviewSchema, submitPublicationReview, } from "./workspace/publication-workflow.js";
@@ -29,7 +31,7 @@ import { abortNativeResearchStage, inspectNativeResearchStage, prepareNativeRese
 import { schemaForStage } from "./workspace/schemas.js";
 import { readAndVerifyScientificDesign, scientificDesignSchema, } from "./workspace/scientific-design.js";
 import { inspectScientificReviewStatus, prepareScientificReview, scientificGateAssessmentSchema, scientificReviewSchema, submitScientificReview, } from "./workspace/scientific-review.js";
-import { pathExists, sha256Text, workspacePaths } from "./workspace/storage.js";
+import { isObject, pathExists, sha256Text, workspacePaths } from "./workspace/storage.js";
 import { doctorResearchWorkspace, initializeResearchWorkspace, requireResearchWorkspace, withWorkspaceLock, } from "./workspace/workspace.js";
 const COMMON_OPTIONS = { help: "boolean", json: "boolean" };
 const WORKSPACE_OPTIONS = { ...COMMON_OPTIONS, workspace: "string" };
@@ -77,7 +79,7 @@ export function researchOrchestrationHelp() {
   tiangong-ai research policy validate <project-id> [--workspace <path>] [--json]
   tiangong-ai research policy approve <project-id> --confirm [--acknowledge-defaults] [--workspace <path>] [--json]
   tiangong-ai research policy resolve <project-id> [--workspace <path>] [--json]
-  tiangong-ai research publication freeze <project-id> --manuscript <absolute-file> --assessment <absolute-json> --producer-agent codex|claude --producer-session <opaque-id> [--supplements <absolute-json-array>] [--workspace <path>] [--json]
+  tiangong-ai research publication freeze <project-id> --manuscript <absolute-file> --assessment <absolute-json> --submission <absolute-json> --producer-agent codex|claude --producer-session <opaque-id> [--supplements <absolute-json-array>] [--workspace <path>] [--json]
   tiangong-ai research publication review prepare <project-id> --role evidence|methods-reproducibility|domain-novelty|journal-editor --reviewer-agent codex|claude --reviewer-session <opaque-id> [--workspace <path>] [--json]
   tiangong-ai research publication review submit <project-id> --role evidence|methods-reproducibility|domain-novelty|journal-editor --review <absolute-json> [--workspace <path>] [--json]
   tiangong-ai research publication status <project-id> [--workspace <path>] [--json]
@@ -107,6 +109,10 @@ export function researchOrchestrationHelp() {
   tiangong-ai research project evidence assessment record <project-id> --record <absolute-json> [--workspace <path>] [--json]
   tiangong-ai research project evidence download bind <project-id> --candidate <id> --record <absolute-json> [--workspace <path>] [--json]
   tiangong-ai research project evidence artifact register <project-id> --candidate <id> --path <absolute-file> [--download-binding <id> | --derived-from-artifact <id>] [--media-type <type>] [--source-url <https-url>] [--license <declared-license>] [--license-url <https-url>] [--host-type <type>] [--article-version <version>] [--workspace <path>] [--json]
+  tiangong-ai research project evidence decomposition record <project-id> --record <absolute-json> [--workspace <path>] [--json]
+  tiangong-ai research project evidence atom register <project-id> --record <absolute-json> [--workspace <path>] [--json]
+  tiangong-ai research project evidence content freeze <project-id> [--workspace <path>] [--json]
+  tiangong-ai research project evidence content status <project-id> [--workspace <path>] [--json]
   tiangong-ai research schema show <discover|acquire|analyze|synthesize|review|doctor|scientific-design|scientific-assessment-research-design|scientific-assessment-evidence-construct|scientific-assessment-pilot-methods|scientific-review-research-design|scientific-review-evidence-construct|scientific-review-pilot-methods|publication-assessment|publication-review-evidence|publication-review-methods-reproducibility|publication-review-domain-novelty|publication-review-journal-editor> [--compatibility claude-code] [--json]
   tiangong-ai research status [--project <project-id>] [--all] [--workspace <absolute-path>] [--json]
   tiangong-ai research run [--project <project-id>] [--max-parallel <1-8>] [--max-cycles <1-100>] [--dry-run] [--progress-jsonl] [--workspace <absolute-path>] [--json]
@@ -124,6 +130,7 @@ async function runPublication(argv, io) {
             manuscript: "string",
             assessment: "string",
             supplements: "string",
+            submission: "string",
             "producer-agent": "string",
             "producer-session": "string",
         }, "research publication freeze");
@@ -133,8 +140,9 @@ async function runPublication(argv, io) {
         const manuscriptPath = strictString(args, "manuscript");
         const assessmentPath = strictString(args, "assessment");
         const producerSessionId = strictString(args, "producer-session");
-        if (!manuscriptPath || !assessmentPath || !producerSessionId) {
-            throw new CliError("research publication freeze requires --manuscript, --assessment, --producer-agent, and --producer-session.", { code: "RESEARCH_PUBLICATION_ARGUMENT_REQUIRED", exitCode: 2 });
+        const submissionPath = strictString(args, "submission");
+        if (!manuscriptPath || !assessmentPath || !submissionPath || !producerSessionId) {
+            throw new CliError("research publication freeze requires --manuscript, --assessment, --submission, --producer-agent, and --producer-session.", { code: "RESEARCH_PUBLICATION_ARGUMENT_REQUIRED", exitCode: 2 });
         }
         const root = await workspaceFromArgs(args);
         const supplementsPath = strictString(args, "supplements");
@@ -144,6 +152,7 @@ async function runPublication(argv, io) {
             manuscriptPath,
             assessmentPath,
             supplementPaths: supplementsPath ? await readAbsolutePathArray(supplementsPath) : [],
+            submissionFiles: await readSubmissionFiles(submissionPath),
             producerAgent: publicationAgent(strictString(args, "producer-agent"), "producer"),
             producerSessionId,
         }), args);
@@ -949,6 +958,66 @@ async function runProject(argv, io) {
             writeJson(io, result, args);
             return 0;
         }
+        if (evidenceAction === "decomposition") {
+            const [decompositionAction, ...decompositionRest] = evidenceRest;
+            if (decompositionAction !== "record") {
+                throw unknownAction("research project evidence decomposition", decompositionAction ?? "");
+            }
+            const args = parseStrictArgs(decompositionRest, { ...WORKSPACE_OPTIONS, record: "string" }, "research project evidence decomposition record");
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, "research project evidence decomposition record");
+            const recordPath = strictString(args, "record");
+            if (!recordPath) {
+                throw new CliError("decomposition record requires --record.", {
+                    code: "RESEARCH_DECOMPOSITION_INVALID",
+                    exitCode: 2,
+                });
+            }
+            const root = await workspaceFromArgs(args);
+            const record = await readBoundedJsonRecord(recordPath, "--record", "RESEARCH_DECOMPOSITION_INVALID");
+            const result = await withWorkspaceLock(root, "research.decomposition.record", () => recordArtifactDecomposition({ root, projectId, value: record }));
+            writeJson(io, result, args);
+            return 0;
+        }
+        if (evidenceAction === "atom") {
+            const [atomAction, ...atomRest] = evidenceRest;
+            if (atomAction !== "register") {
+                throw unknownAction("research project evidence atom", atomAction ?? "");
+            }
+            const args = parseStrictArgs(atomRest, { ...WORKSPACE_OPTIONS, record: "string" }, "research project evidence atom register");
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, "research project evidence atom register");
+            const recordPath = strictString(args, "record");
+            if (!recordPath) {
+                throw new CliError("atom register requires --record.", {
+                    code: "RESEARCH_EVIDENCE_ATOM_INVALID",
+                    exitCode: 2,
+                });
+            }
+            const root = await workspaceFromArgs(args);
+            const record = await readBoundedJsonRecord(recordPath, "--record", "RESEARCH_EVIDENCE_ATOM_INVALID");
+            const result = await withWorkspaceLock(root, "research.evidence-atom.register", () => registerEvidenceAtom({ root, projectId, value: record }));
+            writeJson(io, result, args);
+            return 0;
+        }
+        if (evidenceAction === "content") {
+            const [contentAction, ...contentRest] = evidenceRest;
+            if (contentAction !== "freeze" && contentAction !== "status") {
+                throw unknownAction("research project evidence content", contentAction ?? "");
+            }
+            const args = parseStrictArgs(contentRest, WORKSPACE_OPTIONS, `research project evidence content ${contentAction}`);
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, `research project evidence content ${contentAction}`);
+            const root = await workspaceFromArgs(args);
+            const result = contentAction === "freeze"
+                ? await withWorkspaceLock(root, "research.evidence-content.freeze", () => freezeEvidenceContentSnapshot(root, projectId))
+                : await loadCurrentEvidenceContentSnapshot(root, projectId);
+            writeJson(io, result, args);
+            return 0;
+        }
         if (evidenceAction !== "fetch") {
             throw unknownAction("research project evidence", evidenceAction ?? "");
         }
@@ -1272,7 +1341,8 @@ async function runStatus(argv, io) {
         projects: await Promise.all(projects.map(async (project) => {
             const current = refreshProject(project);
             const nativeStage = await inspectNativeResearchStage(root, current);
-            const snapshot = await inspectSnapshotForStatus(root, current.id);
+            const evidencePipeline = await inspectEvidencePipelineForStatus(root, current);
+            const snapshot = evidencePipeline.acquisition;
             const readyPackage = nextReadyPackage(current)?.id ?? null;
             const scientificReview = await inspectScientificReviewStatus(root, current.id);
             const evidenceAccess = current.scientificDesign
@@ -1290,12 +1360,13 @@ async function runStatus(argv, io) {
                 handoff: current.handoff,
                 evidenceState: current.evidenceState,
                 snapshot,
+                evidencePipeline,
                 nativeStage,
                 scientificReview,
                 evidenceAccess,
                 publication,
                 readyPackage,
-                recommendedAction: projectRecommendedAction(root, current, readyPackage, nativeStage, scientificReview, publication),
+                recommendedAction: projectRecommendedAction(root, current, readyPackage, nativeStage, scientificReview, evidencePipeline, publication),
                 usage: current.usage,
                 inputs: current.inputs,
                 packages: current.packages,
@@ -1306,6 +1377,94 @@ async function runStatus(argv, io) {
     writeJson(io, result, args);
     return 0;
 }
+async function inspectEvidencePipelineForStatus(root, project) {
+    const projectRoot = join(workspacePaths(root).projects, project.id);
+    const acquisition = await inspectSnapshotForStatus(root, project.id);
+    const contentPath = join(projectRoot, "outputs", "content-snapshot.json");
+    let content = { status: "absent" };
+    if (await pathExists(contentPath)) {
+        try {
+            const snapshot = await loadCurrentEvidenceContentSnapshot(root, project.id);
+            content = {
+                status: "verified",
+                snapshotId: snapshot.snapshotId,
+                snapshotSha256: snapshot.snapshotSha256,
+                decompositionCount: snapshot.decompositions.length,
+                atomCount: snapshot.atoms.length,
+                sourceCount: snapshot.sourceCoverage.length,
+                roleCount: snapshot.roleCoverage.length,
+                insufficientRoleIds: snapshot.roleCoverage
+                    .filter((role) => role.decision === "insufficient")
+                    .map((role) => role.roleId),
+                gate: snapshot.gate,
+            };
+        }
+        catch (error) {
+            content = {
+                status: "invalid",
+                code: error instanceof CliError ? error.code : "RESEARCH_EVIDENCE_CONTENT_SNAPSHOT_INVALID",
+            };
+        }
+    }
+    const inferencePath = join(projectRoot, "outputs", "inference-snapshot.json");
+    let inference = { status: "absent" };
+    if (await pathExists(inferencePath)) {
+        try {
+            const snapshot = await loadCurrentInferenceSnapshot(root, project.id);
+            inference = {
+                status: "verified",
+                snapshotId: snapshot.snapshotId,
+                snapshotSha256: snapshot.snapshotSha256,
+                sourceCount: snapshot.sources.length,
+                atomCount: snapshot.atoms.length,
+                claimCount: snapshot.claims.length,
+                artifactCount: snapshot.artifactSha256s.length,
+                gate: snapshot.gate,
+            };
+        }
+        catch (error) {
+            inference = {
+                status: "invalid",
+                code: error instanceof CliError ? error.code : "RESEARCH_INFERENCE_SNAPSHOT_INVALID",
+            };
+        }
+    }
+    else if (acquisition.gate?.decision === "stop") {
+        inference = { status: "blocked", gate: acquisition.gate };
+    }
+    else if (content.gate?.decision === "stop") {
+        inference = { status: "blocked", gate: content.gate };
+    }
+    else if (project.scientificDesign && content.status !== "verified") {
+        inference = {
+            status: "blocked",
+            code: "RESEARCH_EVIDENCE_CONTENT_SNAPSHOT_REQUIRED",
+        };
+    }
+    const graphPath = join(projectRoot, "outputs", "claim-evidence-graph.json");
+    let claimGraph = { status: "absent" };
+    if (await pathExists(graphPath)) {
+        try {
+            const graph = await loadCurrentClaimEvidenceGraph(root, project.id);
+            claimGraph = {
+                status: "verified",
+                graphId: graph.graphId,
+                graphSha256: graph.graphSha256,
+                analysisSha256: graph.analysisSha256,
+                analysisRunId: graph.analysisRunId,
+                nodeCount: graph.nodes.length,
+                edgeCount: graph.edges.length,
+            };
+        }
+        catch (error) {
+            claimGraph = {
+                status: "invalid",
+                code: error instanceof CliError ? error.code : "RESEARCH_CLAIM_EVIDENCE_GRAPH_INVALID",
+            };
+        }
+    }
+    return { acquisition, content, inference, claimGraph };
+}
 async function inspectEvidenceAccessForStatus(root, projectId) {
     try {
         return await inspectEvidenceAccessStatus(root, projectId);
@@ -1352,6 +1511,8 @@ async function inspectSnapshotForStatus(root, projectId) {
             parentSnapshotId: snapshot.parentSnapshotId,
             sourceCount: snapshot.sources.length,
             artifactCount: snapshot.artifacts.length,
+            gapCount: snapshot.gaps.length,
+            gate: snapshot.inferenceGate,
             delta: snapshot.delta,
         };
     }
@@ -1374,7 +1535,7 @@ async function inspectPublicationForStatus(root, projectId) {
         };
     }
 }
-function projectRecommendedAction(root, project, readyPackage, nativeStage, scientificReview, publication) {
+function projectRecommendedAction(root, project, readyPackage, nativeStage, scientificReview, evidencePipeline, publication) {
     if (project.lineage.supersededBy) {
         return `Continue with superseding project ${project.lineage.supersededBy}.`;
     }
@@ -1398,6 +1559,23 @@ function projectRecommendedAction(root, project, readyPackage, nativeStage, scie
     if (nativeStage.status === "active") {
         return nativeStage.recommendedAction ?? "Resume the active native stage.";
     }
+    if (readyPackage === "analyze") {
+        if (evidencePipeline.content.status === "absent") {
+            return `Decompose every acquired full-text/data artifact, register exact evidence atoms, then freeze typed content: tiangong-ai research project evidence content freeze ${project.id} --workspace ${root}`;
+        }
+        if (evidencePipeline.content.status === "invalid") {
+            return `Typed evidence content is invalid (${evidencePipeline.content.code ?? "unknown"}); repair exact decomposition/atom bindings before analysis.`;
+        }
+        if (evidencePipeline.content.gate?.decision === "stop") {
+            return "Typed evidence coverage is insufficient; complete lawful gap filling or request a scope/access handoff instead of starting inference.";
+        }
+        if (evidencePipeline.acquisition.gate?.decision === "stop") {
+            return "Frozen acquisition gaps block inference; request a scope/access handoff after all acquired content is decomposed instead of continuing substitute search.";
+        }
+        if (evidencePipeline.inference.status === "invalid") {
+            return `Inference snapshot is invalid (${evidencePipeline.inference.code ?? "unknown"}); repair its frozen upstream bindings before analysis.`;
+        }
+    }
     if (scientificReview.nextGate) {
         const gate = scientificReview.nextGate;
         if (gate.status === "stopped") {
@@ -1712,6 +1890,19 @@ async function readAbsolutePathArray(path, option = "supplements") {
     }
     return value;
 }
+async function readSubmissionFiles(path) {
+    const value = await readBoundedJsonRecord(path, "--submission", "RESEARCH_PUBLICATION_SUBMISSION_PACKAGE_INVALID");
+    if (value.schemaVersion !== 1 ||
+        !Array.isArray(value.files) ||
+        value.files.some((file) => !isObject(file) ||
+            typeof file.role !== "string" ||
+            typeof file.path !== "string" ||
+            !isAbsolute(file.path) ||
+            resolve(file.path) !== file.path)) {
+        throw new CliError("--submission must declare schemaVersion 1 and role/path entries with absolute canonical paths.", { code: "RESEARCH_PUBLICATION_SUBMISSION_PACKAGE_INVALID", exitCode: 2 });
+    }
+    return value.files;
+}
 function integerOption(value, fallback, label) {
     if (!value)
         return fallback;