@vela-science/canopus 0.7.0 → 0.8.0

package/dist/src/projection/publication.js

@@ -1,47 +0,0 @@
-import { contentDigest } from "../util/canonical.js";
-import { projectPublicRun } from "./public-run.js";
-export function buildPublicationBundle(options) {
-    const projection = projectPublicRun(options);
-    const pendingCommands = {
-        schema: "canopus.pending-commands.v1",
-        authority: "none",
-        proposal_id: projection.policy.proposal_id,
-        commands: [
-            {
-                purpose: "reproduce_pending_artifact",
-                authority: "read_only",
-                command: `vela reproduce . --proposal ${projection.policy.proposal_id} --json`,
-            },
-            {
-                purpose: "inspect_review_material",
-                authority: "read_only",
-                command: `vela review show . ${projection.policy.proposal_id} --json`,
-            },
-            {
-                purpose: "retain_independent_verifier_evidence",
-                authority: "evidence_only",
-                command: `vela verify attach . <attachment.json> --proposal ${projection.policy.proposal_id} --as verifier:<actor> --json`,
-            },
-        ],
-    };
-    const webImport = {
-        schema: "vela-web.canopus-import.v1",
-        authority: "read_only",
-        run_id: projection.run_id,
-        projection_path: "public-run.json",
-        projection_root: contentDigest(projection),
-        route: "defer",
-        accepted_state_delta: 0,
-    };
-    const manifest = {
-        schema: "canopus.publication-manifest.v1",
-        authority: "none",
-        run_id: projection.run_id,
-        files: {
-            "pending-commands.json": contentDigest(pendingCommands),
-            "public-run.json": contentDigest(projection),
-            "web-import.json": contentDigest(webImport),
-        },
-    };
-    return { projection, pendingCommands, webImport, manifest };
-}

package/dist/src/projection/run.d.ts

@@ -1,95 +0,0 @@
-import type { MissionRoots } from "../contracts/mission.js";
-export declare const RUN_RECORD_SCHEMA: "canopus.run.v1";
-export declare const LEGACY_RUN_RECORD_SCHEMA: "canopus.run.v0";
-export declare const RUN_PROJECTION_SCHEMA: "canopus.run-projection.v0";
-export interface RunRecord {
-    schema: typeof RUN_RECORD_SCHEMA | typeof LEGACY_RUN_RECORD_SCHEMA;
-    run_id: string;
-    status: "completed";
-    authority: "non_authoritative";
-    external_gate_credit: false;
-    mission: {
-        id: string;
-        target: string;
-        digest: string;
-        starting_roots: MissionRoots;
-    };
-    candidate: {
-        digest: string;
-        status: "success" | "null" | "failed";
-        claim: string;
-        artifacts: Array<{
-            path: string;
-            kind: string;
-            digest: string;
-            bytes: number;
-        }>;
-        caveats: string[];
-    };
-    observations?: {
-        worker_observations: string[];
-        verifier_observations: string[];
-        standing_caveats: string[];
-    };
-    verifier: {
-        status: "passed" | "failed" | "error";
-        sandbox: "macos_sandbox" | "container_network_denied";
-        record: {
-            argv: string[];
-            executable_digest: string;
-            exit_code: number;
-            stdout_digest: string;
-            stderr_digest: string;
-            duration_ms: number;
-        };
-    };
-    landing: {
-        operation_id: string;
-        receipt_root: string;
-        proposal_id: string;
-        route: "permit" | "defer" | "exact_retry";
-        original_route: "permit" | "defer" | null;
-        accepted_event_delta: number | null;
-        publication_state: string;
-    };
-    final_roots: MissionRoots;
-    reproduction: {
-        matched: boolean;
-        roots: MissionRoots;
-        verifier_status: "passed" | "failed" | "error";
-        stdout_digest: string;
-        stderr_digest: string;
-    };
-    budget: {
-        research_elapsed_ms: number;
-        research_processes: number;
-        research_output_bytes: number;
-        prompt_bytes: number;
-        artifact_bytes: number;
-        attempts: number;
-        observed_tokens: number;
-    };
-}
-export interface RunProjection {
-    schema: typeof RUN_PROJECTION_SCHEMA;
-    authority: "read_only_projection";
-    run_id: string;
-    mission_id: string;
-    target: string;
-    starting_roots: MissionRoots;
-    final_roots: MissionRoots;
-    candidate_digest: string;
-    candidate_status: "success" | "null" | "failed";
-    artifact_digests: string[];
-    verifier_status: "passed" | "failed" | "error";
-    receipt_root: string;
-    proposal_id: string;
-    route: "permit" | "defer" | "exact_retry";
-    original_route: "permit" | "defer" | null;
-    accepted_state_effect: "policy_admitted" | "unchanged_pending" | "exact_retry";
-    publication_state: string;
-    clean_clone_reproduced: boolean;
-    deletion_test: "Vela replay and accepted state do not depend on this projection.";
-}
-export declare function parseRunRecord(value: unknown): RunRecord;
-export declare function projectRun(record: RunRecord): RunProjection;

