@tiangong-ai/cli 0.0.31 → 0.0.33

package/dist/research/workspace/runtime.js

@@ -1,21 +1,64 @@
 import { randomUUID } from "node:crypto";
 import { cp, lstat, readFile, rm } from "node:fs/promises";
-import { basename, dirname, join, relative } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { CliError } from "../../errors.js";
 import { loadCapabilityDeclarations, stageLockedCapabilities, verifyCapabilities, } from "./capabilities.js";
 import { startCapabilityBroker } from "./broker.js";
+import { commitAcquisitionAssessments, freezeEvidenceSnapshot, loadCurrentEvidenceSnapshot, loadImmutableEvidenceSnapshotChain, materializeAcquisitionAudit, parseMaterializedAcquisitionAudit, } from "./acquisition.js";
+import { stageEvidenceArtifacts } from "./artifacts.js";
+import { commitDiscoveryDecisions, materializeDiscoveryEvidence } from "./discovery.js";
+import { inspectDiscoveryProgress } from "./discovery-status.js";
+import { downloadBindingRecordSchema } from "./downloads.js";
 import { loadProjectEvidenceReceipts, stageProjectEvidence } from "./evidence.js";
+import { appendEvidenceLedgerEvent, evidenceLedgerPath, listEvidenceCandidates, registerProjectInputCandidates, } from "./evidence-ledger.js";
 import { executeAgent } from "./executor.js";
 import { requiredDiscoveryCapabilityIds } from "./external-skills.js";
 import { renderInputLineContext } from "./input-plan.js";
 import { appendJournalEvent, readJournal, 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, researchStructuredOutputMaxTurns, reservedAgentPackageCost, } from "./preflight.js";
 import { listProjects, loadProject, nextReadyPackage, packageById, refreshProject, saveProject, } from "./projects.js";
 import { configuredResearchSecrets, sanitizeResearchRecord, sanitizeResearchText, } from "./sanitization.js";
-import { parseStructuredStageOutput, schemaForStage, StructuredOutputError } from "./schemas.js";
+import { parseEvidenceRecord, schemaForDiscoveryAssessmentBatch, parseStructuredStageOutput, schemaForStage, StructuredOutputError, } from "./schemas.js";
 import { canonicalJson, ensureDirectory, fileRecord, isObject, pathExists, readJsonFile, regularTreeFiles, resolveContained, sha256File, sha256Text, workspacePaths, writeJsonAtomic, writeTextAtomic, } from "./storage.js";
 import { loadWorkspaceConfig, verifyDoctorAttestation, withWorkspaceLock } from "./workspace.js";
