@tiangong-ai/cli 0.0.42 → 0.0.44

package/dist/research/orchestration.js

@@ -6,6 +6,7 @@ import { parseStrictArgs, strictBoolean, strictString } from "../strict-args.js"
 import { researchSetupHelp, runResearchSetupCommand } from "./setup-command.js";
 import { loadCapabilityDeclarations, lockCapabilities, verifyCapabilities, } from "./workspace/capabilities.js";
 import { inspectResearchContext } from "./workspace/context.js";
+import { packageVersion } from "./workspace/constants.js";
 import { setCapabilityCredentialFromEnvironment } from "./workspace/credentials.js";
 import { configureExternalSkillProfile, doctorExternalCapabilities, EXTERNAL_SKILL_CONTEXT_PROFILE, EXTERNAL_SKILL_MEDIA_PROFILE, EXTERNAL_SKILL_PROFILE, importExternalCapability, inspectExternalSkillCatalog, } from "./workspace/external-skills.js";
 import { appendJournalEvent } from "./workspace/journal.js";
@@ -13,13 +14,16 @@ import { fetchNativeCandidateSource } from "./workspace/broker.js";
 import { registerEvidenceArtifact } from "./workspace/artifacts.js";
 import { exportProjectAuditBundle, verifyProjectAuditBundle } from "./workspace/audit-bundle.js";
 import { loadCurrentEvidenceSnapshot } from "./workspace/acquisition.js";
+import { freezeEvidenceContentSnapshot, loadCurrentEvidenceContentSnapshot, recordArtifactDecomposition, registerEvidenceAtom, } from "./workspace/content-evidence.js";
 import { inspectDiscoveryProgress } from "./workspace/discovery-status.js";
 import { inspectEvidenceAccessStatus } from "./workspace/evidence-exhaustion.js";
 import { recordDiscoveryAssessmentBatch } from "./workspace/discovery.js";
 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 { readAndVerifyProjectInputPlan } from "./workspace/input-plan.js";
+import { loadCurrentClaimEvidenceGraph, loadCurrentInferenceSnapshot, } from "./workspace/inference.js";
 import { addProjectInput, createProjectAddendum, initializeProject, forkProject, listProjects, loadProject, nextReadyPackage, normalizeEvidenceRequirements, refreshProject, retryProjectPackage, setProjectDisposition, } from "./workspace/projects.js";
 import { evaluateProjectPreflight } from "./workspace/preflight.js";
 import { closePublication, freezePublicationManuscript, inspectPublicationStatus, preparePublicationReview, publicationAssessmentSchema, publicationReviewSchema, submitPublicationReview, } from "./workspace/publication-workflow.js";