package/dist/src/projection/run.js

@@ -1,173 +0,0 @@
-import { arrayAt, enumAt, exactKeys, gitObjectAt, integerAt, objectAt, relativePathAt, sha256At, stringAt, } from "../contracts/validation.js";
-export const RUN_RECORD_SCHEMA = "canopus.run.v1";
-export const LEGACY_RUN_RECORD_SCHEMA = "canopus.run.v0";
-export const RUN_PROJECTION_SCHEMA = "canopus.run-projection.v0";
-function literal(value, expected, at) {
-    if (value !== expected)
-        throw new Error(`${at} must be ${String(expected)}`);
-    return expected;
-}
-function rootsAt(value, at) {
-    const object = objectAt(value, at);
-    exactKeys(object, ["git_commit", "git_tree", "vela_event_log", "vela_snapshot"], [], at);
-    return {
-        git_commit: gitObjectAt(object.git_commit, `${at}.git_commit`),
-        git_tree: gitObjectAt(object.git_tree, `${at}.git_tree`),
-        vela_event_log: sha256At(object.vela_event_log, `${at}.vela_event_log`),
-        vela_snapshot: sha256At(object.vela_snapshot, `${at}.vela_snapshot`),
-    };
-}
-function nullableRoute(value, at) {
-    return value === null ? null : enumAt(value, at, ["permit", "defer"]);
-}
-function nullableCount(value, at) {
-    return value === null ? null : integerAt(value, at, 0, Number.MAX_SAFE_INTEGER);
-}
-export function parseRunRecord(value) {
-    const record = objectAt(value, "run");
-    const schema = enumAt(record.schema, "run.schema", [RUN_RECORD_SCHEMA, LEGACY_RUN_RECORD_SCHEMA]);
-    exactKeys(record, [
-        "schema", "run_id", "status", "authority", "external_gate_credit", "mission",
-        "candidate", "verifier", "landing", "final_roots", "reproduction", "budget",
-        ...(schema === RUN_RECORD_SCHEMA ? ["observations"] : []),
-    ], schema === LEGACY_RUN_RECORD_SCHEMA ? ["observations"] : [], "run");
-    const mission = objectAt(record.mission, "run.mission");
-    exactKeys(mission, ["id", "target", "digest", "starting_roots"], [], "run.mission");
-    const candidate = objectAt(record.candidate, "run.candidate");
-    exactKeys(candidate, ["digest", "status", "claim", "artifacts", "caveats"], [], "run.candidate");
-    const verifier = objectAt(record.verifier, "run.verifier");
-    exactKeys(verifier, ["status", "sandbox", "record"], [], "run.verifier");
-    const testRecord = objectAt(verifier.record, "run.verifier.record");
-    exactKeys(testRecord, ["argv", "executable_digest", "exit_code", "stdout_digest", "stderr_digest", "duration_ms"], [], "run.verifier.record");
-    const landing = objectAt(record.landing, "run.landing");
-    exactKeys(landing, [
-        "operation_id", "receipt_root", "proposal_id", "route", "original_route",
-        "accepted_event_delta", "publication_state",
-    ], [], "run.landing");
-    const reproduction = objectAt(record.reproduction, "run.reproduction");
-    exactKeys(reproduction, ["matched", "roots", "verifier_status", "stdout_digest", "stderr_digest"], [], "run.reproduction");
-    const budget = objectAt(record.budget, "run.budget");
-    exactKeys(budget, [
-        "research_elapsed_ms", "research_processes", "research_output_bytes", "prompt_bytes",
-        "artifact_bytes", "attempts", "observed_tokens",
-    ], [], "run.budget");
-    const observations = record.observations === undefined ? undefined : (() => {
-        const stages = objectAt(record.observations, "run.observations");
-        exactKeys(stages, ["worker_observations", "verifier_observations", "standing_caveats"], [], "run.observations");
-        const strings = (value, at) => arrayAt(value, at, { max: 16 }, (item, itemAt) => stringAt(item, itemAt, { min: 1, max: 4096 }));
-        return {
-            worker_observations: strings(stages.worker_observations, "run.observations.worker_observations"),
-            verifier_observations: strings(stages.verifier_observations, "run.observations.verifier_observations"),
-            standing_caveats: strings(stages.standing_caveats, "run.observations.standing_caveats"),
-        };
-    })();
-    return {
-        schema,
-        run_id: stringAt(record.run_id, "run.run_id", { min: 5, max: 128 }),
-        status: literal(record.status, "completed", "run.status"),
-        authority: literal(record.authority, "non_authoritative", "run.authority"),
-        external_gate_credit: literal(record.external_gate_credit, false, "run.external_gate_credit"),
-        mission: {
-            id: stringAt(mission.id, "run.mission.id", { min: 1, max: 134 }),
-            target: stringAt(mission.target, "run.mission.target", { min: 1, max: 256 }),
-            digest: sha256At(mission.digest, "run.mission.digest"),
-            starting_roots: rootsAt(mission.starting_roots, "run.mission.starting_roots"),
-        },
-        candidate: {
-            digest: sha256At(candidate.digest, "run.candidate.digest"),
-            status: enumAt(candidate.status, "run.candidate.status", ["success", "null", "failed"]),
-            claim: stringAt(candidate.claim, "run.candidate.claim", { min: 1, max: 8192 }),
-            artifacts: arrayAt(candidate.artifacts, "run.candidate.artifacts", { max: 10 }, (item, at) => {
-                const artifact = objectAt(item, at);
-                exactKeys(artifact, ["path", "kind", "digest", "bytes"], [], at);
-                return {
-                    path: relativePathAt(artifact.path, `${at}.path`),
-                    kind: stringAt(artifact.kind, `${at}.kind`, { min: 1, max: 128 }),
-                    digest: sha256At(artifact.digest, `${at}.digest`),
-                    bytes: integerAt(artifact.bytes, `${at}.bytes`, 0, 1_073_741_824),
-                };
-            }),
-            caveats: arrayAt(candidate.caveats, "run.candidate.caveats", { max: 10 }, (item, at) => stringAt(item, at, { min: 1, max: 4096 })),
-        },
-        ...(observations === undefined ? {} : { observations }),
-        verifier: {
-            status: enumAt(verifier.status, "run.verifier.status", ["passed", "failed", "error"]),
-            sandbox: enumAt(verifier.sandbox, "run.verifier.sandbox", ["macos_sandbox", "container_network_denied"]),
-            record: {
-                argv: arrayAt(testRecord.argv, "run.verifier.record.argv", { min: 1, max: 64 }, (item, at) => stringAt(item, at, { max: 4096 })),
-                executable_digest: sha256At(testRecord.executable_digest, "run.verifier.record.executable_digest"),
-                exit_code: integerAt(testRecord.exit_code, "run.verifier.record.exit_code", -1, 255),
-                stdout_digest: sha256At(testRecord.stdout_digest, "run.verifier.record.stdout_digest"),
-                stderr_digest: sha256At(testRecord.stderr_digest, "run.verifier.record.stderr_digest"),
-                duration_ms: integerAt(testRecord.duration_ms, "run.verifier.record.duration_ms", 0, 3_600_000),
-            },
-        },
-        landing: {
-            operation_id: stringAt(landing.operation_id, "run.landing.operation_id", { min: 1, max: 256 }),
-            receipt_root: sha256At(landing.receipt_root, "run.landing.receipt_root"),
-            proposal_id: stringAt(landing.proposal_id, "run.landing.proposal_id", { min: 1, max: 256 }),
-            route: enumAt(landing.route, "run.landing.route", ["permit", "defer", "exact_retry"]),
-            original_route: nullableRoute(landing.original_route, "run.landing.original_route"),
-            accepted_event_delta: nullableCount(landing.accepted_event_delta, "run.landing.accepted_event_delta"),
-            publication_state: stringAt(landing.publication_state, "run.landing.publication_state", { min: 1, max: 64 }),
-        },
-        final_roots: rootsAt(record.final_roots, "run.final_roots"),
-        reproduction: {
-            matched: literal(reproduction.matched, true, "run.reproduction.matched"),
-            roots: rootsAt(reproduction.roots, "run.reproduction.roots"),
-            verifier_status: enumAt(reproduction.verifier_status, "run.reproduction.verifier_status", ["passed", "failed", "error"]),
-            stdout_digest: sha256At(reproduction.stdout_digest, "run.reproduction.stdout_digest"),
-            stderr_digest: sha256At(reproduction.stderr_digest, "run.reproduction.stderr_digest"),
-        },
-        budget: {
-            research_elapsed_ms: integerAt(budget.research_elapsed_ms, "run.budget.research_elapsed_ms", 0, 3_600_000),
-            research_processes: integerAt(budget.research_processes, "run.budget.research_processes", 0, 64),
-            research_output_bytes: integerAt(budget.research_output_bytes, "run.budget.research_output_bytes", 0, 67_108_864),
-            prompt_bytes: integerAt(budget.prompt_bytes, "run.budget.prompt_bytes", 0, 8_388_608),
-            artifact_bytes: integerAt(budget.artifact_bytes, "run.budget.artifact_bytes", 0, 1_073_741_824),
-            attempts: integerAt(budget.attempts, "run.budget.attempts", 0, 8),
-            observed_tokens: integerAt(budget.observed_tokens, "run.budget.observed_tokens", 0, 1_000_000),
-        },
-    };
-}
-export function projectRun(record) {
-    if ((record.landing.route === "exact_retry") !== (record.landing.original_route !== null)) {
-        throw new Error("exact retry must name exactly one durable original route");
-    }
-    const effectiveRoute = record.landing.route === "exact_retry"
-        ? record.landing.original_route
-        : record.landing.route;
-    if (effectiveRoute === null)
-        throw new Error("landing has no effective route");
-    const expectedDelta = effectiveRoute === "permit" ? 1 : 0;
-    if (record.landing.accepted_event_delta !== null &&
-        record.landing.accepted_event_delta !== expectedDelta) {
-        throw new Error(`${record.landing.route} landing has invalid accepted-event delta ${String(record.landing.accepted_event_delta)}`);
-    }
-    const acceptedStateEffect = record.landing.route === "permit"
-        ? "policy_admitted"
-        : record.landing.route === "defer"
-            ? "unchanged_pending"
-            : "exact_retry";
-    return {
-        schema: RUN_PROJECTION_SCHEMA,
-        authority: "read_only_projection",
-        run_id: record.run_id,
-        mission_id: record.mission.id,
-        target: record.mission.target,
-        starting_roots: record.mission.starting_roots,
-        final_roots: record.final_roots,
-        candidate_digest: record.candidate.digest,
-        candidate_status: record.candidate.status,
-        artifact_digests: record.candidate.artifacts.map((artifact) => artifact.digest),
-        verifier_status: record.verifier.status,
-        receipt_root: record.landing.receipt_root,
-        proposal_id: record.landing.proposal_id,
-        route: record.landing.route,
-        original_route: record.landing.original_route,
-        accepted_state_effect: acceptedStateEffect,
-        publication_state: record.landing.publication_state,
-        clean_clone_reproduced: record.reproduction.matched,
-        deletion_test: "Vela replay and accepted state do not depend on this projection.",
-    };
-}