+export const researchHandoffRecordSchema = {
+    $id: "https://schemas.tiangong.ai/research/handoff-request-v1.json",
+    type: "object",
+    additionalProperties: false,
+    required: ["schemaVersion", "state", "reasonCode", "summary", "requestedActions", "evidenceGaps"],
+    properties: {
+        schemaVersion: { type: "integer", const: 1 },
+        state: {
+            type: "string",
+            enum: ["user-action-required", "external-response-required"],
+        },
+        reasonCode: { type: "string", pattern: "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$" },
+        summary: { type: "string", minLength: 8, maxLength: 1_000 },
+        requestedActions: {
+            type: "array",
+            minItems: 1,
+            maxItems: 10,
+            uniqueItems: true,
+            items: { type: "string", minLength: 1, maxLength: 500 },
+        },
+        evidenceGaps: {
+            type: "array",
+            minItems: 1,
+            maxItems: 50,
+            uniqueItems: true,
+            items: { type: "string", minLength: 1, maxLength: 500 },
+        },
+    },
+};
 export async function runResearchWorkspace(root, options, packageExecutor = executeAgent) {
+    return runResearchWorkspaceInternal(root, options, packageExecutor, false);
+}
+/** @internal Test-only seam for exercising deterministic package admission with fake agents. */
+export async function runResearchWorkspaceWithInjectedProducerForTesting(root, options, packageExecutor) {
+    return runResearchWorkspaceInternal(root, options, packageExecutor, true);
+}
+async function runResearchWorkspaceInternal(root, options, packageExecutor, allowInjectedProducerForTesting) {
     validateRunOptions(options);
     const requestId = randomUUID();
     if (options.dryRun)
@@ -36,7 +79,7 @@ export async function runResearchWorkspace(root, options, packageExecutor = exec
         if (config.mode === "production-research") {
             const verification = await verifyDoctorAttestation(root);
             if (verification.status !== "verified" || !verification.attestation) {
-                throw new CliError("Production research requires a current successful producer/reviewer doctor smoke.", {
+                throw new CliError("Production research requires a current successful independent-reviewer doctor smoke.", {
                     code: "RESEARCH_DOCTOR_ATTESTATION_REQUIRED",
                     exitCode: 3,
                     details: { status: verification.status, errors: verification.errors },
@@ -61,6 +104,7 @@ export async function runResearchWorkspace(root, options, packageExecutor = exec
             const selected = projects
                 .map((project) => ({ project, workPackage: nextReadyPackage(project) }))
                 .filter((item) => Boolean(item.workPackage) &&
+                (allowInjectedProducerForTesting || item.workPackage?.executor !== "producer") &&
                 item.project.status !== "blocked" &&
                 item.project.status !== "complete")
                 .slice(0, options.maxParallel);
@@ -78,6 +122,807 @@ export async function runResearchWorkspace(root, options, packageExecutor = exec
         return result;
     });
 }
+export async function inspectNativeResearchStage(root, project) {
+    const path = nativeStageSessionPath(root, project.id);
+    if (!(await pathExists(path))) {
+        return {
+            status: "none",
+            sessionId: null,
+            stage: null,
+            preparedAt: null,
+            reasonCode: null,
+            recommendedAction: null,
+        };
+    }
+    try {
+        const session = await readNativeStageSession(root, project.id);
+        const workPackage = packageById(project, session.packet.packageId);
+        const actualBinding = await nativeStageBinding(root, project, workPackage);
+        const config = await loadWorkspaceConfig(root);
+        const elapsedSeconds = Math.max(0, (Date.now() - Date.parse(session.packet.preparedAt)) / 1_000);
+        const reasonCode = workPackage.status !== "running"
+            ? "package-not-running"
+            : actualBinding !== session.packet.bindingSha256
+                ? "binding-drift"
+                : elapsedSeconds > config.budget.packageMaxWallSeconds[session.packet.stage]
+                    ? "wall-time-expired"
+                    : null;
+        return {
+            status: reasonCode ? "stale" : "active",
+            sessionId: session.packet.sessionId,
+            stage: session.packet.stage,
+            preparedAt: session.packet.preparedAt,
+            reasonCode,
+            recommendedAction: reasonCode
+                ? `tiangong-ai research project stage abort ${project.id} --session ${session.packet.sessionId} --workspace ${root}`
+                : `Resume the current native ${session.packet.stage} stage and submit with the packet command.`,
+        };
+    }
+    catch (error) {
+        return {
+            status: "invalid",
+            sessionId: null,
+            stage: null,
+            preparedAt: null,
+            reasonCode: error instanceof CliError ? error.code : "RESEARCH_NATIVE_STAGE_SESSION_INVALID",
+            recommendedAction: "Inspect the invalid native session and use the explicit abort/retry recovery path; do not delete control files manually.",
+        };
+    }
+}
+export async function prepareNativeResearchStage(input) {
+    return withWorkspaceLock(input.root, "research.native-stage.prepare", async () => {
+        await verifyJournal(workspacePaths(input.root).journal);
+        const config = await loadWorkspaceConfig(input.root);
+        assertExecutionConfiguration(config);
+        if (config.producer.agent !== input.hostAgent) {
+            throw new CliError(`This workspace requires the current native ${config.producer.agent} host, not ${input.hostAgent}.`, { code: "RESEARCH_NATIVE_HOST_MISMATCH", exitCode: 3 });
+        }
+        const capabilityVerification = await verifyCapabilities(input.root);
+        if (capabilityVerification.status !== "verified") {
+            throw new CliError("Native research requires verified capability locks.", {
+                code: "RESEARCH_CAPABILITY_DRIFT",
+                exitCode: 3,
+                details: capabilityVerification,
+            });
+        }
+        if (config.mode === "production-research") {
+            const attestation = await verifyDoctorAttestation(input.root);
+            if (attestation.status !== "verified") {
+                throw new CliError("Native research requires a current independent-reviewer attestation.", {
+                    code: "RESEARCH_DOCTOR_ATTESTATION_REQUIRED",
+                    exitCode: 3,
+                    details: { status: attestation.status, errors: attestation.errors },
+                });
+            }
+        }
+        const project = await loadProject(input.root, input.projectId);
+        if (input.stage === "discover") {
+            await registerProjectInputCandidates(input.root, project.id, project.inputs);
+        }
+        if (input.stage === "analyze" || input.stage === "synthesize") {
+            await loadCurrentEvidenceSnapshot(input.root, project.id);
+        }
+        if (config.mode === "production-research" &&
+            config.budget.maxCostUsd > config.budget.confirmationCostUsd &&
+            !project.budgetConfirmedAt) {
+            throw new CliError("Production research budget has not been explicitly confirmed.", {
+                code: "RESEARCH_BUDGET_CONFIRMATION_REQUIRED",
+                exitCode: 3,
+            });
+        }
+        const activePath = nativeStageSessionPath(input.root, project.id);
+        if (await pathExists(activePath)) {
+            const active = await readNativeStageSession(input.root, project.id);
+            if (active.packet.stage === input.stage &&
+                active.packet.hostAgent === input.hostAgent &&
+                project.packages.find((item) => item.id === active.packet.packageId)?.status === "running") {
+                await assertNativeStageBinding(input.root, project, active.packet);
+                return active.packet;
+            }
+            throw new CliError("Another native stage session is already active for this project.", {
+                code: "RESEARCH_NATIVE_STAGE_ACTIVE",
+                exitCode: 3,
+                details: { sessionId: active.packet.sessionId, stage: active.packet.stage },
+            });
+        }
+        const workPackage = nextReadyPackage(project);
+        if (!workPackage || workPackage.executor !== "producer" || workPackage.stage !== input.stage) {
+            throw new CliError(`Stage ${input.stage} is not the next native producer package.`, {
+                code: "RESEARCH_NATIVE_STAGE_NOT_READY",
+                exitCode: 3,
+                details: { readyPackage: workPackage?.id ?? null },
+            });
+        }
+        if (workPackage.attempts >= workPackage.maxAttempts) {
+            throw new CliError("Native producer package exhausted its reviewed attempt limit.", {
+                code: "RESEARCH_PACKAGE_ATTEMPTS_EXHAUSTED",
+                exitCode: 3,
+            });
+        }
+        const discovery = input.stage === "discover"
+            ? await inspectDiscoveryProgress(input.root, project, config)
+            : null;
+        const reservedPackageTokens = discovery?.plan.reservedDiscoverTokens ?? config.budget.packageMaxTokens[input.stage];
+        const stageOutputTokens = discovery?.plan.outputTokenLimit ?? config.budget.maxOutputTokens;
+        const reservation = reservePackageBudget(project, workPackage, config, reservedPackageTokens);
+        const sessionId = randomUUID();
+        let capsule = null;
+        let preparedStatePersisted = false;
+        try {
+            capsule = await createCapsule(input.root, project, workPackage, sessionId, config);
+            const stageContextContent = await stageContextForPackage(capsule.projectRoot, project, workPackage, config);
+            const declarations = await loadCapabilityDeclarations(input.root);
+            const hasBrokeredEvidence = declarations.capabilities.some((capability) => capability.permissions.includes("brokered-network"));
+            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 prompt = [
+                "Perform this producer stage in the current interactive host session. Do not launch codex exec, claude -p, or any other nested reasoning agent.",
+                input.stage === "discover" && hasBrokeredEvidence
+                    ? "Use native Web/Browser broadly for discovery when useful, but record every native search/navigation with recordActivity and register its candidates. Before admitting any native lead, formalize the same URL or DOI through fetchEvidence so it receives an immutable broker receipt. Assess candidates in bounded batches with recordAssessment as they arrive; the final output is only a small coverage closeout. Native results without broker/input provenance are discovery leads, never evidence."
+                    : input.stage === "acquire"
+                        ? "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);
+            const packetCore = {
+                schemaVersion: 1,
+                kind: "tiangong-native-research-stage",
+                sessionId,
+                projectId: project.id,
+                packageId: workPackage.id,
+                stage: input.stage,
+                hostAgent: input.hostAgent,
+                expectedModel: config.producer.model,
+                preparedAt,
+                bindingSha256,
+                prompt,
+                outputSchema: schemaForStage(input.stage, null, input.stage === "discover" && !hasBrokeredEvidence
+                    ? { inputOnlyProvenanceIds: capsule.inputManifest.map((record) => record.id) }
+                    : {}),
+                discovery,
+                limits: {
+                    maxOutputBytes: config.budget.maxBytesPerPackage,
+                    maxOutputTokens: stageOutputTokens,
+                    reservedPackageTokens,
+                    reservedMaxCostUsd: reservation.costUsd,
+                    maxWallSeconds: config.budget.packageMaxWallSeconds[input.stage],
+                },
+                commands: {
+                    requestHandoff: {
+                        argv: [
+                            "tiangong-ai",
+                            "research",
+                            "project",
+                            "handoff",
+                            "request",
+                            project.id,
+                            "--record",
+                            "<absolute-handoff-record.json>",
+                            "--workspace",
+                            input.root,
+                            "--json",
+                        ],
+                        recordSchema: structuredClone(researchHandoffRecordSchema),
+                    },
+                    recordActivity: input.stage === "discover" || input.stage === "acquire"
+                        ? {
+                            argv: [
+                                "tiangong-ai",
+                                "research",
+                                "project",
+                                "evidence",
+                                "activity",
+                                "record",
+                                project.id,
+                                "--record",
+                                "<absolute-activity.json>",
+                                "--workspace",
+                                input.root,
+                                "--json",
+                            ],
+                            recordSchema: structuredClone(nativeActivityRecordSchema),
+                        }
+                        : null,
+                    fetchEvidence: input.stage === "discover" && hasBrokeredEvidence
+                        ? {
+                            argv: [
+                                "tiangong-ai",
+                                "research",
+                                "project",
+                                "evidence",
+                                "fetch",
+                                project.id,
+                                "--request",
+                                "<absolute-request.json>",
+                                "--workspace",
+                                input.root,
+                                "--json",
+                            ],
+                            requestSchema: {
+                                type: "object",
+                                additionalProperties: false,
+                                required: ["capability_id", "url"],
+                                properties: {
+                                    capability_id: { type: "string" },
+                                    credential_id: { type: "string" },
+                                    url: { type: "string", format: "uri" },
+                                    request_body: { type: "object" },
+                                    json_pointer: { type: "string" },
+                                    item_offset: { type: "integer", minimum: 0 },
+                                    max_items: { type: "integer", minimum: 1 },
+                                    cache_mode: { enum: ["prefer", "bypass"] },
+                                },
+                            },
+                        }
+                        : null,
+                    registerArtifact: input.stage === "acquire"
+                        ? {
+                            argv: [
+                                "tiangong-ai",
+                                "research",
+                                "project",
+                                "evidence",
+                                "artifact",
+                                "register",
+                                project.id,
+                                "--candidate",
+                                "<candidate-id>",
+                                "--path",
+                                "<absolute-file>",
+                                "--download-binding",
+                                "<binding-id-for-network-file>",
+                                "--media-type",
+                                "<media-type>",
+                                "--workspace",
+                                input.root,
+                                "--json",
+                            ],
+                            supportedMediaTypes: [
+                                "application/pdf",
+                                "application/json",
+                                "text/plain",
+                                "text/markdown",
+                                "text/csv",
+                                "text/html",
+                                "application/zip",
+                                "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                                "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                                "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+                            ],
+                            optionalMetadataFields: [
+                                "download-binding",
+                                "derived-from-artifact",
+                                "source-url",
+                                "license",
+                                "license-url",
+                                "host-type",
+                                "article-version",
+                            ],
+                        }
+                        : null,
+                    bindDownload: input.stage === "acquire"
+                        ? {
+                            argv: [
+                                "tiangong-ai",
+                                "research",
+                                "project",
+                                "evidence",
+                                "download",
+                                "bind",
+                                project.id,
+                                "--candidate",
+                                "<candidate-id>",
+                                "--record",
+                                "<absolute-download-record.json>",
+                                "--workspace",
+                                input.root,
+                                "--json",
+                            ],
+                            recordSchema: structuredClone(downloadBindingRecordSchema),
+                        }
+                        : null,
+                    recordAssessment: input.stage === "discover"
+                        ? {
+                            argv: [
+                                "tiangong-ai",
+                                "research",
+                                "project",
+                                "evidence",
+                                "assessment",
+                                "record",
+                                project.id,
+                                "--record",
+                                "<absolute-assessment-batch.json>",
+                                "--workspace",
+                                input.root,
+                                "--json",
+                            ],
+                            recordSchema: schemaForDiscoveryAssessmentBatch(),
+                        }
+                        : null,
+                    registerCandidate: input.stage === "discover"
+                        ? {
+                            argv: [
+                                "tiangong-ai",
+                                "research",
+                                "project",
+                                "evidence",
+                                "candidate",
+                                "register",
+                                project.id,
+                                "--record",
+                                "<absolute-candidate.json>",
+                                "--workspace",
+                                input.root,
+                                "--json",
+                            ],
+                            recordSchema: {
+                                type: "object",
+                                additionalProperties: false,
+                                required: ["title"],
+                                anyOf: [{ required: ["url"] }, { required: ["doi"] }],
+                                properties: {
+                                    title: { type: "string" },
+                                    url: { type: "string", format: "uri" },
+                                    doi: { type: "string" },
+                                    publicationDate: { type: "string" },
+                                    excerpt: { type: "string" },
+                                },
+                            },
+                        }
+                        : null,
+                    submit: {
+                        argv: [
+                            "tiangong-ai",
+                            "research",
+                            "project",
+                            "stage",
+                            "submit",
+                            project.id,
+                            "--session",
+                            sessionId,
+                            "--output",
+                            "<absolute-output.json>",
+                            ...(config.producer.model ? ["--confirm-model", config.producer.model] : []),
+                            "--workspace",
+                            input.root,
+                            "--json",
+                        ],
+                    },
+                    abort: {
+                        argv: [
+                            "tiangong-ai",
+                            "research",
+                            "project",
+                            "stage",
+                            "abort",
+                            project.id,
+                            "--session",
+                            sessionId,
+                            "--workspace",
+                            input.root,
+                            "--json",
+                        ],
+                    },
+                },
+                rules: [
+                    "Current native host performs producer reasoning; the CLI does not spawn a producer.",
+                    "Native Web/Browser activity is visible in the evidence ledger but becomes admissible only after broker/input formalization and strict assessment.",
+                    "When the next material step requires user authorization or an external response, request a durable handoff and stop; do not keep searching low-yield substitutes.",
+                    "Only broker receipts or registered immutable inputs may support discover output.",
+                    "Only exact, structurally validated, content-addressed artifacts may support full-text acquisition claims.",
+                    "Do not place credentials, cookies, authorization data, or sensitive URL parameters in request/output files.",
+                    "A file's existence is not success; submit performs schema, provenance, budget, hash, and atomic-commit checks.",
+                ],
+            };
+            const packet = {
+                ...packetCore,
+                packetSha256: sha256Text(canonicalJson(packetCore)),
+            };
+            const sessionCore = {
+                schemaVersion: 1,
+                kind: "tiangong-native-research-stage-session",
+                packet,
+                capsuleRoot: capsule.capsuleRoot,
+                capsuleProject: capsule.projectRoot,
+            };
+            const session = {
+                ...sessionCore,
+                sessionSha256: sha256Text(canonicalJson(sessionCore)),
+            };
+            const now = new Date().toISOString();
+            workPackage.status = "running";
+            workPackage.attempts += 1;
+            workPackage.startedAt = now;
+            workPackage.completedAt = null;
+            workPackage.lastError = null;
+            workPackage.lastFailureKind = null;
+            workPackage.retryNotBefore = null;
+            refreshProject(project);
+            await ensureDirectory(dirname(activePath));
+            await writeJsonAtomic(activePath, session);
+            await saveProject(input.root, project);
+            preparedStatePersisted = true;
+            await appendJournalEvent(workspacePaths(input.root).journal, "native.stage.prepared", project.id, {
+                sessionId,
+                packetSha256: packet.packetSha256,
+                bindingSha256,
+                projectId: project.id,
+                packageId: workPackage.id,
+                stage: input.stage,
+                hostAgent: input.hostAgent,
+                expectedModel: config.producer.model,
+                accountingMode: "reserved-native-host",
+            });
+            return packet;
+        }
+        catch (error) {
+            if (!preparedStatePersisted) {
+                await rm(activePath, { force: true });
+                if (capsule)
+                    await rm(capsule.capsuleRoot, { recursive: true, force: true });
+            }
+            throw error;
+        }
+    });
+}
+export async function submitNativeResearchStage(input) {
+    return withWorkspaceLock(input.root, "research.native-stage.submit", async () => {
+        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.", {
+                code: "RESEARCH_NATIVE_STAGE_SESSION_MISMATCH",
+                exitCode: 3,
+            });
+        }
+        const outputPath = requireNativeOutputPath(input.outputPath);
+        const outputInfo = await lstat(outputPath).catch(() => undefined);
+        if (!outputInfo?.isFile() || outputInfo.isSymbolicLink()) {
+            throw new CliError("Native stage output must be an existing regular non-symlink file.", {
+                code: "RESEARCH_NATIVE_STAGE_OUTPUT_INVALID",
+                exitCode: 2,
+            });
+        }
+        if (outputInfo.size > session.packet.limits.maxOutputBytes) {
+            throw new CliError("Native stage output exceeds the reviewed byte limit.", {
+                code: "RESEARCH_NATIVE_STAGE_OUTPUT_INVALID",
+                exitCode: 3,
+            });
+        }
+        const raw = await readFile(outputPath, "utf8");
+        const config = await loadWorkspaceConfig(input.root);
+        assertExecutionConfiguration(config);
+        if (input.confirmedModel !== session.packet.expectedModel) {
+            throw new CliError("The confirmed native model does not match the reviewed route.", {
+                code: "RESEARCH_NATIVE_MODEL_MISMATCH",
+                exitCode: 3,
+                details: { expectedModel: session.packet.expectedModel },
+            });
+        }
+        const project = await loadProject(input.root, input.projectId);
+        if (project.handoff.state !== "agent-actionable") {
+            throw new CliError("Native stage is paused for an unresolved project handoff.", {
+                code: "RESEARCH_PROJECT_HANDOFF_REQUIRED",
+                exitCode: 3,
+                details: { state: project.handoff.state, reasonCode: project.handoff.reasonCode },
+            });
+        }
+        await assertNoUnresolvedNativeChallenge(input.root, project.id);
+        const workPackage = packageById(project, session.packet.packageId);
+        if (workPackage.status !== "running" || workPackage.executor !== "producer") {
+            throw new CliError("The bound native producer package is no longer running.", {
+                code: "RESEARCH_NATIVE_STAGE_SESSION_MISMATCH",
+                exitCode: 3,
+            });
+        }
+        await assertNativeStageBinding(input.root, project, session.packet);
+        try {
+            await materializeAndValidateStageOutput(input.root, project, session.capsuleProject, workPackage, raw, null);
+            const elapsed = Math.max(0.001, (Date.now() - Date.parse(session.packet.preparedAt)) / 1_000);
+            const outputTokens = Math.ceil(Buffer.byteLength(raw, "utf8") / RESEARCH_ESTIMATED_BYTES_PER_TOKEN);
+            const reservedTokens = session.packet.limits.reservedPackageTokens;
+            const result = {
+                exitCode: 0,
+                stdout: raw,
+                stderr: "",
+                tokens: reservedTokens,
+                inputTokens: Math.max(0, reservedTokens - outputTokens),
+                cachedInputTokens: 0,
+                outputTokens,
+                costUsd: roundMoney(reservedAgentPackageCost(config.producer, reservedTokens, config)),
+                wallSeconds: elapsed,
+                model: config.producer.model,
+                runtime: null,
+            };
+            assertActualPackageBudget(project, workPackage, config, result, session.packet.limits.maxOutputTokens);
+            assertProjectedBudget(project, config, result);
+            if (workPackage.stage === "discover") {
+                await assertDiscoveryCoverage(input.root, project, resolveContained(session.capsuleProject, "outputs/evidence.json"));
+            }
+            const outputs = await validateAndImportOutputs(input.root, project, workPackage, session.capsuleProject, config, null);
+            if (workPackage.stage === "discover") {
+                await commitDiscoveryDecisions(input.root, project.id, parseStructuredStageOutput("discover", raw).value);
+            }
+            if (workPackage.stage === "acquire") {
+                const audit = parseMaterializedAcquisitionAudit(JSON.parse(await readFile(join(projectRoot(input.root, project.id), "outputs", "acquisition.json"), "utf8")));
+                await commitAcquisitionAssessments(input.root, project.id, audit);
+                await freezeEvidenceSnapshot(input.root, project);
+                outputs.push(await fileRecord(join(projectRoot(input.root, project.id), "outputs", "evidence-snapshot.json"), "outputs/evidence-snapshot.json"));
+            }
+            await commitStageEvidenceBindings(input.root, project, workPackage);
+            applyUsage(project, result);
+            workPackage.status = "complete";
+            workPackage.completedAt = new Date().toISOString();
+            workPackage.lastError = null;
+            workPackage.lastFailureKind = null;
+            workPackage.retryNotBefore = null;
+            refreshProject(project);
+            await saveProject(input.root, project);
+            await writeRunRecord(input.root, {
+                schemaVersion: 1,
+                runId: session.packet.sessionId,
+                projectId: project.id,
+                packageId: workPackage.id,
+                executor: config.producer.agent,
+                startedAt: session.packet.preparedAt,
+                completedAt: workPackage.completedAt,
+                exitCode: 0,
+                tokens: result.tokens,
+                inputTokens: result.inputTokens,
+                cachedInputTokens: result.cachedInputTokens,
+                outputTokens: result.outputTokens,
+                costUsd: result.costUsd,
+                wallSeconds: result.wallSeconds,
+                outputs,
+                stdoutSha256: sha256Text(raw),
+                stderrSha256: sha256Text(""),
+                failureKind: null,
+                failureDetails: null,
+                runtime: null,
+                accountingMode: "reserved-native-host",
+            });
+            const usage = { ...usageSlice(result), accountingMode: "reserved-native-host" };
+            await appendJournalEvent(workspacePaths(input.root).journal, "native.stage.completed", project.id, {
+                sessionId: session.packet.sessionId,
+                packetSha256: session.packet.packetSha256,
+                projectId: project.id,
+                packageId: workPackage.id,
+                stage: workPackage.stage,
+                outputs,
+                usage,
+            });
+            await rm(nativeStageSessionPath(input.root, project.id), { force: true });
+            await rm(session.capsuleRoot, { recursive: true, force: true });
+            return {
+                projectId: project.id,
+                packageId: workPackage.id,
+                stage: workPackage.stage,
+                status: "complete",
+                outputs,
+                usage,
+            };
+        }
+        catch (error) {
+            await appendJournalEvent(workspacePaths(input.root).journal, "native.stage.submit.rejected", input.projectId, {
+                sessionId: session.packet.sessionId,
+                packetSha256: session.packet.packetSha256,
+                error: bounded(sanitizeResearchText(error instanceof Error ? error.message : String(error)), 1_000),
+            });
+            throw error;
+        }
+    });
+}
+async function assertNoUnresolvedNativeChallenge(root, projectId) {
+    const events = await readJournal(evidenceLedgerPath(root, projectId));
+    const lastChallengeIndex = events.findLastIndex((event) => event.type === "activity.recorded" &&
+        event.payload.status === "blocked" &&
+        event.payload.challenge !== "none");
+    if (lastChallengeIndex < 0)
+        return;
+    const lastResolutionIndex = events.findLastIndex((event) => event.type === "handoff.resolved");
+    if (lastResolutionIndex < lastChallengeIndex) {
+        throw new CliError("A login, MFA, CAPTCHA, paywall, security, or authorization challenge requires a durable user handoff before stage submission.", {
+            code: "RESEARCH_PROJECT_HANDOFF_REQUIRED",
+            exitCode: 3,
+            details: { challenge: events[lastChallengeIndex]?.payload.challenge ?? "unknown" },
+        });
+    }
+}
+export async function abortNativeResearchStage(input) {
+    return withWorkspaceLock(input.root, "research.native-stage.abort", async () => {
+        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.", {
+                code: "RESEARCH_NATIVE_STAGE_SESSION_MISMATCH",
+                exitCode: 3,
+            });
+        }
+        const project = await loadProject(input.root, input.projectId);
+        const workPackage = packageById(project, session.packet.packageId);
+        if (workPackage.status !== "running") {
+            throw new CliError("The native stage package is not running.", {
+                code: "RESEARCH_NATIVE_STAGE_SESSION_MISMATCH",
+                exitCode: 3,
+            });
+        }
+        workPackage.status = workPackage.attempts < workPackage.maxAttempts ? "retry" : "failed";
+        workPackage.completedAt = new Date().toISOString();
+        workPackage.lastError = "Native stage was explicitly aborted before submission.";
+        workPackage.lastFailureKind = "deterministic";
+        workPackage.retryNotBefore = null;
+        refreshProject(project);
+        await saveProject(input.root, project);
+        await appendJournalEvent(workspacePaths(input.root).journal, "native.stage.aborted", project.id, {
+            sessionId: session.packet.sessionId,
+            packetSha256: session.packet.packetSha256,
+            projectId: project.id,
+            packageId: workPackage.id,
+            stage: workPackage.stage,
+        });
+        await rm(nativeStageSessionPath(input.root, project.id), { force: true });
+        await rm(session.capsuleRoot, { recursive: true, force: true });
+        return {
+            projectId: project.id,
+            packageId: workPackage.id,
+            status: project.status === "blocked" ? "blocked" : "ready",
+        };
+    });
+}
+export async function requestResearchHandoff(input) {
+    return withWorkspaceLock(input.root, "research.handoff.request", async () => {
+        const value = parseHandoffRequest(input.value);
+        const project = refreshProject(await loadProject(input.root, input.projectId));
+        if (project.lineage.supersededBy ||
+            ["complete", "stale", "archived", "abandoned"].includes(project.status)) {
+            throw new CliError("Historical or closed projects require an immutable addendum, not an in-place handoff.", { code: "RESEARCH_PROJECT_HANDOFF_INVALID", exitCode: 3 });
+        }
+        if (project.handoff.state !== "agent-actionable") {
+            throw new CliError("This project already has an unresolved handoff.", {
+                code: "RESEARCH_PROJECT_HANDOFF_REQUIRED",
+                exitCode: 3,
+                details: { state: project.handoff.state },
+            });
+        }
+        const activePath = nativeStageSessionPath(input.root, input.projectId);
+        const session = (await pathExists(activePath))
+            ? await readNativeStageSession(input.root, input.projectId)
+            : null;
+        if (session) {
+            const workPackage = packageById(project, session.packet.packageId);
+            if (workPackage.status !== "running") {
+                throw new CliError("Active native session is not bound to a running package.", {
+                    code: "RESEARCH_NATIVE_STAGE_SESSION_MISMATCH",
+                    exitCode: 3,
+                });
+            }
+            workPackage.status = "ready";
+            workPackage.attempts = Math.max(0, workPackage.attempts - 1);
+            workPackage.startedAt = null;
+            workPackage.completedAt = null;
+            workPackage.lastError = null;
+            workPackage.lastFailureKind = null;
+            workPackage.retryNotBefore = null;
+        }
+        const requestedAt = new Date().toISOString();
+        project.handoff = {
+            state: value.state,
+            reasonCode: value.reasonCode,
+            summary: value.summary,
+            requestedActions: value.requestedActions,
+            evidenceGaps: value.evidenceGaps,
+            requestedAt,
+            resolvedAt: null,
+            resolutionNote: null,
+        };
+        refreshProject(project);
+        await saveProject(input.root, project);
+        const eventPayload = {
+            state: value.state,
+            reasonCode: value.reasonCode,
+            summary: value.summary,
+            requestedActions: value.requestedActions,
+            evidenceGaps: value.evidenceGaps,
+            requestedAt,
+            interruptedSessionId: session?.packet.sessionId ?? null,
+            interruptedPackageId: session?.packet.packageId ?? null,
+        };
+        await appendEvidenceLedgerEvent(input.root, project.id, "handoff.requested", eventPayload);
+        await appendJournalEvent(workspacePaths(input.root).journal, "project.handoff.requested", project.id, { projectId: project.id, ...eventPayload });
+        if (session) {
+            await rm(activePath, { force: true });
+            await rm(session.capsuleRoot, { recursive: true, force: true });
+        }
+        return {
+            projectId: project.id,
+            status: project.status === "waiting-external" ? "waiting-external" : "waiting-user",
+            handoff: project.handoff,
+            resolveCommand: `tiangong-ai research project handoff resolve ${project.id} --note <resolution-note> --workspace ${input.root}`,
+        };
+    });
+}
+export async function resolveResearchHandoff(input) {
+    return withWorkspaceLock(input.root, "research.handoff.resolve", async () => {
+        const project = await loadProject(input.root, input.projectId);
+        if (project.handoff.state === "agent-actionable" || !project.handoff.requestedAt) {
+            throw new CliError("Project has no unresolved handoff.", {
+                code: "RESEARCH_PROJECT_HANDOFF_INVALID",
+                exitCode: 2,
+            });
+        }
+        const note = sanitizeResearchText(input.note, configuredResearchSecrets(process.env)).trim();
+        if (note.length < 8 || note.length > 1_000) {
+            throw new CliError("Handoff resolution note must contain 8-1000 safe characters.", {
+                code: "RESEARCH_PROJECT_HANDOFF_INVALID",
+                exitCode: 2,
+            });
+        }
+        const previousState = project.handoff.state;
+        const resolvedAt = new Date().toISOString();
+        project.handoff = {
+            ...project.handoff,
+            state: "agent-actionable",
+            resolvedAt,
+            resolutionNote: note,
+        };
+        refreshProject(project);
+        await saveProject(input.root, project);
+        const eventPayload = {
+            previousState,
+            reasonCode: project.handoff.reasonCode,
+            requestedAt: project.handoff.requestedAt,
+            resolvedAt,
+            resolutionNote: note,
+        };
+        await appendEvidenceLedgerEvent(input.root, project.id, "handoff.resolved", eventPayload);
+        await appendJournalEvent(workspacePaths(input.root).journal, "project.handoff.resolved", project.id, { projectId: project.id, ...eventPayload });
+        return { projectId: project.id, status: project.status, handoff: project.handoff };
+    });
+}
+function parseHandoffRequest(value) {
+    const sanitized = sanitizeResearchRecord(value, configuredResearchSecrets(process.env));
+    const allowed = new Set([
+        "schemaVersion",
+        "state",
+        "reasonCode",
+        "summary",
+        "requestedActions",
+        "evidenceGaps",
+    ]);
+    const requestedActions = Array.isArray(sanitized.requestedActions)
+        ? sanitized.requestedActions
+        : [];
+    const evidenceGaps = Array.isArray(sanitized.evidenceGaps) ? sanitized.evidenceGaps : [];
+    if (Object.keys(sanitized).some((key) => !allowed.has(key)) ||
+        sanitized.schemaVersion !== 1 ||
+        !["user-action-required", "external-response-required"].includes(String(sanitized.state)) ||
+        typeof sanitized.reasonCode !== "string" ||
+        !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(sanitized.reasonCode) ||
+        typeof sanitized.summary !== "string" ||
+        sanitized.summary.trim().length < 8 ||
+        sanitized.summary.length > 1_000 ||
+        requestedActions.length < 1 ||
+        requestedActions.length > 10 ||
+        requestedActions.some((item) => typeof item !== "string" || item.length < 1 || item.length > 500) ||
+        new Set(requestedActions).size !== requestedActions.length ||
+        evidenceGaps.length < 1 ||
+        evidenceGaps.length > 50 ||
+        evidenceGaps.some((item) => typeof item !== "string" || item.length < 1 || item.length > 500) ||
+        new Set(evidenceGaps).size !== evidenceGaps.length) {
+        throw new CliError("Handoff request failed validation.", {
+            code: "RESEARCH_PROJECT_HANDOFF_INVALID",
+            exitCode: 2,
+        });
+    }
+    return {
+        state: sanitized.state,
+        reasonCode: sanitized.reasonCode,
+        summary: sanitized.summary.trim(),
+        requestedActions: requestedActions,
+        evidenceGaps: evidenceGaps,
+    };
+}
 async function executeWorkPackage(root, projectId, packageId, config, options, requestId, packageExecutor, doctorAttestation) {
     const project = await loadProject(root, projectId);
     const workPackage = packageById(project, packageId);
@@ -114,7 +959,14 @@ async function executeWorkPackage(root, projectId, packageId, config, options, r
             promotedOutputs = await outputRecords(root, project, workPackage.expectedOutputs);
         }
         else {
-            const reservation = reservePackageBudget(project, workPackage, config);
+            if (["analyze", "synthesize", "review"].includes(workPackage.stage)) {
+                await loadCurrentEvidenceSnapshot(root, project.id);
+            }
+            const discovery = workPackage.stage === "discover"
+                ? await inspectDiscoveryProgress(root, project, config)
+                : 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);
             capsuleRoot = capsule.capsuleRoot;
             if (capsule.reviewPacketRecord) {
@@ -126,7 +978,7 @@ async function executeWorkPackage(root, projectId, packageId, config, options, r
                     packet: capsule.reviewPacketRecord,
                 });
             }
-            const stageContextContent = await stageContextForPackage(capsule.projectRoot, workPackage, config);
+            const stageContextContent = await stageContextForPackage(capsule.projectRoot, project, workPackage, config);
             const route = workPackage.executor === "reviewer" ? config.reviewer : config.producer;
             executor = route.agent;
             broker =
@@ -145,10 +997,11 @@ 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, config.budget.maxBrokerCalls),
+                prompt: packagePrompt(project, workPackage, capsule.inputManifest, capsule.stagedSkills, capsule.capabilityDocumentation, capsule.reviewPacketSha256, capsule.contextBundle, capsule.contextBundleContent, stageContextContent, discovery, await listEvidenceCandidates(root, project.id)),
                 brokerUrl: primaryBrokerUrl,
                 inputOnlyProvenance,
-                maxOutputTokens: Math.min(config.budget.maxOutputTokens, reservation.tokens),
+                maxOutputTokens: Math.min(stageOutputTokens, reservation.tokens),
+                ...(discovery ? { brokerCallBudget: discovery.plan.maxCalls } : {}),
                 maxCostUsd: reservation.costUsd,
                 expectedRuntime: runtimeForRoute(doctorAttestation, route),
             });
