@tiangong-ai/cli 0.0.57 → 0.0.58

package/AGENTS.md

@@ -17,8 +17,8 @@ checkPaths:
   - .docpact/config.yaml
   - docs/agents/**
   - src/**
-lastReviewedAt: 2026-09-01
-lastReviewedCommit: ca716c2fea59d0a8085aa32dbd8f65a686b3353e
+lastReviewedAt: 2026-09-02
+lastReviewedCommit: 8a18ba69f432d2c639517549157ef29545722cff
 ---
 
 # Tiangong AI CLI Contract

package/README.md

@@ -12,8 +12,8 @@ checkPaths:
   - package.json
   - bin/**
   - src/**
-lastReviewedAt: 2026-09-01
-lastReviewedCommit: ca716c2fea59d0a8085aa32dbd8f65a686b3353e
+lastReviewedAt: 2026-09-02
+lastReviewedCommit: 8a18ba69f432d2c639517549157ef29545722cff
 ---
 
 # Tiangong AI CLI
@@ -650,7 +650,33 @@ tiangong-ai research project scientific review submit top-journal-paper \
   --workspace /absolute/path/to/workspace --json
 ```
 
-Repeat the same prepare/submit route for `evidence-construct`, adding an
+For a prepared packet, use explicit isolated execution instead of writing a
+custom reviewer runner:
+
+```bash
+tiangong-ai research reviewer status --workspace /absolute/path/to/workspace --json
+tiangong-ai research project scientific review execute top-journal-paper \
+  --role research-design --confirm-review-cost \
+  --workspace /absolute/path/to/workspace --json
+```
+
+Confirm the bounded cost before execution. The command uses the configured
+`native-direct` or `sandbox-bridge` reviewer, copies exact hash-verified packet
+inputs and human Policy documents into its capsule, and submits only a
+schema-valid, packet/session-bound review. A saved successful execution is
+replayed without another model call after revalidating its immutable proof.
+Failures require explicit `--retry` and remain bounded by the attempt budget;
+unreported usage and interrupted wall time retain conservative reservations.
+A nonpassing mechanical packet can receive an independent stop verdict, never
+an override. The existing manual submit command remains available for an exact
+independent review.
+
+Reviewer status is read-only and transport-aware. Native-direct does not
+require a bridge connection. Smoke configuration readiness is explicitly not
+production readiness and does not demand an attestation that smoke mode never
+writes. Production still requires its current reviewer doctor attestation.
+
+Repeat the same prepare/execute route for `evidence-construct`, adding an
 owner-reviewed JSON array of absolute canonical canary paths with
 `--canary-artifacts /absolute/path/to/canary-paths.json`, and then for
 `pilot-methods` at its stage boundary. A top-journal fork or addendum is a
@@ -966,6 +992,25 @@ 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.
 
+Before submitting an acquisition audit, inspect its exact current eligibility:
+
+```bash
+tiangong-ai research project evidence content forecast PROJECT \
+  --input /absolute/path/acquisition-audit.json --workspace /absolute/workspace --json
+```
+
+This read-only check uses the freeze path's source projection and coverage
+rules, checks registered artifact bytes and provenance, and forecasts required
+roles from potentially assignable source dimensions. Exit `3` identifies known
+deficits; exit `0` means only potential eligibility, never successful atom
+registration, content freeze, independence certification, or review. Pending
+input materialization, decomposition, and exact atom assignments remain
+explicit. Re-run after material acquisition changes, not after every atom.
+Flat `sourceTypeRequirements` arrays mean **all-of**. A design may instead use
+`{"allOf":["academic-paper"],"anyOf":["government","industry"],"atLeast":{"count":2,"from":["academic-paper","government","industry"]}}`;
+every present group applies, and counts use distinct types. Forecast, typed
+content, and scientific review use the same source-type evaluator.
+
 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-
@@ -984,6 +1029,46 @@ closure remains unchanged, the child snapshot records a mechanical delta, and
 default status hides the superseded project (`research status --all` shows full
 lineage).
 
+For many content records, use `research project evidence decomposition batch
+<project-id> --record <absolute-json>` or `research project evidence atom batch
+<project-id> --record <absolute-json>`, with `--workspace` and `--json` as needed.
+The input is `{"schemaVersion":1,"records":[...]}`; each item has exactly the same
+schema and validation as the corresponding single-record command. A batch is
+bounded to 500 records and 4 MiB of input. The CLI verifies acquisition/artifact
+bindings once per batch, groups atoms by artifact to read and parse each referenced
+document once without retaining all files in memory, and commits one hash-bound
+immutable envelope through one ledger event. A bad item commits nothing; identical
+replay is idempotent and a changed ID is rejected. Uncommitted envelopes are never
+visible and a retry can safely complete their commit. `work` reports deterministic
+verification, read, and append counts; no persistent verification cache is trusted.
+
+Retrieve these CLI-owned input schemas with `research schema show evidence-atom`,
+`artifact-decomposition`, `evidence-atom-batch`, or `artifact-decomposition-batch`
+and `--json`. Help and command intake share the batch-limit constants. Schemas
+validate structure; execution still checks exact artifact/lineage bindings,
+locator semantics, stage, and sensitive content. A schema pass is not admission.
+
+Before a potentially large download, use the offline command
+`research project evidence artifact preflight --bytes <known-bytes> --workspace
+<path> --json`, or replace `--bytes` with `--path <exact-local-file>` for a stat-only
+check. `budget.maxBytesPerArtifact` bounds one acquired/downloaded file;
+`budget.maxBytesPerPackage` separately bounds aggregate generated stage outputs.
+Both are exposed in preflight, and native packets expose `maxArtifactBytes` beside
+`maxOutputBytes`. Their defaults remain 20 MiB in smoke mode and 512 MiB in
+production. A missing artifact field in an existing configuration retains its
+existing package limit in memory without rewriting the owner's file; an explicit
+invalid limit is rejected. Preflight exit 3 means stop and request a provider-side
+subset/filter or smaller official export preserving required variables/provenance.
+A size pass is not content acceptance: download binding, format, archive-expansion,
+SHA-256, and snapshot checks still apply. This is not a large-file streaming or
+external-reference bypass.
+
+Use acquisition `gaps` only for unresolved blocking evidence deficiencies;
+`limitations` holds non-blocking scope constraints and intentionally sealed
+outcomes. Future Policy obligations stay in the scientific design and appear
+in `futureGateObligations`, including ordinary planned rules without pending
+model/uncertainty objects. Their declared gate remains authoritative.
+
 Accepted local inputs are normalized into immutable input-backed artifacts while
 the acquire package is still active. JSON, CSV, Markdown, and plain-text inputs
 therefore have an atom-capable identity even when the producer omitted an
@@ -1001,6 +1086,12 @@ JSON/JSONL `projectId`, so historical blocked siblings do not alter its exit
 status. Omit `--project` and use `--max-parallel` only for an intentional
 workspace-wide run.
 
+Run/status share the same due scientific-gate decision: pending/prepared review,
+revision-required, and stopped are distinct from a runnable native stage.
+Future gates do not prevent earlier discovery or acquisition. Legitimate
+historical and user/external-wait project states remain doctor-readable;
+unknown states and broken evidence bindings still block readiness.
+
 Inputs are admitted by SHA-256. Native producer preparation creates an
 ephemeral, hash-bound packet directory but does not copy agent authentication
 or start an agent. The independent reviewer runs with a dedicated capsule HOME
@@ -1279,6 +1370,18 @@ pilot-methods reviews before analysis. `research status --all` marks any legacy
 fork directory without a `project.forked` commit marker as
 `authority.state = "invalid"` rather than authoritative.
 
+To repair completed acquisition before analysis, use
+`research project fork SOURCE --to TARGET --resume-through discover`. This
+preserves the original frozen audit, inherits verified discovery/receipts and
+exact acquired artifacts, and opens TARGET's acquire stage. Reuse the returned
+artifact IDs from the source acquisition audit, run
+`project evidence content forecast TARGET --input AUDIT`,
+then prepare/submit TARGET's acquire stage and rebuild typed content. There is
+no need to repeat paid searches or download unchanged files. Top-journal
+recovery additionally requires a Policy approved for TARGET and `--design`,
+`--design-producer-agent`, and `--design-producer-session`; new generation
+reviews cannot inherit the source generation's scientific approval.
+
 ## Research Search
 
 Forward research-oriented search requests to SCI, report, patent, and ESG edge

package/dist/research/orchestration.js

@@ -11,21 +11,24 @@ import { researchDataCredentialIds, setCapabilityCredentialValue, } from "./work
 import { configureExternalSkillProfile, doctorExternalCapabilities, EXTERNAL_SKILL_CONTEXT_PROFILE, EXTERNAL_SKILL_MEDIA_PROFILE, EXTERNAL_SKILL_PROFILE, importExternalCapability, inspectExternalSkillCatalog, } from "./workspace/external-skills.js";
 import { appendJournalEvent, readJournal } from "./workspace/journal.js";
 import { fetchNativeCandidateSource } from "./workspace/broker.js";
-import { registerEvidenceArtifact } from "./workspace/artifacts.js";
+import { preflightEvidenceArtifact, registerEvidenceArtifact } from "./workspace/artifacts.js";
 import { executeResearchDataCapability } from "./workspace/data-evidence-adapter.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 { inspectAcquisitionForecast } from "./workspace/acquisition-forecast.js";
+import { freezeEvidenceContentSnapshot, loadCurrentEvidenceContentSnapshot, recordArtifactDecomposition, registerEvidenceAtom, registerEvidenceContentBatch, } from "./workspace/content-evidence.js";
 import { inspectDiscoveryProgress } from "./workspace/discovery-status.js";
+import { EVIDENCE_CONTENT_LIMITS, EVIDENCE_CONTENT_SCHEMA_NAMES, evidenceContentInputSchema, isEvidenceContentSchemaName, } from "./workspace/evidence-content-schema.js";
 import { inspectEvidenceAccessStatus } from "./workspace/evidence-exhaustion.js";
 import { recordDiscoveryAssessmentBatch } from "./workspace/discovery.js";
 import { bindEvidenceDownload } from "./workspace/downloads.js";
 import { registerNativeDiscoveryCandidate } from "./workspace/evidence-ledger.js";
 import { recordNativeResearchActivity } from "./workspace/native-activity.js";
-import { inspectReviewerBridgeStatus, startReviewerBridgeSidecar, } from "./workspace/review-executor.js";
+import { inspectReviewerStatus, startReviewerBridgeSidecar } from "./workspace/review-executor.js";
 import { readAndVerifyProjectInputPlan } from "./workspace/input-plan.js";
+import { executeScientificReview } from "./workspace/scientific-review-execution.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 { addProjectInput, createProjectAddendum, initializeProject, forkProject, listProjects, loadProject, nextReadyPackage, normalizeEvidenceRequirements, refreshProject, retryProjectPackage, setProjectDisposition, scientificGateRecommendedAction, } from "./workspace/projects.js";
 import { evaluateProjectPreflight } from "./workspace/preflight.js";
 import { closePublication, freezePublicationManuscript, inspectPublicationStatus, preparePublicationReview, publicationAssessmentSchema, publicationReviewSchema, submitPublicationReview, } from "./workspace/publication-workflow.js";
 import { approveResearchPolicy, initializeResearchPolicy, inspectResearchPolicyCatalog, inspectResearchPolicyStatus, loadApprovedResearchPolicy, } from "./workspace/research-policy.js";
@@ -110,6 +113,7 @@ export function researchOrchestrationHelp() {
   tiangong-ai research project access status <project-id> [--workspace <path>] [--json]
   tiangong-ai research project scientific review prepare <project-id> --role research-design|evidence-construct|pilot-methods --assessment <absolute-json> [--canary-artifacts <absolute-json-array>] --reviewer-agent codex|claude --reviewer-session <opaque-id> [--workspace <path>] [--json]
   tiangong-ai research project scientific review submit <project-id> --role research-design|evidence-construct|pilot-methods --review <absolute-json> [--workspace <path>] [--json]
+  tiangong-ai research project scientific review execute <project-id> --role research-design|evidence-construct|pilot-methods --confirm-review-cost [--retry] [--workspace <path>] [--json]
   tiangong-ai research project scientific status <project-id> [--workspace <path>] [--json]
   tiangong-ai research project audit export <project-id> --output <absolute-new-directory> [--workspace <path>] [--json]
   tiangong-ai research project audit verify --bundle <absolute-directory> [--json]
@@ -124,13 +128,21 @@ export function researchOrchestrationHelp() {
   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 decomposition batch <project-id> --record <absolute-json> [--workspace <path>] [--json]
+  tiangong-ai research project evidence atom batch <project-id> --record <absolute-json> [--workspace <path>] [--json]
+  tiangong-ai research project evidence artifact preflight (--bytes <known-bytes> | --path <absolute-file>) [--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 forecast <project-id> --input <absolute-acquisition-audit.json> [--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]
 
+Evidence input schemas: ${EVIDENCE_CONTENT_SCHEMA_NAMES.join(", ")}.
+Evidence batches: at most ${EVIDENCE_CONTENT_LIMITS.maxBatchRecords} records and ${EVIDENCE_CONTENT_LIMITS.maxBatchInputBytes} bytes (${EVIDENCE_CONTENT_LIMITS.maxBatchInputBytes / (1024 * 1024)} MiB) of UTF-8 input.
+Use research schema show <name> --json; schemas validate shape only, not exact artifact/lineage/locator semantics.
+
 ${researchSetupHelp()}
 `;
 }
@@ -211,8 +223,9 @@ async function runReviewer(argv, io) {
         if (args.positionals.length)
             throw unknownAction("research reviewer status", args.positionals[0]);
         const root = await workspaceFromArgs(args);
-        writeJson(io, await inspectReviewerBridgeStatus(root), args);
-        return 0;
+        const result = await inspectReviewerStatus(root, io.env);
+        writeJson(io, result, args);
+        return isObject(result) && result.status === "ready" ? 0 : 3;
     }
     if (action === "doctor") {
         const args = parseStrictArgs(rest, { ...WORKSPACE_OPTIONS, "confirm-agent-smoke-cost": "boolean" }, "research reviewer doctor");
@@ -493,7 +506,10 @@ async function runSchema(argv, io) {
         return writeHelp(io);
     const stage = onePositional(args.positionals, "research schema show");
     let schema;
-    if (stage === "scientific-design") {
+    if (isEvidenceContentSchemaName(stage)) {
+        schema = evidenceContentInputSchema(stage);
+    }
+    else if (stage === "scientific-design") {
         schema = scientificDesignSchema();
     }
     else if (stage.startsWith("scientific-assessment-")) {
@@ -863,6 +879,28 @@ async function runProject(argv, io) {
             throw unknownAction("research project scientific", scientificAction ?? "");
         }
         const [reviewAction, ...reviewRest] = scientificRest;
+        if (reviewAction === "execute") {
+            const args = parseStrictArgs(reviewRest, {
+                ...WORKSPACE_OPTIONS,
+                role: "string",
+                "confirm-review-cost": "boolean",
+                retry: "boolean",
+            }, "research project scientific review execute");
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, "research project scientific review execute");
+            const root = await workspaceFromArgs(args);
+            const result = await executeScientificReview({
+                root,
+                projectId,
+                role: scientificReviewRole(strictString(args, "role")),
+                confirmCost: strictBoolean(args, "confirm-review-cost"),
+                retry: strictBoolean(args, "retry"),
+                environment: io.env,
+            });
+            writeJson(io, result, args);
+            return result.status === "passed" ? 0 : 3;
+        }
         if (reviewAction === "prepare") {
             const args = parseStrictArgs(reviewRest, {
                 ...WORKSPACE_OPTIONS,
@@ -1110,6 +1148,24 @@ async function runProject(argv, io) {
         }
         if (evidenceAction === "artifact") {
             const [artifactAction, ...artifactRest] = evidenceRest;
+            if (artifactAction === "preflight") {
+                const args = parseStrictArgs(artifactRest, { ...WORKSPACE_OPTIONS, bytes: "string", path: "string" }, "research project evidence artifact preflight");
+                if (strictBoolean(args, "help"))
+                    return writeHelp(io);
+                if (args.positionals.length)
+                    throw unknownAction("research project evidence artifact preflight", args.positionals[0]);
+                const bytes = strictString(args, "bytes");
+                const path = strictString(args, "path");
+                const result = await preflightEvidenceArtifact({
+                    root: await workspaceFromArgs(args),
+                    ...(bytes === undefined
+                        ? {}
+                        : { bytes: /^\d+$/u.test(bytes) ? Number(bytes) : Number.NaN }),
+                    ...(path === undefined ? {} : { path }),
+                });
+                writeJson(io, result, args);
+                return result.decision === "pass" ? 0 : 3;
+            }
             if (artifactAction !== "register") {
                 throw unknownAction("research project evidence artifact", artifactAction ?? "");
             }
@@ -1171,7 +1227,7 @@ async function runProject(argv, io) {
         }
         if (evidenceAction === "decomposition") {
             const [decompositionAction, ...decompositionRest] = evidenceRest;
-            if (decompositionAction !== "record") {
+            if (decompositionAction !== "record" && decompositionAction !== "batch") {
                 throw unknownAction("research project evidence decomposition", decompositionAction ?? "");
             }
             const args = parseStrictArgs(decompositionRest, { ...WORKSPACE_OPTIONS, record: "string" }, "research project evidence decomposition record");
@@ -1186,14 +1242,16 @@ async function runProject(argv, io) {
                 });
             }
             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 }));
+            const record = await readBoundedJsonRecord(recordPath, "--record", "RESEARCH_DECOMPOSITION_INVALID", decompositionAction === "batch" ? EVIDENCE_CONTENT_LIMITS.maxBatchInputBytes : undefined);
+            const result = await withWorkspaceLock(root, "research.decomposition.record", async () => decompositionAction === "batch"
+                ? registerEvidenceContentBatch({ root, projectId, kind: "decomposition", value: record })
+                : recordArtifactDecomposition({ root, projectId, value: record }));
             writeJson(io, result, args);
             return 0;
         }
         if (evidenceAction === "atom") {
             const [atomAction, ...atomRest] = evidenceRest;
-            if (atomAction !== "register") {
+            if (atomAction !== "register" && atomAction !== "batch") {
                 throw unknownAction("research project evidence atom", atomAction ?? "");
             }
             const args = parseStrictArgs(atomRest, { ...WORKSPACE_OPTIONS, record: "string" }, "research project evidence atom register");
@@ -1208,13 +1266,31 @@ async function runProject(argv, io) {
                 });
             }
             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 }));
+            const record = await readBoundedJsonRecord(recordPath, "--record", "RESEARCH_EVIDENCE_ATOM_INVALID", atomAction === "batch" ? EVIDENCE_CONTENT_LIMITS.maxBatchInputBytes : undefined);
+            const result = await withWorkspaceLock(root, "research.evidence-atom.register", async () => atomAction === "batch"
+                ? registerEvidenceContentBatch({ root, projectId, kind: "atom", value: record })
+                : registerEvidenceAtom({ root, projectId, value: record }));
             writeJson(io, result, args);
             return 0;
         }
         if (evidenceAction === "content") {
             const [contentAction, ...contentRest] = evidenceRest;
+            if (contentAction === "forecast") {
+                const args = parseStrictArgs(contentRest, { ...WORKSPACE_OPTIONS, input: "string" }, "research project evidence content forecast");
+                if (strictBoolean(args, "help"))
+                    return writeHelp(io);
+                const projectId = onePositional(args.positionals, "research project evidence content forecast");
+                const inputPath = strictString(args, "input");
+                if (!inputPath)
+                    throw new CliError("content forecast requires --input with a proposed acquisition audit.", { code: "RESEARCH_ACQUISITION_FORECAST_INVALID", exitCode: 2 });
+                const root = await workspaceFromArgs(args);
+                const value = await readBoundedJsonRecord(inputPath, "--input", "RESEARCH_ACQUISITION_FORECAST_INVALID");
+                const result = await inspectAcquisitionForecast(root, projectId, value);
+                writeJson(io, result, args);
+                return result.acquisitionGate.decision === "pass" && !result.knownRoleDeficits.length
+                    ? 0
+                    : 3;
+            }
             if (contentAction !== "freeze" && contentAction !== "status") {
                 throw unknownAction("research project evidence content", contentAction ?? "");
             }
@@ -1600,7 +1676,7 @@ async function runStatus(argv, io) {
                 readyPackage,
                 recommendedAction: authority.state === "invalid"
                     ? "This recovery target has no project.forked commit marker. Do not execute it; inspect and remove or repair the incomplete fork while retaining source authority."
-                    : projectRecommendedAction(root, current, readyPackage, nativeStage, scientificReview, evidencePipeline, publication),
+                    : projectRecommendedAction(root, current, readyPackage, nativeStage, evidencePipeline, publication),
                 usage: current.usage,
                 inputs: current.inputs,
                 packages: current.packages,
@@ -1774,7 +1850,7 @@ async function inspectPublicationForStatus(root, projectId) {
         };
     }
 }
-function projectRecommendedAction(root, project, readyPackage, nativeStage, scientificReview, evidencePipeline, publication) {
+function projectRecommendedAction(root, project, readyPackage, nativeStage, evidencePipeline, publication) {
     if (project.lineage.supersededBy) {
         return `Continue with superseding project ${project.lineage.supersededBy}.`;
     }
@@ -1815,15 +1891,9 @@ function projectRecommendedAction(root, project, readyPackage, nativeStage, scie
             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") {
-            return `Scientific ${gate.role} review stopped the project; inspect the frozen review and request user or external action instead of continuing.`;
-        }
-        const schema = `scientific-assessment-${gate.role}`;
-        const canaryOption = gate.role === "evidence-construct" ? " --canary-artifacts <absolute-json-array>" : "";
-        return `Use the native producer App to create a bounded ${gate.role} assessment from schema ${schema}, then prepare an independent review: tiangong-ai research project scientific review prepare ${project.id} --role ${gate.role} --assessment <absolute-json>${canaryOption} --reviewer-agent <codex|claude> --reviewer-session <fresh-opaque-id> --workspace ${root}`;
-    }
+    const scientificAction = scientificGateRecommendedAction(root, project);
+    if (scientificAction)
+        return scientificAction;
     if (project.status === "complete") {
         if (project.publicationPolicy) {
             if (publication && "code" in publication) {
@@ -1981,7 +2051,7 @@ function nativeHostAgent(value) {
 async function readNativeEvidenceRequest(path) {
     return readBoundedJsonRecord(path, "--request", "RESEARCH_BROKER_REQUEST_INVALID");
 }
-async function readBoundedJsonRecord(path, label, code) {
+async function readBoundedJsonRecord(path, label, code, maxBytes = 1024 * 1024) {
     if (!isAbsolute(path)) {
         throw new CliError(`${label} must be an absolute JSON file path.`, {
             code,
@@ -1990,7 +2060,7 @@ async function readBoundedJsonRecord(path, label, code) {
     }
     const selected = resolve(path);
     const info = await lstat(selected).catch(() => undefined);
-    if (!info?.isFile() || info.isSymbolicLink() || info.size > 1024 * 1024) {
+    if (!info?.isFile() || info.isSymbolicLink() || info.size > maxBytes) {
         throw new CliError(`${label} must be a bounded regular non-symlink JSON file.`, {
             code,
             exitCode: 2,