@tiangong-ai/cli 0.0.59 → 0.0.61

package/dist/research/workspace/scientific-review.js

@@ -1,13 +1,19 @@
 import { Ajv2020 } from "ajv/dist/2020.js";
-import { lstat, readFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { chmod, copyFile, lstat, mkdir, readFile } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { CliError } from "../../errors.js";
+import { taskContext } from "./task-contract.js";
+import { nativeRunArtifactRecords } from "./native-run.js";
+import { loadEvidenceArtifactRecords } from "./artifacts.js";
 import { sourceTypeRequirementGaps } from "./evidence-role-coverage.js";
 import { appendJournalEvent, verifyJournal } from "./journal.js";
 import { loadProject, nextScientificGate, saveProject } from "./projects.js";
+import { projectWithEffectiveAuthority, readProjectAuthorityIndex } from "./project-authority.js";
 import { assertResearchPolicyBinding } from "./research-policy.js";
-import { evaluateScientificDesign, parseScientificDesign, scientificDesignPolicyGaps, } from "./scientific-design.js";
+import { evaluateScientificDesign, scientificDesignPolicyGaps, } from "./scientific-design.js";
 import { resolveScientificObjectBinding } from "./scientific-objects.js";
+import { loadScientificFulfillmentView, scientificFulfillmentLocator, } from "./scientific-fulfillment.js";
 import { sanitizeResearchValue } from "./sanitization.js";
 import { canonicalJson, fileRecord, isObject, pathExists, resolveContained, sha256File, sha256Text, workspacePaths, writeBytesAtomic, writeJsonAtomic, writeTextAtomic, } from "./storage.js";
 import { loadWorkspaceConfig, verifyDoctorAttestation, withWorkspaceLock } from "./workspace.js";
@@ -263,7 +269,8 @@ export async function prepareScientificReview(input) {
                 exitCode: 3,
             });
         }