@@ -156,7 +1009,8 @@ async function executeWorkPackage(root, projectId, packageId, config, options, r
             result = await withHeartbeat(packageExecutor(primaryRequest), options, requestId, project, workPackage, config);
             accountedResult = result;
             assertExecutorSucceeded(result);
-            assertActualPackageBudget(project, workPackage, config, result, config.budget.maxOutputTokens);
+            assertActualPackageBudget(project, workPackage, config, result, stageOutputTokens);
+            let acceptedRaw = result.stdout;
             try {
                 await materializeAndValidateStageOutput(root, project, capsule.projectRoot, workPackage, result.stdout, capsule.reviewPacketSha256);
             }
@@ -189,14 +1043,23 @@ async function executeWorkPackage(root, projectId, packageId, config, options, r
                 const repair = await withHeartbeat(packageExecutor(repairRequest), options, requestId, project, workPackage, config);
                 accountedResult = combineExecutionResults(result, repair);
                 assertExecutorSucceeded(repair);
-                assertActualPackageBudget(project, workPackage, config, accountedResult, config.budget.maxOutputTokens + config.budget.maxRepairTokens);
+                assertActualPackageBudget(project, workPackage, config, accountedResult, stageOutputTokens + config.budget.maxRepairTokens);
+                acceptedRaw = repair.stdout;
                 await materializeAndValidateStageOutput(root, project, capsule.projectRoot, workPackage, repair.stdout, capsule.reviewPacketSha256);
             }
             assertProjectedBudget(project, config, accountedResult);
             promotedOutputs = await validateAndImportOutputs(root, project, workPackage, capsule.projectRoot, config, capsule.reviewPacketSha256);
             if (workPackage.stage === "discover") {
-                await assertEvidenceCoverage(root, project);
+                await assertDiscoveryCoverage(root, project);
+                await commitDiscoveryDecisions(root, project.id, parseStructuredStageOutput("discover", acceptedRaw).value);
+            }
+            if (workPackage.stage === "acquire") {
+                const audit = parseMaterializedAcquisitionAudit(JSON.parse(await readFile(join(projectRoot(root, project.id), "outputs", "acquisition.json"), "utf8")));
+                await commitAcquisitionAssessments(root, project.id, audit);
+                await freezeEvidenceSnapshot(root, project);
+                promotedOutputs.push(await fileRecord(join(projectRoot(root, project.id), "outputs", "evidence-snapshot.json"), "outputs/evidence-snapshot.json"));
             }
+            await commitStageEvidenceBindings(root, project, workPackage);
         }
         const completedAt = new Date().toISOString();
         applyUsage(project, accountedResult);
