@tiangong-ai/cli 0.0.34 → 0.0.35

package/AGENTS.md

@@ -15,8 +15,8 @@ checkPaths:
   - .docpact/config.yaml
   - docs/agents/**
   - src/**
-lastReviewedAt: 2026-08-12
-lastReviewedCommit: 7d692de934c51178df520ccdaa212acc7dc303f0
+lastReviewedAt: 2026-08-13
+lastReviewedCommit: df263405bccb21cd5838d92d82dccf80ca01acb1
 ---
 
 # Tiangong AI CLI Contract
@@ -47,6 +47,8 @@ This repository owns the Tiangong AI command-line interface.
 - `tiangong-ai kb status`
 - `tiangong-ai research context`
 - `tiangong-ai research setup`
+- `tiangong-ai research policy`
+- `tiangong-ai research publication`
 - `tiangong-ai research workspace`
 - `tiangong-ai research capability`
 - `tiangong-ai research project`

package/README.md

@@ -269,6 +269,69 @@ regular non-symlink `runtime-lock.json` exact stable CLI version. Setup and
 release CI reject a missing resolver or any stale exact CLI version in the
 orchestrator's `SKILL.md` or `references/*.md`.
 
+### Top-journal Research Policy and final publication gate
+
+A `top-journal` project starts with a human-reviewed Markdown Policy, not with
+model execution. After project-scoped setup reaches `READY`, use the guided
+Wizard:
+
+```bash
+tiangong-ai research policy wizard top-journal-paper \
+  --workspace /absolute/path/to/workspace
+tiangong-ai research policy status top-journal-paper \
+  --workspace /absolute/path/to/workspace --json
+```
+
+The Wizard resolves only the verified project-installed
+`tiangong-auto-research` tree. It copies a baseline plus one article type,
+field, journal class, project brief, and four reviewer rubrics. Generic defaults
+are clearly reported and require a separate acknowledgement. An exact-journal
+Policy additionally requires a current official HTTPS guideline URL, retrieval
+date, and substantive human content for all journal-specific sections. Approval
+binds the manifest and every document by SHA-256; edits, manifest tampering, or
+expiry block preflight and all later stages until the Policy is reviewed and
+approved again.
+
+Use the Policy project ID when admitting the research project:
+
+```bash
+tiangong-ai research project preflight \
+  --question "A specific, testable research question" \
+  --goal top-journal --policy-project top-journal-paper \
+  --requirements /absolute/path/to/evidence-requirements.json \
+  --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. After base closure, the
+current native host writes a final manuscript and schema-valid publication
+assessment. `research publication freeze` then content-addresses the Policy,
+evidence snapshot, base outputs, manuscript, assessment, and supplements.
+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
+producer/reviewer session identifiers are accepted only at the command boundary;
+generation, packet, review, journal, and closure objects persist only their
+SHA-256 bindings.
+
+```bash
+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 \
+  --producer-agent codex --producer-session OPAQUE_NATIVE_SESSION \
+  --workspace /absolute/path/to/workspace --json
+tiangong-ai research publication status top-journal-paper \
+  --workspace /absolute/path/to/workspace --json
+```
+
+The CLI returns a mechanically bounded ceiling:
+`top-journal-candidate`, `top-journal-class-ready`, or
+`target-journal-submission-ready`. Evidence and review failures can only lower
+it. None of these states predicts or guarantees editorial acceptance.
+
 `research setup status --json` reports credential persistence separately from
 readiness. It also reports the effective exact-npx CLI package/version/root,
 the selected project orchestrator, any temporary recovery shim, ignored global

package/dist/research/orchestration.js

@@ -20,6 +20,9 @@ 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 { pathExists, sha256Text, workspacePaths } from "./workspace/storage.js";
@@ -35,6 +38,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,9 +66,21 @@ 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] [--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>] [--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]
@@ -78,13 +97,206 @@ 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|publication-assessment|publication-review-evidence|publication-review-methods-reproducibility|publication-review-domain-novelty|publication-review-journal-editor> [--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")
@@ -95,6 +307,15 @@ async function runSchema(argv, io) {
     if (strictBoolean(args, "help"))
         return writeHelp(io);
     const stage = onePositional(args.positionals, "research schema show");
+    if (stage === "publication-assessment") {
+        writeJson(io, publicationAssessmentSchema(), args);
+        return 0;
+    }
+    if (stage.startsWith("publication-review-")) {
+        const role = publicationReviewRole(stage.slice("publication-review-".length));
+        writeJson(io, publicationReviewSchema(role), args);
+        return 0;
+    }
     if (stage !== "discover" &&
         stage !== "acquire" &&
         stage !== "analyze" &&
@@ -576,6 +797,7 @@ async function runProject(argv, io) {
         const args = parseStrictArgs(rest, {
             ...WORKSPACE_OPTIONS,
             question: "string",
+            goal: "string",
             requirements: "string",
             "input-plan": "string",
             "confirm-budget": "boolean",
@@ -591,9 +813,10 @@ 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 project = await initializeProject(root, projectId, question, requirementsPath ? await readEvidenceRequirements(requirementsPath) : undefined, strictBoolean(args, "confirm-budget"), inputPlanPath ? await readAndVerifyProjectInputPlan(inputPlanPath) : undefined, goal === "top-journal" ? await loadApprovedResearchPolicy(root, projectId) : undefined);
         writeJson(io, project, args);
         return 0;
     }
@@ -601,6 +824,8 @@ async function runProject(argv, io) {
         const args = parseStrictArgs(rest, {
             ...WORKSPACE_OPTIONS,
             question: "string",
+            goal: "string",
+            "policy-project": "string",
             requirements: "string",
             "input-plan": "string",
         }, "research project preflight");
@@ -615,6 +840,23 @@ async function runProject(argv, io) {
             });
         }
         const root = await workspaceFromArgs(args);
+        const goal = researchGoal(strictString(args, "goal"));
+        const policyProject = strictString(args, "policy-project");
+        if (goal === "top-journal") {
+            if (!policyProject) {
+                throw new CliError("Top-journal preflight requires --policy-project.", {
+                    code: "RESEARCH_POLICY_REQUIRED",
+                    exitCode: 2,
+                });
+            }
+            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");
@@ -629,7 +871,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 +890,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;
     }
@@ -744,6 +996,9 @@ 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 publication = current.publicationPolicy
+                ? await inspectPublicationForStatus(root, current.id)
+                : null;
             return {
                 id: current.id,
                 question: current.question,
@@ -754,8 +1009,9 @@ async function runStatus(argv, io) {
                 evidenceState: current.evidenceState,
                 snapshot,
                 nativeStage,
+                publication,
                 readyPackage,
-                recommendedAction: projectRecommendedAction(root, current, readyPackage, nativeStage),
+                recommendedAction: projectRecommendedAction(root, current, readyPackage, nativeStage, publication),
                 usage: current.usage,
                 inputs: current.inputs,
                 packages: current.packages,
@@ -812,7 +1068,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, publication) {
     if (project.lineage.supersededBy) {
         return `Continue with superseding project ${project.lineage.supersededBy}.`;
     }
@@ -832,6 +1099,21 @@ function projectRecommendedAction(root, project, readyPackage, nativeStage) {
         return nativeStage.recommendedAction ?? "Resume the active native stage.";
     }
     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 +1215,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 +1326,71 @@ 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 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;