@tiangong-ai/cli 0.0.59 → 0.0.60

package/dist/research/workspace/runtime.js

@@ -2,6 +2,10 @@ import { randomUUID } from "node:crypto";
 import { cp, lstat, readFile, rm } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { CliError } from "../../errors.js";
+import { isConsistentAnalysisRunMetadata } from "./analysis-run.js";
+import { taskContext } from "./task-contract.js";
+import { compileTaskAcceptanceContext, inspectProjectTask, taskAcceptancePrompt, validateTaskReview, } from "./task-acceptance.js";
+import { assertProjectAuthority, projectAuthority, projectWithEffectiveAuthority, readProjectAuthorityIndex, } from "./project-authority.js";
 import { dataPublicSchemas } from "../../data/schemas.js";
 import { loadCapabilityDeclarations, stageLockedCapabilities, verifyCapabilities, } from "./capabilities.js";
 import { startCapabilityBroker } from "./broker.js";
@@ -177,13 +181,13 @@ async function runResearchWorkspaceInternal(root, options, packageExecutor, allo
     if (options.dryRun)
         return dryRunResult(root, requestId, options.projectId);
     return withWorkspaceLock(root, "research.run", async () => {
-        await verifyJournal(workspacePaths(root).journal);
+        const authority = await readProjectAuthorityIndex(root);
         const config = await loadWorkspaceConfig(root);
         assertExecutionConfiguration(config);
         const reviewerPackageExecutor = useConfiguredReviewerExecutor
             ? createReviewExecutor({ root, execution: config.reviewerExecution }).execute
             : null;
-        for (const project of await projectsForRun(root, options.projectId)) {
+        for (const project of await projectsForRun(root, options.projectId, authority)) {
             await assertProjectPublicationPolicy(root, project);
         }
         let doctorAttestation = null;
@@ -205,7 +209,7 @@ async function runResearchWorkspaceInternal(root, options, packageExecutor, allo
                 });
             }
             doctorAttestation = verification.attestation;
-            const unconfirmed = (await projectsForRun(root, options.projectId)).filter((project) => config.budget.maxCostUsd > config.budget.confirmationCostUsd &&
+            const unconfirmed = (await projectsForRun(root, options.projectId, authority)).filter((project) => config.budget.maxCostUsd > config.budget.confirmationCostUsd &&
                 !project.budgetConfirmedAt);
             if (unconfirmed.length) {
                 throw new CliError("Production research budget has not been explicitly confirmed.", {
@@ -219,7 +223,7 @@ async function runResearchWorkspaceInternal(root, options, packageExecutor, allo
         const executed = [];
         let cycles = 0;
         while (cycles < options.maxCycles) {
-            const projects = await projectsForRun(root, options.projectId);
+            const projects = await projectsForRun(root, options.projectId, authority);
             const selected = projects
                 .map((project) => ({ project, workPackage: nextReadyPackage(project) }))
                 .filter((item) => Boolean(item.workPackage) &&
@@ -233,7 +237,7 @@ async function runResearchWorkspaceInternal(root, options, packageExecutor, allo
             const results = await Promise.all(selected.map(({ project, workPackage }) => executeWorkPackage(root, project.id, workPackage.id, config, options, requestId, packageExecutor, reviewerPackageExecutor, doctorAttestation)));
             executed.push(...results);
         }
-        const result = await summarizeRun(root, requestId, cycles, executed, options.maxCycles, options.projectId);
+        const result = await summarizeRun(root, requestId, cycles, executed, options.maxCycles, options.projectId, authority);
         emitProgress(options, progressEvent("run.completed", requestId, options.projectId ?? null, null, null, {
             status: result.status,
             stopReason: result.stopReason,
@@ -306,10 +310,11 @@ export async function inspectNativeResearchStage(root, project) {
 }
 export async function prepareNativeResearchStage(input) {
     return withWorkspaceLock(input.root, "research.native-stage.prepare", async () => {
-        await verifyJournal(workspacePaths(input.root).journal);
+        const authority = await readProjectAuthorityIndex(input.root);
         const config = await loadWorkspaceConfig(input.root);
         assertExecutionConfiguration(config);
-        const project = await loadProject(input.root, input.projectId);
+        const project = projectWithEffectiveAuthority(await loadProject(input.root, input.projectId), authority);
+        assertProjectAuthority(project, authority);
         await assertScientificGateForStage(input.root, project, input.stage);
         await assertProjectPublicationPolicy(input.root, project);
         if (config.producer.agent !== input.hostAgent) {
@@ -397,9 +402,22 @@ export async function prepareNativeResearchStage(input) {
             const dataCapabilities = projectResearchDataCapabilities();
             const hasDataEvidence = dataCapabilities.capabilities.length > 0;
             const basePrompt = packagePrompt(project, workPackage, capsule.inputManifest, capsule.stagedSkills, capsule.capabilityDocumentation, null, capsule.contextBundle, capsule.contextBundleContent, stageContextContent, discovery, await listEvidenceCandidates(input.root, project.id));
+            const taskContract = await taskContext(input.root, project.id, authority.taskEvents.get(project.id) ?? []);
+            const taskPrompt = taskContract
+                ? "Original task and current authorized scope (a workflow finish is not task completion):\n" +
+                    JSON.stringify(taskContract)
+                : "";
+            if (taskContract &&
+                Buffer.byteLength(taskPrompt +
+                    (input.stage === "discover" ? capsule.contextBundleContent : "") +
+                    stageContextContent, "utf8") >
+                    config.budget.maxInputContextTokens * RESEARCH_ESTIMATED_BYTES_PER_TOKEN) {
+                throw new CliError("The complete task and evidence context exceeds the reviewed input allowance. Condense representation without dropping requirements or explicitly review a larger context budget.", { code: "RESEARCH_TASK_CONTEXT_TOO_LARGE", exitCode: 3 });
+            }
             const prompt = [
                 "Perform this producer stage in the current interactive host session. Do not launch codex exec, claude -p, or any other nested reasoning agent.",
                 capsule.publicationPolicyDocumentation,
+                taskPrompt,
                 input.stage === "discover" && (hasBrokeredEvidence || hasDataEvidence)
                     ? [
                         hasBrokeredEvidence
@@ -436,6 +454,7 @@ export async function prepareNativeResearchStage(input) {
                     ? { inputOnlyProvenanceIds: capsule.inputManifest.map((record) => record.id) }
                     : {}),
                 publicationPolicy: capsule.publicationPolicy,
+                taskContract,
                 discovery,
                 limits: {
                     maxOutputBytes: config.budget.maxBytesPerPackage,
@@ -792,6 +811,8 @@ export function nativeEvidenceRequestSchema(requireAcquisitionRoute) {
 }
 export async function submitNativeResearchStage(input) {
     return withWorkspaceLock(input.root, "research.native-stage.submit", async () => {
+        const authority = await readProjectAuthorityIndex(input.root);
+        assertProjectAuthority(await loadProject(input.root, input.projectId), authority);
         const session = await readNativeStageSession(input.root, input.projectId);
         if (session.packet.sessionId !== input.sessionId) {
             throw new CliError("Native stage session ID does not match the active session.", {
@@ -1264,7 +1285,11 @@ async function executeWorkPackage(root, projectId, packageId, config, options, r
                 : null;
             const stageOutputTokens = discovery?.plan.outputTokenLimit ?? config.budget.maxOutputTokens;
             const reservation = reservePackageBudget(project, workPackage, config, discovery?.plan.reservedDiscoverTokens);
-            const capsule = await createCapsule(root, project, workPackage, runId, config);
+            const taskAcceptance = workPackage.stage === "review" ? await compileTaskAcceptanceContext(root, project) : null;
+            if (taskAcceptance?.requirements.some((row) => row.current && row.status === "unanswered")) {
+                throw new CliError("Record an actual check or an honest not-run/inconclusive disposition for each current requirement before spending review budget.", { code: "RESEARCH_TASK_ACCEPTANCE_REQUIRED", exitCode: 3 });
+            }
+            const capsule = await createCapsule(root, project, workPackage, runId, config, taskAcceptance);
             capsuleRoot = capsule.capsuleRoot;
             capsuleDisposition = capsuleDispositionForHost(config.producer.agent);
             retainedCapsuleId =
@@ -1303,7 +1328,8 @@ async function executeWorkPackage(root, projectId, packageId, config, options, r
                 prompt: packagePrompt(project, workPackage, capsule.inputManifest, capsule.stagedSkills, capsule.capabilityDocumentation, capsule.reviewPacketSha256, capsule.contextBundle, capsule.contextBundleContent, stageContextContent, discovery, await listEvidenceCandidates(root, project.id)) +
                     (capsule.publicationPolicyDocumentation
                         ? `\n\n${capsule.publicationPolicyDocumentation}`
-                        : ""),
+                        : "") +
+                    (capsule.taskAcceptancePrompt ? `\n\n${capsule.taskAcceptancePrompt}` : ""),
                 brokerUrl: primaryBrokerUrl,
                 inputOnlyProvenance,
                 maxOutputTokens: Math.min(stageOutputTokens, reservation.tokens),
@@ -1557,7 +1583,7 @@ async function stagePublicationPolicy(root, project, capsuleProject) {
     await writeJsonAtomic(staged.manifestPath, staged);
     return staged;
 }
-async function createCapsule(root, project, workPackage, runId, config) {
+async function createCapsule(root, project, workPackage, runId, config, taskAcceptance = null) {
     const paths = workspacePaths(root);
     const capsuleRoot = join(paths.runtime, runId);
     const capsuleProject = join(capsuleRoot, "project");
@@ -1673,7 +1699,7 @@ async function createCapsule(root, project, workPackage, runId, config) {
         ? await writeReviewEvidenceContext(root, project.id, capsuleProject, contextBundleContent, evidenceReceipts, contextualEvidenceArtifacts, config.budget.maxInputContextTokens * RESEARCH_ESTIMATED_BYTES_PER_TOKEN)
         : null;
     const reviewPacket = reviewEvidenceContext
-        ? await writeReviewPacket(root, capsuleProject, project, inputManifest, evidenceReceipts, evidenceArtifacts, reviewEvidenceContext.persistent)
+        ? await writeReviewPacket(root, capsuleProject, project, inputManifest, evidenceReceipts, evidenceArtifacts, reviewEvidenceContext.persistent, taskAcceptance)
         : null;
     return {
         capsuleRoot,
@@ -1687,6 +1713,8 @@ async function createCapsule(root, project, workPackage, runId, config) {
         publicationPolicyDocumentation,
         reviewPacketSha256: reviewPacket?.sha256 ?? null,
         reviewPacketRecord: reviewPacket?.record ?? null,
+        taskAcceptance,
+        taskAcceptancePrompt: await taskAcceptancePrompt(root, taskAcceptance),
     };
 }
 async function buildCapabilityDocumentation(capsuleProject, stagedSkills, maxBytes) {
@@ -1733,7 +1761,7 @@ async function buildInputContextBundle(capsuleProject, inputManifest) {
     }
     return `${sections.join("\n\n")}\n`;
 }
-async function writeReviewPacket(root, capsuleProject, project, inputManifest, evidenceReceipts, evidenceArtifacts, reviewEvidenceContext) {
+async function writeReviewPacket(root, capsuleProject, project, inputManifest, evidenceReceipts, evidenceArtifacts, reviewEvidenceContext, taskAcceptance) {
     const snapshot = await loadCurrentEvidenceSnapshot(root, project.id);
     const immutableSnapshots = await loadImmutableEvidenceSnapshotChain(root, project.id, snapshot.snapshotSha256);
     const snapshotChain = await Promise.all(immutableSnapshots.map((immutableSnapshot) => {
@@ -1790,6 +1818,7 @@ async function writeReviewPacket(root, capsuleProject, project, inputManifest, e
             parentSnapshotSha256: snapshot.parentSnapshotSha256,
         },
         snapshotChain,
+        taskAcceptance,
         inputs: inputManifest,
         reviewEvidenceContext,
         inputFiles: [...inputFiles.values()].sort((left, right) => left.path.localeCompare(right.path)),
@@ -2130,7 +2159,7 @@ async function persistReviewPacket(root, projectId, packet, packetSha256) {
     }
     return fileRecord(path, logicalPath);
 }
-async function loadVerifiedReviewPacket(root, projectId, packetSha256) {
+export async function loadVerifiedReviewPacket(root, projectId, packetSha256) {
     const logicalPath = `review/packets/${packetSha256}.json`;
     const path = resolveContained(projectRoot(root, projectId), logicalPath);
     const packet = await readJsonFile(path, "Research review packet");
@@ -2295,9 +2324,19 @@ function agentRequest(input) {
     return {
         route: input.route,
         prompt: input.prompt,
-        outputSchema: schemaForStage(input.workPackage.stage, input.capsule.reviewPacketSha256, input.inputOnlyProvenance
-            ? { inputOnlyProvenanceIds: input.capsule.inputManifest.map((record) => record.id) }
-            : {}),
+        outputSchema: schemaForStage(input.workPackage.stage, input.capsule.reviewPacketSha256, {
+            ...(input.inputOnlyProvenance
+                ? { inputOnlyProvenanceIds: input.capsule.inputManifest.map((record) => record.id) }
+                : {}),
+            ...(input.capsule.taskAcceptance
+                ? {
+                    taskAcceptance: {
+                        contextSha256: input.capsule.taskAcceptance.contextSha256,
+                        requirementSha256s: input.capsule.taskAcceptance.requirements.map((row) => row.requirementSha256),
+                    },
+                }
+                : {}),
+        }),
         requestId: input.requestId,
         purpose: input.purpose,
         capsuleRoot: input.capsule.capsuleRoot,
@@ -2400,6 +2439,7 @@ async function validateOutputShape(root, project, workPackage, path, reviewPacke
         await validateAnalysis(path, value);
     }
     if (workPackage.stage === "review") {
+        validateTaskReview(value, await compileTaskAcceptanceContext(root, project));
         if (value.decision !== "pass") {
             throw new CliError("Independent review requested revision.", {
                 code: "RESEARCH_REVIEW_REVISION_REQUIRED",
@@ -2514,23 +2554,10 @@ async function validateAnalysis(path, value) {
         inputArtifactSha256s.some((sha256) => !allowedInputSha256s.has(sha256))) {
         throw new StructuredOutputError("Analysis run refers to an artifact outside the inference snapshot.");
     }
-    if (run.mode === "qualitative") {
-        if (run.status !== "not-applicable" ||
-            run.command !== null ||
-            run.randomSeed !== null ||
-            implementationSha256s.length > 0 ||
-            environmentSha256s.length > 0) {
-            throw new StructuredOutputError("Qualitative analysis run metadata is inconsistent.");
-        }
-    }
-    else if (run.status !== "reproduced" ||
-        typeof run.command !== "string" ||
-        run.command.trim().length < 1 ||
-        typeof run.randomSeed !== "string" ||
-        run.randomSeed.trim().length < 1 ||
-        implementationSha256s.length < 1 ||
-        environmentSha256s.length < 1) {
-        throw new StructuredOutputError("Computational analysis requires exact reproduced run metadata.");
+    if (!isConsistentAnalysisRunMetadata(run)) {
+        throw new StructuredOutputError(run.mode === "qualitative"
+            ? "Qualitative analysis run metadata is inconsistent."
+            : "Computational analysis requires exact reproduced run metadata.");
     }
     const findings = value.findings;
     const findingIds = new Set();
@@ -2872,6 +2899,7 @@ async function closeProjectMechanically(root, project, workPackage) {
         throw deterministicError("Project review does not bind a valid review packet hash.");
     }
     const reviewPacket = await loadVerifiedReviewPacket(root, project.id, review.packetSha256);
+    validateTaskReview(review, await compileTaskAcceptanceContext(root, project));
     await verifyReviewLedgerBinding(root, project.id, snapshot.snapshotId, review.packetSha256);
     const evidenceReceipts = await loadProjectEvidenceReceipts(root, project.id);
     const journal = await verifyJournal(workspacePaths(root).journal);
@@ -3529,9 +3557,20 @@ function projectRunSummary(root, project) {
         usage: project.usage,
     };
 }
-async function summarizeRun(root, requestId, cycles, executed, maxCycles, projectId) {
-    const projects = await projectsForRun(root, projectId);
-    const summaries = projects.map((project) => projectRunSummary(root, project));
+async function summarizeRun(root, requestId, cycles, executed, maxCycles, projectId, authority) {
+    // One fresh journal view after execution includes newly committed reviewer results.
+    const summaryAuthority = executed.length
+        ? await readProjectAuthorityIndex(root)
+        : (authority ?? (await readProjectAuthorityIndex(root)));
+    const projects = await projectsForRun(root, projectId, summaryAuthority);
+    const summaries = await Promise.all(projects.map(async (project) => {
+        const summary = projectRunSummary(root, project);
+        const events = summaryAuthority.taskEvents.get(project.id);
+        if (!events)
+            return summary;
+        const task = await inspectProjectTask(root, project.id, events);
+        return task.status === "configured" ? { ...summary, task } : summary;
+    }));
     const unfinished = summaries.filter((project) => project.status !== "complete");
     const waiting = unfinished.filter((project) => project.status === "waiting-user" || project.status === "waiting-external");
     const hasReadyPackage = summaries.some((project) => project.readyPackage !== null);
@@ -3583,27 +3622,16 @@ async function summarizeRun(root, requestId, cycles, executed, maxCycles, projec
         projects: summaries,
     };
 }
-async function projectsForRun(root, projectId) {
+async function projectsForRun(root, projectId, knownAuthority) {
+    const authority = knownAuthority ?? (await readProjectAuthorityIndex(root));
     if (projectId) {
-        const project = await loadProject(root, projectId);
-        if (project.lineage.supersededBy ||
-            project.status === "archived" ||
-            project.status === "abandoned") {
-            throw new CliError(`Research project ${projectId} is historical and cannot be executed.`, {
-                code: "RESEARCH_PROJECT_NOT_AUTHORITATIVE",
-                exitCode: 3,
-                details: {
-                    projectId,
-                    status: project.status,
-                    authoritativeProjectId: project.lineage.supersededBy ?? null,
-                },
-            });
-        }
+        const project = projectWithEffectiveAuthority(await loadProject(root, projectId), authority);
+        assertProjectAuthority(project, authority);
         return [project];
     }
-    return (await listProjects(root)).filter((project) => project.lineage.supersededBy === null &&
-        project.status !== "archived" &&
-        project.status !== "abandoned");
+    return (await listProjects(root, authority))
+        .filter((project) => projectAuthority(project, authority).state === "authoritative")
+        .map((project) => projectWithEffectiveAuthority(project, authority));
 }
 function assertPublicEvidenceUrl(value, sourceId) {
     let url;
@@ -3704,6 +3732,7 @@ async function nativeStageBinding(root, project, workPackage) {
     return sha256Text(canonicalJson({
         projectId: project.id,
         questionSha256: sha256Text(project.question),
+        taskContractSha256: (await taskContext(root, project.id))?.contractSha256 ?? null,
         evidenceRequirements: project.evidenceRequirements,
         inputs: project.inputs.map((record) => ({
             id: record.id,