package/dist/src/receipt/map.js

@@ -1,168 +0,0 @@
-import { constants } from "node:fs";
-import { chmod, copyFile, mkdir } from "node:fs/promises";
-import path from "node:path";
-import { hashRegularFile, } from "../artifact/freeze.js";
-import { parseCandidate } from "../contracts/candidate.js";
-function unique(values) {
-    return [...new Set(values)];
-}
-function finalizeWorkerCaveat(value) {
-    if (/verif(?:y|ication|ier).*(?:pending|has not run)|pending.*verif(?:y|ication|ier)/iu.test(value)) {
-        return "The worker handed off without verifier authority; Canopus subsequently recorded the separate verifier outcome.";
-    }
-    return value;
-}
-export function finalizeCandidate(options) {
-    const draftPaths = options.engine.draft.artifacts.map((artifact) => `${artifact.path}:${artifact.kind}`).sort();
-    const supporting = new Map((options.supportingArtifacts ?? []).map((entry) => [entry.path, entry.kind]));
-    const frozenPaths = options.frozen
-        .filter((entry) => !supporting.has(entry.artifact.path))
-        .map((entry) => `${entry.artifact.path}:${entry.artifact.kind}`)
-        .sort();
-    if (JSON.stringify(draftPaths) !== JSON.stringify(frozenPaths)) {
-        throw new Error("frozen artifacts do not exactly match the engine declaration");
-    }
-    for (const [path, kind] of supporting) {
-        const entry = options.frozen.find((candidate) => candidate.artifact.path === path);
-        if (entry === undefined || entry.artifact.kind !== kind) {
-            throw new Error(`supporting artifact ${path} is absent or misclassified`);
-        }
-    }
-    const verifierFailed = options.engine.draft.status === "success" && options.verifier.status !== "passed";
-    const status = verifierFailed ? "failed" : options.engine.draft.status;
-    const exactPositiveClaim = options.mission.schema === "canopus.mission.v1" &&
-        options.mission.result_contract !== undefined &&
-        options.engine.draft.status === "success" &&
-        options.verifier.status === "passed"
-        ? options.mission.result_contract.claim_exact
-        : undefined;
-    const claim = verifierFailed
-        ? `The engine proposed a candidate, but the declared verifier did not pass: ${options.engine.draft.claim}`
-        : exactPositiveClaim ?? options.engine.draft.claim;
-    const caveats = unique([
-        ...options.engine.draft.caveats.map(finalizeWorkerCaveat),
-        `Declared verifier outcome: ${options.verifier.status}.`,
-        "Canopus produced this record; it is not a human acceptance decision.",
-    ]);
-    const base = {
-        schema: "canopus.candidate.v0",
-        mission_id: options.mission.id,
-        status,
-        claim,
-        artifacts: options.frozen.map((entry) => entry.artifact),
-        observations: options.engine.draft.observations,
-        tests: [options.verifier.record],
-        costs: {
-            wall_time_ms: options.budget.research_elapsed_ms,
-            attempt: options.budget.attempts,
-            input_tokens: options.engine.usage.input_tokens,
-            output_tokens: options.engine.usage.output_tokens,
-        },
-        caveats,
-        engine: options.engine.engine,
-    };
-    return parseCandidate(options.mission.parent_candidate === undefined
-        ? base
-        : {
-            ...base,
-            repair: {
-                parent_candidate: options.mission.parent_candidate,
-                reason: options.mission.repair_reason ?? "Bounded repair of the named candidate.",
-            },
-        });
-}
-export function mapCandidateToReceipt(mission, candidate, verifier, work) {
-    if (candidate.mission_id !== mission.id) {
-        throw new Error("candidate belongs to a different mission");
-    }
-    if (candidate.artifacts.length === 0) {
-        throw new Error("Receipt v1 requires at least one frozen artifact");
-    }
-    if (candidate.status === "success" && verifier.status !== "passed") {
-        throw new Error("a success candidate requires a passing declared verifier");
-    }
-    if (mission.schema === "canopus.mission.v1" && mission.result_contract !== undefined) {
-        const contract = mission.result_contract;
-        if (candidate.status !== contract.candidate_status ||
-            candidate.claim !== contract.claim_exact ||
-            verifier.status !== contract.verifier_status ||
-            mission.target !== contract.target ||
-            mission.claim_type !== contract.claim_type ||
-            mission.replayability !== contract.replayability) {
-            throw new Error("candidate does not satisfy the exact positive result contract");
-        }
-        const artifactKinds = new Set(candidate.artifacts.map((artifact) => artifact.kind));
-        for (const kind of contract.required_artifact_kinds) {
-            if (!artifactKinds.has(kind)) {
-                throw new Error(`candidate is missing result-contract artifact kind ${kind}`);
-            }
-        }
-    }
-    const result = verifier.status === "passed"
-        ? "The declared verifier exited zero on the frozen artifact set."
-        : verifier.status === "failed"
-            ? `The declared verifier returned nonzero exit ${verifier.record.exit_code}.`
-            : `The declared verifier could not complete: ${verifier.error ?? "unspecified error"}.`;
-    const evidence = [
-        ...candidate.artifacts.map((artifact) => `artifact:${artifact.digest}`),
-        `verifier_executable:${verifier.record.executable_digest}`,
-        `verifier_stdout:${verifier.record.stdout_digest}`,
-        `verifier_stderr:${verifier.record.stderr_digest}`,
-    ];
-    const counterevidence = verifier.status === "passed"
-        ? []
-        : [
-            `verifier_outcome:${verifier.status}`,
-        ];
-    const prediction = "predicted_observable" in mission.scientific_chain
-        ? { predictedObservable: mission.scientific_chain.predicted_observable }
-        : { notApplicable: true };
-    return {
-        claim: candidate.claim,
-        claimType: mission.claim_type,
-        replayability: mission.replayability,
-        artifacts: candidate.artifacts.map((artifact) => ({
-            path: artifact.path,
-            kind: artifact.kind,
-        })),
-        caveats: unique(candidate.caveats),
-        ...prediction,
-        performedTest: mission.scientific_chain.performed_test,
-        result,
-        evidence,
-        counterevidence,
-        ...(mission.schema === "canopus.mission.v1" && mission.execution_binding !== undefined
-            ? { executionBinding: mission.execution_binding }
-            : {}),
-        ...(work === undefined ? {} : { work }),
-    };
-}
-export async function installFrozenArtifacts(options) {
-    const frontierRoot = path.resolve(options.landingRepo, options.frontier);
-    const installed = [];
-    for (const entry of options.frozen) {
-        const target = path.resolve(frontierRoot, entry.artifact.path);
-        const relative = path.relative(frontierRoot, target);
-        if (relative === "" ||
-            relative === ".." ||
-            relative.startsWith(`..${path.sep}`) ||
-            path.isAbsolute(relative)) {
-            throw new Error(`artifact path escapes the landing frontier: ${entry.artifact.path}`);
-        }
-        await mkdir(path.dirname(target), { recursive: true, mode: 0o700 });
-        try {
-            await copyFile(entry.frozenPath, target, constants.COPYFILE_EXCL);
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-        }
-        const observed = await hashRegularFile(target, options.maxBytes);
-        if (observed.digest !== entry.artifact.digest || observed.bytes !== entry.artifact.bytes) {
-            throw new Error(`installed artifact ${entry.artifact.path} does not match frozen bytes`);
-        }
-        await chmod(target, 0o444);
-        installed.push(target);
-    }
-    return installed;
-}

