@tiangong-ai/cli 0.0.59 → 0.0.61

package/dist/research/workspace/runtime.js

@@ -1,7 +1,13 @@
 import { randomUUID } from "node:crypto";
-import { cp, lstat, readFile, rm } from "node:fs/promises";
+import { cp, lstat, readFile, realpath, 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 { artifactPromptContext, artifactReadInstructions, openArtifactViews, persistArtifactReads, persistArtifactViewIndex, writeArtifactViewIndex, verifyPersistedArtifactViewIndex, } from "./artifact-views.js";
+import { taskContext } from "./task-contract.js";
+import { nativeRunArtifactRecords } from "./native-run.js";
+import { compileTaskAcceptanceContext, inspectProjectTask, taskAcceptancePrompt, validateTaskReview, } from "./task-acceptance.js";
+import { assertProjectAuthority, projectAuthority, projectAuthorityIndex, projectWithEffectiveAuthority, readProjectAuthorityIndex, } from "./project-authority.js";
 import { dataPublicSchemas } from "../../data/schemas.js";
 import { loadCapabilityDeclarations, stageLockedCapabilities, verifyCapabilities, } from "./capabilities.js";
 import { startCapabilityBroker } from "./broker.js";
@@ -19,9 +25,9 @@ import { createReviewExecutor } from "./review-executor.js";
 import { requiredDiscoveryCapabilityIds } from "./external-skills.js";
 import { renderInputLineContext } from "./input-plan.js";
 import { freezeClaimEvidenceGraph, freezeInferenceSnapshot, loadCurrentInferenceSnapshot, } from "./inference.js";
-import { appendJournalEvent, readJournal, verifyJournal } from "./journal.js";
+import { appendJournalEvent, readJournal, readVerifiedJournal, verifyJournal } from "./journal.js";
 import { nativeActivityRecordSchema } from "./native-activity.js";
-import { calculateAgentCallTokenReservation, RESEARCH_BROKER_MAX_TURNS, RESEARCH_ESTIMATED_BYTES_PER_TOKEN, RESEARCH_MAX_REPAIR_SOURCE_BYTES, RESEARCH_REPAIR_MAX_TURNS, researchStageContextTokenLimit, researchStructuredOutputMaxTurns, reservedAgentPackageCost, } from "./preflight.js";
+import { calculateAgentCallTokenReservation, RESEARCH_BROKER_MAX_TURNS, RESEARCH_ESTIMATED_BYTES_PER_TOKEN, RESEARCH_MAX_REPAIR_SOURCE_BYTES, RESEARCH_REPAIR_MAX_TURNS, RESEARCH_PACKET_READ_MAX_TURNS, RESEARCH_EXPECTED_ARTIFACT_READ_TOKENS, researchStructuredOutputMaxTurns, reservedAgentPackageCost, } from "./preflight.js";
 import { blockingScientificGate, listProjects, loadProject, nextReadyPackage, packageById, refreshProject, saveProject, scientificGateRecommendedAction, } from "./projects.js";
 import { assertResearchPolicyBinding } from "./research-policy.js";
 import { assertScientificGateForStage } from "./scientific-review.js";
@@ -177,13 +183,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 +211,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 +225,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 +239,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,
@@ -304,12 +310,70 @@ export async function inspectNativeResearchStage(root, project) {
         };
     }
 }