@@ -402,6 +1265,16 @@ async function createCapsule(root, project, workPackage, runId, config) {
     await writeTextAtomic(contextBundlePath, contextBundleContent);
     const contextBundle = await fileRecord(contextBundlePath, "inputs/context-bundle.txt");
     const evidenceReceipts = await stageProjectEvidence(root, project.id, capsuleProject);
+    const frozenSnapshot = ["analyze", "synthesize", "review"].includes(workPackage.stage)
+        ? await loadCurrentEvidenceSnapshot(root, project.id)
+        : null;
+    const evidenceArtifacts = frozenSnapshot
+        ? await stageEvidenceArtifacts(root, project.id, capsuleProject, new Set(frozenSnapshot.artifacts.map((artifact) => artifact.artifactId)))
+        : [];
+    if ((workPackage.stage === "analyze" || workPackage.stage === "synthesize") &&
+        evidenceArtifacts.length) {
+        await writeProducerArtifactContext(capsuleProject, evidenceArtifacts, Math.floor((config.budget.maxInputContextTokens * RESEARCH_ESTIMATED_BYTES_PER_TOKEN) / 2));
+    }
     await writeJsonAtomic(join(capsuleProject, "inputs", "evidence-receipts.json"), evidenceReceipts.map(reviewSafeReceipt));
     await writeJsonAtomic(join(capsuleProject, "project.json"), {
         ...project,
@@ -414,10 +1287,10 @@ async function createCapsule(root, project, workPackage, runId, config) {
     const stagedSkills = await stageLockedCapabilities(root, join(capsuleProject, "skills"));
     const capabilityDocumentation = await buildCapabilityDocumentation(capsuleProject, stagedSkills, config.budget.maxInputContextTokens * RESEARCH_ESTIMATED_BYTES_PER_TOKEN);
     const reviewEvidenceContext = workPackage.stage === "review"
-        ? await writeReviewEvidenceContext(root, project.id, capsuleProject, contextBundleContent, evidenceReceipts, config.budget.maxInputContextTokens * RESEARCH_ESTIMATED_BYTES_PER_TOKEN)
+        ? await writeReviewEvidenceContext(root, project.id, capsuleProject, contextBundleContent, evidenceReceipts, evidenceArtifacts, config.budget.maxInputContextTokens * RESEARCH_ESTIMATED_BYTES_PER_TOKEN)
         : null;
     const reviewPacket = reviewEvidenceContext
-        ? await writeReviewPacket(root, capsuleProject, project, inputManifest, evidenceReceipts, reviewEvidenceContext.persistent)
+        ? await writeReviewPacket(root, capsuleProject, project, inputManifest, evidenceReceipts, evidenceArtifacts, reviewEvidenceContext.persistent)
         : null;
     return {
         capsuleRoot,
@@ -475,8 +1348,21 @@ async function buildInputContextBundle(capsuleProject, inputManifest) {
     }
     return `${sections.join("\n\n")}\n`;
 }
-async function writeReviewPacket(root, capsuleProject, project, inputManifest, evidenceReceipts, reviewEvidenceContext) {
-    const artifactPaths = ["outputs/evidence.json", "outputs/analysis.json", "outputs/report.md"];
+async function writeReviewPacket(root, capsuleProject, project, inputManifest, evidenceReceipts, evidenceArtifacts, reviewEvidenceContext) {
+    const snapshot = await loadCurrentEvidenceSnapshot(root, project.id);
+    const immutableSnapshots = await loadImmutableEvidenceSnapshotChain(root, project.id, snapshot.snapshotSha256);
+    const snapshotChain = await Promise.all(immutableSnapshots.map((immutableSnapshot) => {
+        const sha256 = immutableSnapshot.snapshotSha256;
+        const logicalPath = `evidence/snapshots/${sha256}.json`;
+        return fileRecord(resolveContained(projectRoot(root, project.id), logicalPath), logicalPath);
+    }));
+    const artifactPaths = [
+        "outputs/evidence.json",
+        "outputs/acquisition.json",
+        "outputs/evidence-snapshot.json",
+        "outputs/analysis.json",
+        "outputs/report.md",
+    ];
     const evidenceFiles = new Map();
     for (const receipt of evidenceReceipts) {
         for (const locator of [receipt.locator, receipt.contextLocator]) {
@@ -485,6 +1371,11 @@ async function writeReviewPacket(root, capsuleProject, project, inputManifest, e
             }
         }
     }
+    for (const artifact of evidenceArtifacts) {
+        if (!evidenceFiles.has(artifact.locator)) {
+            evidenceFiles.set(artifact.locator, await fileRecord(resolveContained(capsuleProject, artifact.locator), artifact.locator));
+        }
+    }
     const environment = await reviewEnvironmentPacket(root, project.id);
     const inputFiles = new Map();
     for (const input of inputManifest) {
@@ -500,10 +1391,18 @@ async function writeReviewPacket(root, capsuleProject, project, inputManifest, e
         projectId: project.id,
         questionSha256: sha256Text(project.question),
         evidenceRequirements: project.evidenceRequirements,
+        evidenceSnapshot: {
+            snapshotId: snapshot.snapshotId,
+            snapshotSha256: snapshot.snapshotSha256,
+            parentSnapshotId: snapshot.parentSnapshotId,
+            parentSnapshotSha256: snapshot.parentSnapshotSha256,
+        },
+        snapshotChain,
         inputs: inputManifest,
         reviewEvidenceContext,
         inputFiles: [...inputFiles.values()].sort((left, right) => left.path.localeCompare(right.path)),
         evidenceReceipts: evidenceReceipts.map(reviewSafeReceipt),
+        evidenceArtifacts,
         evidenceFiles: [...evidenceFiles.values()].sort((left, right) => left.path.localeCompare(right.path)),
         environment,
         environmentFile: await fileRecord(join(capsuleProject, "inputs", "runtime-fingerprint.json"), "inputs/runtime-fingerprint.json"),
@@ -518,27 +1417,42 @@ async function writeReviewPacket(root, capsuleProject, project, inputManifest, e
     const record = await persistReviewPacket(root, project.id, completePacket, packetSha256);
     return { sha256: packetSha256, record };
 }
-async function writeReviewEvidenceContext(root, projectId, capsuleProject, inputContextBundle, evidenceReceipts, maxBytes) {
+async function writeReviewEvidenceContext(root, projectId, capsuleProject, inputContextBundle, evidenceReceipts, evidenceArtifacts, maxBytes) {
     const header = [
         "TIANGONG REVIEW EVIDENCE CONTEXT v1",
         "The following are deterministic excerpts from hash-verified bounded views. Full objects and original bounded contexts remain bound in the review packet.",
     ].join("\n");
+    const brokerReferences = await loadBrokerReviewReferences(capsuleProject);
     const views = [
         {
             prefix: "--- LOCAL INPUT CONTEXT BUNDLE ---\n--- BEGIN BOUNDED REVIEW EXCERPT ---\n",
-            content: inputContextBundle.trimEnd(),
+            content: sanitizeResearchText(inputContextBundle.trimEnd()),
             suffix: "\n--- END BOUNDED REVIEW EXCERPT ---",
+            active: true,
         },
     ];
-    const seen = new Set();
-    for (const receipt of [...evidenceReceipts].sort((left, right) => left.attemptId.localeCompare(right.attemptId))) {
-        if (seen.has(receipt.contextLocator))
-            continue;
-        seen.add(receipt.contextLocator);
+    const seenUnreferencedContexts = new Set();
+    const orderedReceipts = [...evidenceReceipts].sort((left, right) => {
+        const leftReferenced = (brokerReferences.get(left.attemptId)?.length ?? 0) > 0;
+        const rightReferenced = (brokerReferences.get(right.attemptId)?.length ?? 0) > 0;
+        if (leftReferenced !== rightReferenced)
+            return leftReferenced ? -1 : 1;
+        return left.attemptId.localeCompare(right.attemptId);
+    });
+    for (const receipt of orderedReceipts) {
         const metadata = reviewSafeReceipt(receipt);
-        const content = reviewableTextContentType(receipt.contentType)
-            ? await readFile(resolveContained(capsuleProject, receipt.contextLocator), "utf8")
-            : "[Binary bounded view omitted from model context; verify the bound file mechanically.]";
+        const references = brokerReferences.get(receipt.attemptId) ?? [];
+        // Every admitted receipt gets its own exact projection even when another
+        // request produced identical bounded bytes. Only uncited duplicate views
+        // may be collapsed; otherwise random receipt UUID ordering can hide the
+        // one receipt actually cited by evidence.json.
+        if (references.length === 0 && seenUnreferencedContexts.has(receipt.contextLocator))
+            continue;
+        if (references.length === 0)
+            seenUnreferencedContexts.add(receipt.contextLocator);
+        const content = references.length
+            ? await citedBrokerReviewContent(capsuleProject, receipt, references)
+            : "[No admitted evidence source cites this receipt; its raw object and bounded context remain hash-bound in the review packet.]";
         views.push({
             prefix: [
                 `--- BROKER RECEIPT ${receipt.attemptId} ---`,
@@ -548,9 +1462,40 @@ async function writeReviewEvidenceContext(root, projectId, capsuleProject, input
             ].join("\n"),
             content: content.trimEnd(),
             suffix: "\n--- END BOUNDED REVIEW EXCERPT ---",
+            active: references.length > 0,
         });
     }
-    const fixedContent = [header, ...views.map((view) => `${view.prefix}${view.suffix}`)].join("\n\n");
+    for (const artifact of [...evidenceArtifacts].sort((left, right) => left.artifactId.localeCompare(right.artifactId))) {
+        const textArtifact = reviewableTextContentType(artifact.mediaType);
+        const content = textArtifact
+            ? sanitizeResearchText((await readFile(resolveContained(capsuleProject, artifact.locator), "utf8")).trimEnd())
+            : "[Binary artifact omitted from model context; the complete structurally validated file remains hash-bound in the persistent review packet.]";
+        const safeMetadata = {
+            artifactId: artifact.artifactId,
+            candidateId: artifact.candidateId,
+            sha256: artifact.sha256,
+            bytes: artifact.bytes,
+            mediaType: artifact.mediaType,
+            originalFilename: artifact.originalFilename,
+            locator: artifact.locator,
+            validation: artifact.validation,
+        };
+        views.push({
+            prefix: [
+                `--- FROZEN EVIDENCE ARTIFACT ${artifact.artifactId} ---`,
+                `metadata: ${JSON.stringify(safeMetadata)}`,
+                "--- BEGIN BOUNDED REVIEW EXCERPT ---",
+                "",
+            ].join("\n"),
+            content,
+            suffix: "\n--- END BOUNDED REVIEW EXCERPT ---",
+            active: textArtifact,
+        });
+    }
+    const fixedContent = [
+        header,
+        ...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.", {
@@ -559,10 +1504,11 @@ async function writeReviewEvidenceContext(root, projectId, capsuleProject, input
             details: { fixedBytes, maxBytes, views: views.length },
         });
     }
-    const contentBudgetPerView = Math.floor((maxBytes - fixedBytes) / views.length);
+    const activeViews = views.filter((view) => view.active).length;
+    const contentBudgetPerView = activeViews ? Math.floor((maxBytes - fixedBytes) / activeViews) : 0;
     const sections = [
         header,
-        ...views.map((view) => `${view.prefix}${boundedUtf8ReviewExcerpt(view.content, contentBudgetPerView)}${view.suffix}`),
+        ...views.map((view) => `${view.prefix}${view.active ? boundedUtf8ReviewExcerpt(view.content, contentBudgetPerView) : view.content}${view.suffix}`),
     ];
     const logicalPath = "inputs/review-evidence-context.txt";
     const path = resolveContained(capsuleProject, logicalPath);
@@ -597,8 +1543,155 @@ async function writeReviewEvidenceContext(root, projectId, capsuleProject, input
         persistent: await fileRecord(persistentPath, persistentLogicalPath),
     };
 }
+async function writeProducerArtifactContext(capsuleProject, evidenceArtifacts, maxBytes) {
+    const header = [
+        "TIANGONG PRODUCER ARTIFACT CONTEXT v1",
+        "Only deterministic sanitized excerpts from producer-visible text artifacts are included. Binary files remain hash-bound but are not treated as read full text.",
+    ].join("\n");
+    const views = await Promise.all([...evidenceArtifacts]
+        .sort((left, right) => left.artifactId.localeCompare(right.artifactId))
+        .map(async (artifact) => {
+        const active = reviewableTextContentType(artifact.mediaType);
+        return {
+            prefix: [
+                `--- FROZEN ARTIFACT ${artifact.artifactId} ---`,
+                `candidateId: ${artifact.candidateId}`,
+                `sha256: ${artifact.sha256}`,
+                `mediaType: ${artifact.mediaType}`,
+                "--- BEGIN BOUNDED ARTIFACT CONTEXT ---",
+                "",
+            ].join("\n"),
+            content: active
+                ? sanitizeResearchText((await readFile(resolveContained(capsuleProject, artifact.locator), "utf8")).trimEnd())
+                : "[Binary artifact is hash-bound but omitted from producer context. It is not counted as producer-visible full text.]",
+            suffix: "\n--- END BOUNDED ARTIFACT CONTEXT ---",
+            active,
+        };
+    }));
+    const fixed = `${header}\n\n${views
+        .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 content = `${header}\n\n${views
+        .map((view) => `${view.prefix}${view.active ? boundedUtf8ReviewExcerpt(view.content, perView) : view.content}${view.suffix}`)
+        .join("\n\n")}\n`;
+    const logicalPath = "inputs/evidence-artifact-context.txt";
+    const path = resolveContained(capsuleProject, logicalPath);
+    await writeTextAtomic(path, content);
+    return fileRecord(path, logicalPath);
+}
+async function loadBrokerReviewReferences(capsuleProject) {
+    const evidencePath = resolveContained(capsuleProject, "outputs/evidence.json");
+    if (!(await pathExists(evidencePath)))
+        return new Map();
+    const evidence = await readJsonFile(evidencePath, "Research evidence");
+    const references = new Map();
+    if (!Array.isArray(evidence.sources))
+        return references;
+    for (const source of evidence.sources) {
+        if (!isObject(source) || !isObject(source.provenance))
+            continue;
+        if (source.provenance.kind !== "broker" || typeof source.provenance.id !== "string")
+            continue;
+        if (typeof source.id !== "string" || typeof source.title !== "string")
+            continue;
+        const current = references.get(source.provenance.id) ?? [];
+        current.push({
+            sourceId: source.id,
+            title: source.title,
+            jsonPointer: typeof source.jsonPointer === "string" ? source.jsonPointer : null,
+            excerpt: typeof source.excerpt === "string" ? source.excerpt : null,
+        });
+        references.set(source.provenance.id, current);
+    }
+    for (const values of references.values()) {
+        values.sort((left, right) => left.sourceId.localeCompare(right.sourceId));
+    }
+    return references;
+}
+async function citedBrokerReviewContent(capsuleProject, receipt, references) {
+    let rawValue;
+    if (jsonReviewContentType(receipt.contentType)) {
+        try {
+            rawValue = JSON.parse(await readFile(resolveContained(capsuleProject, receipt.locator), "utf8"));
+        }
+        catch {
+            rawValue = undefined;
+        }
+    }
+    let needsFallback = false;
+    const sections = [
+        "The following items are deterministic, sanitized projections selected from the hash-bound raw broker object by the JSON Pointers declared in admitted evidence.",
+    ];
+    for (const reference of references) {
+        const lines = [
+            `--- CITED EVIDENCE SOURCE ${reference.sourceId} ---`,
+            `title: ${reference.title}`,
+            `jsonPointer: ${reference.jsonPointer ?? "unavailable"}`,
+        ];
+        if (rawValue !== undefined && reference.jsonPointer !== null) {
+            try {
+                const selected = resolveReviewJsonPointer(rawValue, reference.jsonPointer);
+                lines.push("exactItem:", JSON.stringify(selected, null, 2));
+            }
+            catch {
+                needsFallback = true;
+                lines.push("exactItem: [JSON Pointer did not resolve; bounded-context fallback follows.] ");
+            }
+        }
+        else {
+            needsFallback = true;
+            lines.push("exactItem: [Exact JSON item unavailable; bounded-context fallback follows.] ");
+        }
+        if (reference.excerpt !== null)
+            lines.push(`declaredExcerpt: ${reference.excerpt}`);
+        sections.push(lines.join("\n"));
+    }
+    if (needsFallback) {
+        const fallback = reviewableTextContentType(receipt.contentType)
+            ? await readFile(resolveContained(capsuleProject, receipt.contextLocator), "utf8")
+            : "[Binary bounded view omitted from model context; verify the bound file mechanically.]";
+        sections.push(`--- BOUNDED CONTEXT FALLBACK ---\n${fallback.trimEnd()}`);
+    }
+    return sanitizeResearchText(sections.join("\n\n"));
+}
+function jsonReviewContentType(contentType) {
+    return /^application\/(?:[^;]+\+)?json(?:;|$)/i.test(contentType);
+}
+function resolveReviewJsonPointer(value, pointer) {
+    if (pointer === "")
+        return value;
+    if (!pointer.startsWith("/") || /~(?:[^01]|$)/.test(pointer)) {
+        throw new Error("invalid JSON Pointer");
+    }
+    let selected = value;
+    for (const rawPart of pointer.slice(1).split("/")) {
+        const part = rawPart.replaceAll("~1", "/").replaceAll("~0", "~");
+        if (Array.isArray(selected) &&
+            /^(0|[1-9][0-9]*)$/.test(part) &&
+            Number(part) < selected.length) {
+            selected = selected[Number(part)];
+        }
+        else if (isObject(selected) && Object.hasOwn(selected, part)) {
+            selected = selected[part];
+        }
+        else {
+            throw new Error("JSON Pointer does not resolve");
+        }
+    }
+    return selected;
+}
 function reviewableTextContentType(contentType) {
-    return /^(?:text\/|application\/(?:[^;]+\+)?(?:json|xml|javascript|xhtml\+xml|csv))(?:;|$)/i.test(contentType);
+    return /^(?:text\/[^;]+|application\/(?:[^;]+\+)?(?:json|xml|javascript|xhtml\+xml|csv))(?:;|$)/i.test(contentType);
 }
 function boundedUtf8ReviewExcerpt(value, maxBytes) {
     if (Buffer.byteLength(value, "utf8") <= maxBytes)
@@ -675,6 +1768,41 @@ async function loadVerifiedReviewPacket(root, projectId, packetSha256) {
             exitCode: 3,
         });
     }
+    const snapshotChain = packet.snapshotChain;
+    if (!Array.isArray(snapshotChain)) {
+        throw new CliError("Persistent review packet has no evidence snapshot chain.", {
+            code: "RESEARCH_REVIEW_PACKET_DRIFT",
+            exitCode: 3,
+        });
+    }
+    for (const record of snapshotChain) {
+        if (!isObject(record) ||
+            typeof record.path !== "string" ||
+            typeof record.sha256 !== "string" ||
+            !Number.isInteger(record.bytes) ||
+            !/^evidence\/snapshots\/[0-9a-f]{64}\.json$/.test(record.path)) {
+            throw new CliError("Persistent review packet has an invalid snapshot-chain record.", {
+                code: "RESEARCH_REVIEW_PACKET_DRIFT",
+                exitCode: 3,
+            });
+        }
+        let actual;
+        try {
+            actual = await fileRecord(resolveContained(projectRoot(root, projectId), record.path), record.path);
+        }
+        catch {
+            throw new CliError("Persistent review snapshot chain is missing.", {
+                code: "RESEARCH_REVIEW_PACKET_DRIFT",
+                exitCode: 3,
+            });
+        }
+        if (actual.sha256 !== record.sha256 || actual.bytes !== record.bytes) {
+            throw new CliError("Persistent review snapshot chain failed hash verification.", {
+                code: "RESEARCH_REVIEW_PACKET_DRIFT",
+                exitCode: 3,
+            });
+        }
+    }
     return fileRecord(path, logicalPath);
 }
 function verifyReviewPacketValue(packet, packetSha256) {
@@ -783,7 +1911,8 @@ function agentRequest(input) {
         maxTurns,
         maxOutputTokens: input.maxOutputTokens,
         maxToolContextTokens: input.brokerUrl
-            ? input.config.budget.maxBrokerContextTokens * input.config.budget.maxBrokerCalls
+            ? input.config.budget.maxBrokerContextTokens *
+                (input.brokerCallBudget ?? input.config.budget.maxBrokerCalls)
             : 0,
         maxCostUsd: input.maxCostUsd,
         expectedRuntime: input.expectedRuntime,
@@ -814,8 +1943,10 @@ async function materializeAndValidateStageOutput(root, project, capsuleProject,
     const parsed = parseStructuredStageOutput(workPackage.stage, raw, reviewPacketSha256);
     const destination = resolveContained(capsuleProject, workPackage.expectedOutputs[0]);
     const fileContent = workPackage.stage === "discover"
-        ? `${JSON.stringify(normalizeEvidenceCoverage(project, parsed.value), null, 2)}\n`
-        : parsed.fileContent;
+        ? `${JSON.stringify(normalizeEvidenceCoverage(project, await materializeDiscoveryEvidence(root, project, parsed.value)), null, 2)}\n`
+        : workPackage.stage === "acquire"
+            ? `${JSON.stringify(await materializeAcquisitionAudit(root, project, parsed.value), null, 2)}\n`
+            : parsed.fileContent;
     await writeTextAtomic(destination, fileContent);
     await validateOutputShape(root, project, workPackage, destination, reviewPacketSha256);
     if (parsed.normalizations.length > 0) {
@@ -854,12 +1985,20 @@ async function validateOutputShape(root, project, workPackage, path, reviewPacke
     const content = await readFile(path, "utf8");
     if (!content.trim())
         throw deterministicError(`${workPackage.expectedOutputs[0]} is empty.`);
-    if (workPackage.stage === "synthesize")
+    if (workPackage.stage === "synthesize") {
+        await validateSynthesisDocument(path, content);
         return;
-    const { value } = parseStructuredStageOutput(workPackage.stage, content, reviewPacketSha256);
+    }
     if (workPackage.stage === "discover") {
+        const value = parseEvidenceRecord(content);
         await validateEvidenceSources(root, project, value.sources);
+        return;
     }
+    if (workPackage.stage === "acquire") {
+        parseMaterializedAcquisitionAudit(JSON.parse(content));
+        return;
+    }
+    const { value } = parseStructuredStageOutput(workPackage.stage, content, reviewPacketSha256);
     if (workPackage.stage === "analyze") {
         await validateFindings(path, value.findings);
     }
@@ -933,10 +2072,10 @@ async function validateEvidenceSources(root, project, sources) {
     }
 }
 async function validateFindings(path, findings) {
-    const evidencePath = join(dirname(path), "evidence.json");
+    const evidencePath = join(dirname(path), "evidence-snapshot.json");
     const evidence = JSON.parse(await readFile(evidencePath, "utf8"));
     if (!isObject(evidence) || !Array.isArray(evidence.sources)) {
-        throw deterministicError("Analysis requires admitted evidence.json.");
+        throw deterministicError("Analysis requires a frozen evidence-snapshot.json.");
     }
     const sourceIds = new Set(evidence.sources
         .filter((source) => isObject(source))
@@ -959,6 +2098,105 @@ async function validateFindings(path, findings) {
         findingIds.add(finding.id);
     }
 }
+async function validateSynthesisDocument(path, content) {
+    const validation = [];
+    if ([...content.matchAll(/`([^`\n]*)`/g)].some((match) => /https?:\/\//i.test(match[1] ?? ""))) {
+        validation.push("URLs must be real Markdown links or bare links, not inline-code literals");
+    }
+    if (/%(?:60|0a|0d)|\\u0060|https?:\/\/[^\s<>"'`)\]]*`/i.test(content)) {
+        validation.push("URLs contain encoded or literal backtick/newline contamination");
+    }
+    const markdownTargets = [];
+    for (const match of content.matchAll(/!?\[[^\]\n]*\]\(([^)\s]+)(?:\s+["'][^"']*["'])?\)/g)) {
+        if (match[1])
+            markdownTargets.push(stripMarkdownDestination(match[1]));
+    }
+    const referenceIds = new Set();
+    for (const match of content.matchAll(/^\s*\[([^\]\n]+)\]:\s*(\S+)/gm)) {
+        const id = match[1].trim().toLowerCase().replace(/\s+/g, " ");
+        if (referenceIds.has(id))
+            validation.push(`duplicate Markdown reference ID: ${id}`);
+        referenceIds.add(id);
+        markdownTargets.push(stripMarkdownDestination(match[2]));
+    }
+    for (const target of markdownTargets) {
+        await validateReportTarget(path, target, validation);
+    }
+    const urls = new Set([...content.matchAll(/https?:\/\/[^\s<>"'`)\]]+/gi)]
+        .map((match) => stripTrailingUrlPunctuation(match[0]))
+        .filter(Boolean));
+    for (const value of urls)
+        validateReportHttpsUrl(value, validation);
+    if (validation.length) {
+        throw new StructuredOutputError("Synthesis output failed mechanical link QA.", {
+            validation: [...new Set(validation)].slice(0, 20),
+        });
+    }
+}
+async function validateReportTarget(reportPath, target, validation) {
+    if (!target || target.startsWith("#"))
+        return;
+    if (/^https?:\/\//i.test(target)) {
+        validateReportHttpsUrl(target, validation);
+        return;
+    }
+    if (/^mailto:/i.test(target))
+        return;
+    if (/^[a-z][a-z0-9+.-]*:/i.test(target)) {
+        validation.push(`unsupported Markdown link scheme: ${target.split(":", 1)[0]}`);
+        return;
+    }
+    let decoded;
+    try {
+        decoded = decodeURIComponent(target.split(/[?#]/, 1)[0] ?? "");
+    }
+    catch {
+        validation.push("Markdown link contains invalid percent encoding");
+        return;
+    }
+    if (!decoded || isAbsolute(decoded)) {
+        validation.push("Markdown local links must be relative files inside the research capsule");
+        return;
+    }
+    const capsuleProject = dirname(dirname(reportPath));
+    const selected = resolve(dirname(reportPath), decoded);
+    if (relative(capsuleProject, selected).startsWith("..")) {
+        validation.push("Markdown local link escapes the research capsule");
+        return;
+    }
+    const info = await lstat(selected).catch(() => undefined);
+    if (!info?.isFile() || info.isSymbolicLink()) {
+        validation.push(`Markdown local link does not resolve to a regular file: ${decoded}`);
+    }
+}
+function validateReportHttpsUrl(value, validation) {
+    if (/%(?:60|0a|0d)|`/i.test(value)) {
+        validation.push("URL contains encoded or literal backtick/newline contamination");
+        return;
+    }
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        validation.push("report contains an invalid URL");
+        return;
+    }
+    if (url.protocol !== "https:")
+        validation.push(`report URL must use HTTPS: ${url.host}`);
+    if (url.username || url.password)
+        validation.push("report URL contains embedded credentials");
+    const sensitive = /^(access_token|api[_-]?key|apikey|auth|authorization|code|cookie|key|password|secret|session|sig|signature|token)$/i;
+    if ([...url.searchParams.keys()].some((key) => sensitive.test(key))) {
+        validation.push("report URL contains sensitive query parameters");
+    }
+}
+function stripMarkdownDestination(value) {
+    return value.startsWith("<") && value.endsWith(">") ? value.slice(1, -1) : value;
+}
+function stripTrailingUrlPunctuation(value) {
+    return value.replace(/[),.;!?`]+$/g, "");
+}
 function normalizeEvidenceCoverage(project, value) {
     const inputIds = new Set(project.inputs.map((input) => input.id));
     const sources = (value.sources ?? []).map((source) => {
@@ -1051,13 +2289,16 @@ function computeEvidenceCoverage(project, sources, declared) {
         mechanicalGaps: gaps,
     };
 }
-async function assertEvidenceCoverage(root, project) {
-    const path = resolveContained(projectRoot(root, project.id), "outputs/evidence.json");
+async function assertDiscoveryCoverage(root, project, evidencePath) {
+    const path = evidencePath ?? resolveContained(projectRoot(root, project.id), "outputs/evidence.json");
     const value = JSON.parse(await readFile(path, "utf8"));
     const sources = value.sources;
     const declared = value.coverage;
     const computed = computeEvidenceCoverage(project, sources, declared);
-    const gaps = [...computed.mechanicalGaps];
+    // Full-text acquisition is intentionally the next phase. Discovery must
+    // establish breadth, dates, source types and dimensions, but cannot claim
+    // that a search-result receipt is already acquired full text.
+    const gaps = computed.mechanicalGaps.filter((gap) => !/full-text source\(s\)/.test(gap));
     const requiredCapabilities = requiredDiscoveryCapabilityIds(await loadCapabilityDeclarations(root));
     const exercisedCapabilities = new Set((await loadProjectEvidenceReceipts(root, project.id)).map((receipt) => receipt.capabilityId));
     const journalEvents = await readJournal(workspacePaths(root).journal);
@@ -1103,9 +2344,6 @@ async function assertEvidenceCoverage(root, project) {
         canonicalJson(declared.publicationDateRange) !== canonicalJson(computed.publicationDateRange)) {
         gaps.push("coverage summary does not match admitted sources");
     }
-    if (declared.decision !== computed.decision) {
-        gaps.push(`coverage decision must be ${computed.decision}`);
-    }
     if (gaps.length) {
         throw new CliError("Evidence coverage is insufficient; downstream packages were not started.", {
             code: "RESEARCH_EVIDENCE_INSUFFICIENT",
@@ -1142,9 +2380,14 @@ function publicationDateInterval(value) {
     return { earliest: `${match[1]}-01-01`, latest: `${match[1]}-12-31` };
 }
 async function closeProjectMechanically(root, project, workPackage) {
-    await assertEvidenceCoverage(root, project);
+    const snapshot = await loadCurrentEvidenceSnapshot(root, project.id);
+    project.evidenceState.currentSnapshotId = snapshot.snapshotId;
+    project.evidenceState.currentSnapshotSha256 = snapshot.snapshotSha256;
+    project.evidenceState.closureSnapshotId = snapshot.snapshotId;
     const required = [
         "outputs/evidence.json",
+        "outputs/acquisition.json",
+        "outputs/evidence-snapshot.json",
         "outputs/analysis.json",
         "outputs/report.md",
         "outputs/review.json",
@@ -1159,6 +2402,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);
+    await verifyReviewLedgerBinding(root, project.id, snapshot.snapshotId, review.packetSha256);
     const evidenceReceipts = await loadProjectEvidenceReceipts(root, project.id);
     const journal = await verifyJournal(workspacePaths(root).journal);
     const closure = {
@@ -1168,6 +2412,12 @@ async function closeProjectMechanically(root, project, workPackage) {
         closedAt: new Date().toISOString(),
         questionSha256: sha256Text(project.question),
         evidenceRequirements: project.evidenceRequirements,
+        evidenceSnapshot: {
+            snapshotId: snapshot.snapshotId,
+            snapshotSha256: snapshot.snapshotSha256,
+            parentSnapshotId: snapshot.parentSnapshotId,
+            parentSnapshotSha256: snapshot.parentSnapshotSha256,
+        },
         inputs: project.inputs.map((input) => ({
             id: input.id,
             role: input.role,
@@ -1191,6 +2441,75 @@ async function closeProjectMechanically(root, project, workPackage) {
     await writeJsonAtomic(closurePath, closure);
     return zeroExecutionResult();
 }
+async function commitStageEvidenceBindings(root, project, workPackage) {
+    if (workPackage.stage !== "analyze" && workPackage.stage !== "review")
+        return;
+    const snapshot = await loadCurrentEvidenceSnapshot(root, project.id);
+    const events = await readJournal(evidenceLedgerPath(root, project.id));
+    if (workPackage.stage === "analyze") {
+        const path = join(projectRoot(root, project.id), "outputs", "analysis.json");
+        const value = JSON.parse(await readFile(path, "utf8"));
+        if (!isObject(value) || !Array.isArray(value.findings)) {
+            throw deterministicError("Analysis claim bindings require a valid analysis output.");
+        }
+        const committed = new Set(events
+            .filter((event) => event.type === "claim.used")
+            .map((event) => String(event.payload.bindingSha256)));
+        for (const finding of value.findings) {
+            if (!isObject(finding) ||
+                typeof finding.id !== "string" ||
+                !Array.isArray(finding.evidence) ||
+                finding.evidence.some((sourceId) => typeof sourceId !== "string")) {
+                throw deterministicError("Analysis contains an invalid claim binding.");
+            }
+            const binding = {
+                claimId: finding.id,
+                snapshotId: snapshot.snapshotId,
+                sourceIds: [...finding.evidence].sort(),
+                claimSha256: sha256Text(canonicalJson(finding)),
+            };
+            const bindingSha256 = sha256Text(canonicalJson(binding));
+            if (committed.has(bindingSha256))
+                continue;
+            await appendEvidenceLedgerEvent(root, project.id, "claim.used", {
+                ...binding,
+                bindingSha256,
+            });
+        }
+        return;
+    }
+    const path = join(projectRoot(root, project.id), "outputs", "review.json");
+    const value = JSON.parse(await readFile(path, "utf8"));
+    if (!isObject(value) || value.decision !== "pass" || typeof value.packetSha256 !== "string") {
+        throw deterministicError("Review binding requires a passing schema-valid review.");
+    }
+    const binding = {
+        snapshotId: snapshot.snapshotId,
+        packetSha256: value.packetSha256,
+        reviewSha256: await sha256File(path),
+        decision: value.decision,
+    };
+    const bindingSha256 = sha256Text(canonicalJson(binding));
+    if (events.some((event) => event.type === "review.bound" && event.payload.bindingSha256 === bindingSha256)) {
+        return;
+    }
+    await appendEvidenceLedgerEvent(root, project.id, "review.bound", {
+        ...binding,
+        bindingSha256,
+    });
+}
+async function verifyReviewLedgerBinding(root, projectId, snapshotId, packetSha256) {
+    const reviewPath = join(projectRoot(root, projectId), "outputs", "review.json");
+    const reviewSha256 = await sha256File(reviewPath);
+    const events = await readJournal(evidenceLedgerPath(root, projectId));
+    const bound = events.some((event) => event.type === "review.bound" &&
+        event.payload.snapshotId === snapshotId &&
+        event.payload.packetSha256 === packetSha256 &&
+        event.payload.reviewSha256 === reviewSha256);
+    if (!bound) {
+        throw deterministicError("Project review is not bound to the current evidence snapshot ledger.");
+    }
+}
 async function verifyProjectInputBindings(project) {
     for (const input of project.inputs) {
         const info = await lstat(input.path).catch(() => undefined);
@@ -1230,19 +2549,37 @@ 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, workPackage, config) {
-    const logicalPaths = workPackage.stage === "analyze"
-        ? ["outputs/evidence.json"]
-        : workPackage.stage === "synthesize"
-            ? ["outputs/evidence.json", "outputs/analysis.json"]
-            : workPackage.stage === "review"
+async function stageContextForPackage(capsuleProject, project, workPackage, config) {
+    const logicalPaths = workPackage.stage === "discover" && project.lineage.kind === "addendum"
+        ? ["outputs/base-evidence-snapshot.json"]
+        : workPackage.stage === "acquire"
+            ? [
+                "outputs/evidence.json",
+                ...(project.lineage.kind === "addendum" ? ["outputs/base-evidence-snapshot.json"] : []),
+            ]
+            : workPackage.stage === "analyze"
                 ? [
-                    "inputs/review-evidence-context.txt",
-                    "outputs/evidence.json",
-                    "outputs/analysis.json",
-                    "outputs/report.md",
+                    "outputs/evidence-snapshot.json",
+                    ...((await pathExists(resolveContained(capsuleProject, "inputs/evidence-artifact-context.txt")))
+                        ? ["inputs/evidence-artifact-context.txt"]
+                        : []),
                 ]
-                : [];
+                : workPackage.stage === "synthesize"
+                    ? [
+                        "outputs/evidence-snapshot.json",
+                        "outputs/analysis.json",
+                        ...((await pathExists(resolveContained(capsuleProject, "inputs/evidence-artifact-context.txt")))
+                            ? ["inputs/evidence-artifact-context.txt"]
+                            : []),
+                    ]
+                    : workPackage.stage === "review"
+                        ? [
+                            "inputs/review-evidence-context.txt",
+                            "outputs/evidence-snapshot.json",
+                            "outputs/analysis.json",
+                            "outputs/report.md",
+                        ]
+                        : [];
     const sections = [];
     for (const logicalPath of logicalPaths) {
         const content = await readFile(resolveContained(capsuleProject, logicalPath), "utf8");
@@ -1250,13 +2587,17 @@ async function stageContextForPackage(capsuleProject, workPackage, config) {
     }
     const bundled = sections.join("\n\n");
     const estimatedTokens = Math.ceil(Buffer.byteLength(bundled, "utf8") / RESEARCH_ESTIMATED_BYTES_PER_TOKEN);
-    const maxStageContextTokens = workPackage.stage === "review"
-        ? config.budget.maxInputContextTokens + config.budget.maxOutputTokens * 3
-        : workPackage.stage === "synthesize"
-            ? config.budget.maxOutputTokens * 2
-            : workPackage.stage === "analyze"
-                ? config.budget.maxOutputTokens
-                : 0;
+    const maxStageContextTokens = workPackage.stage === "discover" && project.lineage.kind === "addendum"
+        ? config.budget.maxInputContextTokens
+        : workPackage.stage === "review"
+            ? config.budget.maxInputContextTokens + config.budget.maxOutputTokens * 4
+            : workPackage.stage === "synthesize"
+                ? config.budget.maxInputContextTokens
+                : workPackage.stage === "analyze"
+                    ? config.budget.maxInputContextTokens
+                    : workPackage.stage === "acquire"
+                        ? config.budget.maxOutputTokens
+                        : 0;
     if (estimatedTokens > maxStageContextTokens) {
         throw new CliError(`Admitted stage context exceeds the configured input context limit for ${workPackage.id}.`, {
             code: "RESEARCH_INPUT_CONTEXT_BUDGET_EXCEEDED",
@@ -1270,10 +2611,11 @@ async function stageContextForPackage(capsuleProject, workPackage, config) {
     }
     return bundled;
 }
-function packagePrompt(project, workPackage, inputs, stagedSkills, capabilityDocumentation, reviewPacketSha256, contextBundle, contextBundleContent, stageContextContent, maxBrokerCalls) {
+function packagePrompt(project, workPackage, inputs, stagedSkills, capabilityDocumentation, reviewPacketSha256, contextBundle, contextBundleContent, stageContextContent, discovery, evidenceCandidates) {
     const stageInstructions = {
-        discover: "Return the evidence object defined by the supplied JSON Schema. Cite only declared inputs or broker receipts. Each source.id is your concise evidence label; it must not be reused as provenance.id. For declared inputs, provenance must use the exact id and path shown in the declared input manifest, with locator=path. Every declared input binds an exact registered full source, so fullTextAvailable=true even when fullTextStaged=false; that flag means the producer receives only its bounded context while independent review binds both the verified full-file hash and the exact bounded review view. For broker evidence, provenance.id must be the exact receipt attemptId and locator must be the receipt locator (not contextLocator); use contextLocator only to inspect the bounded view. Include source type, retrieval metadata, an excerpt or JSON Pointer when available, quality, applicability, coverage dimensions, limitations, and an honest coverage assessment. A partial dimension is usable but incomplete; missing means no admitted source covers it. coverage.gaps records qualitative limitations and does not alone force an insufficient decision. The CLI mechanically derives local-input full-text availability, sourceTypes, counts, date range, sourceIds, and the pass/insufficient decision from admitted sources and declared minimums. Never place credentials or sensitive URL parameters in any field.",
-        analyze: "Use only the complete embedded admitted evidence below and return the schema-defined analysis object. Every finding must cite admitted evidence source IDs and state uncertainty and applicability.",
+        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 and broker 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 frozen evidence snapshot below and return the schema-defined analysis object. Every finding must cite source IDs present in that snapshot and state uncertainty and applicability. When the snapshot has a parent, use its mechanical delta to focus re-analysis on added, changed, and removed evidence while still returning one complete current analysis.",
         synthesize: "Use only the complete embedded admitted evidence and findings below. Return the schema-defined object whose reportMarkdown separates supported conclusions, uncertainty, limitations, and next actions. Use real Markdown line breaks encoded exactly once for JSON; never place literal /n or double-escaped \\n markers in reportMarkdown. When the admitted publication-date range is narrower than the requested range, state the exact admitted range and missing interval prominently in the opening summary.",
         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.`,
         close: "No agent action is allowed for mechanical closure.",
@@ -1289,16 +2631,26 @@ function packagePrompt(project, workPackage, inputs, stagedSkills, capabilityDoc
         `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."
-            : "Capability files are provenance-bound but are not available as execution tools in this stage.",
+            : 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"
-            ? `Use the broker only, with at most ${maxBrokerCalls} total fetch_candidate_source calls. Prefer broad, high-yield queries and stop querying once the declared coverage minimums are met. Do not execute a staged Skill's curl/CLI examples or read provider environment variables. Invoke fetch_candidate_source with the manifest capability ID and obey its exact declared HTTP method. GET capabilities use only declared query parameters; POST capabilities require request_body containing only the documented non-secret request JSON. Never place API keys, tokens, authorization data, cookies, or other credential-like fields in request_body. The broker injects the sole declared logical credential, disables caching for credentialed requests, and never persists the POST body (only its hash). The tool result includes the exact bounded context together with its receipt and remaining call budget; use that inline context and its provenance fields. Exercise every manifest capability with requiredForDiscovery=true, or the mechanical coverage gate will stop downstream work.`
+            ? `Follow the reviewed discovery plan: ${JSON.stringify(discovery)}. The plan's max broker-view 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. The broker or an immutable registered input is the sole admissible evidence path. Do not execute a staged Skill's curl/CLI examples or read provider environment variables. Invoke fetch_candidate_source with the manifest capability ID and obey its exact declared HTTP method. GET capabilities use only declared query parameters; POST capabilities require request_body containing only the documented non-secret request JSON. Never place API keys, tokens, authorization data, cookies, or other credential-like fields in request_body. The broker injects the sole declared logical credential, disables caching for credentialed requests, and never persists the POST body (only its hash). The tool result includes exact bounded context, registered candidate IDs, its receipt, whether a network call was avoided, and remaining view budget. Exercise every manifest capability with requiredForDiscovery=true, or the mechanical coverage gate will stop downstream work.`
             : "Use only the complete embedded stage context; no tools or additional source reads are allowed.",
         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.",
         "Do not edit project.json, input manifests, prior outputs, evidence objects, or staged capability files.",
     ];
     if (workPackage.stage === "discover") {
-        prompt.push("The complete external capability documentation bundle is embedded below:", capabilityDocumentation, `Exact local-input provenance mappings: ${JSON.stringify(inputs.map((input) => ({ kind: "input", id: input.id, locator: input.path })))}`, "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);
+        prompt.push(`Candidate index already registered at stage start: ${JSON.stringify(evidenceCandidates.map((candidate) => ({
+            candidateId: candidate.id,
+            title: candidate.title,
+            url: candidate.url,
+            doi: candidate.doi,
+            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);
     }
     if (stageContextContent) {
         prompt.push("The complete admitted stage context is embedded below. Use it directly and do not re-read output files.", stageContextContent);
@@ -1345,11 +2697,12 @@ function assertPreCallTokenReservation(project, workPackage, config, request, al
         });
     }
 }
-function reservePackageBudget(project, workPackage, config) {
+function reservePackageBudget(project, workPackage, config, requestedTokens) {
     if (workPackage.stage === "close")
         return { tokens: 0, costUsd: 0 };
     const route = workPackage.executor === "reviewer" ? config.reviewer : config.producer;
-    const tokens = config.budget.packageMaxTokens[workPackage.stage];
+    const packageMaximum = config.budget.packageMaxTokens[workPackage.stage];
+    const tokens = Math.min(packageMaximum, requestedTokens ?? packageMaximum);
     const costUsd = roundMoney(reservedAgentPackageCost(route, tokens, config));
     const wallSeconds = config.budget.packageMaxWallSeconds[workPackage.stage];
     const remaining = remainingBudget(project, config);
@@ -1443,6 +2796,10 @@ function remainingWallSeconds(project, config) {
     return Math.max(1, Math.floor(config.budget.maxWallSeconds - project.usage.wallSeconds));
 }
 function assertExecutionConfiguration(config) {
+    if (config.producer.executionMode !== "native-host" ||
+        config.reviewer.executionMode !== "headless-cli") {
+        throw new CliError("Research requires a native-host producer and a separate headless-CLI reviewer.", { code: "RESEARCH_EXECUTION_MODE_INVALID", exitCode: 3 });
+    }
     if (config.producer.agent === config.reviewer.agent) {
         throw new CliError("Research producer and reviewer must use different agent families.", {
             code: "RESEARCH_REVIEW_ROUTE_INVALID",
@@ -1686,21 +3043,33 @@ async function summarizeRun(root, requestId, cycles, executed, maxCycles, projec
         usage: project.usage,
     }));
     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);
+    const nativeStageRequired = projects.some((project) => project.packages.some((workPackage) => workPackage.executor === "producer" &&
+        (workPackage.status === "ready" || workPackage.status === "running")));
     const status = summaries.length > 0 && summaries.every((project) => project.status === "complete")
         ? "complete"
-        : unfinished.length > 0 && unfinished.every((project) => project.status === "blocked")
-            ? "blocked"
-            : "ready";
+        : waiting.length > 0 &&
+            unfinished.every((project) => project.status === "blocked" ||
+                project.status === "waiting-user" ||
+                project.status === "waiting-external")
+            ? "waiting"
+            : unfinished.length > 0 && unfinished.every((project) => project.status === "blocked")
+                ? "blocked"
+                : "ready";
     const stopReason = summaries.length === 0
         ? "no-projects"
         : status === "complete"
             ? "all-projects-complete"
-            : hasReadyPackage && cycles >= maxCycles
-                ? "cycle-limit"
-                : status === "blocked"
-                    ? "project-blocked"
-                    : "no-ready-work";
+            : status === "waiting"
+                ? "handoff-required"
+                : hasReadyPackage && cycles >= maxCycles
+                    ? "cycle-limit"
+                    : nativeStageRequired
+                        ? "native-stage-required"
+                        : status === "blocked"
+                            ? "project-blocked"
+                            : "no-ready-work";
     return {
         workspace: root,
         requestId,
@@ -1713,7 +3082,26 @@ async function summarizeRun(root, requestId, cycles, executed, maxCycles, projec
     };
 }
 async function projectsForRun(root, projectId) {
-    return projectId ? [await loadProject(root, projectId)] : listProjects(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,
+                },
+            });
+        }
+        return [project];
+    }
+    return (await listProjects(root)).filter((project) => project.lineage.supersededBy === null &&
+        project.status !== "archived" &&
+        project.status !== "abandoned");
 }
 function assertPublicEvidenceUrl(value, sourceId) {
     let url;
@@ -1723,6 +3111,9 @@ function assertPublicEvidenceUrl(value, sourceId) {
     catch {
         throw deterministicError(`Evidence source ${sourceId} contains an invalid URL.`);
     }
+    if (url.protocol !== "https:") {
+        throw deterministicError(`Evidence source ${sourceId} URL must use HTTPS.`);
+    }
     if (url.username || url.password) {
         throw deterministicError(`Evidence source ${sourceId} URL contains credentials.`);
     }
@@ -1737,6 +3128,120 @@ function deterministicError(message) {
 function projectRoot(root, projectId) {
     return join(workspacePaths(root).projects, projectId);
 }
+function nativeStageSessionPath(root, projectId) {
+    return join(projectRoot(root, projectId), "native", "active.json");
+}
+async function readNativeStageSession(root, projectId) {
+    const path = nativeStageSessionPath(root, projectId);
+    const info = await lstat(path).catch(() => undefined);
+    if (!info?.isFile() || info.isSymbolicLink()) {
+        throw new CliError("No valid native stage session is active for this project.", {
+            code: "RESEARCH_NATIVE_STAGE_SESSION_REQUIRED",
+            exitCode: 3,
+        });
+    }
+    const value = await readJsonFile(path, "Native research stage session");
+    if (!isObject(value) ||
+        value.schemaVersion !== 1 ||
+        value.kind !== "tiangong-native-research-stage-session" ||
+        !isObject(value.packet) ||
+        typeof value.capsuleRoot !== "string" ||
+        typeof value.capsuleProject !== "string" ||
+        typeof value.sessionSha256 !== "string") {
+        throw new CliError("Native stage session has an unsupported shape.", {
+            code: "RESEARCH_NATIVE_STAGE_SESSION_INVALID",
+            exitCode: 3,
+        });
+    }
+    const { sessionSha256, ...core } = value;
+    if (sha256Text(canonicalJson(core)) !== sessionSha256) {
+        throw new CliError("Native stage session failed its content hash.", {
+            code: "RESEARCH_NATIVE_STAGE_SESSION_INVALID",
+            exitCode: 3,
+        });
+    }
+    const packet = value.packet;
+    const { packetSha256, ...packetCore } = packet;
+    if (packet.schemaVersion !== 1 ||
+        packet.kind !== "tiangong-native-research-stage" ||
+        packet.projectId !== projectId ||
+        typeof packetSha256 !== "string" ||
+        sha256Text(canonicalJson(packetCore)) !== packetSha256) {
+        throw new CliError("Native stage packet failed its content hash or project binding.", {
+            code: "RESEARCH_NATIVE_STAGE_SESSION_INVALID",
+            exitCode: 3,
+        });
+    }
+    const runtimeRoot = resolve(workspacePaths(root).runtime);
+    const capsuleRoot = resolve(value.capsuleRoot);
+    const capsuleProject = resolve(value.capsuleProject);
+    if (relative(runtimeRoot, capsuleRoot).startsWith("..") ||
+        relative(capsuleRoot, capsuleProject).startsWith("..") ||
+        !(await lstat(capsuleRoot).catch(() => undefined))?.isDirectory() ||
+        !(await lstat(capsuleProject).catch(() => undefined))?.isDirectory()) {
+        throw new CliError("Native stage capsule is missing or outside the workspace runtime.", {
+            code: "RESEARCH_NATIVE_STAGE_SESSION_INVALID",
+            exitCode: 3,
+        });
+    }
+    return value;
+}
+async function nativeStageBinding(root, project, workPackage) {
+    const paths = workspacePaths(root);
+    const outputRoot = join(projectRoot(root, project.id), "outputs");
+    const outputs = [];
+    if (await pathExists(outputRoot)) {
+        for (const path of await regularTreeFiles(outputRoot)) {
+            outputs.push(await fileRecord(path, relative(projectRoot(root, project.id), path).replaceAll("\\", "/")));
+        }
+    }
+    return sha256Text(canonicalJson({
+        projectId: project.id,
+        questionSha256: sha256Text(project.question),
+        evidenceRequirements: project.evidenceRequirements,
+        inputs: project.inputs.map((record) => ({
+            id: record.id,
+            role: record.role,
+            sha256: record.sha256,
+            bytes: record.bytes,
+            contextSha256: record.contextSha256 ?? null,
+            contextBytes: record.contextBytes ?? null,
+        })),
+        package: {
+            id: workPackage.id,
+            stage: workPackage.stage,
+            dependencies: workPackage.dependencies,
+            expectedOutputs: workPackage.expectedOutputs,
+        },
+        outputs,
+        configSha256: await sha256File(paths.config),
+        runtimeLockSha256: await sha256File(paths.runtimeLock),
+        capabilityDeclarationsSha256: await sha256File(paths.capabilityDeclarations),
+        capabilityLockSha256: (await pathExists(paths.capabilityLock))
+            ? await sha256File(paths.capabilityLock)
+            : null,
+    }));
+}
+async function assertNativeStageBinding(root, project, packet) {
+    const workPackage = packageById(project, packet.packageId);
+    const actual = await nativeStageBinding(root, project, workPackage);
+    if (actual !== packet.bindingSha256) {
+        throw new CliError("Native stage inputs, configuration, or admitted outputs drifted.", {
+            code: "RESEARCH_NATIVE_STAGE_BINDING_DRIFT",
+            exitCode: 3,
+            details: { expectedSha256: packet.bindingSha256, actualSha256: actual },
+        });
+    }
+}
+function requireNativeOutputPath(value) {
+    if (!value || !isAbsolute(value) || /[\0\r\n]/.test(value)) {
+        throw new CliError("Native stage output requires an explicit absolute file path.", {
+            code: "RESEARCH_NATIVE_STAGE_OUTPUT_INVALID",
+            exitCode: 2,
+        });
+    }
+    return resolve(value);
+}
 function validateRunOptions(options) {
     if (!Number.isInteger(options.maxParallel) ||
         options.maxParallel < 1 ||