package/dist/src/repair/plan.d.ts

@@ -1,2 +0,0 @@
-import type { Mission } from "../contracts/mission.js";
-export declare function planRepair(mission: Mission, parentCandidate: string, reason: string, remainingAttempts: number): Mission;

package/dist/src/repair/plan.js

@@ -1,22 +0,0 @@
-import { parseMission } from "../contracts/mission.js";
-import { sha256At, stringAt } from "../contracts/validation.js";
-import { contentDigest } from "../util/canonical.js";
-export function planRepair(mission, parentCandidate, reason, remainingAttempts) {
-    const parent = sha256At(parentCandidate, "parent_candidate");
-    const repairReason = stringAt(reason, "repair_reason", { min: 1, max: 4096 });
-    if (!Number.isSafeInteger(remainingAttempts) || remainingAttempts < 1) {
-        throw new Error("repair requires at least one remaining attempt");
-    }
-    const suffix = contentDigest({ mission: mission.id, parent, repairReason }).slice(7, 19);
-    return parseMission({
-        ...mission,
-        id: `mission_repair_${suffix}`,
-        objective: `Repair candidate ${parent}: ${repairReason}`.slice(0, 8192),
-        budgets: {
-            ...mission.budgets,
-            max_attempts: Math.min(mission.budgets.max_attempts, remainingAttempts),
-        },
-        parent_candidate: parent,
-        repair_reason: repairReason,
-    });
-}

