@tiangong-ai/cli 0.0.60 → 0.0.62

package/dist/research/orchestration.js

@@ -1,3 +1,9 @@
+import { closeInvestigation, investigationCloseInputSchema, } from "./workspace/investigation-close.js";
+import { planInvestigationPromotion, approveInvestigationPromotion, investigationPromotionInputSchema, } from "./workspace/investigation-promotion.js";
+import { selectInvestigationCandidate, investigationCandidateInputSchema, } from "./workspace/investigation-candidate.js";
+import { observeInvestigationAttempt, investigationAttemptInputSchema, } from "./workspace/investigation-attempt.js";
+import { planInvestigation, approveInvestigation, inspectInvestigation, investigationInputSchema, } from "./workspace/investigation.js";
+import { projectBudgetAmount, projectBudgetView, providerCostLimits, } from "./workspace/project-budget.js";
 import { lstat, readFile } from "node:fs/promises";
 import { isAbsolute, join, resolve } from "node:path";
 import { CliError } from "../errors.js";
@@ -13,7 +19,7 @@ import { configureExternalSkillProfile, doctorExternalCapabilities, EXTERNAL_SKI
 import { appendJournalEvent } from "./workspace/journal.js";
 import { fetchNativeCandidateSource } from "./workspace/broker.js";
 import { preflightEvidenceArtifact, registerEvidenceArtifact } from "./workspace/artifacts.js";
-import { executeResearchDataCapability } from "./workspace/data-evidence-adapter.js";
+import { executeResearchDataCapability, projectResearchDataEvidenceViewResult, projectResearchDataExecutionResult, readResearchDataEvidence, } from "./workspace/data-evidence-adapter.js";
 import { exportProjectAuditBundle, verifyProjectAuditBundle } from "./workspace/audit-bundle.js";
 import { loadCurrentEvidenceSnapshot } from "./workspace/acquisition.js";
 import { inspectAcquisitionForecast } from "./workspace/acquisition-forecast.js";
@@ -31,16 +37,21 @@ import { recordNativeResearchActivity } from "./workspace/native-activity.js";
 import { inspectReviewerStatus, startReviewerBridgeSidecar } from "./workspace/review-executor.js";
 import { readAndVerifyProjectInputPlan } from "./workspace/input-plan.js";
 import { executeScientificReview } from "./workspace/scientific-review-execution.js";
+import { claudeCodeCompatibleSchema } from "./workspace/schema-compatibility.js";
 import { loadCurrentClaimEvidenceGraph, loadCurrentInferenceSnapshot, } from "./workspace/inference.js";
-import { addProjectInput, createProjectAddendum, initializeProject, forkProject, listProjects, loadProject, nextReadyPackage, normalizeEvidenceRequirements, refreshProject, retryProjectPackage, setProjectDisposition, scientificGateRecommendedAction, } from "./workspace/projects.js";
+import { addProjectInput, createProjectAddendum, initializeProject, setProjectBudget, resolveProjectBudgetReservation, forkProject, listProjects, loadProject, nextReadyPackage, normalizeEvidenceRequirements, refreshProject, retryProjectPackage, setProjectDisposition, scientificGateRecommendedAction, } from "./workspace/projects.js";
 import { evaluateProjectPreflight } from "./workspace/preflight.js";
-import { closePublication, freezePublicationManuscript, inspectPublicationStatus, preparePublicationReview, publicationAssessmentSchema, publicationReviewSchema, submitPublicationReview, } from "./workspace/publication-workflow.js";
+import { closePublication, freezePublicationManuscript, inspectPublicationStatus, inspectPublicationLineage, preparePublicationReview, publicationAssessmentSchema, publicationReviewSchema, submitPublicationReview, } from "./workspace/publication-workflow.js";
+import { publicationResultLineageSchema } from "./workspace/publication-lineage.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 { abortNativeResearchStage, inspectNativeResearchStage, prepareNativeResearchStage, readNativeStageArtifact, requestResearchHandoff, resolveResearchHandoff, runResearchWorkspace, submitNativeResearchStage, } from "./workspace/runtime.js";
 import { schemaForStage } from "./workspace/schemas.js";
 import { readAndVerifyScientificDesign, scientificDesignSchema, } from "./workspace/scientific-design.js";
 import { inspectScientificObject, parseScientificObjectKind, registerScientificObject, } from "./workspace/scientific-objects.js";
+import { inspectScientificFulfillment, recordScientificFulfillment, scientificFulfillmentSchema, } from "./workspace/scientific-fulfillment.js";
+import { applyScientificAmendment, inspectScientificAmendment, planScientificAmendment, scientificAmendmentSchema, } from "./workspace/scientific-amendment.js";
+import { inspectNativeRun, nativeRunInputSchema, observeNativeRun, } from "./workspace/native-run.js";
 import { inspectScientificReviewStatus, prepareScientificReview, scientificGateAssessmentSchema, scientificReviewSchema, submitScientificReview, } from "./workspace/scientific-review.js";
 import { isObject, pathExists, sha256Text, workspacePaths } from "./workspace/storage.js";
 import { doctorResearchWorkspace, initializeResearchWorkspace, loadWorkspaceConfig, requireResearchWorkspace, withWorkspaceLock, } from "./workspace/workspace.js";
@@ -98,14 +109,32 @@ export function researchOrchestrationHelp() {
   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> --submission <absolute-json> --producer-agent codex|claude|workbuddy|codebuddy --producer-session <opaque-id> [--supplements <absolute-json-array>] [--workspace <path>] [--json]
+  tiangong-ai research publication lineage <project-id> [--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 scientific object register --kind model-implementation|environment-lock --path <absolute-file> [--media-type <type>] [--workspace <path>] [--json]
   tiangong-ai research scientific object inspect --kind model-implementation|environment-lock --locator <control-relative-locator> [--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 scientific fulfillment record <project> --input <json-file> [--workspace <path>] [--json]
+  tiangong-ai research scientific fulfillment status <project> [--workspace <path>] [--json]
+  tiangong-ai research scientific amendment plan <project> --input <json-file> [--workspace <path>] [--json]
+  tiangong-ai research scientific amendment apply <project> --plan <json-file> --confirm <plan-sha256> --authorization-source <text-file> [--workspace <path>] [--json]
+  tiangong-ai research project investigation plan <project> --input <json-file> [--workspace <path>] [--json]
+  tiangong-ai research project investigation approve <project> --input <json-file> --confirm <plan-sha256> --authorization-source <text-file> [--workspace <path>] [--json]
+  tiangong-ai research project investigation attempt <project> --input <json-file> [--workspace <path>] [--json]
+  tiangong-ai research project investigation select <project> --input <json-file> [--workspace <path>] [--json]
+  tiangong-ai research project investigation promotion plan <project> --input <json-file> [--workspace <path>] [--json]
+  tiangong-ai research project investigation promotion approve <project> --input <json-file> --confirm <plan-sha256> --authorization-source <text-file> [--workspace <path>] [--json]
+  tiangong-ai research project investigation close <project> --input <json-file> [--workspace <path>] [--json]
+  tiangong-ai research project investigation status <project> --investigation <id> [--workspace <path>] [--json]
+  tiangong-ai research scientific amendment status <project> [--workspace <path>] [--json]
+  tiangong-ai research project task run observe <project> --input <json-file> --confirm-execution [--workspace <path>] [--json]
+  tiangong-ai research project task run inspect <project> --run <run-id> [--workspace <path>] [--json]
+  tiangong-ai research project budget resolve <project-id> --reservation <id> --accounted-cost-usd <estimate> --reason <text> --confirm-budget [--workspace <path>] [--json]
+  tiangong-ai research project budget set <project-id> --max-cost-usd <amount> [--provider-costs <absolute-json>] [--confirm-budget] [--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>] [--max-cost-usd <amount>] [--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>] [--max-cost-usd <amount>] [--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 task define <project-id> --input <absolute-json> [--workspace <path>] [--json]
@@ -129,8 +158,11 @@ export function researchOrchestrationHelp() {
   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 stage artifacts <project-id> --session <id> [--offset <n>] [--limit <n>] [--path-prefix <prefix>] [--workspace <path>] [--json]
+  tiangong-ai research project stage read <project-id> --session <id> --artifact <object-id> [--offset <bytes>] [--length <bytes|all>] [--encoding utf8|base64] [--workspace <path>] [--json]
   tiangong-ai research project evidence fetch <project-id> --request <absolute-json> [--workspace <path>] [--json]
   tiangong-ai research project evidence data run <project-id> --request <absolute-data-run-request.json> [--workspace <path>] [--json]
+  tiangong-ai research project evidence data read <project-id> --receipt <attempt-id> --cursor <opaque-cursor> [--workspace <path>] [--json]
   tiangong-ai research project evidence activity record <project-id> --record <absolute-json> [--workspace <path>] [--json]
   tiangong-ai research project evidence candidate register <project-id> --record <absolute-json> [--workspace <path>] [--json]
   tiangong-ai research project evidence assessment record <project-id> --record <absolute-json> [--workspace <path>] [--json]
@@ -160,6 +192,64 @@ async function runScientific(argv, io) {
     const [action, ...rest] = argv;
     if (!action || action === "--help" || action === "-h")
         return writeHelp(io);
+    if (action === "amendment") {
+        const [operation, ...arguments_] = rest;
+        if (!["plan", "apply", "status"].includes(operation ?? ""))
+            throw unknownAction("research scientific amendment", operation ?? "");
+        const args = parseStrictArgs(arguments_, {
+            ...WORKSPACE_OPTIONS,
+            ...(operation === "plan" ? { input: "string" } : {}),
+            ...(operation === "apply"
+                ? {
+                    plan: "string",
+                    confirm: "string",
+                    "authorization-source": "string",
+                }
+                : {}),
+        }, `research scientific amendment ${operation}`);
+        if (strictBoolean(args, "help"))
+            return writeHelp(io);
+        const projectId = onePositional(args.positionals, `research scientific amendment ${operation}`);
+        const root = await workspaceFromArgs(args);
+        if (operation === "status")
+            writeJson(io, await inspectScientificAmendment(root, projectId), args);
+        else {
+            const field = operation === "plan" ? "input" : "plan";
+            const path = strictString(args, field);
+            if (!path)
+                throw new CliError(`Amendment ${operation} requires --${field}.`, {
+                    code: "RESEARCH_SCIENTIFIC_AMENDMENT_INVALID",
+                    exitCode: 2,
+                });
+            const value = await readBoundedJsonRecord(path, `--${field}`, "RESEARCH_SCIENTIFIC_AMENDMENT_INVALID");
+            writeJson(io, operation === "plan"
+                ? await planScientificAmendment(root, projectId, value)
+                : await applyScientificAmendment(root, projectId, value, strictString(args, "confirm"), strictString(args, "authorization-source")), args);
+        }
+        return 0;
+    }
+    if (action === "fulfillment") {
+        const [operation, ...arguments_] = rest;
+        if (operation !== "record" && operation !== "status")
+            throw unknownAction("research scientific fulfillment", operation ?? "");
+        const args = parseStrictArgs(arguments_, { ...WORKSPACE_OPTIONS, ...(operation === "record" ? { input: "string" } : {}) }, `research scientific fulfillment ${operation}`);
+        if (strictBoolean(args, "help"))
+            return writeHelp(io);
+        const projectId = onePositional(args.positionals, `research scientific fulfillment ${operation}`);
+        const root = await workspaceFromArgs(args);
+        if (operation === "status")
+            writeJson(io, await inspectScientificFulfillment(root, projectId), args);
+        else {
+            const path = strictString(args, "input");
+            if (!path)
+                throw new CliError("Fulfillment record requires --input.", {
+                    code: "RESEARCH_SCIENTIFIC_FULFILLMENT_INVALID",
+                    exitCode: 2,
+                });
+            writeJson(io, await recordScientificFulfillment(root, projectId, await readBoundedJsonRecord(path, "--input", "RESEARCH_SCIENTIFIC_FULFILLMENT_INVALID")), args);
+        }
+        return 0;
+    }
     if (action !== "object")
         throw unknownAction("research scientific", action);
     const [objectAction, ...objectRest] = rest;
@@ -313,6 +403,13 @@ async function runPublication(argv, io) {
     const [action, ...rest] = argv;
     if (!action || action === "--help" || action === "-h")
         return writeHelp(io);
+    if (action === "lineage") {
+        const args = parseStrictArgs(rest, { ...WORKSPACE_OPTIONS }, "research publication lineage");
+        if (strictBoolean(args, "help"))
+            return writeHelp(io);
+        writeJson(io, await inspectPublicationLineage(await workspaceFromArgs(args), onePositional(args.positionals, "research publication lineage")), args);
+        return 0;
+    }
     if (action === "freeze") {
         const args = parseStrictArgs(rest, {
             ...WORKSPACE_OPTIONS,
@@ -335,13 +432,15 @@ async function runPublication(argv, io) {
         }
         const root = await workspaceFromArgs(args);
         const supplementsPath = strictString(args, "supplements");
+        const submission = await readSubmissionFiles(submissionPath);
         writeJson(io, await freezePublicationManuscript({
             root,
             projectId,
             manuscriptPath,
             assessmentPath,
             supplementPaths: supplementsPath ? await readAbsolutePathArray(supplementsPath) : [],
-            submissionFiles: await readSubmissionFiles(submissionPath),
+            submissionFiles: submission.files,
+            resultLineage: submission.resultLineage,
             producerAgent: publicationAgent(strictString(args, "producer-agent"), "producer"),
             producerSessionId,
         }), args);
@@ -519,6 +618,9 @@ async function runSchema(argv, io) {
     if (stage === "task-acceptance") {
         schema = taskAcceptanceInputSchema();
     }
+    else if (stage === "task-native-run") {
+        schema = nativeRunInputSchema();
+    }
     else if (isTaskSchemaName(stage)) {
         schema = taskInputSchema(stage);
     }
@@ -528,6 +630,27 @@ async function runSchema(argv, io) {
     else if (stage === "scientific-design") {
         schema = scientificDesignSchema();
     }
+    else if (stage === "scientific-fulfillment") {
+        schema = scientificFulfillmentSchema();
+    }
+    else if (stage === "investigation-close") {
+        schema = investigationCloseInputSchema();
+    }
+    else if (stage === "investigation-promotion") {
+        schema = investigationPromotionInputSchema();
+    }
+    else if (stage === "investigation-candidate") {
+        schema = investigationCandidateInputSchema();
+    }
+    else if (stage === "investigation-attempt") {
+        schema = investigationAttemptInputSchema();
+    }
+    else if (stage === "investigation") {
+        schema = investigationInputSchema();
+    }
+    else if (stage === "scientific-amendment") {
+        schema = scientificAmendmentSchema();
+    }
     else if (stage.startsWith("scientific-assessment-")) {
         const role = scientificReviewRole(stage.slice("scientific-assessment-".length));
         schema = scientificGateAssessmentSchema(role);
@@ -539,6 +662,9 @@ async function runSchema(argv, io) {
     else if (stage === "publication-assessment") {
         schema = publicationAssessmentSchema();
     }
+    else if (stage === "publication-result-lineage") {
+        schema = publicationResultLineageSchema();
+    }
     else if (stage.startsWith("publication-review-")) {
         const role = publicationReviewRole(stage.slice("publication-review-".length));
         schema = publicationReviewSchema(role);
@@ -570,23 +696,7 @@ function compatibleSchema(schema, compatibility) {
             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;
+    return claudeCodeCompatibleSchema(schema);
 }
 async function runContext(argv, io) {
     const [action, ...rest] = argv;
@@ -793,6 +903,67 @@ async function runProject(argv, io) {
     const [action, ...rest] = argv;
     if (!action || action === "--help" || action === "-h")
         return writeHelp(io);
+    if (action === "investigation") {
+        const [firstOperation, ...firstArguments] = rest;
+        const operation = firstOperation === "promotion" ? `promotion-${firstArguments[0] ?? ""}` : firstOperation;
+        const arguments_ = firstOperation === "promotion" ? firstArguments.slice(1) : firstArguments;
+        if (![
+            "plan",
+            "approve",
+            "status",
+            "attempt",
+            "select",
+            "close",
+            "promotion-plan",
+            "promotion-approve",
+        ].includes(operation ?? ""))
+            throw unknownAction("research project investigation", operation ?? "");
+        const args = parseStrictArgs(arguments_, {
+            ...WORKSPACE_OPTIONS,
+            ...(operation === "status"
+                ? { investigation: "string" }
+                : { input: "string" }),
+            ...(["approve", "promotion-approve"].includes(operation)
+                ? { confirm: "string", "authorization-source": "string" }
+                : {}),
+        }, `research project investigation ${operation}`);
+        if (strictBoolean(args, "help"))
+            return writeHelp(io);
+        const projectId = onePositional(args.positionals, `research project investigation ${operation}`);
+        const root = await workspaceFromArgs(args);
+        if (operation === "status") {
+            const id = strictString(args, "investigation");
+            if (!id)
+                throw new CliError("Investigation status requires --investigation.", {
+                    code: "RESEARCH_INVESTIGATION_INVALID",
+                    exitCode: 2,
+                });
+            writeJson(io, await inspectInvestigation(root, projectId, id), args);
+        }
+        else {
+            const path = strictString(args, "input");
+            if (!path)
+                throw new CliError("Investigation plan/approve requires --input.", {
+                    code: "RESEARCH_INVESTIGATION_INVALID",
+                    exitCode: 2,
+                });
+            const value = await readBoundedJsonRecord(path, "--input", "RESEARCH_INVESTIGATION_INVALID");
+            writeJson(io, operation === "plan"
+                ? await planInvestigation(root, projectId, value)
+                : operation === "attempt"
+                    ? await observeInvestigationAttempt(root, projectId, value)
+                    : operation === "select"
+                        ? await selectInvestigationCandidate(root, projectId, value)
+                        : operation === "close"
+                            ? await closeInvestigation(root, projectId, value)
+                            : operation === "promotion-plan"
+                                ? await planInvestigationPromotion(root, projectId, value)
+                                : operation === "promotion-approve"
+                                    ? await approveInvestigationPromotion(root, projectId, value, strictString(args, "confirm"), strictString(args, "authorization-source"))
+                                    : await approveInvestigation(root, projectId, value, strictString(args, "confirm"), strictString(args, "authorization-source")), args);
+        }
+        return 0;
+    }
     if (action === "audit") {
         const [auditAction, ...auditRest] = rest;
         if (auditAction === "export") {
@@ -981,6 +1152,60 @@ async function runProject(argv, io) {
     }
     if (action === "stage") {
         const [stageAction, ...stageRest] = rest;
+        if (stageAction === "artifacts" || stageAction === "read") {
+            const args = parseStrictArgs(stageRest, {
+                ...WORKSPACE_OPTIONS,
+                session: "string",
+                artifact: "string",
+                offset: "string",
+                limit: "string",
+                length: "string",
+                encoding: "string",
+                "path-prefix": "string",
+            }, `research project stage ${stageAction}`);
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const sessionId = strictString(args, "session");
+            const objectId = strictString(args, "artifact");
+            if (!sessionId || (stageAction === "read" && !objectId))
+                throw new CliError("Stage artifact reads require --session and an exact --artifact for read.", { code: "RESEARCH_NATIVE_STAGE_SESSION_REQUIRED", exitCode: 3 });
+            const offset = strictString(args, "offset");
+            const limit = strictString(args, "limit");
+            const length = strictString(args, "length");
+            const encoding = strictString(args, "encoding");
+            if (encoding && encoding !== "utf8" && encoding !== "base64")
+                throw new CliError("Artifact encoding must be utf8 or base64.", {
+                    code: "RESEARCH_ARTIFACT_VIEW_INVALID",
+                    exitCode: 3,
+                });
+            const projectId = onePositional(args.positionals, `research project stage ${stageAction}`);
+            writeJson(io, await readNativeStageArtifact({
+                root: await workspaceFromArgs(args),
+                projectId,
+                sessionId,
+                ...(stageAction === "read"
+                    ? {
+                        selection: {
+                            objectId: objectId,
+                            ...(offset === undefined ? {} : { offset: Number(offset) }),
+                            ...(length === undefined
+                                ? {}
+                                : { length: length === "all" ? null : Number(length) }),
+                            ...(encoding ? { encoding: encoding } : {}),
+                        },
+                    }
+                    : {
+                        listing: {
+                            ...(offset === undefined ? {} : { offset: Number(offset) }),
+                            ...(limit === undefined ? {} : { limit: Number(limit) }),
+                            ...(strictString(args, "path-prefix")
+                                ? { pathPrefix: strictString(args, "path-prefix") }
+                                : {}),
+                        },
+                    }),
+            }), args);
+            return 0;
+        }
         if (stageAction === "prepare") {
             const args = parseStrictArgs(stageRest, { ...WORKSPACE_OPTIONS, stage: "string", "host-agent": "string" }, "research project stage prepare");
             if (strictBoolean(args, "help"))
@@ -1043,6 +1268,21 @@ async function runProject(argv, io) {
     }
     if (action === "task") {
         const [taskAction, ...taskRest] = rest;
+        if (taskAction === "run") {
+            const [runAction, ...runRest] = taskRest;
+            if (runAction !== "observe" && runAction !== "inspect")
+                throw unknownAction("research project task run", runAction ?? "");
+            const args = parseStrictArgs(runRest, { ...WORKSPACE_OPTIONS, input: "string", run: "string", "confirm-execution": "boolean" }, `research project task run ${runAction}`);
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, `research project task run ${runAction}`);
+            const root = await workspaceFromArgs(args);
+            const result = runAction === "inspect"
+                ? await inspectNativeRun(root, projectId, strictString(args, "run") ?? "")
+                : await observeNativeRun(root, projectId, await readBoundedJsonRecord(strictString(args, "input") ?? "", "--input", "RESEARCH_NATIVE_RUN_INVALID"), strictBoolean(args, "confirm-execution"));
+            writeJson(io, result, args);
+            return "record" in result && result.record && result.record.status !== "succeeded" ? 3 : 0;
+        }
         if (taskAction === "acceptance") {
             const [acceptanceAction, ...acceptanceRest] = taskRest;
             if (acceptanceAction !== "record")
@@ -1116,9 +1356,27 @@ async function runProject(argv, io) {
         }
         if (evidenceAction === "data") {
             const [dataAction, ...dataRest] = evidenceRest;
-            if (dataAction !== "run") {
+            if (dataAction !== "run" && dataAction !== "read") {
                 throw unknownAction("research project evidence data", dataAction ?? "");
             }
+            if (dataAction === "read") {
+                const args = parseStrictArgs(dataRest, { ...WORKSPACE_OPTIONS, receipt: "string", cursor: "string" }, "research project evidence data read");
+                if (strictBoolean(args, "help"))
+                    return writeHelp(io);
+                const projectId = onePositional(args.positionals, "research project evidence data read");
+                const receiptId = strictString(args, "receipt");
+                const cursor = strictString(args, "cursor");
+                if (!receiptId || !cursor) {
+                    throw new CliError("evidence data read requires --receipt and --cursor.", {
+                        code: "RESEARCH_DATA_EVIDENCE_CURSOR_INVALID",
+                        exitCode: 2,
+                    });
+                }
+                const root = await workspaceFromArgs(args);
+                const result = await withWorkspaceLock(root, "research.data-evidence.read", () => readResearchDataEvidence({ root, projectId, receiptId, cursor }));
+                writeJson(io, projectResearchDataEvidenceViewResult(result), args);
+                return 0;
+            }
             const args = parseStrictArgs(dataRest, { ...WORKSPACE_OPTIONS, request: "string" }, "research project evidence data run");
             if (strictBoolean(args, "help"))
                 return writeHelp(io);
@@ -1137,7 +1395,7 @@ async function runProject(argv, io) {
                 projectId,
                 request,
             }));
-            writeJson(io, result, args);
+            writeJson(io, projectResearchDataExecutionResult(result), args);
             return result.coreResult.status === "success"
                 ? 0
                 : result.coreResult.status === "partial"
@@ -1414,10 +1672,54 @@ async function runProject(argv, io) {
         writeJson(io, result, args);
         return 0;
     }
+    if (action === "budget") {
+        const [budgetAction, ...budgetRest] = rest;
+        if (budgetAction === "resolve") {
+            const args = parseStrictArgs(budgetRest, {
+                ...WORKSPACE_OPTIONS,
+                reservation: "string",
+                "accounted-cost-usd": "string",
+                reason: "string",
+                "confirm-budget": "boolean",
+            }, "research project budget resolve");
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, "research project budget resolve");
+            const reservation = strictString(args, "reservation"), amount = strictString(args, "accounted-cost-usd"), reason = strictString(args, "reason");
+            if (!reservation || amount === undefined || !reason)
+                throw new CliError("Budget resolution requires --reservation, --accounted-cost-usd and --reason.", { code: "INVALID_ARGS", exitCode: 2 });
+            const root = await workspaceFromArgs(args);
+            writeJson(io, await resolveProjectBudgetReservation(root, projectId, reservation, Number(amount), reason, strictBoolean(args, "confirm-budget")), args);
+            return 0;
+        }
+        if (budgetAction !== "set")
+            throw unknownAction("research project budget", budgetAction ?? "");
+        const args = parseStrictArgs(budgetRest, {
+            ...WORKSPACE_OPTIONS,
+            "max-cost-usd": "string",
+            "confirm-budget": "boolean",
+            "provider-costs": "string",
+        }, "research project budget set");
+        if (strictBoolean(args, "help"))
+            return writeHelp(io);
+        const projectId = onePositional(args.positionals, "research project budget set");
+        const amount = projectBudgetAmount(strictString(args, "max-cost-usd"));
+        if (amount === undefined)
+            throw new CliError("project budget set requires --max-cost-usd.", {
+                code: "INVALID_ARGS",
+                exitCode: 2,
+            });
+        const root = await workspaceFromArgs(args);
+        writeJson(io, await setProjectBudget(root, projectId, amount, strictBoolean(args, "confirm-budget"), strictString(args, "provider-costs")
+            ? providerCostLimits(await readBoundedJsonRecord(strictString(args, "provider-costs"), "--provider-costs", "RESEARCH_BUDGET_INVALID"))
+            : undefined), args);
+        return 0;
+    }
     if (action === "init") {
         const args = parseStrictArgs(rest, {
             ...WORKSPACE_OPTIONS,
             question: "string",
+            "max-cost-usd": "string",
             goal: "string",
             requirements: "string",
             "input-plan": "string",
@@ -1453,13 +1755,14 @@ async function runProject(argv, io) {
                 exitCode: 2,
             });
         }
+        const projectMaxCostUsd = projectBudgetAmount(strictString(args, "max-cost-usd"));
         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);
+            : undefined, projectMaxCostUsd === undefined ? undefined : { maxCostUsd: projectMaxCostUsd });
         writeJson(io, project, args);
         return 0;
     }
@@ -1467,6 +1770,7 @@ async function runProject(argv, io) {
         const args = parseStrictArgs(rest, {
             ...WORKSPACE_OPTIONS,
             question: "string",
+            "max-cost-usd": "string",
             goal: "string",
             "policy-project": "string",
             requirements: "string",
@@ -1522,9 +1826,11 @@ async function runProject(argv, io) {
         const scientificDesign = designPath
             ? await readAndVerifyScientificDesign(designPath, policyProject)
             : null;
+        const projectMaxCostUsd = projectBudgetAmount(strictString(args, "max-cost-usd"));
         const result = await evaluateProjectPreflight(root, question, requirements, inputPlan, {
             publicationPolicy,
             scientificDesign,
+            ...(projectMaxCostUsd === undefined ? {} : { projectMaxCostUsd }),
         });
         writeJson(io, result, args);
         return result.readyToInitialize ? 0 : 3;
@@ -1762,6 +2068,7 @@ async function runStatus(argv, io) {
                     ? "This recovery target has no project.forked commit marker. Do not execute it; inspect and remove or repair the incomplete fork while retaining source authority."
                     : projectRecommendedAction(root, current, readyPackage, nativeStage, evidencePipeline, publication),
                 usage: current.usage,
+                budget: projectBudgetView(current, config),
                 inputs: current.inputs,
                 packages: current.packages,
                 discovery: await inspectDiscoveryProgress(root, current),
@@ -1904,6 +2211,7 @@ async function inspectPublicationForStatus(root, projectId) {
         return {
             generationStatus: "invalid",
             code: error instanceof CliError ? error.code : "RESEARCH_PUBLICATION_STATE_INVALID",
+            ...(error instanceof CliError && error.details ? { details: error.details } : {}),
         };
     }
 }
@@ -2264,15 +2572,20 @@ async function readAbsolutePathArray(path, option = "supplements") {
 async function readSubmissionFiles(path) {
     const value = await readBoundedJsonRecord(path, "--submission", "RESEARCH_PUBLICATION_SUBMISSION_PACKAGE_INVALID");
     if (value.schemaVersion !== 1 ||
+        Object.keys(value).some((key) => !["schemaVersion", "files", "resultLineage"].includes(key)) ||
         !Array.isArray(value.files) ||
         value.files.some((file) => !isObject(file) ||
+            Object.keys(file).some((key) => !["role", "path"].includes(key)) ||
             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;
+    return {
+        files: value.files,
+        resultLineage: value.resultLineage,
+    };
 }
 function integerOption(value, fallback, label) {
     if (!value)