@vela-science/canopus 0.4.0-rc.1

package/dist/src/engines/engine.d.ts

@@ -0,0 +1,55 @@
+import type { CandidateStatus } from "../contracts/candidate.js";
+import type { Mission } from "../contracts/mission.js";
+import type { BudgetTracker } from "../budget/enforce.js";
+import type { WorkspacePaths } from "../workspace/prepare.js";
+export declare const ENGINE_OUTPUT_SCHEMA: "canopus.engine-output.v0";
+export declare const MAX_ENGINE_ARTIFACTS = 8;
+export declare const MAX_ENGINE_OBSERVATIONS = 16;
+export declare const MAX_ENGINE_CAVEATS = 8;
+export interface DraftArtifact {
+    path: string;
+    kind: string;
+    encoding: "utf8";
+    content: string;
+}
+export interface CandidateDraft {
+    schema: typeof ENGINE_OUTPUT_SCHEMA;
+    status: CandidateStatus;
+    claim: string;
+    artifacts: DraftArtifact[];
+    observations: string[];
+    caveats: string[];
+}
+export interface EngineUsage {
+    input_tokens: number;
+    cached_input_tokens: number;
+    output_tokens: number;
+    reasoning_output_tokens: number;
+}
+export interface EngineIdentity {
+    name: string;
+    version: string;
+    binary_sha256: string | null;
+    model: string | null;
+    configuration_sha256: string;
+}
+export interface EngineResult {
+    draft: CandidateDraft;
+    engine: EngineIdentity;
+    usage: EngineUsage;
+    wallTimeMs: number;
+    eventTypes: string[];
+    actionTypes: string[];
+    eventsDigest: string;
+    stderrDigest: string;
+}
+export interface EngineContext {
+    mission: Mission;
+    briefing: Record<string, unknown>;
+    paths: WorkspacePaths;
+    budget: BudgetTracker;
+}
+export interface Engine {
+    readonly name: string;
+    run(context: EngineContext): Promise<EngineResult>;
+}

package/dist/src/engines/engine.js

@@ -0,0 +1,4 @@
+export const ENGINE_OUTPUT_SCHEMA = "canopus.engine-output.v0";
+export const MAX_ENGINE_ARTIFACTS = 8;
+export const MAX_ENGINE_OBSERVATIONS = 16;
+export const MAX_ENGINE_CAVEATS = 8;

package/dist/src/engines/fake.d.ts

@@ -0,0 +1,7 @@
+import type { CandidateDraft, Engine, EngineContext, EngineResult } from "./engine.js";
+export declare class FakeEngine implements Engine {
+    #private;
+    readonly name = "fake";
+    constructor(draft: CandidateDraft | ((context: EngineContext) => CandidateDraft | Promise<CandidateDraft>));
+    run(context: EngineContext): Promise<EngineResult>;
+}

package/dist/src/engines/fake.js

@@ -0,0 +1,37 @@
+import { contentDigest, sha256Bytes } from "../util/canonical.js";
+export class FakeEngine {
+    name = "fake";
+    #draft;
+    constructor(draft) {
+        this.#draft = draft;
+    }
+    async run(context) {
+        const started = performance.now();
+        context.budget.beginAttempt();
+        context.budget.beginProcess();
+        const draft = typeof this.#draft === "function" ? await this.#draft(context) : structuredClone(this.#draft);
+        const serialized = JSON.stringify(draft);
+        context.budget.addOutput(Buffer.byteLength(serialized));
+        return {
+            draft,
+            engine: {
+                name: this.name,
+                version: "1",
+                binary_sha256: null,
+                model: null,
+                configuration_sha256: contentDigest({ engine: this.name, version: "1" }),
+            },
+            usage: {
+                input_tokens: 0,
+                cached_input_tokens: 0,
+                output_tokens: 0,
+                reasoning_output_tokens: 0,
+            },
+            wallTimeMs: Math.max(0, Math.round(performance.now() - started)),
+            eventTypes: ["fake.completed"],
+            actionTypes: [],
+            eventsDigest: contentDigest({ type: "fake.completed", output: draft }),
+            stderrDigest: sha256Bytes(""),
+        };
+    }
+}

package/dist/src/evidence/manifests.d.ts