-        const design = await loadBoundScientificDesign(input.root, project);
+        const fulfillment = await loadScientificFulfillmentView(input.root, project, input.role);
+        const design = fulfillment.contract;
         const assessment = await readAssessment(input.assessmentPath, input.role);
         if (assessment.designSha256 !== project.scientificDesign.designSha256) {
             throw new CliError("Scientific assessment does not match the frozen design.", {
@@ -272,6 +279,68 @@ export async function prepareScientificReview(input) {
             });
         }
         const stageInputs = await stageInputRecords(input.root, project, input.role, design, assessment, input.canaryArtifactPaths ?? []);
+        const currentTask = await taskContext(input.root, project.id);
+        if (currentTask) {
+            for (const record of await nativeRunArtifactRecords(input.root, project.id)) {
+                const locator = `projects/${project.id}/${record.path}`;
+                stageInputs.push({
+                    ...record,
+                    path: locator,
+                    sourceLocator: locator,
+                    purpose: "native-calculation",
+                    ownerId: project.id,
+                    hashBasis: "raw-file-bytes",
+                    mediaType: record.path.endsWith(".json")
+                        ? "application/json"
+                        : "application/octet-stream",
+                    objectKind: null,
+                    registrationRecordSha256: null,
+                });
+            }
+        }
+        const requestSource = currentTask?.requestProvenance.source;
+        if (requestSource) {
+            const locator = `projects/${project.id}/task/request-sources/${requestSource.objectSha256}.json`;
+            stageInputs.push({
+                ...(await fileRecord(resolveContained(paths.control, locator), locator)),
+                purpose: "original-request-source",
+                ownerId: project.id,
+                sourceLocator: locator,
+                hashBasis: "raw-file-bytes",
+                mediaType: "application/json",
+                objectKind: null,
+                registrationRecordSha256: null,
+            });
+        }
+        if (input.role !== "research-design")
+            stageInputs.push(...(await modelObjectInputs(input.root, project.id, design)));
+        if (fulfillment.records.length) {
+            for (const record of fulfillment.records) {
+                const locator = scientificFulfillmentLocator(project.id, record.recordSha256);
+                stageInputs.push({
+                    ...(await fileRecord(resolveContained(paths.control, locator), locator)),
+                    purpose: "scientific-fulfillment",
+                    ownerId: project.id,
+                    sourceLocator: locator,
+                    hashBasis: "raw-file-bytes",
+                    mediaType: "application/json",
+                    objectKind: null,
+                    registrationRecordSha256: null,
+                });
+            }
+            const locator = `projects/${project.id}/scientific/design/views/${fulfillment.effectiveSha256}.json`;
+            await writeImmutableJson(resolveContained(paths.control, locator), design);
+            stageInputs.push({
+                ...(await fileRecord(resolveContained(paths.control, locator), locator)),
+                purpose: "effective-scientific-design",
+                ownerId: project.id,
+                sourceLocator: locator,
+                hashBasis: "raw-file-bytes",
+                mediaType: "application/json",
+                objectKind: null,
+                registrationRecordSha256: null,
+            });
+        }
         const assessmentSha256 = exactJsonSha256(assessment);
         const assessmentLocator = `projects/${project.id}/scientific/assessments/${input.role}/${assessmentSha256}.json`;
         await writeImmutableJson(join(paths.control, assessmentLocator), assessment);
@@ -287,7 +356,7 @@ export async function prepareScientificReview(input) {
         };
         await assertBoundPolicyObject(input.root, project, packetPolicy);
         const designEvaluation = evaluateScientificDesign(design);
-        const issues = evaluateAssessment(input.role, assessment, design, project.evidenceRequirements, project.publicationPolicy, await assessmentEvidenceContext(input.root, project, input.role, stageInputs));
+        const issues = evaluateAssessment(input.role, assessment, design, project.evidenceRequirements, project.publicationPolicy, await assessmentEvidenceContext(input.root, project, input.role, stageInputs), fulfillment.deferredObjectRuleIds);
         const futureGateObligations = scientificFutureGateObligations(design, input.role);
         const packetCore = {
             schemaVersion: 1,
@@ -297,11 +366,16 @@ export async function prepareScientificReview(input) {
             design: {
                 sha256: project.scientificDesign.designSha256,
                 objectLocator: project.scientificDesign.objectLocator,
+                fulfillment: {
+                    headSha256: fulfillment.headSha256,
+                    effectiveSha256: fulfillment.effectiveSha256,
+                },
             },
             policy: packetPolicy,
             reviewer: { agent: input.reviewerAgent, sessionSha256: reviewerSessionSha256 },
             preparedAt: new Date().toISOString(),
             stageInputs,
+            taskContract: currentTask,
             assessment: { sha256: assessmentSha256, objectLocator: assessmentLocator },
             mechanicalAssessment: {
                 canPass: issues.length === 0 && assessment.recommendation === "pass",
@@ -328,7 +402,10 @@ export async function prepareScientificReview(input) {
                 newGenerationOnMaterialChange: true,
                 revisionReserveIncluded: true,
             },
-            instructions: reviewInstructions(input.role),
+            instructions: [
+                ...reviewInstructions(input.role),
+                "Scientific fulfillment files supply only previously declared pending object slots. The base design and policy dispositions remain immutable. Discharging an object-filing blocker does not establish calibration, justification or scientific correctness: independently assess the actual code, locks and source-bound values under every original policy rule.",
+            ],
         };
         const packetSha256 = sha256Text(canonicalJson(packetCore));
         const packet = { ...packetCore, packetSha256 };
@@ -500,8 +577,9 @@ export { readReview as readScientificReviewOutput };
 export async function assertScientificGateForStage(root, project, stage) {
     if (!project.scientificDesign)
         return;
-    const design = await loadBoundScientificDesign(root, project);
     for (const role of requiredGateRoles(stage)) {
+        const fulfillment = await loadScientificFulfillmentView(root, project, role);
+        const design = fulfillment.contract;
         const gate = project.scientificDesign.gates[role];
         if (gate.status !== "passed" || !gate.packetSha256 || !gate.reviewSha256) {
             throw new CliError(`Scientific ${role} review must pass before ${stage}.`, {
@@ -513,7 +591,7 @@ export async function assertScientificGateForStage(root, project, stage) {
         const packet = await loadBoundPacket(root, project, role, gate.packetSha256);
         const review = await loadBoundReview(root, project, role, gate.reviewSha256);
         const assessment = await loadBoundAssessment(root, project, role, packet);
-        const currentIssues = evaluateAssessment(role, assessment, design, project.evidenceRequirements, project.publicationPolicy, await assessmentEvidenceContext(root, project, role, packet.stageInputs)).map((issue) => issue.code);
+        const currentIssues = evaluateAssessment(role, assessment, design, project.evidenceRequirements, project.publicationPolicy, await assessmentEvidenceContext(root, project, role, packet.stageInputs), fulfillment.deferredObjectRuleIds).map((issue) => issue.code);
         if (packet.assessment.sha256 !== gate.assessmentSha256 ||
             packet.reviewer.sessionSha256 !== gate.reviewerSessionSha256 ||
             review.packetSha256 !== packet.packetSha256 ||
@@ -526,8 +604,9 @@ export async function assertScientificGateForStage(root, project, stage) {
         }
     }
 }
-export async function inspectScientificReviewStatus(root, projectId) {
-    const project = await loadProject(root, projectId);
+export async function inspectScientificReviewStatus(root, projectId, knownProject) {
+    const project = knownProject ??
+        projectWithEffectiveAuthority(await loadProject(root, projectId), await readProjectAuthorityIndex(root));
     if (!project.scientificDesign) {
         return { projectId, reviewState: "not-required", nextGate: null, gates: null };
     }
@@ -546,7 +625,7 @@ export async function inspectScientificReviewStatus(root, projectId) {
         gates: structuredClone(project.scientificDesign.gates),
     };
 }
-function evaluateAssessment(role, assessment, design, requirements, policy, evidenceContext = null) {
+function evaluateAssessment(role, assessment, design, requirements, policy, evidenceContext = null, deferredObjectRuleIds = []) {
     const issues = new Map();
     const add = (code, message, objectIds = []) => {
         if (!issues.has(code))
@@ -562,25 +641,26 @@ function evaluateAssessment(role, assessment, design, requirements, policy, evid
         add(`POLICY_${gap.replaceAll(/[^A-Za-z0-9]+/gu, "_").toUpperCase()}`, "The frozen scientific design no longer matches its approved Research Policy disposition contract.", [gap]);
     }
     const duePolicyRules = design.policyRuleDispositions.filter((disposition) => disposition.status === "planned" &&
+        !deferredObjectRuleIds.includes(disposition.ruleId) &&
         disposition.dueGate !== "publication-freeze" &&
         gateRank[disposition.dueGate] <= gateRank[role]);
     if (duePolicyRules.length) {
-        add("POLICY_RULE_DUE_UNRESOLVED", "A planned Research Policy rule reached its declared early-review gate without a new design generation that records how it was satisfied.", duePolicyRules.map((disposition) => disposition.ruleId));
+        add("POLICY_RULE_DUE_UNRESOLVED", "A planned Research Policy rule reached its early-review gate without its declared object fulfillment or reviewed design resolution.", duePolicyRules.map((disposition) => disposition.ruleId));
     }
     const dueUncertaintyFreezes = design.uncertaintyParameters.filter((parameter) => parameter.stateValueStatus === "pending-source-acquisition" &&
         gateRank[parameter.freezeBeforeGate] <= gateRank[role]);
     if (dueUncertaintyFreezes.length) {
-        add("UNCERTAINTY_STATE_VALUES_NOT_FROZEN", "Source-derived uncertainty values reached their declared freeze gate without a new authoritative design generation containing exact states and source bindings.", dueUncertaintyFreezes.map((parameter) => parameter.id));
+        add("UNCERTAINTY_STATE_VALUES_NOT_FROZEN", "Source-derived uncertainty values reached their freeze gate without exact states and admitted source bindings.", dueUncertaintyFreezes.map((parameter) => parameter.id));
     }
     const dueModelImplementations = design.identity.modelStructures.filter((model) => model.implementationStatus === "pending-source-acquisition" &&
         gateRank[model.implementationFreezeBeforeGate] <= gateRank[role]);
     if (dueModelImplementations.length) {
-        add("MODEL_IMPLEMENTATION_NOT_FROZEN", "A model implementation reached its declared freeze gate without a new authoritative design generation binding executable model bytes.", dueModelImplementations.map((model) => model.id));
+        add("MODEL_IMPLEMENTATION_NOT_FROZEN", "A model implementation reached its freeze gate without binding the declared executable bytes.", dueModelImplementations.map((model) => model.id));
     }
     const dueModelEnvironmentLocks = design.identity.modelStructures.filter((model) => model.environmentLockStatus === "pending-runtime-lock" &&
         gateRank[model.environmentLockFreezeBeforeGate] <= gateRank[role]);
     if (dueModelEnvironmentLocks.length) {
-        add("MODEL_ENVIRONMENT_LOCK_NOT_FROZEN", "A model environment reached its declared freeze gate without a new authoritative design generation binding an exact runtime and dependency lock.", dueModelEnvironmentLocks.map((model) => model.id));
+        add("MODEL_ENVIRONMENT_LOCK_NOT_FROZEN", "A model environment reached its freeze gate without an exact runtime and dependency lock.", dueModelEnvironmentLocks.map((model) => model.id));
     }
     if (role === "research-design") {
         const value = assessment;
@@ -844,30 +924,7 @@ async function stageInputRecords(root, project, role, design, assessment, canary
                 registrationRecordSha256: null,
             });
         };
-        for (const model of design.identity.modelStructures) {
-            if (model.implementationStatus === "executable-frozen") {
-                records.push(await promoteRegisteredModelObject({
-                    root,
-                    projectId: project.id,
-                    objectKind: "model-implementation",
-                    sourceLocator: model.implementationArtifactLocator,
-                    sha256: model.implementationArtifactSha256,
-                    purpose: "model-implementation",
-                    ownerId: model.id,
-                }));
-            }
-            if (model.environmentLockStatus === "exact-frozen") {
-                records.push(await promoteRegisteredModelObject({
-                    root,
-                    projectId: project.id,
-                    objectKind: "environment-lock",
-                    sourceLocator: model.environmentLockLocator,
-                    sha256: model.environmentLockSha256,
-                    purpose: "model-environment-lock",
-                    ownerId: model.id,
-                }));
-            }
-        }
+        records.push(...(await modelObjectInputs(root, project.id, design)));
         for (const gap of design.knownGaps) {
             for (const artifact of gap.sourceArtifacts) {
                 await promoteLegacyJson({
@@ -891,8 +948,7 @@ async function stageInputRecords(root, project, role, design, assessment, canary
         });
     }
     const relativeOutputs = ["outputs/acquisition.json", "outputs/evidence-snapshot.json"];
-    if (role === "evidence-construct" &&
-        (await pathExists(join(projectRoot, "outputs", "content-snapshot.json")))) {
+    if (await pathExists(join(projectRoot, "outputs", "content-snapshot.json"))) {
         relativeOutputs.push("outputs/content-snapshot.json");
     }
     const stageOutputs = await Promise.all(relativeOutputs.map(async (relativePath) => {
@@ -908,6 +964,62 @@ async function stageInputRecords(root, project, role, design, assessment, canary
             registrationRecordSha256: null,
         };
     }));
+    const snapshot = await readExactJson(join(projectRoot, "outputs/evidence-snapshot.json"), "Scientific evidence snapshot", "RESEARCH_SCIENTIFIC_GATE_INVALID");
+    if (!isObject(snapshot) || !Array.isArray(snapshot.artifacts))
+        throw scientificGateError("Scientific evidence snapshot has no exact artifact set.", role);
+    if (snapshot.artifacts.length) {
+        const registered = new Map((await loadEvidenceArtifactRecords(root, project.id)).map((artifact) => [
+            artifact.artifactId,
+            artifact,
+        ]));
+        for (const selected of snapshot.artifacts) {
+            const artifact = isObject(selected) && typeof selected.artifactId === "string"
+                ? registered.get(selected.artifactId)
+                : undefined;
+            if (!artifact ||
+                !isObject(selected) ||
+                artifact.sha256 !== selected.sha256 ||
+                artifact.bytes !== selected.bytes ||
+                artifact.locator !== selected.locator ||
+                artifact.mediaType !== selected.mediaType)
+                throw scientificGateError("Scientific review source is not the exact frozen registered artifact.", role);
+            let directory = projectRoot;
+            for (const part of ["scientific", "evidence-objects", artifact.sha256]) {
+                directory = join(directory, part);
+                await mkdir(directory, { mode: 0o700 }).catch((error) => {
+                    if (error.code !== "EEXIST")
+                        throw error;
+                });
+                const info = await lstat(directory);
+                if (!info.isDirectory() || info.isSymbolicLink())
+                    throw scientificGateError("Scientific evidence directories cannot redirect through links.", role);
+            }
+            const path = `projects/${project.id}/scientific/evidence-objects/${artifact.sha256}/blob`;
+            const target = resolveContained(paths.control, path);
+            if (!(await pathExists(target))) {
+                await copyFile(resolveContained(paths.control, artifact.locator), target, constants.COPYFILE_EXCL | constants.COPYFILE_FICLONE);
+                await chmod(target, 0o444);
+            }
+            const info = await lstat(target);
+            if (!info.isFile() ||
+                info.isSymbolicLink() ||
+                info.size !== artifact.bytes ||
+                (await sha256File(target)) !== artifact.sha256)
+                throw scientificGateError("Scientific review source bytes changed while staging.", role);
+            stageOutputs.push({
+                path,
+                sha256: artifact.sha256,
+                bytes: artifact.bytes,
+                purpose: "acquired-evidence",
+                ownerId: artifact.artifactId,
+                sourceLocator: artifact.locator,
+                hashBasis: "raw-file-bytes",
+                mediaType: artifact.mediaType,
+                objectKind: null,
+                registrationRecordSha256: null,
+            });
+        }
+    }
     if (role !== "evidence-construct") {
         if (canaryArtifactPaths.length)
             throw canaryArtifactError("Only evidence-construct accepts canary artifacts.");
@@ -981,6 +1093,32 @@ async function stageInputRecords(root, project, role, design, assessment, canary
     }
     return [...stageOutputs, ...canaryRecords];
 }
+async function modelObjectInputs(root, projectId, design) {
+    const records = [];
+    for (const model of design.identity.modelStructures) {
+        if (model.implementationStatus === "executable-frozen")
+            records.push(await promoteRegisteredModelObject({
+                root,
+                projectId,
+                objectKind: "model-implementation",
+                sourceLocator: model.implementationArtifactLocator,
+                sha256: model.implementationArtifactSha256,
+                purpose: "model-implementation",
+                ownerId: model.id,
+            }));
+        if (model.environmentLockStatus === "exact-frozen")
+            records.push(await promoteRegisteredModelObject({
+                root,
+                projectId,
+                objectKind: "environment-lock",
+                sourceLocator: model.environmentLockLocator,
+                sha256: model.environmentLockSha256,
+                purpose: "model-environment-lock",
+                ownerId: model.id,
+            }));
+    }
+    return records;
+}
 async function promoteRegisteredModelObject(input) {
     const resolvedObject = await resolveScientificObjectBinding({
         root: input.root,
@@ -1116,19 +1254,7 @@ async function assessmentEvidenceContext(root, project, role, stageInputs) {
     };
 }
 async function loadBoundScientificDesign(root, project) {
-    const binding = project.scientificDesign;
-    if (!binding)
-        throw scientificGateError("Project has no scientific design binding.");
-    const path = join(workspacePaths(root).control, binding.objectLocator);
-    const value = await readExactJson(path, "Scientific design", "RESEARCH_SCIENTIFIC_GATE_INVALID");
-    const design = parseScientificDesign(value);
-    const normalized = normalizedJson(design);
-    if (design.projectId !== project.id ||
-        sha256Text(normalized) !== binding.designSha256 ||
-        (await readFile(path, "utf8")) !== normalized) {
-        throw scientificGateError("Frozen scientific design failed its exact binding.");
-    }
-    return design;
+    return (await loadScientificFulfillmentView(root, project)).contract;
 }
 async function loadBoundPacket(root, project, role, packetSha256) {
     const path = join(workspacePaths(root).projects, project.id, "scientific", "review-packets", role, `${packetSha256}.json`);
@@ -1143,6 +1269,20 @@ async function loadBoundPacket(root, project, role, packetSha256) {
         throw scientificGateError("Scientific review packet failed its immutable hash binding.", role);
     }
     await assertBoundPolicyObject(root, project, value.policy);
+    const fulfillment = await loadScientificFulfillmentView(root, project, role);
+    if (value.design.fulfillment) {
+        if (value.design.fulfillment.effectiveSha256 !== fulfillment.effectiveSha256 ||
+            (value.design.fulfillment.headSha256 !== null &&
+                !fulfillment.records.some((record) => record.recordSha256 === value.design.fulfillment.headSha256))) {
+            throw scientificGateError("Scientific review has a stale or uncommitted fulfillment view.", role);
+        }
+    }
+    else if (canonicalJson(fulfillment.contract) !== canonicalJson(fulfillment.base)) {
+        throw scientificGateError("Scientific review does not bind the fulfilled scientific objects.", role);
+    }
+    if (canonicalJson(value.taskContract ?? null) !== canonicalJson(await taskContext(root, project.id))) {
+        throw scientificGateError("Scientific review no longer binds the current authorized task scope.", role);
+    }
     await assertBoundStageInputs(root, value.stageInputs, role);
     return value;
 }
@@ -1305,6 +1445,13 @@ function isScientificReviewPacket(value, projectId, role, finalPublicationReview
         isObject(value.design) &&
         typeof value.design.sha256 === "string" &&
         typeof value.design.objectLocator === "string" &&
+        (value.design.fulfillment === undefined ||
+            (isObject(value.design.fulfillment) &&
+                (value.design.fulfillment.headSha256 === null ||
+                    (typeof value.design.fulfillment.headSha256 === "string" &&
+                        new RegExp(SHA256_PATTERN).test(value.design.fulfillment.headSha256))) &&
+                typeof value.design.fulfillment.effectiveSha256 === "string" &&
+                new RegExp(SHA256_PATTERN).test(value.design.fulfillment.effectiveSha256))) &&
         isObject(value.policy) &&
         typeof value.policy.resolvedPolicySha256 === "string" &&
         typeof value.policy.approvalSha256 === "string" &&
@@ -1330,6 +1477,11 @@ function isScientificReviewPacket(value, projectId, role, finalPublicationReview
                 "inherited-gap",
                 "model-implementation",
                 "model-environment-lock",
+                "scientific-fulfillment",
+                "effective-scientific-design",
+                "original-request-source",
+                "native-calculation",
+                "acquired-evidence",
                 "stage-output",
             ].includes(String(record.purpose)) &&
             typeof record.ownerId === "string" &&