@tiangong-ai/cli 0.0.34 → 0.0.36

package/dist/research/orchestration.js

@@ -11,6 +11,7 @@ import { configureExternalSkillProfile, doctorExternalCapabilities, EXTERNAL_SKI
 import { appendJournalEvent } from "./workspace/journal.js";
 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 { inspectDiscoveryProgress } from "./workspace/discovery-status.js";
 import { recordDiscoveryAssessmentBatch } from "./workspace/discovery.js";
@@ -20,8 +21,13 @@ import { recordNativeResearchActivity } from "./workspace/native-activity.js";
 import { readAndVerifyProjectInputPlan } from "./workspace/input-plan.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";
+import { approveResearchPolicy, initializeResearchPolicy, inspectResearchPolicyCatalog, inspectResearchPolicyStatus, loadApprovedResearchPolicy, } from "./workspace/research-policy.js";
+import { resolveInstalledResearchPolicySource, runInteractiveResearchPolicyWizard, } from "./workspace/research-policy-wizard.js";
 import { abortNativeResearchStage, inspectNativeResearchStage, prepareNativeResearchStage, requestResearchHandoff, resolveResearchHandoff, runResearchWorkspace, submitNativeResearchStage, } from "./workspace/runtime.js";
 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 { doctorResearchWorkspace, initializeResearchWorkspace, requireResearchWorkspace, withWorkspaceLock, } from "./workspace/workspace.js";
 const COMMON_OPTIONS = { help: "boolean", json: "boolean" };
@@ -35,6 +41,10 @@ export async function runResearchOrchestrationCommand(subcommand, argv, io) {
         return runWorkspace(argv, io);
     if (subcommand === "capability")
         return runCapability(argv, io);
+    if (subcommand === "policy")
+        return runPolicy(argv, io);
+    if (subcommand === "publication")
+        return runPublication(argv, io);
     if (subcommand === "project")
         return runProject(argv, io);
     if (subcommand === "schema")
@@ -59,16 +69,33 @@ export function researchOrchestrationHelp() {
   tiangong-ai research capability credential set --id <logical-id> --from-env <name> [--workspace <absolute-path>] [--json]
   tiangong-ai research capability lock [--workspace <absolute-path>] [--json]
   tiangong-ai research capability verify [--workspace <absolute-path>] [--json]
-  tiangong-ai research project init <project-id> --question <question> [--requirements <absolute-json>] [--input-plan <absolute-json>] [--confirm-budget] [--workspace <path>] [--json]
-  tiangong-ai research project preflight --question <question> [--requirements <absolute-json>] [--input-plan <absolute-json>] [--workspace <path>] [--json]
-  tiangong-ai research project input add <project-id> --path <absolute-file> [--role primary|reference|replication] [--workspace <path>] [--json]
+  tiangong-ai research policy wizard <project-id> [--workspace <path>] [--json]
+  tiangong-ai research policy catalog [--source-root <absolute-installed-skill-root>] [--workspace <path>] [--json]
+  tiangong-ai research policy init <project-id> [--source-root <absolute-installed-skill-root>] --article-type <id> --field <id> --journal-class <id> [--include-exact-journal-template] [--workspace <path>] [--json]
+  tiangong-ai research policy status <project-id> [--workspace <path>] [--json]
+  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 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]
+  tiangong-ai research publication close <project-id> [--workspace <path>] [--json]
+  tiangong-ai research project init <project-id> --question <question> [--goal evidence-report|top-journal] [--design <absolute-json> --design-producer-agent codex|claude --design-producer-session <opaque-id>] [--requirements <absolute-json>] [--input-plan <absolute-json>] [--confirm-budget] [--workspace <path>] [--json]
+  tiangong-ai research project preflight --question <question> [--goal evidence-report|top-journal] [--policy-project <project-id> --design <absolute-json>] [--requirements <absolute-json>] [--input-plan <absolute-json>] [--workspace <path>] [--json]
+  tiangong-ai research project input add <project-id> --path <absolute-file> [--role primary|reference|replication] [--trust-status verified-owner-input|unverified-owner-input|reference-only|replication-candidate] [--independently-reproduced] [--workspace <path>] [--json]
   tiangong-ai research project retry <project-id> [--package <package-id>] [--workspace <path>] [--json]
-  tiangong-ai research project fork <source-project-id> --to <target-project-id> [--resume-through discover|acquire|analyze|synthesize] [--workspace <path>] [--json]
-  tiangong-ai research project addendum <closed-project-id> --to <target-project-id> [--workspace <path>] [--json]
+  tiangong-ai research project fork <source-project-id> --to <target-project-id> [--resume-through discover|acquire|analyze|synthesize] [--design <absolute-json> --design-producer-agent codex|claude --design-producer-session <opaque-id>] [--workspace <path>] [--json]
+  tiangong-ai research project addendum <closed-project-id> --to <target-project-id> [--design <absolute-json> --design-producer-agent codex|claude --design-producer-session <opaque-id>] [--workspace <path>] [--json]
   tiangong-ai research project archive <project-id> --reason <text> [--workspace <path>] [--json]
   tiangong-ai research project abandon <project-id> --reason <text> [--workspace <path>] [--json]
   tiangong-ai research project handoff request <project-id> --record <absolute-json> [--workspace <path>] [--json]
   tiangong-ai research project handoff resolve <project-id> --note <text> [--workspace <path>] [--json]
+  tiangong-ai research project scientific review prepare <project-id> --role research-design|evidence-construct|pilot-methods --assessment <absolute-json> --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 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]
   tiangong-ai research project stage prepare <project-id> --stage discover|acquire|analyze|synthesize --host-agent codex|claude [--workspace <path>] [--json]
   tiangong-ai research project stage submit <project-id> --session <id> --output <absolute-json> [--confirm-model <id>] [--workspace <path>] [--json]
   tiangong-ai research project stage abort <project-id> --session <id> [--workspace <path>] [--json]
@@ -78,37 +105,280 @@ 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 schema show <discover|acquire|analyze|synthesize|review|doctor> [--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]
 
 ${researchSetupHelp()}
 `;
 }
+async function runPublication(argv, io) {
+    const [action, ...rest] = argv;
+    if (!action || action === "--help" || action === "-h")
+        return writeHelp(io);
+    if (action === "freeze") {
+        const args = parseStrictArgs(rest, {
+            ...WORKSPACE_OPTIONS,
+            manuscript: "string",
+            assessment: "string",
+            supplements: "string",
+            "producer-agent": "string",
+            "producer-session": "string",
+        }, "research publication freeze");
+        if (strictBoolean(args, "help"))
+            return writeHelp(io);
+        const projectId = onePositional(args.positionals, "research publication freeze");
+        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 root = await workspaceFromArgs(args);
+        const supplementsPath = strictString(args, "supplements");
+        writeJson(io, await freezePublicationManuscript({
+            root,
+            projectId,
+            manuscriptPath,
+            assessmentPath,
+            supplementPaths: supplementsPath ? await readAbsolutePathArray(supplementsPath) : [],
+            producerAgent: publicationAgent(strictString(args, "producer-agent"), "producer"),
+            producerSessionId,
+        }), args);
+        return 0;
+    }
+    if (action === "review") {
+        const [reviewAction, ...reviewRest] = rest;
+        if (reviewAction === "--help" || reviewAction === "-h")
+            return writeHelp(io);
+        if (reviewAction === "prepare") {
+            const args = parseStrictArgs(reviewRest, {
+                ...WORKSPACE_OPTIONS,
+                role: "string",
+                "reviewer-agent": "string",
+                "reviewer-session": "string",
+            }, "research publication review prepare");
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, "research publication review prepare");
+            const reviewerSessionId = strictString(args, "reviewer-session");
+            if (!reviewerSessionId) {
+                throw new CliError("publication review prepare requires --reviewer-session.", {
+                    code: "RESEARCH_PUBLICATION_ARGUMENT_REQUIRED",
+                    exitCode: 2,
+                });
+            }
+            const root = await workspaceFromArgs(args);
+            writeJson(io, await preparePublicationReview({
+                root,
+                projectId,
+                role: publicationReviewRole(strictString(args, "role")),
+                reviewerAgent: publicationAgent(strictString(args, "reviewer-agent"), "reviewer"),
+                reviewerSessionId,
+            }), args);
+            return 0;
+        }
+        if (reviewAction === "submit") {
+            const args = parseStrictArgs(reviewRest, { ...WORKSPACE_OPTIONS, role: "string", review: "string" }, "research publication review submit");
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, "research publication review submit");
+            const reviewPath = strictString(args, "review");
+            if (!reviewPath) {
+                throw new CliError("publication review submit requires --review.", {
+                    code: "RESEARCH_PUBLICATION_ARGUMENT_REQUIRED",
+                    exitCode: 2,
+                });
+            }
+            const root = await workspaceFromArgs(args);
+            writeJson(io, await submitPublicationReview({
+                root,
+                projectId,
+                role: publicationReviewRole(strictString(args, "role")),
+                reviewPath,
+            }), args);
+            return 0;
+        }
+        throw unknownAction("research publication review", reviewAction ?? "missing");
+    }
+    if (action === "status" || action === "close") {
+        const args = parseStrictArgs(rest, WORKSPACE_OPTIONS, `research publication ${action}`);
+        if (strictBoolean(args, "help"))
+            return writeHelp(io);
+        const projectId = onePositional(args.positionals, `research publication ${action}`);
+        const root = await workspaceFromArgs(args);
+        writeJson(io, action === "status"
+            ? await inspectPublicationStatus(root, projectId)
+            : await closePublication(root, projectId), args);
+        return 0;
+    }
+    throw unknownAction("research publication", action);
+}
+async function runPolicy(argv, io) {
+    const [action, ...rest] = argv;
+    if (!action || action === "--help" || action === "-h")
+        return writeHelp(io);
+    if (action === "wizard") {
+        const args = parseStrictArgs(rest, WORKSPACE_OPTIONS, "research policy wizard");
+        if (strictBoolean(args, "help"))
+            return writeHelp(io);
+        const projectId = onePositional(args.positionals, "research policy wizard");
+        const root = await workspaceFromArgs(args);
+        return runInteractiveResearchPolicyWizard({
+            root,
+            projectId,
+            io,
+            json: strictBoolean(args, "json"),
+        });
+    }
+    if (action === "catalog") {
+        const args = parseStrictArgs(rest, { ...WORKSPACE_OPTIONS, "source-root": "string" }, "research policy catalog");
+        if (strictBoolean(args, "help"))
+            return writeHelp(io);
+        rejectPositionals(args.positionals, "research policy catalog");
+        const explicitSourceRoot = strictString(args, "source-root");
+        const sourceRoot = explicitSourceRoot ??
+            (await resolveInstalledResearchPolicySource(await workspaceFromArgs(args), io.env));
+        writeJson(io, await inspectResearchPolicyCatalog(sourceRoot), args);
+        return 0;
+    }
+    if (action === "init") {
+        const args = parseStrictArgs(rest, {
+            ...WORKSPACE_OPTIONS,
+            "source-root": "string",
+            "article-type": "string",
+            field: "string",
+            "journal-class": "string",
+            "include-exact-journal-template": "boolean",
+        }, "research policy init");
+        if (strictBoolean(args, "help"))
+            return writeHelp(io);
+        const projectId = onePositional(args.positionals, "research policy init");
+        const articleType = strictString(args, "article-type");
+        const field = strictString(args, "field");
+        const journalClass = strictString(args, "journal-class");
+        if (!articleType || !field || !journalClass) {
+            throw new CliError("research policy init requires --article-type, --field, and --journal-class.", { code: "RESEARCH_POLICY_INVALID", exitCode: 2 });
+        }
+        const root = await workspaceFromArgs(args);
+        const sourceRoot = strictString(args, "source-root") ??
+            (await resolveInstalledResearchPolicySource(root, io.env));
+        writeJson(io, await initializeResearchPolicy({
+            root,
+            projectId,
+            sourceRoot,
+            articleType,
+            field,
+            journalClass,
+            includeExactJournalTemplate: strictBoolean(args, "include-exact-journal-template"),
+        }), args);
+        return 0;
+    }
+    if (["status", "validate", "approve", "resolve"].includes(action)) {
+        const args = parseStrictArgs(rest, {
+            ...WORKSPACE_OPTIONS,
+            confirm: "boolean",
+            "acknowledge-defaults": "boolean",
+        }, `research policy ${action}`);
+        if (strictBoolean(args, "help"))
+            return writeHelp(io);
+        const projectId = onePositional(args.positionals, `research policy ${action}`);
+        const root = await workspaceFromArgs(args);
+        if (action === "approve") {
+            const result = await approveResearchPolicy(root, projectId, {
+                confirm: strictBoolean(args, "confirm"),
+                acknowledgeDefaults: strictBoolean(args, "acknowledge-defaults"),
+            });
+            writeJson(io, result, args);
+            return 0;
+        }
+        if (action === "resolve") {
+            writeJson(io, await loadApprovedResearchPolicy(root, projectId), args);
+            return 0;
+        }
+        const result = await inspectResearchPolicyStatus(root, projectId);
+        writeJson(io, result, args);
+        return action === "validate" &&
+            ["missing", "invalid", "changed", "stale"].includes(result.status)
+            ? 3
+            : 0;
+    }
+    throw unknownAction("research policy", action);
+}
 async function runSchema(argv, io) {
     const [action, ...rest] = argv;
     if (!action || action === "--help" || action === "-h")
         return writeHelp(io);
     if (action !== "show")
         throw unknownAction("research schema", action);
-    const args = parseStrictArgs(rest, COMMON_OPTIONS, "research schema show");
+    const args = parseStrictArgs(rest, { ...COMMON_OPTIONS, compatibility: "string" }, "research schema show");
     if (strictBoolean(args, "help"))
         return writeHelp(io);
     const stage = onePositional(args.positionals, "research schema show");
-    if (stage !== "discover" &&
-        stage !== "acquire" &&
-        stage !== "analyze" &&
-        stage !== "synthesize" &&
-        stage !== "review" &&
-        stage !== "doctor") {
+    let schema;
+    if (stage === "scientific-design") {
+        schema = scientificDesignSchema();
+    }
+    else if (stage.startsWith("scientific-assessment-")) {
+        const role = scientificReviewRole(stage.slice("scientific-assessment-".length));
+        schema = scientificGateAssessmentSchema(role);
+    }
+    else if (stage.startsWith("scientific-review-")) {
+        const role = scientificReviewRole(stage.slice("scientific-review-".length));
+        schema = scientificReviewSchema(role);
+    }
+    else if (stage === "publication-assessment") {
+        schema = publicationAssessmentSchema();
+    }
+    else if (stage.startsWith("publication-review-")) {
+        const role = publicationReviewRole(stage.slice("publication-review-".length));
+        schema = publicationReviewSchema(role);
+    }
+    else if (stage === "discover" ||
+        stage === "acquire" ||
+        stage === "analyze" ||
+        stage === "synthesize" ||
+        stage === "review" ||
+        stage === "doctor") {
+        schema = schemaForStage(stage);
+    }
+    else {
         throw new CliError(`Unsupported research schema stage: ${stage}`, {
             code: "RESEARCH_SCHEMA_INVALID",
             exitCode: 2,
         });
     }
-    writeJson(io, schemaForStage(stage), args);
+    writeJson(io, compatibleSchema(schema, strictString(args, "compatibility")), args);
     return 0;
 }
+function compatibleSchema(schema, compatibility) {
+    if (!compatibility)
+        return schema;
+    if (compatibility !== "claude-code") {
+        throw new CliError(`Unsupported schema compatibility target: ${compatibility}`, {
+            code: "RESEARCH_SCHEMA_COMPATIBILITY_INVALID",
+            exitCode: 2,
+            details: { supported: ["claude-code"] },
+        });
+    }
+    const compatible = structuredClone(schema);
+    const stripMetadata = (value) => {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                stripMetadata(item);
+            return;
+        }
+        if (!value || typeof value !== "object")
+            return;
+        const record = value;
+        delete record.$schema;
+        delete record.$id;
+        for (const item of Object.values(record))
+            stripMetadata(item);
+    };
+    stripMetadata(compatible);
+    return compatible;
+}
 async function runContext(argv, io) {
     const [action, ...rest] = argv;
     if (!action || action === "--help" || action === "-h")
@@ -299,6 +569,41 @@ async function runProject(argv, io) {
     const [action, ...rest] = argv;
     if (!action || action === "--help" || action === "-h")
         return writeHelp(io);
+    if (action === "audit") {
+        const [auditAction, ...auditRest] = rest;
+        if (auditAction === "export") {
+            const args = parseStrictArgs(auditRest, { ...WORKSPACE_OPTIONS, output: "string" }, "research project audit export");
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, "research project audit export");
+            const destination = strictString(args, "output");
+            if (!destination) {
+                throw new CliError("Audit export requires --output.", {
+                    code: "RESEARCH_AUDIT_BUNDLE_PATH_INVALID",
+                    exitCode: 2,
+                });
+            }
+            const root = await workspaceFromArgs(args);
+            writeJson(io, await exportProjectAuditBundle({ root, projectId, destination }), args);
+            return 0;
+        }
+        if (auditAction === "verify") {
+            const args = parseStrictArgs(auditRest, { ...COMMON_OPTIONS, bundle: "string" }, "research project audit verify");
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            rejectPositionals(args.positionals, "research project audit verify");
+            const bundlePath = strictString(args, "bundle");
+            if (!bundlePath) {
+                throw new CliError("Audit verification requires --bundle.", {
+                    code: "RESEARCH_AUDIT_BUNDLE_PATH_INVALID",
+                    exitCode: 2,
+                });
+            }
+            writeJson(io, await verifyProjectAuditBundle(bundlePath), args);
+            return 0;
+        }
+        throw unknownAction("research project audit", auditAction ?? "");
+    }
     if (action === "handoff") {
         const [handoffAction, ...handoffRest] = rest;
         if (handoffAction === "request") {
@@ -338,6 +643,71 @@ async function runProject(argv, io) {
         }
         throw unknownAction("research project handoff", handoffAction ?? "");
     }
+    if (action === "scientific") {
+        const [scientificAction, ...scientificRest] = rest;
+        if (scientificAction === "status") {
+            const args = parseStrictArgs(scientificRest, WORKSPACE_OPTIONS, "research project scientific status");
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, "research project scientific status");
+            const root = await workspaceFromArgs(args);
+            writeJson(io, await inspectScientificReviewStatus(root, projectId), args);
+            return 0;
+        }
+        if (scientificAction !== "review") {
+            throw unknownAction("research project scientific", scientificAction ?? "");
+        }
+        const [reviewAction, ...reviewRest] = scientificRest;
+        if (reviewAction === "prepare") {
+            const args = parseStrictArgs(reviewRest, {
+                ...WORKSPACE_OPTIONS,
+                role: "string",
+                assessment: "string",
+                "reviewer-agent": "string",
+                "reviewer-session": "string",
+            }, "research project scientific review prepare");
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, "research project scientific review prepare");
+            const assessmentPath = strictString(args, "assessment");
+            const reviewerSessionId = strictString(args, "reviewer-session");
+            if (!assessmentPath || !reviewerSessionId) {
+                throw new CliError("Scientific review prepare requires --assessment, --reviewer-agent, and --reviewer-session.", { code: "RESEARCH_SCIENTIFIC_REVIEW_ARGUMENT_REQUIRED", exitCode: 2 });
+            }
+            const root = await workspaceFromArgs(args);
+            writeJson(io, await prepareScientificReview({
+                root,
+                projectId,
+                role: scientificReviewRole(strictString(args, "role")),
+                assessmentPath,
+                reviewerAgent: publicationAgent(strictString(args, "reviewer-agent"), "reviewer"),
+                reviewerSessionId,
+            }), args);
+            return 0;
+        }
+        if (reviewAction === "submit") {
+            const args = parseStrictArgs(reviewRest, { ...WORKSPACE_OPTIONS, role: "string", review: "string" }, "research project scientific review submit");
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, "research project scientific review submit");
+            const reviewPath = strictString(args, "review");
+            if (!reviewPath) {
+                throw new CliError("Scientific review submit requires --review.", {
+                    code: "RESEARCH_SCIENTIFIC_REVIEW_ARGUMENT_REQUIRED",
+                    exitCode: 2,
+                });
+            }
+            const root = await workspaceFromArgs(args);
+            writeJson(io, await submitScientificReview({
+                root,
+                projectId,
+                role: scientificReviewRole(strictString(args, "role")),
+                reviewPath,
+            }), args);
+            return 0;
+        }
+        throw unknownAction("research project scientific review", reviewAction ?? "");
+    }
     if (action === "stage") {
         const [stageAction, ...stageRest] = rest;
         if (stageAction === "prepare") {
@@ -576,8 +946,12 @@ async function runProject(argv, io) {
         const args = parseStrictArgs(rest, {
             ...WORKSPACE_OPTIONS,
             question: "string",
+            goal: "string",
             requirements: "string",
             "input-plan": "string",
+            design: "string",
+            "design-producer-agent": "string",
+            "design-producer-session": "string",
             "confirm-budget": "boolean",
         }, "research project init");
         if (strictBoolean(args, "help"))
@@ -591,9 +965,29 @@ async function runProject(argv, io) {
             });
         }
         const root = await workspaceFromArgs(args);
+        const goal = researchGoal(strictString(args, "goal"));
         const requirementsPath = strictString(args, "requirements");
         const inputPlanPath = strictString(args, "input-plan");
-        const project = await initializeProject(root, projectId, question, requirementsPath ? await readEvidenceRequirements(requirementsPath) : undefined, strictBoolean(args, "confirm-budget"), inputPlanPath ? await readAndVerifyProjectInputPlan(inputPlanPath) : undefined);
+        const publicationPolicy = goal === "top-journal" ? await loadApprovedResearchPolicy(root, projectId) : undefined;
+        const designPath = strictString(args, "design");
+        const designProducerAgent = strictString(args, "design-producer-agent");
+        const designProducerSession = strictString(args, "design-producer-session");
+        if (goal === "top-journal" && (!designPath || !designProducerAgent || !designProducerSession)) {
+            throw new CliError("Top-journal init requires --design, --design-producer-agent, and --design-producer-session.", { code: "RESEARCH_SCIENTIFIC_DESIGN_REQUIRED", exitCode: 2 });
+        }
+        if (goal !== "top-journal" && (designPath || designProducerAgent || designProducerSession)) {
+            throw new CliError("Scientific design options are only valid with --goal top-journal.", {
+                code: "RESEARCH_SCIENTIFIC_DESIGN_POLICY_REQUIRED",
+                exitCode: 2,
+            });
+        }
+        const project = await initializeProject(root, projectId, question, requirementsPath ? await readEvidenceRequirements(requirementsPath) : undefined, strictBoolean(args, "confirm-budget"), inputPlanPath ? await readAndVerifyProjectInputPlan(inputPlanPath) : undefined, publicationPolicy, designPath && designProducerAgent && designProducerSession
+            ? {
+                design: await readAndVerifyScientificDesign(designPath, projectId),
+                producerAgent: publicationAgent(designProducerAgent, "design producer"),
+                producerSessionId: designProducerSession,
+            }
+            : undefined);
         writeJson(io, project, args);
         return 0;
     }
@@ -601,8 +995,11 @@ async function runProject(argv, io) {
         const args = parseStrictArgs(rest, {
             ...WORKSPACE_OPTIONS,
             question: "string",
+            goal: "string",
+            "policy-project": "string",
             requirements: "string",
             "input-plan": "string",
+            design: "string",
         }, "research project preflight");
         if (strictBoolean(args, "help"))
             return writeHelp(io);
@@ -615,11 +1012,48 @@ async function runProject(argv, io) {
             });
         }
         const root = await workspaceFromArgs(args);
+        const goal = researchGoal(strictString(args, "goal"));
+        const policyProject = strictString(args, "policy-project");
+        let publicationPolicy = null;
+        if (goal === "top-journal") {
+            if (!policyProject) {
+                throw new CliError("Top-journal preflight requires --policy-project.", {
+                    code: "RESEARCH_POLICY_REQUIRED",
+                    exitCode: 2,
+                });
+            }
+            publicationPolicy = await loadApprovedResearchPolicy(root, policyProject);
+        }
+        else if (policyProject) {
+            throw new CliError("--policy-project is only valid with --goal top-journal.", {
+                code: "RESEARCH_POLICY_INVALID",
+                exitCode: 2,
+            });
+        }
         const requirementsPath = strictString(args, "requirements");
         const requirements = requirementsPath ? await readEvidenceRequirements(requirementsPath) : null;
         const inputPlanPath = strictString(args, "input-plan");
         const inputPlan = inputPlanPath ? await readAndVerifyProjectInputPlan(inputPlanPath) : null;
-        const result = await evaluateProjectPreflight(root, question, requirements, inputPlan);
+        const designPath = strictString(args, "design");
+        if (goal === "top-journal" && !designPath) {
+            throw new CliError("Top-journal preflight requires --design.", {
+                code: "RESEARCH_SCIENTIFIC_DESIGN_REQUIRED",
+                exitCode: 2,
+            });
+        }
+        if (goal !== "top-journal" && designPath) {
+            throw new CliError("--design is only valid with --goal top-journal.", {
+                code: "RESEARCH_SCIENTIFIC_DESIGN_POLICY_REQUIRED",
+                exitCode: 2,
+            });
+        }
+        const scientificDesign = designPath
+            ? await readAndVerifyScientificDesign(designPath, policyProject)
+            : null;
+        const result = await evaluateProjectPreflight(root, question, requirements, inputPlan, {
+            publicationPolicy,
+            scientificDesign,
+        });
         writeJson(io, result, args);
         return result.readyToInitialize ? 0 : 3;
     }
@@ -629,7 +1063,13 @@ async function runProject(argv, io) {
             return writeHelp(io);
         if (inputAction !== "add")
             throw unknownAction("research project input", inputAction ?? "");
-        const args = parseStrictArgs(inputRest, { ...WORKSPACE_OPTIONS, path: "string", role: "string" }, "research project input add");
+        const args = parseStrictArgs(inputRest, {
+            ...WORKSPACE_OPTIONS,
+            path: "string",
+            role: "string",
+            "trust-status": "string",
+            "independently-reproduced": "boolean",
+        }, "research project input add");
         if (strictBoolean(args, "help"))
             return writeHelp(io);
         const projectId = onePositional(args.positionals, "research project input add");
@@ -642,7 +1082,11 @@ async function runProject(argv, io) {
         }
         const role = inputRole(strictString(args, "role"));
         const root = await workspaceFromArgs(args);
-        const input = await addProjectInput(root, projectId, inputPath, role);
+        const trustStatus = projectInputTrustStatus(strictString(args, "trust-status"), role);
+        const input = await addProjectInput(root, projectId, inputPath, role, {
+            ...(trustStatus ? { trustStatus } : {}),
+            independentlyReproduced: strictBoolean(args, "independently-reproduced"),
+        });
         writeJson(io, input, args);
         return 0;
     }
@@ -657,7 +1101,14 @@ async function runProject(argv, io) {
         return 0;
     }
     if (action === "fork") {
-        const args = parseStrictArgs(rest, { ...WORKSPACE_OPTIONS, to: "string", "resume-through": "string" }, "research project fork");
+        const args = parseStrictArgs(rest, {
+            ...WORKSPACE_OPTIONS,
+            to: "string",
+            "resume-through": "string",
+            design: "string",
+            "design-producer-agent": "string",
+            "design-producer-session": "string",
+        }, "research project fork");
         if (strictBoolean(args, "help"))
             return writeHelp(io);
         const sourceProjectId = onePositional(args.positionals, "research project fork");
@@ -669,12 +1120,41 @@ async function runProject(argv, io) {
             });
         }
         const root = await workspaceFromArgs(args);
-        const project = await forkProject(root, sourceProjectId, targetProjectId, resumeStage(strictString(args, "resume-through")));
+        const source = await loadProject(root, sourceProjectId);
+        const designPath = strictString(args, "design");
+        const designProducerAgent = strictString(args, "design-producer-agent");
+        const designProducerSession = strictString(args, "design-producer-session");
+        if (source.publicationPolicy &&
+            (!designPath || !designProducerAgent || !designProducerSession)) {
+            throw new CliError("A top-journal fork requires a target-specific approved policy plus --design, --design-producer-agent, and --design-producer-session.", { code: "RESEARCH_SCIENTIFIC_DESIGN_REAPPROVAL_REQUIRED", exitCode: 3 });
+        }
+        if (!source.publicationPolicy && (designPath || designProducerAgent || designProducerSession)) {
+            throw new CliError("Scientific reapproval options require a top-journal source project.", {
+                code: "RESEARCH_SCIENTIFIC_DESIGN_REAPPROVAL_INVALID",
+                exitCode: 2,
+            });
+        }
+        const project = await forkProject(root, sourceProjectId, targetProjectId, resumeStage(strictString(args, "resume-through")), designPath && designProducerAgent && designProducerSession
+            ? {
+                publicationPolicy: await loadApprovedResearchPolicy(root, targetProjectId),
+                scientificDesign: {
+                    design: await readAndVerifyScientificDesign(designPath, targetProjectId),
+                    producerAgent: publicationAgent(designProducerAgent, "design producer"),
+                    producerSessionId: designProducerSession,
+                },
+            }
+            : undefined);
         writeJson(io, project, args);
         return 0;
     }
     if (action === "addendum") {
-        const args = parseStrictArgs(rest, { ...WORKSPACE_OPTIONS, to: "string" }, "research project addendum");
+        const args = parseStrictArgs(rest, {
+            ...WORKSPACE_OPTIONS,
+            to: "string",
+            design: "string",
+            "design-producer-agent": "string",
+            "design-producer-session": "string",
+        }, "research project addendum");
         if (strictBoolean(args, "help"))
             return writeHelp(io);
         const sourceProjectId = onePositional(args.positionals, "research project addendum");
@@ -686,7 +1166,30 @@ async function runProject(argv, io) {
             });
         }
         const root = await workspaceFromArgs(args);
-        const project = await createProjectAddendum(root, sourceProjectId, targetProjectId);
+        const source = await loadProject(root, sourceProjectId);
+        const designPath = strictString(args, "design");
+        const designProducerAgent = strictString(args, "design-producer-agent");
+        const designProducerSession = strictString(args, "design-producer-session");
+        if (source.publicationPolicy &&
+            (!designPath || !designProducerAgent || !designProducerSession)) {
+            throw new CliError("A top-journal addendum requires a target-specific approved policy plus --design, --design-producer-agent, and --design-producer-session.", { code: "RESEARCH_SCIENTIFIC_DESIGN_REAPPROVAL_REQUIRED", exitCode: 3 });
+        }
+        if (!source.publicationPolicy && (designPath || designProducerAgent || designProducerSession)) {
+            throw new CliError("Scientific reapproval options require a top-journal source project.", {
+                code: "RESEARCH_SCIENTIFIC_DESIGN_REAPPROVAL_INVALID",
+                exitCode: 2,
+            });
+        }
+        const project = await createProjectAddendum(root, sourceProjectId, targetProjectId, designPath && designProducerAgent && designProducerSession
+            ? {
+                publicationPolicy: await loadApprovedResearchPolicy(root, targetProjectId),
+                scientificDesign: {
+                    design: await readAndVerifyScientificDesign(designPath, targetProjectId),
+                    producerAgent: publicationAgent(designProducerAgent, "design producer"),
+                    producerSessionId: designProducerSession,
+                },
+            }
+            : undefined);
         writeJson(io, project, args);
         return 0;
     }
@@ -744,6 +1247,10 @@ async function runStatus(argv, io) {
             const nativeStage = await inspectNativeResearchStage(root, current);
             const snapshot = await inspectSnapshotForStatus(root, current.id);
             const readyPackage = nextReadyPackage(current)?.id ?? null;
+            const scientificReview = await inspectScientificReviewStatus(root, current.id);
+            const publication = current.publicationPolicy
+                ? await inspectPublicationForStatus(root, current.id)
+                : null;
             return {
                 id: current.id,
                 question: current.question,
@@ -754,8 +1261,10 @@ async function runStatus(argv, io) {
                 evidenceState: current.evidenceState,
                 snapshot,
                 nativeStage,
+                scientificReview,
+                publication,
                 readyPackage,
-                recommendedAction: projectRecommendedAction(root, current, readyPackage, nativeStage),
+                recommendedAction: projectRecommendedAction(root, current, readyPackage, nativeStage, scientificReview, publication),
                 usage: current.usage,
                 inputs: current.inputs,
                 packages: current.packages,
@@ -812,7 +1321,18 @@ async function inspectSnapshotForStatus(root, projectId) {
         };
     }
 }
-function projectRecommendedAction(root, project, readyPackage, nativeStage) {
+async function inspectPublicationForStatus(root, projectId) {
+    try {
+        return await inspectPublicationStatus(root, projectId);
+    }
+    catch (error) {
+        return {
+            generationStatus: "invalid",
+            code: error instanceof CliError ? error.code : "RESEARCH_PUBLICATION_STATE_INVALID",
+        };
+    }
+}
+function projectRecommendedAction(root, project, readyPackage, nativeStage, scientificReview, publication) {
     if (project.lineage.supersededBy) {
         return `Continue with superseding project ${project.lineage.supersededBy}.`;
     }
@@ -831,7 +1351,30 @@ function projectRecommendedAction(root, project, readyPackage, nativeStage) {
     if (nativeStage.status === "active") {
         return nativeStage.recommendedAction ?? "Resume the active native stage.";
     }
+    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}`;
+        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> --reviewer-agent <codex|claude> --reviewer-session <fresh-opaque-id> --workspace ${root}`;
+    }
     if (project.status === "complete") {
+        if (project.publicationPolicy) {
+            if (publication && "code" in publication) {
+                return `Publication state is invalid (${publication.code}); inspect Research Policy and frozen object bindings before continuing.`;
+            }
+            if (!publication || publication.generationStatus === "not-started") {
+                return `Freeze the final manuscript and publication assessment, then inspect publication status: tiangong-ai research publication freeze ${project.id} --help`;
+            }
+            if (publication.closureSha256) {
+                return `Publication closure is complete at ${publication.readinessVerdict}; inspect the immutable closure before post-closure authoring.`;
+            }
+            if (publication.reviewState !== "complete") {
+                return `Complete fresh independent publication reviews for ${publication.missingReviewRoles.join(", ")}; inspect: tiangong-ai research publication status ${project.id} --workspace ${root}`;
+            }
+            return `Mechanically close the reviewed frozen manuscript: tiangong-ai research publication close ${project.id} --workspace ${root}`;
+        }
         return `Create an immutable evidence addendum only when new evidence exists: tiangong-ai research project addendum ${project.id} --to <new-project-id> --workspace ${root}`;
     }
     if (project.status === "blocked") {
@@ -933,6 +1476,16 @@ function researchMode(value) {
         exitCode: 2,
     });
 }
+function researchGoal(value) {
+    if (!value || value === "evidence-report")
+        return "evidence-report";
+    if (value === "top-journal")
+        return value;
+    throw new CliError(`Unsupported research goal: ${value}`, {
+        code: "RESEARCH_GOAL_INVALID",
+        exitCode: 2,
+    });
+}
 function resumeStage(value) {
     if (!value)
         return undefined;
@@ -1034,6 +1587,80 @@ function inputRole(value) {
         exitCode: 2,
     });
 }
+function projectInputTrustStatus(value, role) {
+    if (!value)
+        return undefined;
+    if (value === "verified-owner-input" ||
+        value === "unverified-owner-input" ||
+        value === "reference-only" ||
+        value === "replication-candidate") {
+        return value;
+    }
+    throw new CliError(`Unsupported trust status for ${role} input: ${value}`, {
+        code: "RESEARCH_INPUT_TRUST_INVALID",
+        exitCode: 2,
+    });
+}
+function publicationReviewRole(value) {
+    if (value === "evidence" ||
+        value === "methods-reproducibility" ||
+        value === "domain-novelty" ||
+        value === "journal-editor") {
+        return value;
+    }
+    throw new CliError("--role must be evidence, methods-reproducibility, domain-novelty, or journal-editor.", { code: "RESEARCH_PUBLICATION_REVIEW_ROLE_INVALID", exitCode: 2 });
+}
+function scientificReviewRole(value) {
+    if (value === "research-design" || value === "evidence-construct" || value === "pilot-methods") {
+        return value;
+    }
+    throw new CliError("--role must be research-design, evidence-construct, or pilot-methods.", {
+        code: "RESEARCH_SCIENTIFIC_REVIEW_ROLE_INVALID",
+        exitCode: 2,
+    });
+}
+function publicationAgent(value, label) {
+    if (value === "codex" || value === "claude")
+        return value;
+    throw new CliError(`--${label}-agent must be codex or claude.`, {
+        code: "RESEARCH_PUBLICATION_AGENT_INVALID",
+        exitCode: 2,
+    });
+}
+async function readAbsolutePathArray(path) {
+    if (!isAbsolute(path)) {
+        throw new CliError("--supplements must be an absolute JSON file path.", {
+            code: "RESEARCH_PUBLICATION_FILE_INVALID",
+            exitCode: 2,
+        });
+    }
+    const selected = resolve(path);
+    const info = await lstat(selected).catch(() => undefined);
+    if (!info?.isFile() || info.isSymbolicLink() || info.size > 1024 * 1024) {
+        throw new CliError("--supplements must be a bounded regular non-symlink JSON file.", {
+            code: "RESEARCH_PUBLICATION_FILE_INVALID",
+            exitCode: 2,
+        });
+    }
+    let value;
+    try {
+        value = JSON.parse(await readFile(selected, "utf8"));
+    }
+    catch {
+        throw new CliError("--supplements contains invalid JSON.", {
+            code: "RESEARCH_PUBLICATION_FILE_INVALID",
+            exitCode: 2,
+        });
+    }
+    if (!Array.isArray(value) ||
+        value.some((item) => typeof item !== "string" || !isAbsolute(item) || resolve(item) !== item)) {
+        throw new CliError("--supplements must contain an array of absolute canonical paths.", {
+            code: "RESEARCH_PUBLICATION_FILE_INVALID",
+            exitCode: 2,
+        });
+    }
+    return value;
+}
 function integerOption(value, fallback, label) {
     if (!value)
         return fallback;