package/dist/src/roles.d.ts

@@ -1,2 +0,0 @@
-import type { MissionRole } from "./contracts/mission.js";
-export declare function roleInstruction(role: MissionRole): string;

package/dist/src/roles.js

@@ -1,9 +0,0 @@
-const ROLE_INSTRUCTIONS = {
-    producer: "Construct the smallest candidate that meets the completion condition. Preserve a null result when the evidence does not support the claim.",
-    adversary: "Try to falsify or narrow the inherited candidate. Prefer a concrete counterexample or an explicit no-counterexample result over stylistic criticism.",
-    verifier: "Inspect whether the candidate and declared checks correspond. You do not replace the separate frozen verifier and you do not issue an acceptance verdict.",
-    fidelity: "Check that the claim says no more than the frozen artifacts and verifier facts support. Record mismatches as caveats or a failed candidate.",
-};
-export function roleInstruction(role) {
-    return ROLE_INSTRUCTIONS[role];
-}

package/missions/formal-erdos-505-test-dim-one-gpt56/mission.draft.json

@@ -1,40 +0,0 @@
-{
-  "id": "mission_formal_erdos_505_test_dim_one_gpt56_native1",
-  "target": "auto",
-  "frontier": ".",
-  "actor": "agent:canopus-local",
-  "role": "producer",
-  "claim_type": "theoretical",
-  "replayability": "exact",
-  "objective": "Produce one exactly checkable, sorry-free Lean proof term for Erdos505.erdos_505.test_dim_one in the frozen Lean 4.27.0 and Mathlib environment bound by the target packet. Write exactly one UTF-8 artifact at artifacts/erdos505-test-dim-one-proof.lean. The file must begin with by and contain only the proof term: no imports, theorem declaration, JSON, markdown fence, or surrounding prose. Do not use sorry, admit, an axiom declaration, or an unsafe declaration. Return engine status success only after the exact artifact exists. This bounded mission proves only the frozen one-dimensional category test; it does not prove the general Erdős 505 statement or establish scientific acceptance.",
-  "completion_condition": "The independent frozen capsule supplies the exact theorem statement, elaborates the candidate with Lean 4.27.0 against the frozen formal-conjectures and Mathlib commits, and confirms that its axiom closure contains only propext, Classical.choice, and Quot.sound and never sorryAx.",
-  "allowed_paths": [
-    "artifacts/erdos505-test-dim-one-proof.lean"
-  ],
-  "budgets": {
-    "max_research_wall_time_ms": 1800000,
-    "max_research_processes": 8,
-    "max_research_output_bytes": 16777216,
-    "max_prompt_bytes": 2097152,
-    "max_artifact_bytes": 131072,
-    "max_attempts": 1,
-    "max_observed_tokens": 120000
-  },
-  "worker": {
-    "model": "gpt-5.6-sol"
-  },
-  "verifier": {
-    "argv": [
-      "capsule/verifier",
-      "{artifact:artifacts/erdos505-test-dim-one-proof.lean}"
-    ],
-    "cwd": "targets",
-    "timeout_ms": 600000,
-    "max_output_bytes": 65536,
-    "capsule_path": "capsule/verifier"
-  },
-  "scientific_chain": {
-    "predicted_observable": "The frozen Lean verifier elaborates the exact candidate against Erdos505.erdos_505.test_dim_one, reports only the registered standard axioms, and exits zero on the unchanged proof bytes.",
-    "performed_test": "capsule/verifier artifacts/erdos505-test-dim-one-proof.lean"
-  }
-}