+export async function readNativeStageArtifact(input) {
+    return withWorkspaceLock(input.root, "research.native-stage.read", async () => {
+        const project = await loadProject(input.root, input.projectId);
+        const events = await readVerifiedJournal(workspacePaths(input.root).journal);
+        assertProjectAuthority(project, projectAuthorityIndex(events));
+        const session = await readNativeStageSession(input.root, input.projectId);
+        const prepared = events.findLast((event) => event.scope === project.id &&
+            event.type === "native.stage.prepared" &&
+            event.payload.sessionId === input.sessionId);
+        const runtimeRoot = await realpath(workspacePaths(input.root).runtime);
+        const capsule = await realpath(session.capsuleProject);
+        if (session.packet.sessionId !== input.sessionId ||
+            prepared?.payload.packetSha256 !== session.packet.packetSha256 ||
+            project.handoff.state !== "agent-actionable" ||
+            relative(runtimeRoot, capsule).startsWith("..") ||
+            isAbsolute(relative(runtimeRoot, capsule)) ||
+            Date.now() - Date.parse(session.packet.preparedAt) >
+                session.packet.limits.maxWallSeconds * 1000 ||
+            packageById(project, session.packet.packageId).status !== "running" ||
+            !session.packet.artifactViews) {
+            throw new CliError("Artifact reads require the exact active native stage packet.", {
+                code: "RESEARCH_NATIVE_STAGE_SESSION_REQUIRED",
+                exitCode: 3,
+            });
+        }
+        await assertNativeStageBinding(input.root, project, session.packet);
+        const views = await openArtifactViews(session.capsuleProject, session.packet.artifactViews, session.packet.packetSha256);
+        if (views.index.projectId !== project.id)
+            throw new CliError("Artifact directory belongs to another project.", {
+                code: "RESEARCH_ARTIFACT_VIEW_INVALID",
+                exitCode: 3,
+            });
+        if (!input.selection)
+            return views.list(input.listing);
+        const result = await views.read(input.selection);
+        await persistArtifactReads(projectRoot(input.root, project.id), session.capsuleProject, session.packet.artifactViews, session.packet.packetSha256, [result.receipt]);
+        await appendJournalEvent(workspacePaths(input.root).journal, "native.artifact.read", project.id, sanitizeResearchRecord({ ...result.receipt }));
+        return result;
+    });
+}
+/** Called under an existing short lease; observing a calculation never opens a producer. */
+export async function inspectNativeCalculationScope(root, project, sessionId) {
+    const session = await readNativeStageSession(root, project.id);
+    const events = await readVerifiedJournal(workspacePaths(root).journal);
+    const prepared = events.findLast((event) => event.scope === project.id &&
+        event.type === "native.stage.prepared" &&
+        event.payload.sessionId === sessionId);
+    if (session.packet.sessionId !== sessionId ||
+        !["analyze", "synthesize"].includes(session.packet.stage) ||
+        prepared?.payload.packetSha256 !== session.packet.packetSha256 ||
+        packageById(project, session.packet.packageId).status !== "running" ||
+        Date.now() - Date.parse(session.packet.preparedAt) > session.packet.limits.maxWallSeconds * 1000) {
+        throw new CliError("The calculation must bind the exact active post-acquisition native packet.", { code: "RESEARCH_NATIVE_RUN_BINDING_INVALID", exitCode: 3 });
+    }
+    await assertNativeStageBinding(root, project, session.packet);
+    return session.packet.packetSha256;
+}
 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) {
@@ -391,15 +455,24 @@ export async function prepareNativeResearchStage(input) {
         let preparedStatePersisted = false;
         try {
             capsule = await createCapsule(input.root, project, workPackage, sessionId, config);
-            const stageContextContent = await stageContextForPackage(capsule.projectRoot, project, workPackage, config);
+            const stageContextContent = await stageContextForPackage(capsule.projectRoot, project, workPackage, capsule.artifactViews, config);
             const declarations = await loadCapabilityDeclarations(input.root);
             const hasBrokeredEvidence = declarations.capabilities.some((capability) => capability.permissions.includes("brokered-network"));
             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 basePrompt = packagePrompt(project, workPackage, capsule.inputManifest, capsule.stagedSkills, capsule.capabilityDocumentation, null, capsule.contextBundle, capsule.contextBundleContent, stageContextContent, discovery, await listEvidenceCandidates(input.root, project.id), "native-host");
+            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" +
+                    (await artifactPromptContext(capsule.projectRoot, capsule.artifactViews, [
+                        "inputs/task-context.json",
+                    ]))
+                : "";
             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,
+                artifactReadInstructions(capsule.artifactViews),
+                taskPrompt,
                 input.stage === "discover" && (hasBrokeredEvidence || hasDataEvidence)
                     ? [
                         hasBrokeredEvidence
@@ -416,7 +489,6 @@ export async function prepareNativeResearchStage(input) {
                         ? "Acquire the provisionally admitted sources with the installed external acquisition/document Skills or an explicitly selected user-authorized browser. Capture the exact browser/adapter Download object, save it to the planned unique staging path, and call bindDownload before registerArtifact. Record browser/download/file-inspection activity with recordActivity. Failed or cancelled downloads cannot create bindings or artifacts. Never scan a download directory or infer success from file existence."
                         : "Do not acquire additional evidence in this stage.",
                 basePrompt,
-                "Save only the final schema-conforming JSON object to a new regular file, then submit it with the packet's submit command. The CLI remains the sole authority for validation and atomic promotion.",
             ].join("\n\n");
             const preparedAt = new Date().toISOString();
             const bindingSha256 = await nativeStageBinding(input.root, project, workPackage);
@@ -436,6 +508,8 @@ export async function prepareNativeResearchStage(input) {
                     ? { inputOnlyProvenanceIds: capsule.inputManifest.map((record) => record.id) }
                     : {}),
                 publicationPolicy: capsule.publicationPolicy,
+                taskContract,
+                artifactViews: capsule.artifactViews,
                 discovery,
                 limits: {
                     maxOutputBytes: config.budget.maxBytesPerPackage,
@@ -446,6 +520,42 @@ export async function prepareNativeResearchStage(input) {
                     maxWallSeconds: config.budget.packageMaxWallSeconds[input.stage],
                 },
                 commands: {
+                    listArtifacts: {
+                        argv: [
+                            "tiangong-ai",
+                            "research",
+                            "project",
+                            "stage",
+                            "artifacts",
+                            project.id,
+                            "--session",
+                            sessionId,
+                            "--workspace",
+                            input.root,
+                            "--json",
+                        ],
+                    },
+                    readArtifact: {
+                        argv: [
+                            "tiangong-ai",
+                            "research",
+                            "project",
+                            "stage",
+                            "read",
+                            project.id,
+                            "--session",
+                            sessionId,
+                            "--artifact",
+                            "<objectId-from-directory>",
+                            "--offset",
+                            "<byte-offset>",
+                            "--length",
+                            "<bytes-or-all>",
+                            "--workspace",
+                            input.root,
+                            "--json",
+                        ],
+                    },
                     inspectAccess: project.scientificDesign
                         ? {
                             argv: [
@@ -745,6 +855,7 @@ export async function prepareNativeResearchStage(input) {
             await appendJournalEvent(workspacePaths(input.root).journal, "native.stage.prepared", project.id, {
                 sessionId,
                 packetSha256: packet.packetSha256,
+                artifactViewIndexSha256: packet.artifactViews.sha256,
                 bindingSha256,
                 projectId: project.id,
                 packageId: workPackage.id,
@@ -792,6 +903,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 +1377,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 =
@@ -1278,7 +1395,7 @@ async function executeWorkPackage(root, projectId, packageId, config, options, r
                     packet: capsule.reviewPacketRecord,
                 });
             }
-            const stageContextContent = await stageContextForPackage(capsule.projectRoot, project, workPackage, config);
+            const stageContextContent = await stageContextForPackage(capsule.projectRoot, project, workPackage, capsule.artifactViews, config);
             const route = workPackage.executor === "reviewer" ? config.reviewer : config.producer;
             const selectedPackageExecutor = workPackage.executor === "reviewer" && reviewerPackageExecutor
                 ? reviewerPackageExecutor
@@ -1300,9 +1417,13 @@ async function executeWorkPackage(root, projectId, packageId, config, options, r
                 options,
                 requestId,
                 purpose: "primary",
-                prompt: packagePrompt(project, workPackage, capsule.inputManifest, capsule.stagedSkills, capsule.capabilityDocumentation, capsule.reviewPacketSha256, capsule.contextBundle, capsule.contextBundleContent, stageContextContent, discovery, await listEvidenceCandidates(root, project.id)) +
+                prompt: packagePrompt(project, workPackage, capsule.inputManifest, capsule.stagedSkills, capsule.capabilityDocumentation, capsule.reviewPacketSha256, capsule.contextBundle, capsule.contextBundleContent, stageContextContent, discovery, await listEvidenceCandidates(root, project.id), "headless-cli") +
                     (capsule.publicationPolicyDocumentation
                         ? `\n\n${capsule.publicationPolicyDocumentation}`
+                        : "") +
+                    (capsule.taskAcceptancePrompt ? `\n\n${capsule.taskAcceptancePrompt}` : "") +
+                    (workPackage.stage === "review"
+                        ? `\n\n${artifactReadInstructions(capsule.artifactViews)}`
                         : ""),
                 brokerUrl: primaryBrokerUrl,
                 inputOnlyProvenance,
@@ -1314,6 +1435,15 @@ async function executeWorkPackage(root, projectId, packageId, config, options, r
             assertPreCallTokenReservation(project, workPackage, config, primaryRequest, 0, true);
             result = await withHeartbeat(selectedPackageExecutor(primaryRequest), options, requestId, project, workPackage, config);
             accountedResult = result;
+            if (primaryRequest.artifactViews && result.artifactReads?.length) {
+                await persistArtifactReads(projectRoot(root, project.id), capsule.projectRoot, capsule.artifactViews, primaryRequest.artifactViews.packetSha256, result.artifactReads);
+                await appendJournalEvent(workspacePaths(root).journal, "review.artifacts.read", project.id, sanitizeResearchRecord({
+                    requestId,
+                    packetSha256: primaryRequest.artifactViews.packetSha256,
+                    indexSha256: capsule.artifactViews.sha256,
+                    receipts: result.artifactReads.map((receipt) => receipt.receiptSha256),
+                }));
+            }
             assertExecutorSucceeded(result);
             assertActualPackageBudget(project, workPackage, config, result, stageOutputTokens);
             let acceptedRaw = result.stdout;
@@ -1554,10 +1684,17 @@ async function stagePublicationPolicy(root, project, capsuleProject) {
         manifestPath: resolveContained(capsuleProject, manifestPath),
         documents,
     };
-    await writeJsonAtomic(staged.manifestPath, staged);
+    await writeJsonAtomic(staged.manifestPath, {
+        ...staged,
+        manifestPath,
+        documents: documents.map((document) => ({
+            ...document,
+            path: relative(capsuleProject, document.path).replaceAll("\\", "/"),
+        })),
+    });
     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");
@@ -1663,33 +1800,65 @@ async function createCapsule(root, project, workPackage, runId, config) {
             "Approved Research Policy (mandatory for every producer and reviewer decision):",
             `resolvedPolicySha256=${publicationPolicy.resolvedPolicySha256}`,
             `verdictCeiling=${publicationPolicy.verdictCeiling}`,
-            ...publicationPolicy.documents.map((document) => `- ${document.kind}:${document.id} sha256=${document.sha256} path=${document.path}`),
+            ...publicationPolicy.documents.map((document) => `- ${document.kind}:${document.id} sha256=${document.sha256} path=${relative(capsuleProject, document.path).replaceAll("\\", "/")}`),
             "Read every listed policy document before reasoning. Generic defaults are explicit constraints, not evidence that a target journal will accept the manuscript.",
         ].join("\n")
         : "";
     const stagedSkills = await stageLockedCapabilities(root, join(capsuleProject, "skills"));
-    const capabilityDocumentation = await buildCapabilityDocumentation(capsuleProject, stagedSkills, config.budget.maxInputContextTokens * RESEARCH_ESTIMATED_BYTES_PER_TOKEN);
+    const capabilityDocumentation = await buildCapabilityDocumentation(capsuleProject, stagedSkills);
+    await writeTextAtomic(join(capsuleProject, "inputs/capability-documentation.txt"), capabilityDocumentation);
     const reviewEvidenceContext = workPackage.stage === "review"
         ? await writeReviewEvidenceContext(root, project.id, capsuleProject, contextBundleContent, evidenceReceipts, contextualEvidenceArtifacts, config.budget.maxInputContextTokens * RESEARCH_ESTIMATED_BYTES_PER_TOKEN)
         : null;
+    const task = taskAcceptance ?? (await taskContext(root, project.id));
+    if (task) {
+        await writeJsonAtomic(join(capsuleProject, "inputs/task-context.json"), task);
+        const source = task.requestProvenance.source;
+        if (source) {
+            const logical = `task/request-sources/${source.objectSha256}.json`;
+            await ensureDirectory(dirname(resolveContained(capsuleProject, logical)));
+            await cp(resolveContained(projectRoot(root, project.id), logical), resolveContained(capsuleProject, logical), { force: false });
+        }
+    }
+    const taskArtifacts = new Map((taskAcceptance?.results ?? []).map((record) => [record.path, record]));
+    if (task)
+        for (const record of await nativeRunArtifactRecords(root, project.id))
+            taskArtifacts.set(record.path, record);
+    for (const result of taskArtifacts.values()) {
+        await ensureDirectory(dirname(resolveContained(capsuleProject, result.path)));
+        await cp(resolveContained(projectRoot(root, project.id), result.path), resolveContained(capsuleProject, result.path), { force: false });
+        if ((await sha256File(resolveContained(capsuleProject, result.path))) !== result.sha256)
+            throw new CliError("Native run/check artifact changed while staging the packet.", {
+                code: "RESEARCH_TASK_ARTIFACT_DRIFT",
+                exitCode: 3,
+            });
+    }
     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;
+    const artifactViews = reviewPacket?.artifactViews ?? (await writeArtifactViewIndex(capsuleProject, project.id));
     return {
         capsuleRoot,
         projectRoot: capsuleProject,
         inputManifest,
         contextBundle,
-        contextBundleContent,
+        contextBundleContent: await artifactPromptContext(capsuleProject, artifactViews, [
+            "inputs/context-bundle.txt",
+        ]),
         stagedSkills,
-        capabilityDocumentation,
+        capabilityDocumentation: await artifactPromptContext(capsuleProject, artifactViews, [
+            "inputs/capability-documentation.txt",
+        ]),
         publicationPolicy,
         publicationPolicyDocumentation,
         reviewPacketSha256: reviewPacket?.sha256 ?? null,
         reviewPacketRecord: reviewPacket?.record ?? null,
+        taskAcceptance,
+        taskAcceptancePrompt: await taskAcceptancePrompt(taskAcceptance, capsuleProject, artifactViews),
+        artifactViews,
     };
 }
-async function buildCapabilityDocumentation(capsuleProject, stagedSkills, maxBytes) {
+async function buildCapabilityDocumentation(capsuleProject, stagedSkills) {
     const documents = [
         {
             path: "skills/manifest.json",
@@ -1705,14 +1874,6 @@ async function buildCapabilityDocumentation(capsuleProject, stagedSkills, maxByt
     const bundle = documents
         .map((document) => `--- ${document.path} ---\n${document.content.trimEnd()}`)
         .join("\n\n");
-    const bytes = Buffer.byteLength(bundle, "utf8");
-    if (bytes > maxBytes) {
-        throw new CliError("Staged external Skill documentation exceeds the input context budget.", {
-            code: "RESEARCH_CAPABILITY_CONTEXT_BUDGET_EXCEEDED",
-            exitCode: 3,
-            details: { bytes, maxBytes, skills: stagedSkills.map((path) => basename(path)) },
-        });
-    }
     return bundle;
 }
 async function buildInputContextBundle(capsuleProject, inputManifest) {
@@ -1733,7 +1894,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) => {
@@ -1778,6 +1939,8 @@ async function writeReviewPacket(root, capsuleProject, project, inputManifest, e
         }
     }
     await writeJsonAtomic(join(capsuleProject, "inputs", "runtime-fingerprint.json"), environment);
+    const artifactViews = await writeArtifactViewIndex(capsuleProject, project.id);
+    const persistedViews = await persistArtifactViewIndex(projectRoot(root, project.id), capsuleProject, artifactViews);
     const packet = {
         schemaVersion: 1,
         projectId: project.id,
@@ -1790,6 +1953,8 @@ async function writeReviewPacket(root, capsuleProject, project, inputManifest, e
             parentSnapshotSha256: snapshot.parentSnapshotSha256,
         },
         snapshotChain,
+        taskAcceptance,
+        artifactViews: persistedViews,
         inputs: inputManifest,
         reviewEvidenceContext,
         inputFiles: [...inputFiles.values()].sort((left, right) => left.path.localeCompare(right.path)),
@@ -1809,7 +1974,7 @@ async function writeReviewPacket(root, capsuleProject, project, inputManifest, e
     };
     await writeJsonAtomic(join(capsuleProject, "inputs", "review-packet.json"), completePacket);
     const record = await persistReviewPacket(root, project.id, completePacket, packetSha256);
-    return { sha256: packetSha256, record };
+    return { sha256: packetSha256, record, artifactViews };
 }
 async function writeReviewEvidenceContext(root, projectId, capsuleProject, inputContextBundle, evidenceReceipts, evidenceArtifacts, maxBytes) {
     const header = [
@@ -1891,15 +2056,10 @@ async function writeReviewEvidenceContext(root, projectId, capsuleProject, input
         ...views.map((view) => `${view.prefix}${view.active ? "" : view.content}${view.suffix}`),
     ].join("\n\n");
     const fixedBytes = Buffer.byteLength(`${fixedContent}\n`, "utf8");
-    if (fixedBytes > maxBytes) {
-        throw new CliError("Review evidence metadata exceeds the configured context budget.", {
-            code: "RESEARCH_REVIEW_CONTEXT_BUDGET_EXCEEDED",
-            exitCode: 3,
-            details: { fixedBytes, maxBytes, views: views.length },
-        });
-    }
     const activeViews = views.filter((view) => view.active).length;
-    const contentBudgetPerView = activeViews ? Math.floor((maxBytes - fixedBytes) / activeViews) : 0;
+    const contentBudgetPerView = activeViews
+        ? Math.max(0, Math.floor((maxBytes - fixedBytes) / activeViews))
+        : 0;
     const sections = [
         header,
         ...views.map((view) => `${view.prefix}${view.active ? boundedUtf8ReviewExcerpt(view.content, contentBudgetPerView) : view.content}${view.suffix}`),
@@ -1907,14 +2067,6 @@ async function writeReviewEvidenceContext(root, projectId, capsuleProject, input
     const logicalPath = "inputs/review-evidence-context.txt";
     const path = resolveContained(capsuleProject, logicalPath);
     const content = `${sections.join("\n\n")}\n`;
-    const actualBytes = Buffer.byteLength(content, "utf8");
-    if (actualBytes > maxBytes) {
-        throw new CliError("Review evidence context exceeded its deterministic byte budget.", {
-            code: "RESEARCH_REVIEW_CONTEXT_BUDGET_EXCEEDED",
-            exitCode: 3,
-            details: { actualBytes, maxBytes },
-        });
-    }
     await writeTextAtomic(path, content);
     const capsule = await fileRecord(path, logicalPath);
     const persistentLogicalPath = `review/contexts/${capsule.sha256}.txt`;
@@ -1966,15 +2118,8 @@ async function writeProducerArtifactContext(capsuleProject, evidenceArtifacts, m
         .map((view) => `${view.prefix}${view.active ? "" : view.content}${view.suffix}`)
         .join("\n\n")}\n`;
     const fixedBytes = Buffer.byteLength(fixed, "utf8");
-    if (fixedBytes > maxBytes) {
-        throw new CliError("Producer artifact metadata exceeds the configured context budget.", {
-            code: "RESEARCH_INPUT_CONTEXT_BUDGET_EXCEEDED",
-            exitCode: 3,
-            details: { fixedBytes, maxBytes, artifacts: views.length },
-        });
-    }
     const activeViews = views.filter((view) => view.active).length;
-    const perView = activeViews ? Math.floor((maxBytes - fixedBytes) / activeViews) : 0;
+    const perView = activeViews ? Math.max(0, Math.floor((maxBytes - fixedBytes) / activeViews)) : 0;
     const content = `${header}\n\n${views
         .map((view) => `${view.prefix}${view.active ? boundedUtf8ReviewExcerpt(view.content, perView) : view.content}${view.suffix}`)
         .join("\n\n")}\n`;
@@ -2130,11 +2275,18 @@ 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");
     verifyReviewPacketValue(packet, packetSha256);
+    if (packet.projectId !== projectId)
+        throw new CliError("Review packet belongs to another project.", {
+            code: "RESEARCH_REVIEW_PACKET_DRIFT",
+            exitCode: 3,
+        });
+    if (packet.artifactViews !== undefined)
+        await verifyPersistedArtifactViewIndex(projectRoot(root, projectId), projectId, packet.artifactViews);
     const context = packet.reviewEvidenceContext;
     if (!isObject(context) ||
         typeof context.path !== "string" ||
@@ -2286,18 +2438,33 @@ function reviewSafeReceipt(receipt) {
     };
 }
 function agentRequest(input) {
-    const toolPolicy = "none";
+    const packetRead = input.purpose === "primary" &&
+        input.workPackage.stage === "review" &&
+        input.capsule.reviewPacketSha256 !== null;
+    const toolPolicy = packetRead ? "packet-read" : "none";
     const maxTurns = input.purpose === "repair"
         ? RESEARCH_REPAIR_MAX_TURNS
-        : input.brokerUrl
-            ? RESEARCH_BROKER_MAX_TURNS
-            : researchStructuredOutputMaxTurns(input.route);
+        : packetRead
+            ? RESEARCH_PACKET_READ_MAX_TURNS
+            : input.brokerUrl
+                ? RESEARCH_BROKER_MAX_TURNS
+                : researchStructuredOutputMaxTurns(input.route);
     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,
@@ -2306,11 +2473,22 @@ function agentRequest(input) {
         timeoutSeconds: Math.min(remainingWallSeconds(input.project, input.config), input.maxWallSeconds ??
             input.config.budget.packageMaxWallSeconds[input.workPackage.stage]),
         maxTurns,
+        ...(packetRead
+            ? {
+                reservationTurns: researchStructuredOutputMaxTurns(input.route),
+                artifactViews: {
+                    index: input.capsule.artifactViews,
+                    packetSha256: input.capsule.reviewPacketSha256,
+                },
+            }
+            : {}),
         maxOutputTokens: input.maxOutputTokens,
         maxToolContextTokens: input.brokerUrl
             ? input.config.budget.maxBrokerContextTokens *
                 (input.brokerCallBudget ?? input.config.budget.maxBrokerCalls)
-            : 0,
+            : packetRead
+                ? RESEARCH_EXPECTED_ARTIFACT_READ_TOKENS
+                : 0,
         maxCostUsd: input.maxCostUsd,
         expectedRuntime: input.expectedRuntime,
         toolPolicy,
@@ -2400,6 +2578,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 +2693,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 +3038,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);
@@ -3038,7 +3205,7 @@ async function verifyProjectInputBindings(project) {
 async function outputRecords(root, project, logicalPaths) {
     return Promise.all(logicalPaths.map((logicalPath) => fileRecord(resolveContained(projectRoot(root, project.id), logicalPath), logicalPath)));
 }
-async function stageContextForPackage(capsuleProject, project, workPackage, config) {
+async function stageContextForPackage(capsuleProject, project, workPackage, index, config) {
     let analyzeFallbackContext = [];
     if (workPackage.stage === "analyze") {
         const inference = JSON.parse(await readFile(resolveContained(capsuleProject, "outputs/inference-snapshot.json"), "utf8"));
@@ -3073,41 +3240,21 @@ async function stageContextForPackage(capsuleProject, project, workPackage, conf
                             "outputs/report.md",
                         ]
                         : [];
-    const sections = [];
-    for (const logicalPath of logicalPaths) {
-        const content = await readFile(resolveContained(capsuleProject, logicalPath), "utf8");
-        sections.push(`### ${logicalPath}\n${content.trimEnd()}`);
-    }
-    const bundled = sections.join("\n\n");
-    const estimatedTokens = Math.ceil(Buffer.byteLength(bundled, "utf8") / RESEARCH_ESTIMATED_BYTES_PER_TOKEN);
-    const maxStageContextTokens = researchStageContextTokenLimit(config, workPackage.stage, project.lineage.kind === "addendum");
-    if (estimatedTokens > maxStageContextTokens) {
-        throw new CliError(`Admitted stage context exceeds the configured input context limit for ${workPackage.id}.`, {
-            code: "RESEARCH_INPUT_CONTEXT_BUDGET_EXCEEDED",
-            exitCode: 3,
-            details: {
-                packageId: workPackage.id,
-                estimatedTokens,
-                maxStageContextTokens,
-                limitField: "budget.maxInputContextTokens",
-                contextPaths: logicalPaths,
-                recommendedAction: "Keep frozen evidence unchanged. Use research project fork to regenerate a bounded context with concise metadata, or explicitly review budget.maxInputContextTokens in .tiangong-research/config.json and rerun project preflight plus workspace doctor before preparing this stage again. Do not raise output limits to accommodate input context.",
-            },
-        });
-    }
-    return bundled;
+    return artifactPromptContext(capsuleProject, index, logicalPaths, Math.min(8_000, config.budget.maxInputContextTokens) * RESEARCH_ESTIMATED_BYTES_PER_TOKEN);
 }
-function packagePrompt(project, workPackage, inputs, stagedSkills, capabilityDocumentation, reviewPacketSha256, contextBundle, contextBundleContent, stageContextContent, discovery, evidenceCandidates) {
+function packagePrompt(project, workPackage, inputs, stagedSkills, capabilityDocumentation, reviewPacketSha256, contextBundle, contextBundleContent, stageContextContent, discovery, evidenceCandidates, executionMode) {
     const stageInstructions = {
         discover: "Assess candidates incrementally through the packet's recordAssessment command; do not accumulate a source-sized final response. The control plane has already assigned every immutable input, broker result, and structured data result a candidateId and retains its title, URL, DOI, dates, receipt, locator, JSON Pointer, hashes, and retrieval metadata. Reference candidateId; never repeat or invent those deterministic fields. Give each admitted candidate a concise sourceId plus source type, relevance, quality, applicability, coverage dimensions, and limitations. Record meaningful explicit rejections; omitted candidates remain unassessed for later gap filling. Native Web or Browser discoveries are supplemental candidates only and cannot be admitted until an immutable broker receipt is attached to the same canonical URL or DOI. After broad search, strict assessment, and focused gap filling, return only the small closeout object with one judgment for every reviewed dimension plus limitations and remaining gaps. The CLI mechanically joins the latest recorded assessments to provenance, derives counts/date range/coverage, and rejects unknown or unformalized candidates.",
         acquire: "Audit every provisionally admitted source exactly once. For each source, bind its ledger candidateId, list only artifactIds returned by the exact artifact registration command, and choose accepted, limited, or rejected with a concise rationale and explicit limitations. A broker receipt is an immutable discovery record but is not full text. Use an empty artifactIds array only when intentionally retaining a source as metadata/abstract evidence or when the source is an already registered local input. Put unresolved blocking acquisition or coverage deficiencies in gaps; put honest non-blocking scope constraints in limitations. Do not invent file paths, hashes, URLs, artifact IDs, or successful downloads.",
-        analyze: "Use only the complete embedded inference snapshot below and return analysis schema v2. Bind the exact inference snapshot hash and one reproducible analysisRun. Every finding must cite admitted source IDs and exact evidenceAtomIds; a top-journal finding must also bind design claimIds. State uncertainty and applicability. Never promote a source-level citation when no exact atom supports the statement.",
-        synthesize: "Use only the complete embedded inference snapshot, analysis, and Claim–Evidence Graph below. Return the schema-defined object whose reportMarkdown separates supported conclusions, uncertainty, limitations, and next actions. Every material statement must remain within a graph-bound finding. Use real Markdown line breaks encoded exactly once for JSON; never place literal /n or double-escaped \\n markers in reportMarkdown.",
-        review: `Independently inspect the complete embedded artifacts and globally bounded evidence excerpts. The CLI has already verified every bound full evidence object's size and SHA-256 and persistently stored the complete review packet; its hash is schema-bound even though the packet metadata is not duplicated in model context. Do not claim to have read beyond the embedded excerpts. Return the schema-defined review bound to packetSha256 ${reviewPacketSha256 ?? "unavailable"}. Use pass only when every material claim is traceable within the admitted evidence and clearly scoped to its limitations.`,
+        analyze: "Use only the admitted inference snapshot and its packet-bound on-demand artifacts; return analysis schema v2. Bind the exact inference snapshot hash and one reproducible analysisRun. Every finding must cite admitted source IDs and exact evidenceAtomIds; a top-journal finding must also bind design claimIds. State uncertainty and applicability. Never promote a source-level citation when no exact atom supports the statement.",
+        synthesize: "Use only the admitted inference snapshot, analysis, and Claim–Evidence Graph, reading their complete packet-bound objects on demand. Return the schema-defined object whose reportMarkdown separates supported conclusions, uncertainty, limitations, and next actions. Every material statement must remain within a graph-bound finding. Use real Markdown line breaks encoded exactly once for JSON; never place literal /n or double-escaped \\n markers in reportMarkdown.",
+        review: `Independently inspect the supplied excerpts and use the packet-only artifact tools for further material, including failed checks and counterevidence. Every full object's size and SHA-256 is bound; metadata or a digest is not proof that you read it. Return the schema-defined review bound to packetSha256 ${reviewPacketSha256 ?? "unavailable"}. Use pass only after sufficient inspection supports every material claim and its stated limitations.`,
         close: "No agent action is allowed for mechanical closure.",
     };
     const prompt = [
-        "Operate only inside this isolated research capsule.",
+        executionMode === "native-host"
+            ? "Operate in the current native host with this project's authorized inputs and packet operations; host permissions still apply."
+            : "Operate only inside this isolated research capsule.",
         `Project: ${project.id}`,
         `Question: ${project.question}`,
         `Stage: ${workPackage.stage}`,
@@ -3116,15 +3263,19 @@ function packagePrompt(project, workPackage, inputs, stagedSkills, capabilityDoc
         `Bounded input context bundle: ${JSON.stringify(contextBundle)}`,
         `Staged capability directories: ${JSON.stringify(stagedSkills.map((path) => `skills/${basename(path)}`))}`,
         workPackage.stage === "discover"
-            ? "The exact capability manifest and each staged external SKILL.md are embedded below. Use this documentation directly; filesystem tools are disabled."
+            ? "The exact capability manifest and each staged external SKILL.md are supplied inline or through the native packet's artifact read commands. Read the required documentation; do not launch its standalone commands for broker work."
             : workPackage.stage === "acquire"
                 ? "Use the installed external acquisition/document Skills in the current native host, but treat the CLI artifact registry and acquisition schema as the only authority for durable evidence."
                 : "Capability files are provenance-bound but are not available as execution tools in this stage.",
         workPackage.stage === "discover"
             ? `Follow the reviewed discovery plan: ${JSON.stringify(discovery)}. The plan's max evidence-call count is a hard working ceiling, not a target to exhaust. Execute required first-pass channels before supplemental channels, prefer broad high-yield queries, assess registered candidates between batches, and use the next gap-fill batch only for explicit uncovered dimensions, source types, date ranges, full text, limitations, or counterevidence. Stop fetching as soon as the declared coverage minimums are supportable. Native Web/Browser may broaden lead discovery, but every such action must be recorded through recordActivity, every useful result must be registered as a candidate, and the same URL/DOI must then be formalized through the broker before admission. A broker receipt, structured data-runtime receipt, or immutable registered input is an admissible evidence path. Do not execute a staged Skill's curl/CLI examples or read provider environment variables. For generic broker capabilities, invoke fetch_candidate_source with the manifest capability ID and obey its exact declared HTTP method. For structured data capabilities, use the packet's dynamic catalog and describe command, then invoke runDataCapability; never call standalone data run for project evidence. Never place API keys, tokens, authorization data, cookies, or other credential-like fields in request files. The Research control plane injects declared logical credentials and persists only safe hash-bound results. Exercise every manifest capability with requiredForDiscovery=true and every project-required data capability ID, or the mechanical coverage gate will stop downstream work.`
-            : "Use only the complete embedded stage context; no tools or additional source reads are allowed.",
+            : executionMode === "native-host" && workPackage.stage === "acquire"
+                ? "Acquire files and readable derivatives only for provisionally admitted sources using the packet's bindDownload and registerArtifact commands. Do not reopen discovery, admit new sources, or access unrelated host files."
+                : "Use only admitted stage context and this packet's read-only artifact channel. No new evidence acquisition or arbitrary host-file access is authorized.",
         stageInstructions[workPackage.stage],
-        "Do not write stage output files directly. Your final response must be only the JSON object required by the supplied output schema; the CLI will validate and atomically materialize it.",
+        executionMode === "native-host"
+            ? "Do not write admitted output paths or control-plane files directly. Save only the final schema-conforming JSON object to a new regular file, then submit it with the packet's submit command. The CLI remains the sole authority for validation and atomic promotion."
+            : "Do not write stage output files directly. Your final response must be only the JSON object required by the supplied output schema; the CLI will validate and atomically materialize it.",
         "Do not edit project.json, input manifests, prior outputs, evidence objects, or staged capability files.",
     ];
     if (workPackage.stage === "discover") {
@@ -3136,10 +3287,10 @@ function packagePrompt(project, workPackage, inputs, stagedSkills, capabilityDoc
             publicationDate: candidate.publicationDate,
             excerpt: candidate.excerpt,
             originKind: candidate.origin.kind,
-        })))}`, "The complete external capability documentation bundle is embedded below:", capabilityDocumentation, "The complete authorized local-input context is embedded below. Use it directly and do not re-read individual local input files. Full evidence files are intentionally withheld from producer packages when fullTextStaged=false.", contextBundleContent);
+        })))}`, "External capability documentation (inline or exact on-demand reference):", capabilityDocumentation, "Authorized local-input context (inline or exact on-demand reference). Full evidence files are intentionally withheld from producer packages when fullTextStaged=false; the read channel does not widen that authorization.", contextBundleContent);
     }
     if (stageContextContent) {
-        prompt.push("The complete admitted stage context is embedded below. Use it directly and do not re-read output files.", stageContextContent);
+        prompt.push("Admitted stage context (inline or exact on-demand reference; no material is discarded to meet an embedding preference):", stageContextContent);
     }
     return prompt.join("\n\n");
 }
@@ -3160,7 +3311,7 @@ function assertPreCallTokenReservation(project, workPackage, config, request, al
         route: request.route,
         primaryPayloadTokens: Math.ceil((schemaBytes + promptBytes) / RESEARCH_ESTIMATED_BYTES_PER_TOKEN),
         repairPayloadTokens: Math.ceil((schemaBytes + RESEARCH_MAX_REPAIR_SOURCE_BYTES + 2_048) / RESEARCH_ESTIMATED_BYTES_PER_TOKEN),
-        maxTurns: request.maxTurns,
+        maxTurns: request.reservationTurns ?? request.maxTurns,
         maxOutputTokens: request.maxOutputTokens,
         maxToolContextTokens: request.maxToolContextTokens ?? 0,
         maxRepairTokens: config.budget.maxRepairTokens,
@@ -3529,9 +3680,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 +3745,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 +3855,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,