@@ -0,0 +1,9 @@
+import type { Mission } from "../contracts/mission.js";
+import type { EngineResult } from "../engines/engine.js";
+export interface SupportingArtifactSpec {
+    path: string;
+    kind: "engine-manifest" | "verifier-manifest";
+    value: Record<string, unknown>;
+}
+export declare function engineManifest(engine: EngineResult): SupportingArtifactSpec;
+export declare function verifierManifest(mission: Mission): SupportingArtifactSpec;

package/dist/src/evidence/manifests.js

@@ -0,0 +1,56 @@
+import { contentDigest } from "../util/canonical.js";
+function manifestPath(kind, value) {
+    const directory = kind === "engine-manifest" ? "engine-manifests" : "verifier-manifests";
+    return `canopus/${directory}/${contentDigest(value).slice("sha256:".length)}.json`;
+}
+export function engineManifest(engine) {
+    const value = {
+        schema: "canopus.engine-manifest.v0",
+        engine: engine.engine,
+        usage: engine.usage,
+        wall_time_ms: engine.wallTimeMs,
+        event_types: engine.eventTypes,
+        action_types: engine.actionTypes,
+        events_sha256: engine.eventsDigest,
+        stderr_sha256: engine.stderrDigest,
+    };
+    return { path: manifestPath("engine-manifest", value), kind: "engine-manifest", value };
+}
+export function verifierManifest(mission) {
+    const common = {
+        capsule_path: mission.verifier.argv[0],
+        executable_sha256: mission.verifier.executable_sha256,
+        argv_template: mission.verifier.argv,
+        cwd: mission.verifier.cwd,
+    };
+    const value = mission.schema === "canopus.mission.v1"
+        ? {
+            schema: "canopus.verifier-manifest.v1",
+            ...common,
+            image: mission.verifier.image,
+            sandbox: {
+                backend: "docker",
+                network: "deny",
+                root_filesystem: "read_only",
+                bind_mounts: "exact_inputs_read_only",
+                capabilities: "drop_all",
+                privilege_escalation: "deny",
+            },
+            platform: {
+                os: "linux",
+                arch: mission.verifier.platform?.slice("linux/".length) ?? "unspecified",
+            },
+        }
+        : {
+            schema: "canopus.verifier-manifest.v0",
+            ...common,
+            sandbox: {
+                backend: "macos_seatbelt",
+                network: "deny",
+                persistent_writes: "deny",
+                process_fork: "deny",
+            },
+            platform: { os: "darwin", arch: process.arch },
+        };
+    return { path: manifestPath("verifier-manifest", value), kind: "verifier-manifest", value };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,32 @@
+export * from "./contracts/candidate.js";
+export * from "./contracts/mission.js";
+export * from "./contracts/validation.js";
+export * from "./budget/enforce.js";
+export * from "./evidence/manifests.js";
+export * from "./artifact/freeze.js";
+export * from "./activity/events.js";
+export * from "./activity/store.js";
+export * from "./candidate/validate.js";
+export * from "./util/canonical.js";
+export * from "./util/command.js";
+export * from "./util/files.js";
+export * from "./roles.js";
+export * from "./receipt/map.js";
+export * from "./repair/plan.js";
+export * from "./projection/run.js";
+export * from "./projection/diagnostic.js";
+export * from "./product/doctor.js";
+export * from "./product/profile.js";
+export * from "./product/profile-bundle.js";
+export * from "./product/replay.js";
+export * from "./product/run.js";
+export * from "./run.js";
+export * from "./engines/engine.js";
+export * from "./engines/fake.js";
+export * from "./engines/codex-events.js";
+export * from "./engines/codex-tool-free.js";
+export * from "./engines/codex-exec.js";
+export * from "./vela/cli.js";
+export * from "./vela/types.js";
+export * from "./workspace/prepare.js";
+export * from "./verifier/run.js";

package/dist/src/index.js

@@ -0,0 +1,32 @@
+export * from "./contracts/candidate.js";
+export * from "./contracts/mission.js";
+export * from "./contracts/validation.js";
+export * from "./budget/enforce.js";
+export * from "./evidence/manifests.js";
+export * from "./artifact/freeze.js";
+export * from "./activity/events.js";
+export * from "./activity/store.js";
+export * from "./candidate/validate.js";
+export * from "./util/canonical.js";
+export * from "./util/command.js";
+export * from "./util/files.js";
+export * from "./roles.js";
+export * from "./receipt/map.js";
+export * from "./repair/plan.js";
+export * from "./projection/run.js";
+export * from "./projection/diagnostic.js";
+export * from "./product/doctor.js";
+export * from "./product/profile.js";
+export * from "./product/profile-bundle.js";
+export * from "./product/replay.js";
+export * from "./product/run.js";
+export * from "./run.js";
+export * from "./engines/engine.js";
+export * from "./engines/fake.js";
+export * from "./engines/codex-events.js";
+export * from "./engines/codex-tool-free.js";
+export * from "./engines/codex-exec.js";
+export * from "./vela/cli.js";
+export * from "./vela/types.js";
+export * from "./workspace/prepare.js";
+export * from "./verifier/run.js";

package/dist/src/mission/prepare.d.ts

@@ -0,0 +1,33 @@
+import { type LandingSpec, type MissionV1, type PositiveResultContractV1 } from "../contracts/mission.js";
+import { type CommandRunner } from "../util/command.js";
+export interface PrepareMissionOptions {
+    draft: unknown;
+    draftRoot: string;
+    sourceRepo: string;
+    outputRoot: string;
+    velaBinary: string;
+    codexBinary: string;
+    dockerBinary: string;
+    verifierImage: string;
+    verifierPlatform?: "linux/amd64" | "linux/arm64";
+    outputSchema: string;
+    permissionProfile: string;
+    targetPacket?: {
+        target: string;
+        schema: string;
+    };
+    landing?: LandingSpec;
+    profileName?: string;
+    profileRoot?: string;
+    resultContract?: PositiveResultContractV1;
+    runner?: CommandRunner;
+}
+export interface PreparedMission {
+    mission: MissionV1;
+    bundleRoot: string;
+    missionPath: string;
+    manifestPath: string;
+}
+export declare function assertVerifierWorkingDirectory(sourceRepo: string, declaredCwd: string): Promise<void>;
+export declare function validateMissionBundle(mission: MissionV1, bundleRoot: string): Promise<void>;
+export declare function prepareMission(options: PrepareMissionOptions): Promise<PreparedMission>;

package/dist/src/mission/prepare.js

@@ -0,0 +1,375 @@
+import { constants } from "node:fs";
+import { access, chmod, copyFile, lstat, mkdir, mkdtemp, realpath, rm, writeFile, } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { EXECUTION_BINDING_SCHEMA, parseMission, } from "../contracts/mission.js";
+import { objectAt, relativePathAt, sha256At, stringAt, } from "../contracts/validation.js";
+import { canonicalJson, contentDigest, sha256Bytes } from "../util/canonical.js";
+import { isolatedEnvironment, runCommand } from "../util/command.js";
+import { MAX_EXECUTABLE_BYTES, readBoundedRegularFile, sha256RegularFile } from "../util/files.js";
+import { VelaClient } from "../vela/cli.js";
+export async function assertVerifierWorkingDirectory(sourceRepo, declaredCwd) {
+    const root = await realpath(sourceRepo);
+    const relative = relativePathAt(declaredCwd, "mission.verifier.cwd");
+    const candidate = path.resolve(root, relative);
+    let resolved;
+    let stat;
+    try {
+        [resolved, stat] = await Promise.all([realpath(candidate), lstat(candidate)]);
+    }
+    catch {
+        throw new Error(`mission verifier cwd does not exist in the sealed source checkout: ${relative}`);
+    }
+    if (!resolved.startsWith(`${root}${path.sep}`) || !stat.isDirectory() || stat.isSymbolicLink()) {
+        throw new Error(`mission verifier cwd is not a real directory below the sealed source checkout: ${relative}`);
+    }
+}
+export async function validateMissionBundle(mission, bundleRoot) {
+    const root = await realpath(bundleRoot);
+    const capsule = await sourceFile(root, mission.verifier.capsule_path, "verifier capsule");
+    await access(capsule, constants.X_OK);
+    const capsuleDigest = sha256Bytes(await readBoundedRegularFile(capsule, 268_435_456));
+    if (capsuleDigest !== mission.verifier.capsule_sha256 ||
+        capsuleDigest !== mission.verifier.executable_sha256) {
+        throw new Error("mission bundle verifier capsule drifted");
+    }
+    const packet = await sourceFile(root, "packet/target.json", "bundled target packet");
+    if (sha256Bytes(await readBoundedRegularFile(packet, 64 * 1024 * 1024)) !== mission.target_packet.sha256) {
+        throw new Error("mission bundle target packet drifted");
+    }
+    const outputSchema = await sourceFile(root, "contract/engine-output.v0.json", "bundled engine output schema");
+    if (sha256Bytes(await readBoundedRegularFile(outputSchema, 8 * 1024 * 1024)) !==
+        mission.worker.output_schema_sha256) {
+        throw new Error("mission bundle engine output schema drifted");
+    }
+    const permissionProfile = await sourceFile(root, mission.worker.permission_profile_path, "bundled worker permission profile");
+    if (sha256Bytes(await readBoundedRegularFile(permissionProfile, 8 * 1024 * 1024)) !==
+        mission.worker.permission_profile_sha256) {
+        throw new Error("mission bundle worker permission profile drifted");
+    }
+    const manifestBytes = await readBoundedRegularFile(path.join(root, "bundle-manifest.json"), 8 * 1024 * 1024);
+    let manifestValue;
+    try {
+        manifestValue = JSON.parse(manifestBytes.toString("utf8"));
+    }
+    catch (error) {
+        throw new Error(`mission bundle manifest is invalid JSON: ${String(error)}`);
+    }
+    const manifest = objectAt(manifestValue, "mission bundle manifest");
+    if (manifest.schema !== "canopus.mission-bundle.v1" ||
+        manifest.authority !== "non_authoritative" ||
+        manifest.mission_sha256 !== contentDigest(mission)) {
+        throw new Error("mission bundle manifest does not bind the mission");
+    }
+}
+async function commandText(runner, argv, cwd, home, allowStderr = false) {
+    const result = await runner({
+        argv,
+        cwd,
+        env: isolatedEnvironment(home),
+        timeoutMs: 120_000,
+        maxOutputBytes: 8 * 1024 * 1024,
+    });
+    if (result.exitCode !== 0 || (!allowStderr && result.stderr.length !== 0)) {
+        throw new Error(`${argv[0]} ${argv.slice(1).join(" ")} failed with exit ${result.exitCode}; ` +
+            `stdout_sha256=${sha256Bytes(result.stdout)}; stderr_sha256=${sha256Bytes(result.stderr)}`);
+    }
+    return result.stdout.toString("utf8").trim();
+}
+async function assertFreshOutput(outputRoot) {
+    try {
+        await lstat(outputRoot);
+        throw new Error("mission output root already exists");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+function below(child, parent) {
+    const relative = path.relative(parent, child);
+    return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+async function sourceFile(root, relative, label) {
+    const parent = await realpath(root);
+    const resolved = await realpath(path.resolve(parent, relative));
+    if (!below(resolved, parent))
+        throw new Error(`${label} escapes its registered root`);
+    const stat = await lstat(resolved);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1) {
+        throw new Error(`${label} must be one regular, singly linked file`);
+    }
+    return resolved;
+}
+function boundedObjective(value) {
+    const objective = stringAt(value, "mission.objective", { min: 1, max: 8192 });
+    const universal = /\b(?:settle|solve|prove|establish)\b[^.]{0,160}\b(?:for all|for every|unbounded|universally)\b/iu;
+    const finite = /\b(?:bounded|exact|finite|range|through|up to|k\s*=\s*\d+|witness|counterexample|exhaust)\b/iu;
+    if (universal.test(objective) || !finite.test(objective)) {
+        throw new Error("mission objective must name a finite or exactly checkable obligation");
+    }
+    return objective;
+}
+function selectedAttack(offer, requested) {
+    if (!Array.isArray(offer.targets))
+        throw new Error("vela next omitted targets");
+    const attacks = [];
+    for (const [index, raw] of offer.targets.entries()) {
+        const target = objectAt(raw, `vela next.targets[${index}]`);
+        if (target.lane === "attack")
+            attacks.push(target);
+    }
+    if (attacks.length === 0) {
+        throw new Error("vela next returned no non-review attack target in the first 128 offers");
+    }
+    if (requested === undefined)
+        return attacks[0];
+    const matches = attacks.filter((target) => (target.target_id ?? target.id) === requested);
+    if (matches.length !== 1) {
+        throw new Error(`explicit mission target ${requested} must appear exactly once among the first 128 attack offers; ` +
+            `observed ${matches.length}`);
+    }
+    return matches[0];
+}
+function packetFromTarget(target, expected) {
+    const packet = target.packet === undefined
+        ? objectAt(objectAt(target.task, "vela next attack.task").packet_ref, "vela next attack.task.packet_ref")
+        : objectAt(target.packet, "vela next attack.packet");
+    const targetId = target.target_id ?? target.id;
+    if (expected !== undefined && targetId !== expected.target) {
+        throw new Error(`selected attack target ${String(targetId)} does not match profile target ${expected.target}`);
+    }
+    const schema = stringAt(packet.schema, "vela next attack.packet.schema", { min: 1, max: 128 });
+    if (expected !== undefined && schema !== expected.schema) {
+        throw new Error(`selected packet schema ${schema} does not match profile schema ${expected.schema}`);
+    }
+    if (expected === undefined && schema !== "erdos-frontier.problem-work.v1") {
+        throw new Error("selected attack target has no registered exact problem packet schema");
+    }
+    return {
+        path: relativePathAt(packet.path, "vela next attack.packet.path"),
+        sha256: sha256At(packet.sha256, "vela next attack.packet.sha256"),
+    };
+}
+async function imageId(runner, dockerBinary, image, cwd, home) {
+    const observed = await commandText(runner, [dockerBinary, "image", "inspect", "--format={{.Id}}", image], cwd, home);
+    return sha256At(observed, "Docker image ID");
+}
+async function workerIdentity(runner, binaryPath, cwd, home) {
+    if (process.platform !== "darwin" && process.platform !== "linux") {
+        throw new Error("canopus.mission.v1 tool workers require macOS, Linux, or WSL2");
+    }
+    const binary = await realpath(binaryPath);
+    const output = await commandText(runner, [binary, "--version"], cwd, home, true);
+    const version = stringAt(output, "worker Codex version", {
+        min: 10,
+        max: 64,
+        pattern: /^codex-cli [0-9]+\.[0-9]+\.[0-9]+(?:[-+][A-Za-z0-9.-]+)?$/u,
+    });
+    return {
+        codex_version: version,
+        codex_sha256: await sha256RegularFile(binary, MAX_EXECUTABLE_BYTES),
+    };
+}
+export async function prepareMission(options) {
+    const runner = options.runner ?? runCommand;
+    const sourceRepo = await realpath(options.sourceRepo);
+    const draftRoot = await realpath(options.draftRoot);
+    const outputRoot = path.resolve(options.outputRoot);
+    await assertFreshOutput(outputRoot);
+    const runtimeHome = await mkdtemp(path.join(os.tmpdir(), "canopus-prepare-"));
+    try {
+        const status = await commandText(runner, ["git", "status", "--porcelain=v1", "--untracked-files=all"], sourceRepo, runtimeHome);
+        if (status !== "")
+            throw new Error("mission source checkout must be clean");
+        const raw = objectAt(options.draft, "mission draft");
+        const frontier = raw.frontier === "."
+            ? "."
+            : relativePathAt(raw.frontier, "mission.frontier");
+        const velaBinary = await realpath(options.velaBinary);
+        const velaSha256 = await sha256RegularFile(velaBinary, MAX_EXECUTABLE_BYTES);
+        const versionText = await commandText(runner, [velaBinary, "--version"], sourceRepo, runtimeHome);
+        const versionMatch = /^vela (0\.[0-9]+\.[0-9]+)$/u.exec(versionText);
+        if (versionMatch?.[1] === undefined)
+            throw new Error("Vela returned an invalid version");
+        const velaVersion = versionMatch[1];
+        const vela = new VelaClient({
+            binary: velaBinary,
+            expectedVersion: velaVersion,
+            expectedSha256: velaSha256,
+            home: path.join(runtimeHome, "vela"),
+            runner,
+        });
+        const strictBaseline = await vela.observeStrictBaseline(sourceRepo, frontier);
+        const inspection = await vela.inspect(sourceRepo, frontier, strictBaseline);
+        const offer = await vela.offer(sourceRepo, frontier, inspection.roots, strictBaseline, 128);
+        const requestedTarget = raw.target === undefined || raw.target === "auto"
+            ? undefined
+            : stringAt(raw.target, "mission.target", { min: 1, max: 256 });
+        const target = selectedAttack(offer.value, requestedTarget);
+        const targetId = stringAt(target.target_id ?? target.id, "vela next attack.target_id", { min: 1, max: 256 });
+        const packet = packetFromTarget(target, options.targetPacket);
+        const packetSource = await sourceFile(sourceRepo, packet.path, "target packet");
+        const packetBytes = await readBoundedRegularFile(packetSource, 64 * 1024 * 1024);
+        if (sha256Bytes(packetBytes) !== packet.sha256) {
+            throw new Error("selected target packet digest does not match vela next");
+        }
+        const tracked = await commandText(runner, ["git", "ls-files", "--error-unmatch", "--", packet.path], sourceRepo, runtimeHome);
+        if (tracked !== packet.path)
+            throw new Error("target packet is not an exact tracked source file");
+        const verifierDraft = objectAt(raw.verifier, "mission.verifier");
+        const sourceCapsuleRelative = relativePathAt(verifierDraft.capsule_path, "mission.verifier.capsule_path");
+        const sourceCapsule = await sourceFile(draftRoot, sourceCapsuleRelative, "verifier capsule");
+        await access(sourceCapsule, constants.X_OK);
+        const capsuleBytes = await readBoundedRegularFile(sourceCapsule, 268_435_456);
+        const capsuleDigest = sha256Bytes(capsuleBytes);
+        const workerDraft = objectAt(raw.worker, "mission.worker");
+        const outputSchemaSource = await sourceFile(path.dirname(await realpath(options.outputSchema)), path.basename(options.outputSchema), "engine output schema");
+        const outputSchemaBytes = await readBoundedRegularFile(outputSchemaSource, 8 * 1024 * 1024);
+        const outputSchemaDigest = sha256Bytes(outputSchemaBytes);
+        const permissionProfileSource = await sourceFile(path.dirname(await realpath(options.permissionProfile)), path.basename(options.permissionProfile), "worker permission profile");
+        const permissionProfileBytes = await readBoundedRegularFile(permissionProfileSource, 8 * 1024 * 1024);
+        const permissionProfileDigest = sha256Bytes(permissionProfileBytes);
+        const verifierImage = await imageId(runner, options.dockerBinary, options.verifierImage, sourceRepo, runtimeHome);
+        const identity = await workerIdentity(runner, options.codexBinary, sourceRepo, runtimeHome);
+        const verifierArgv = Array.isArray(verifierDraft.argv)
+            ? [...verifierDraft.argv]
+            : verifierDraft.argv;
+        if (!Array.isArray(verifierArgv) || verifierArgv.length === 0) {
+            throw new Error("mission verifier argv is required");
+        }
+        verifierArgv[0] = "capsule/verifier";
+        const prepared = parseMission({
+            ...raw,
+            schema: "canopus.mission.v1",
+            target: targetId,
+            vela_version: velaVersion,
+            vela_sha256: velaSha256,
+            objective: boundedObjective(raw.objective),
+            roots: inspection.roots,
+            target_packet: packet,
+            strict_baseline: strictBaseline,
+            worker: {
+                ...workerDraft,
+                kind: "codex_tools_native",
+                platform: process.platform,
+                ...identity,
+                permission_profile_path: "contract/native-worker.config.toml",
+                permission_profile_sha256: permissionProfileDigest,
+                workspace: "target_packet_only",
+                output_schema_sha256: outputSchemaDigest,
+                network: "provider_only",
+                tools: ["shell", "apply_patch"],
+            },
+            verifier: {
+                ...verifierDraft,
+                argv: verifierArgv,
+                executable_sha256: capsuleDigest,
+                capsule_path: "capsule/verifier",
+                capsule_sha256: capsuleDigest,
+                image: verifierImage,
+                ...(options.verifierPlatform === undefined
+                    ? {}
+                    : { platform: options.verifierPlatform }),
+                network: "deny",
+                writes: "deny",
+            },
+            landing: options.landing ?? { expected_routes: ["defer"], max_accepted_delta: 0 },
+            ...(options.profileName === undefined || options.profileRoot === undefined
+                ? {}
+                : {
+                    profile: {
+                        name: options.profileName,
+                        root: sha256At(options.profileRoot, "profile root"),
+                    },
+                }),
+            ...(options.profileRoot === undefined || options.resultContract === undefined
+                ? {}
+                : {
+                    execution_binding: {
+                        schema: EXECUTION_BINDING_SCHEMA,
+                        packet_root: packet.sha256,
+                        profile_root: sha256At(options.profileRoot, "profile root"),
+                        verifier_capsule_root: capsuleDigest,
+                        result_contract_root: contentDigest(options.resultContract),
+                    },
+                    result_contract: options.resultContract,
+                }),
+        });
+        if ((options.profileName === undefined) !== (options.profileRoot === undefined)) {
+            throw new Error("mission preparation requires profile name and root together");
+        }
+        if (options.resultContract !== undefined && options.profileRoot === undefined) {
+            throw new Error("mission result contract requires a profile root");
+        }
+        if (prepared.schema !== "canopus.mission.v1") {
+            throw new Error("prepared mission did not produce mission v1");
+        }
+        await assertVerifierWorkingDirectory(sourceRepo, prepared.verifier.cwd);
+        const capsuleTarget = path.join(outputRoot, "capsule", "verifier");
+        const packetTarget = path.join(outputRoot, "packet", "target.json");
+        const outputSchemaTarget = path.join(outputRoot, "contract", "engine-output.v0.json");
+        const permissionProfileTarget = path.join(outputRoot, "contract", "native-worker.config.toml");
+        await Promise.all([
+            mkdir(path.dirname(capsuleTarget), { recursive: true, mode: 0o700 }),
+            mkdir(path.dirname(packetTarget), { recursive: true, mode: 0o700 }),
+            mkdir(path.dirname(outputSchemaTarget), { recursive: true, mode: 0o700 }),
+        ]);
+        await Promise.all([
+            copyFile(sourceCapsule, capsuleTarget),
+            copyFile(packetSource, packetTarget),
+            copyFile(outputSchemaSource, outputSchemaTarget),
+            copyFile(permissionProfileSource, permissionProfileTarget),
+        ]);
+        await chmod(capsuleTarget, 0o555);
+        const missionPath = path.join(outputRoot, "mission.json");
+        const manifestPath = path.join(outputRoot, "bundle-manifest.json");
+        const manifest = {
+            schema: "canopus.mission-bundle.v1",
+            authority: "non_authoritative",
+            mission_sha256: contentDigest(prepared),
+            source: {
+                git_commit: prepared.roots.git_commit,
+                git_tree: prepared.roots.git_tree,
+            },
+            packet: {
+                source_path: packet.path,
+                bundle_path: "packet/target.json",
+                sha256: packet.sha256,
+            },
+            verifier: {
+                bundle_path: "capsule/verifier",
+                sha256: capsuleDigest,
+                image: verifierImage,
+                ...(options.verifierPlatform === undefined
+                    ? {}
+                    : { platform: options.verifierPlatform }),
+            },
+            worker: {
+                platform: process.platform,
+                codex_version: identity.codex_version,
+                codex_sha256: identity.codex_sha256,
+                permission_profile_path: "contract/native-worker.config.toml",
+                permission_profile_sha256: permissionProfileDigest,
+                workspace: "target_packet_only",
+                output_schema_sha256: outputSchemaDigest,
+            },
+            ...(prepared.execution_binding === undefined
+                ? {}
+                : { execution_binding: prepared.execution_binding }),
+        };
+        await Promise.all([
+            writeFile(missionPath, canonicalJson(prepared), { flag: "wx", mode: 0o600 }),
+            writeFile(manifestPath, canonicalJson(manifest), { flag: "wx", mode: 0o600 }),
+        ]);
+        return { mission: prepared, bundleRoot: outputRoot, missionPath, manifestPath };
+    }
+    catch (error) {
+        await rm(outputRoot, { recursive: true, force: true });
+        throw error;
+    }
+    finally {
+        await rm(runtimeHome, { recursive: true, force: true });
+    }
+}