package/missions/quantum-10-1-4-retry/mission.draft.json

@@ -1,40 +0,0 @@
-{
-  "id": "mission_quantum_10_1_4_stabilizer_v2",
-  "target": "quantum:[[10,1,4]]",
-  "frontier": ".",
-  "actor": "agent:canopus-local",
-  "role": "producer",
-  "claim_type": "computational",
-  "replayability": "exact",
-  "objective": "Produce exactly one explicit stabilizer witness at artifacts/quantum-10-1-4.witness.json. The JSON fields must be exactly schema, target, n, k, and generators. Set schema to canopus.quantum-stabilizer-witness.v1, target to quantum:[[10,1,4]], n to 10, k to 1, and generators to exactly nine distinct length-10 strings over I, X, Y, Z. The generators must be non-identity, pairwise commuting, GF(2)-independent, and define no undetectable non-stabilizer Pauli of weight one, two, or three. A null or failed result is valid if no candidate is found. Work only from the supplied frontier and do not assume access to any earlier run artifact. Do not claim classification, optimality, or universal nonexistence.",
-  "completion_condition": "The frozen verifier independently checks generator validity, pairwise symplectic commutation, rank nine, stabilizer-span membership, and all 3,675 Pauli errors of weight one through three in a separate network-denied and write-denied container.",
-  "allowed_paths": [
-    "artifacts/quantum-10-1-4.witness.json"
-  ],
-  "budgets": {
-    "max_research_wall_time_ms": 1800000,
-    "max_research_processes": 16,
-    "max_research_output_bytes": 16777216,
-    "max_prompt_bytes": 2097152,
-    "max_artifact_bytes": 65536,
-    "max_attempts": 1,
-    "max_observed_tokens": 400000
-  },
-  "worker": {
-    "model": "gpt-5.4"
-  },
-  "verifier": {
-    "argv": [
-      "capsule/verifier",
-      "{artifact:artifacts/quantum-10-1-4.witness.json}"
-    ],
-    "cwd": "targets",
-    "timeout_ms": 30000,
-    "max_output_bytes": 65536,
-    "capsule_path": "capsule/verifier"
-  },
-  "scientific_chain": {
-    "predicted_observable": "The frozen verifier reports rank nine, stabilizer size 512, exactly 3,675 checked Pauli errors, and distance_at_least=4 for the supplied generator set.",
-    "performed_test": "capsule/verifier artifacts/quantum-10-1-4.witness.json"
-  }
-}