@@ -29,8 +33,8 @@ import { abortNativeResearchStage, inspectNativeResearchStage, prepareNativeRese
 import { schemaForStage } from "./workspace/schemas.js";
 import { readAndVerifyScientificDesign, scientificDesignSchema, } from "./workspace/scientific-design.js";
 import { inspectScientificReviewStatus, prepareScientificReview, scientificGateAssessmentSchema, scientificReviewSchema, submitScientificReview, } from "./workspace/scientific-review.js";
-import { pathExists, sha256Text, workspacePaths } from "./workspace/storage.js";
-import { doctorResearchWorkspace, initializeResearchWorkspace, requireResearchWorkspace, withWorkspaceLock, } from "./workspace/workspace.js";
+import { isObject, pathExists, sha256Text, workspacePaths } from "./workspace/storage.js";
+import { doctorResearchWorkspace, initializeResearchWorkspace, loadWorkspaceConfig, requireResearchWorkspace, withWorkspaceLock, } from "./workspace/workspace.js";
 const COMMON_OPTIONS = { help: "boolean", json: "boolean" };
 const WORKSPACE_OPTIONS = { ...COMMON_OPTIONS, workspace: "string" };
 export async function runResearchOrchestrationCommand(subcommand, argv, io) {
@@ -40,6 +44,8 @@ export async function runResearchOrchestrationCommand(subcommand, argv, io) {
         return runResearchSetupCommand(argv, io);
     if (subcommand === "workspace")
         return runWorkspace(argv, io);
+    if (subcommand === "reviewer")
+        return runReviewer(argv, io);
     if (subcommand === "capability")
         return runCapability(argv, io);
     if (subcommand === "policy")
@@ -63,6 +69,9 @@ export function researchOrchestrationHelp() {
   tiangong-ai research context inspect [--path <absolute-path>] [--json]
   tiangong-ai research workspace init <absolute-path> [--name <name>] [--mode smoke-test|production-research] [--json]
   tiangong-ai research workspace doctor [--workspace <absolute-path>] [--agent-smoke] [--capability-smoke] [--json]
+  tiangong-ai research reviewer serve --state-dir <absolute-private-directory> [--workspace <absolute-path>] [--json]
+  tiangong-ai research reviewer status [--workspace <absolute-path>] [--json]
+  tiangong-ai research reviewer doctor --confirm-agent-smoke-cost [--workspace <absolute-path>] [--json]
   tiangong-ai research capability catalog [--path <absolute-path>] [--workspace <absolute-path>] [--skill-root <absolute-path>] [--json]
   tiangong-ai research capability configure [--profile ${EXTERNAL_SKILL_PROFILE}|${EXTERNAL_SKILL_CONTEXT_PROFILE}|${EXTERNAL_SKILL_MEDIA_PROFILE}] [--skill-root <absolute-path>] [--workspace <absolute-path>] [--json]
   tiangong-ai research capability import --definition <absolute-json> [--workspace <absolute-path>] [--json]
@@ -77,7 +86,7 @@ export function researchOrchestrationHelp() {
   tiangong-ai research policy validate <project-id> [--workspace <path>] [--json]
   tiangong-ai research policy approve <project-id> --confirm [--acknowledge-defaults] [--workspace <path>] [--json]
   tiangong-ai research policy resolve <project-id> [--workspace <path>] [--json]
-  tiangong-ai research publication freeze <project-id> --manuscript <absolute-file> --assessment <absolute-json> --producer-agent codex|claude --producer-session <opaque-id> [--supplements <absolute-json-array>] [--workspace <path>] [--json]
+  tiangong-ai research publication freeze <project-id> --manuscript <absolute-file> --assessment <absolute-json> --submission <absolute-json> --producer-agent codex|claude|workbuddy|codebuddy --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]
@@ -98,7 +107,7 @@ export function researchOrchestrationHelp() {
   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 prepare <project-id> --stage discover|acquire|analyze|synthesize --host-agent codex|claude|workbuddy|codebuddy [--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]
   tiangong-ai research project evidence fetch <project-id> --request <absolute-json> [--workspace <path>] [--json]
@@ -107,6 +116,10 @@ export function researchOrchestrationHelp() {
   tiangong-ai research project evidence assessment record <project-id> --record <absolute-json> [--workspace <path>] [--json]
   tiangong-ai research project evidence download bind <project-id> --candidate <id> --record <absolute-json> [--workspace <path>] [--json]
   tiangong-ai research project evidence artifact register <project-id> --candidate <id> --path <absolute-file> [--download-binding <id> | --derived-from-artifact <id>] [--media-type <type>] [--source-url <https-url>] [--license <declared-license>] [--license-url <https-url>] [--host-type <type>] [--article-version <version>] [--workspace <path>] [--json]
+  tiangong-ai research project evidence decomposition record <project-id> --record <absolute-json> [--workspace <path>] [--json]
+  tiangong-ai research project evidence atom register <project-id> --record <absolute-json> [--workspace <path>] [--json]
+  tiangong-ai research project evidence content freeze <project-id> [--workspace <path>] [--json]
+  tiangong-ai research project evidence content status <project-id> [--workspace <path>] [--json]
   tiangong-ai research schema show <discover|acquire|analyze|synthesize|review|doctor|scientific-design|scientific-assessment-research-design|scientific-assessment-evidence-construct|scientific-assessment-pilot-methods|scientific-review-research-design|scientific-review-evidence-construct|scientific-review-pilot-methods|publication-assessment|publication-review-evidence|publication-review-methods-reproducibility|publication-review-domain-novelty|publication-review-journal-editor> [--compatibility claude-code] [--json]
   tiangong-ai research status [--project <project-id>] [--all] [--workspace <absolute-path>] [--json]
   tiangong-ai research run [--project <project-id>] [--max-parallel <1-8>] [--max-cycles <1-100>] [--dry-run] [--progress-jsonl] [--workspace <absolute-path>] [--json]
@@ -114,6 +127,92 @@ export function researchOrchestrationHelp() {
 ${researchSetupHelp()}
 `;
 }
+async function runReviewer(argv, io) {
+    const [action, ...rest] = argv;
+    if (!action || action === "--help" || action === "-h")
+        return writeHelp(io);
+    if (action === "status") {
+        const args = parseStrictArgs(rest, WORKSPACE_OPTIONS, "research reviewer status");
+        if (strictBoolean(args, "help"))
+            return writeHelp(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;
+    }
+    if (action === "doctor") {
+        const args = parseStrictArgs(rest, { ...WORKSPACE_OPTIONS, "confirm-agent-smoke-cost": "boolean" }, "research reviewer doctor");
+        if (strictBoolean(args, "help"))
+            return writeHelp(io);
+        if (args.positionals.length)
+            throw unknownAction("research reviewer doctor", args.positionals[0]);
+        if (!strictBoolean(args, "confirm-agent-smoke-cost")) {
+            throw new CliError("Reviewer doctor requires explicit model-cost confirmation.", {
+                code: "RESEARCH_REVIEW_BRIDGE_CONFIRMATION_REQUIRED",
+                exitCode: 3,
+                details: {
+                    minimumAction: "Rerun with --confirm-agent-smoke-cost after reviewing reviewer provider quota and cost.",
+                },
+            });
+        }
+        const root = await workspaceFromArgs(args);
+        const result = await doctorResearchWorkspace(root, {
+            agentSmoke: true,
+            environment: io.env,
+        });
+        writeJson(io, result, args);
+        return result.status === "ready" ? 0 : 3;
+    }
+    if (action === "serve") {
+        const args = parseStrictArgs(rest, { ...WORKSPACE_OPTIONS, "state-dir": "string" }, "research reviewer serve");
+        if (strictBoolean(args, "help"))
+            return writeHelp(io);
+        if (args.positionals.length)
+            throw unknownAction("research reviewer serve", args.positionals[0]);
+        const stateDirectory = strictString(args, "state-dir");
+        if (!stateDirectory ||
+            !isAbsolute(stateDirectory) ||
+            resolve(stateDirectory) !== stateDirectory) {
+            throw new CliError("Reviewer sidecar --state-dir must be an explicit absolute directory.", {
+                code: "RESEARCH_REVIEW_BRIDGE_STATE_INVALID",
+                exitCode: 2,
+            });
+        }
+        const root = await workspaceFromArgs(args);
+        const sidecar = await startReviewerBridgeSidecar({
+            root,
+            stateDirectory,
+            environment: io.env,
+        });
+        writeJson(io, {
+            status: "ready",
+            workspaceId: sidecar.workspaceId,
+            packageVersion: packageVersion(),
+            keyFingerprint: sidecar.keyFingerprint,
+            supportedActions: ["execute", "fingerprint", "status"],
+        }, args);
+        try {
+            await waitForReviewerSidecarTermination();
+        }
+        finally {
+            await sidecar.close();
+        }
+        return 0;
+    }
+    throw unknownAction("research reviewer", action);
+}
+async function waitForReviewerSidecarTermination() {
+    await new Promise((resolvePromise) => {
+        const stop = () => {
+            process.off("SIGINT", stop);
+            process.off("SIGTERM", stop);
+            resolvePromise();
+        };
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+    });
+}
 async function runPublication(argv, io) {
     const [action, ...rest] = argv;
     if (!action || action === "--help" || action === "-h")
@@ -124,6 +223,7 @@ async function runPublication(argv, io) {
             manuscript: "string",
             assessment: "string",
             supplements: "string",
+            submission: "string",
             "producer-agent": "string",
             "producer-session": "string",
         }, "research publication freeze");
@@ -133,8 +233,9 @@ async function runPublication(argv, io) {
         const manuscriptPath = strictString(args, "manuscript");
         const assessmentPath = strictString(args, "assessment");
         const producerSessionId = strictString(args, "producer-session");
-        if (!manuscriptPath || !assessmentPath || !producerSessionId) {
-            throw new CliError("research publication freeze requires --manuscript, --assessment, --producer-agent, and --producer-session.", { code: "RESEARCH_PUBLICATION_ARGUMENT_REQUIRED", exitCode: 2 });
+        const submissionPath = strictString(args, "submission");
+        if (!manuscriptPath || !assessmentPath || !submissionPath || !producerSessionId) {
+            throw new CliError("research publication freeze requires --manuscript, --assessment, --submission, --producer-agent, and --producer-session.", { code: "RESEARCH_PUBLICATION_ARGUMENT_REQUIRED", exitCode: 2 });
         }
         const root = await workspaceFromArgs(args);
         const supplementsPath = strictString(args, "supplements");
@@ -144,6 +245,7 @@ async function runPublication(argv, io) {
             manuscriptPath,
             assessmentPath,
             supplementPaths: supplementsPath ? await readAbsolutePathArray(supplementsPath) : [],
+            submissionFiles: await readSubmissionFiles(submissionPath),
             producerAgent: publicationAgent(strictString(args, "producer-agent"), "producer"),
             producerSessionId,
         }), args);
@@ -949,6 +1051,66 @@ async function runProject(argv, io) {
             writeJson(io, result, args);
             return 0;
         }
+        if (evidenceAction === "decomposition") {
+            const [decompositionAction, ...decompositionRest] = evidenceRest;
+            if (decompositionAction !== "record") {
+                throw unknownAction("research project evidence decomposition", decompositionAction ?? "");
+            }
+            const args = parseStrictArgs(decompositionRest, { ...WORKSPACE_OPTIONS, record: "string" }, "research project evidence decomposition record");
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, "research project evidence decomposition record");
+            const recordPath = strictString(args, "record");
+            if (!recordPath) {
+                throw new CliError("decomposition record requires --record.", {
+                    code: "RESEARCH_DECOMPOSITION_INVALID",
+                    exitCode: 2,
+                });
+            }
+            const root = await workspaceFromArgs(args);
+            const record = await readBoundedJsonRecord(recordPath, "--record", "RESEARCH_DECOMPOSITION_INVALID");
+            const result = await withWorkspaceLock(root, "research.decomposition.record", () => recordArtifactDecomposition({ root, projectId, value: record }));
+            writeJson(io, result, args);
+            return 0;
+        }
+        if (evidenceAction === "atom") {
+            const [atomAction, ...atomRest] = evidenceRest;
+            if (atomAction !== "register") {
+                throw unknownAction("research project evidence atom", atomAction ?? "");
+            }
+            const args = parseStrictArgs(atomRest, { ...WORKSPACE_OPTIONS, record: "string" }, "research project evidence atom register");
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, "research project evidence atom register");
+            const recordPath = strictString(args, "record");
+            if (!recordPath) {
+                throw new CliError("atom register requires --record.", {
+                    code: "RESEARCH_EVIDENCE_ATOM_INVALID",
+                    exitCode: 2,
+                });
+            }
+            const root = await workspaceFromArgs(args);
+            const record = await readBoundedJsonRecord(recordPath, "--record", "RESEARCH_EVIDENCE_ATOM_INVALID");
+            const result = await withWorkspaceLock(root, "research.evidence-atom.register", () => registerEvidenceAtom({ root, projectId, value: record }));
+            writeJson(io, result, args);
+            return 0;
+        }
+        if (evidenceAction === "content") {
+            const [contentAction, ...contentRest] = evidenceRest;
+            if (contentAction !== "freeze" && contentAction !== "status") {
+                throw unknownAction("research project evidence content", contentAction ?? "");
+            }
+            const args = parseStrictArgs(contentRest, WORKSPACE_OPTIONS, `research project evidence content ${contentAction}`);
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, `research project evidence content ${contentAction}`);
+            const root = await workspaceFromArgs(args);
+            const result = contentAction === "freeze"
+                ? await withWorkspaceLock(root, "research.evidence-content.freeze", () => freezeEvidenceContentSnapshot(root, projectId))
+                : await loadCurrentEvidenceContentSnapshot(root, projectId);
+            writeJson(io, result, args);
+            return 0;
+        }
         if (evidenceAction !== "fetch") {
             throw unknownAction("research project evidence", evidenceAction ?? "");
         }
@@ -1245,6 +1407,7 @@ async function runStatus(argv, io) {
         return writeHelp(io);
     rejectPositionals(args.positionals, "research status");
     const root = await workspaceFromArgs(args);
+    const config = await loadWorkspaceConfig(root);
     const selectedProject = strictString(args, "project");
     const workspaceProjects = await listProjects(root);
     const allProjects = selectedProject
@@ -1260,6 +1423,20 @@ async function runStatus(argv, io) {
             project.status !== "abandoned");
     const result = {
         workspace: root,
+        execution: {
+            producer: {
+                host: config.producer.agent,
+                model: config.producer.model,
+                mode: config.producer.executionMode,
+            },
+            reviewer: {
+                agent: config.reviewer.agent,
+                model: config.reviewer.model,
+                mode: config.reviewer.executionMode,
+                transport: config.reviewerExecution.transport,
+                isolationProvider: config.reviewerExecution.isolationProvider,
+            },
+        },
         hiddenSupersededProjects: selectedProject || strictBoolean(args, "all")
             ? 0
             : workspaceProjects.filter((project) => project.lineage.supersededBy !== null).length,
@@ -1272,7 +1449,8 @@ async function runStatus(argv, io) {
         projects: await Promise.all(projects.map(async (project) => {
             const current = refreshProject(project);
             const nativeStage = await inspectNativeResearchStage(root, current);
-            const snapshot = await inspectSnapshotForStatus(root, current.id);
+            const evidencePipeline = await inspectEvidencePipelineForStatus(root, current);
+            const snapshot = evidencePipeline.acquisition;
             const readyPackage = nextReadyPackage(current)?.id ?? null;
             const scientificReview = await inspectScientificReviewStatus(root, current.id);
             const evidenceAccess = current.scientificDesign
@@ -1290,12 +1468,13 @@ async function runStatus(argv, io) {
                 handoff: current.handoff,
                 evidenceState: current.evidenceState,
                 snapshot,
+                evidencePipeline,
                 nativeStage,
                 scientificReview,
                 evidenceAccess,
                 publication,
                 readyPackage,
-                recommendedAction: projectRecommendedAction(root, current, readyPackage, nativeStage, scientificReview, publication),
+                recommendedAction: projectRecommendedAction(root, current, readyPackage, nativeStage, scientificReview, evidencePipeline, publication),
                 usage: current.usage,
                 inputs: current.inputs,
                 packages: current.packages,
@@ -1306,6 +1485,94 @@ async function runStatus(argv, io) {
     writeJson(io, result, args);
     return 0;
 }
+async function inspectEvidencePipelineForStatus(root, project) {
+    const projectRoot = join(workspacePaths(root).projects, project.id);
+    const acquisition = await inspectSnapshotForStatus(root, project.id);
+    const contentPath = join(projectRoot, "outputs", "content-snapshot.json");
+    let content = { status: "absent" };
+    if (await pathExists(contentPath)) {
+        try {
+            const snapshot = await loadCurrentEvidenceContentSnapshot(root, project.id);
+            content = {
+                status: "verified",
+                snapshotId: snapshot.snapshotId,
+                snapshotSha256: snapshot.snapshotSha256,
+                decompositionCount: snapshot.decompositions.length,
+                atomCount: snapshot.atoms.length,
+                sourceCount: snapshot.sourceCoverage.length,
+                roleCount: snapshot.roleCoverage.length,
+                insufficientRoleIds: snapshot.roleCoverage
+                    .filter((role) => role.decision === "insufficient")
+                    .map((role) => role.roleId),
+                gate: snapshot.gate,
+            };
+        }
+        catch (error) {
+            content = {
+                status: "invalid",
+                code: error instanceof CliError ? error.code : "RESEARCH_EVIDENCE_CONTENT_SNAPSHOT_INVALID",
+            };
+        }
+    }
+    const inferencePath = join(projectRoot, "outputs", "inference-snapshot.json");
+    let inference = { status: "absent" };
+    if (await pathExists(inferencePath)) {
+        try {
+            const snapshot = await loadCurrentInferenceSnapshot(root, project.id);
+            inference = {
+                status: "verified",
+                snapshotId: snapshot.snapshotId,
+                snapshotSha256: snapshot.snapshotSha256,
+                sourceCount: snapshot.sources.length,
+                atomCount: snapshot.atoms.length,
+                claimCount: snapshot.claims.length,
+                artifactCount: snapshot.artifactSha256s.length,
+                gate: snapshot.gate,
+            };
+        }
+        catch (error) {
+            inference = {
+                status: "invalid",
+                code: error instanceof CliError ? error.code : "RESEARCH_INFERENCE_SNAPSHOT_INVALID",
+            };
+        }
+    }
+    else if (acquisition.gate?.decision === "stop") {
+        inference = { status: "blocked", gate: acquisition.gate };
+    }
+    else if (content.gate?.decision === "stop") {
+        inference = { status: "blocked", gate: content.gate };
+    }
+    else if (project.scientificDesign && content.status !== "verified") {
+        inference = {
+            status: "blocked",
+            code: "RESEARCH_EVIDENCE_CONTENT_SNAPSHOT_REQUIRED",
+        };
+    }
+    const graphPath = join(projectRoot, "outputs", "claim-evidence-graph.json");
+    let claimGraph = { status: "absent" };
+    if (await pathExists(graphPath)) {
+        try {
+            const graph = await loadCurrentClaimEvidenceGraph(root, project.id);
+            claimGraph = {
+                status: "verified",
+                graphId: graph.graphId,
+                graphSha256: graph.graphSha256,
+                analysisSha256: graph.analysisSha256,
+                analysisRunId: graph.analysisRunId,
+                nodeCount: graph.nodes.length,
+                edgeCount: graph.edges.length,
+            };
+        }
+        catch (error) {
+            claimGraph = {
+                status: "invalid",
+                code: error instanceof CliError ? error.code : "RESEARCH_CLAIM_EVIDENCE_GRAPH_INVALID",
+            };
+        }
+    }
+    return { acquisition, content, inference, claimGraph };
+}
 async function inspectEvidenceAccessForStatus(root, projectId) {
     try {
         return await inspectEvidenceAccessStatus(root, projectId);
@@ -1352,6 +1619,8 @@ async function inspectSnapshotForStatus(root, projectId) {
             parentSnapshotId: snapshot.parentSnapshotId,
             sourceCount: snapshot.sources.length,
             artifactCount: snapshot.artifacts.length,
+            gapCount: snapshot.gaps.length,
+            gate: snapshot.inferenceGate,
             delta: snapshot.delta,
         };
     }
@@ -1374,7 +1643,7 @@ async function inspectPublicationForStatus(root, projectId) {
         };
     }
 }
-function projectRecommendedAction(root, project, readyPackage, nativeStage, scientificReview, publication) {
+function projectRecommendedAction(root, project, readyPackage, nativeStage, scientificReview, evidencePipeline, publication) {
     if (project.lineage.supersededBy) {
         return `Continue with superseding project ${project.lineage.supersededBy}.`;
     }
@@ -1398,6 +1667,23 @@ function projectRecommendedAction(root, project, readyPackage, nativeStage, scie
     if (nativeStage.status === "active") {
         return nativeStage.recommendedAction ?? "Resume the active native stage.";
     }
+    if (readyPackage === "analyze") {
+        if (evidencePipeline.content.status === "absent") {
+            return `Decompose every acquired full-text/data artifact, register exact evidence atoms, then freeze typed content: tiangong-ai research project evidence content freeze ${project.id} --workspace ${root}`;
+        }
+        if (evidencePipeline.content.status === "invalid") {
+            return `Typed evidence content is invalid (${evidencePipeline.content.code ?? "unknown"}); repair exact decomposition/atom bindings before analysis.`;
+        }
+        if (evidencePipeline.content.gate?.decision === "stop") {
+            return "Typed evidence coverage is insufficient; complete lawful gap filling or request a scope/access handoff instead of starting inference.";
+        }
+        if (evidencePipeline.acquisition.gate?.decision === "stop") {
+            return "Frozen acquisition gaps block inference; request a scope/access handoff after all acquired content is decomposed instead of continuing substitute search.";
+        }
+        if (evidencePipeline.inference.status === "invalid") {
+            return `Inference snapshot is invalid (${evidencePipeline.inference.code ?? "unknown"}); repair its frozen upstream bindings before analysis.`;
+        }
+    }
     if (scientificReview.nextGate) {
         const gate = scientificReview.nextGate;
         if (gate.status === "stopped") {
@@ -1432,7 +1718,7 @@ function projectRecommendedAction(root, project, readyPackage, nativeStage, scie
             : "Inspect the blocking package and use explicit retry or fork recovery.";
     }
     if (readyPackage && ["discover", "acquire", "analyze", "synthesize"].includes(readyPackage)) {
-        return `Prepare native ${readyPackage}: tiangong-ai research project stage prepare ${project.id} --stage ${readyPackage} --host-agent <codex|claude> --workspace ${root}`;
+        return `Prepare native ${readyPackage}: tiangong-ai research project stage prepare ${project.id} --stage ${readyPackage} --host-agent <codex|claude|workbuddy|codebuddy> --workspace ${root}`;
     }
     return readyPackage === "review"
         ? `Run the independent reviewer package: tiangong-ai research run --project ${project.id} --workspace ${root}`
@@ -1553,9 +1839,10 @@ function nativeProducerStage(value) {
     });
 }
 function nativeHostAgent(value) {
-    if (value === "codex" || value === "claude")
+    if (value === "codex" || value === "claude" || value === "workbuddy" || value === "codebuddy") {
         return value;
-    throw new CliError("--host-agent must be codex or claude.", {
+    }
+    throw new CliError("--host-agent must be codex, claude, workbuddy, or codebuddy.", {
         code: "RESEARCH_NATIVE_HOST_INVALID",
         exitCode: 2,
     });
@@ -1668,9 +1955,13 @@ function scientificReviewRole(value) {
     });
 }
 function publicationAgent(value, label) {
-    if (value === "codex" || value === "claude")
+    const producer = label.includes("producer");
+    if (value === "codex" ||
+        value === "claude" ||
+        (producer && (value === "workbuddy" || value === "codebuddy"))) {
         return value;
-    throw new CliError(`--${label}-agent must be codex or claude.`, {
+    }
+    throw new CliError(`--${label}-agent must be ${producer ? "codex, claude, workbuddy, or codebuddy" : "codex or claude"}.`, {
         code: "RESEARCH_PUBLICATION_AGENT_INVALID",
         exitCode: 2,
     });
@@ -1712,6 +2003,19 @@ async function readAbsolutePathArray(path, option = "supplements") {
     }
     return value;
 }
+async function readSubmissionFiles(path) {
+    const value = await readBoundedJsonRecord(path, "--submission", "RESEARCH_PUBLICATION_SUBMISSION_PACKAGE_INVALID");
+    if (value.schemaVersion !== 1 ||
+        !Array.isArray(value.files) ||
+        value.files.some((file) => !isObject(file) ||
+            typeof file.role !== "string" ||
+            typeof file.path !== "string" ||
+            !isAbsolute(file.path) ||
+            resolve(file.path) !== file.path)) {
+        throw new CliError("--submission must declare schemaVersion 1 and role/path entries with absolute canonical paths.", { code: "RESEARCH_PUBLICATION_SUBMISSION_PACKAGE_INVALID", exitCode: 2 });
+    }
+    return value.files;
+}
 function integerOption(value, fallback, label) {
     if (!value)
         return fallback;