package/missions/sidon-a24-at-least-7194-gpt56/mission.draft.json

@@ -1,42 +0,0 @@
-{
-  "id": "mission_sidon_a24_at_least_7194_gpt56_v1",
-  "target": "auto",
-  "frontier": ".",
-  "actor": "agent:canopus-local",
-  "role": "producer",
-  "claim_type": "computational",
-  "replayability": "exact",
-  "objective": "Produce exactly one genuinely new Vela-native Sidon witness at artifacts/sidon-a24-gpt56-7194.witness.json and declare it as kind vela-witness. The input frontier contains a mechanically verified but pending 7,193-point baseline at artifacts/sidon-a24-improvement.witness.json with SHA-256 f3712b47633a239133b5e0491e68fffc85831b761c27402ba9de8057f09252e7, plus the prior exact 1-for-2 exchange implementation and benchmark under research/. Use those immutable inputs as a starting point, but do not return the existing 7,193 witness or merely replay its already-known one-point-extension and 1-for-2 result. Design, implement, and execute a stronger bounded search capable of a net improvement, such as a broader 1-for-2 search on the 7,193 baseline, a 2-for-3 or larger conflict-hypergraph exchange, or another exact collision-preserving repair method. Temporary source and diagnostics may be created outside the declared artifact path, but the only declared scientific artifact is the final witness. The artifact must be compact JSON with kind sidon, n 24, claimed_size at least 7194, and points as claimed_size distinct arrays of exactly 24 binary integers. Before reporting success, independently recheck the complete candidate by generating all m(m+1)/2 componentwise integer pair sums and confirming they are distinct. Report engine status success only after that check passes. If the bounded search does not find a valid improvement, return null with the strongest exact negative observations and no artifact. Do not claim maximality, classification, scientific acceptance, or a world record.",
-  "completion_condition": "The separate frozen Vela verifier parses the declared witness, independently checks 24-bit distinctness and every unordered componentwise pair sum, binds the exact claim that a Sidon subset of {0,1}^24 with at least 7,194 elements exists, and exits zero in a network-denied, read-only container. Canopus then clean-clone replays the same artifact and verifier roots and Vela routes the Receipt to Defer with accepted-state delta zero.",
-  "allowed_paths": [
-    "artifacts/sidon-a24-gpt56-7194.witness.json"
-  ],
-  "budgets": {
-    "max_research_wall_time_ms": 1800000,
-    "max_research_processes": 16,
-    "max_research_output_bytes": 16777216,
-    "max_prompt_bytes": 2097152,
-    "max_artifact_bytes": 1048576,
-    "max_attempts": 1,
-    "max_observed_tokens": 400000
-  },
-  "worker": {
-    "model": "gpt-5.6-sol"
-  },
-  "verifier": {
-    "argv": [
-      "capsule/verifier",
-      "--claim",
-      "There exists a Sidon subset of {0,1}^24 with at least 7,194 elements.",
-      "{artifact:artifacts/sidon-a24-gpt56-7194.witness.json}"
-    ],
-    "cwd": "targets",
-    "timeout_ms": 300000,
-    "max_output_bytes": 65536,
-    "capsule_path": "capsule/verifier"
-  },
-  "scientific_chain": {
-    "predicted_observable": "A newly produced set contains at least 7,194 distinct 24-bit points and all of its unordered componentwise integer pair sums are distinct.",
-    "performed_test": "capsule/verifier --claim 'There exists a Sidon subset of {0,1}^24 with at least 7,194 elements.' artifacts/sidon-a24-gpt56-7194.witness.json"
-  }
-}