@vela-science/canopus 0.4.5 → 0.5.0

package/capsules/quantum-10-1-4/verifier.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""Verify one explicit [[10,1,d>=4]] stabilizer witness."""
+
+from __future__ import annotations
+
+import itertools
+import json
+import pathlib
+import sys
+
+SCHEMA = "canopus.quantum-stabilizer-witness.v1"
+TARGET = "quantum:[[10,1,4]]"
+N = 10
+K = 1
+EXPECTED_KEYS = {"schema", "target", "n", "k", "generators"}
+
+
+def fail(message: str) -> "NoReturn":
+    print(f"quantum verifier: {message}", file=sys.stderr)
+    raise SystemExit(1)
+
+
+def pauli_vector(pauli: str) -> int:
+    if len(pauli) != N or any(symbol not in "IXYZ" for symbol in pauli):
+        fail("each generator must be a length-10 string over I, X, Y, Z")
+    vector = 0
+    for qubit, symbol in enumerate(pauli):
+        if symbol in "XY":
+            vector |= 1 << qubit
+        if symbol in "ZY":
+            vector |= 1 << (N + qubit)
+    return vector
+
+
+def symplectic(left: int, right: int) -> int:
+    mask = (1 << N) - 1
+    left_x, left_z = left & mask, left >> N
+    right_x, right_z = right & mask, right >> N
+    return ((left_x & right_z).bit_count() + (left_z & right_x).bit_count()) & 1
+
+
+def binary_rank(rows: list[int]) -> int:
+    basis: dict[int, int] = {}
+    for original in rows:
+        row = original
+        while row:
+            pivot = row.bit_length() - 1
+            if pivot in basis:
+                row ^= basis[pivot]
+            else:
+                basis[pivot] = row
+                break
+    return len(basis)
+
+
+def stabilizer_span(generators: list[int]) -> set[int]:
+    span = {0}
+    for generator in generators:
+        span.update(value ^ generator for value in tuple(span))
+    return span
+
+
+def error_vector(positions: tuple[int, ...], symbols: tuple[str, ...]) -> int:
+    vector = 0
+    for qubit, symbol in zip(positions, symbols, strict=True):
+        if symbol in "XY":
+            vector |= 1 << qubit
+        if symbol in "ZY":
+            vector |= 1 << (N + qubit)
+    return vector
+
+
+def main() -> None:
+    if len(sys.argv) != 2:
+        fail("usage: verifier.py WITNESS.json")
+    witness_path = pathlib.Path(sys.argv[1])
+    metadata = witness_path.lstat()
+    if not witness_path.is_file() or witness_path.is_symlink() or metadata.st_size > 65_536:
+        fail("witness must be one bounded regular file")
+    with witness_path.open("rb") as source:
+        raw = source.read(65_537)
+    if len(raw) > 65_536:
+        fail("witness exceeds 65536 bytes")
+    try:
+        witness = json.loads(raw)
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        fail(f"witness is not valid UTF-8 JSON: {error}")
+    if not isinstance(witness, dict) or set(witness) != EXPECTED_KEYS:
+        fail("witness fields must be exactly schema, target, n, k, generators")
+    if witness["schema"] != SCHEMA or witness["target"] != TARGET:
+        fail("witness schema or target is wrong")
+    if type(witness["n"]) is not int or type(witness["k"]) is not int:
+        fail("n and k must be integers")
+    if witness["n"] != N or witness["k"] != K:
+        fail("witness must declare n=10 and k=1")
+    declared = witness["generators"]
+    if not isinstance(declared, list) or len(declared) != N - K:
+        fail("witness must contain exactly nine generators")
+    if any(not isinstance(generator, str) for generator in declared):
+        fail("every generator must be a string")
+    if len(set(declared)) != len(declared):
+        fail("generators must be distinct")
+    generators = [pauli_vector(generator) for generator in declared]
+    if any(generator == 0 for generator in generators):
+        fail("identity is not a generator")
+    for left, right in itertools.combinations(generators, 2):
+        if symplectic(left, right) != 0:
+            fail("generators do not commute")
+    rank = binary_rank(generators)
+    if rank != N - K:
+        fail(f"generator rank is {rank}, expected nine")
+    span = stabilizer_span(generators)
+    if len(span) != 1 << (N - K):
+        fail("stabilizer span has the wrong cardinality")
+
+    tested = 0
+    degenerate = 0
+    for weight in range(1, 4):
+        for positions in itertools.combinations(range(N), weight):
+            for symbols in itertools.product("XYZ", repeat=weight):
+                tested += 1
+                error = error_vector(positions, symbols)
+                if all(symplectic(error, generator) == 0 for generator in generators):
+                    if error not in span:
+                        fail(
+                            "found an undetectable non-stabilizer Pauli below weight four: "
+                            f"positions={positions}, symbols={''.join(symbols)}"
+                        )
+                    degenerate += 1
+    if tested != 3_675:
+        fail(f"internal enumeration count is {tested}, expected 3675")
+    print(
+        json.dumps(
+            {
+                "schema": "canopus.quantum-stabilizer-verification.v1",
+                "target": TARGET,
+                "n": N,
+                "k": K,
+                "rank": rank,
+                "stabilizer_size": len(span),
+                "errors_weight_1_to_3_tested": tested,
+                "low_weight_stabilizers": degenerate,
+                "distance_at_least": 4,
+            },
+            sort_keys=True,
+            separators=(",", ":"),
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

package/dist/src/engines/codex-tools-native.d.ts

@@ -1,3 +1,4 @@
+import { parseCandidateDraft } from "../candidate/validate.js";
 import { type CommandRunner } from "../util/command.js";
 import type { Engine, EngineContext, EngineResult } from "./engine.js";
 export declare const NATIVE_WORKER_DISABLED_FEATURES: readonly ["apps", "artifact", "auth_elicitation", "browser_use", "browser_use_external", "computer_use", "enable_fanout", "enable_mcp_apps", "goals", "hooks", "image_generation", "in_app_browser", "memories", "multi_agent", "multi_agent_v2", "plugin_sharing", "plugins", "remote_plugin", "standalone_web_search", "tool_call_mcp_elicitation", "tool_suggest", "workspace_dependencies"];
@@ -8,6 +9,12 @@ export interface CodexToolsNativeOptions {
     permissionProfile: string;
     runner?: CommandRunner;
 }
+export declare function hydrateWorkspaceArtifacts(options: {
+    draft: ReturnType<typeof parseCandidateDraft>;
+    workspace: string;
+    maxArtifactBytes: number;
+    secrets: readonly Buffer[];
+}): Promise<ReturnType<typeof parseCandidateDraft>>;
 export declare function assertNativeRuntimeProfile(options: {
     binary: string;
     runner: CommandRunner;

package/dist/src/engines/codex-tools-native.js

@@ -3,6 +3,7 @@ import { constants } from "node:fs";
 import { chmod, copyFile, lstat, mkdir, realpath, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
+import { TextDecoder } from "node:util";
 import { assertDraftArtifactsAllowed, parseCandidateDraft } from "../candidate/validate.js";
 import { canonicalJson, contentDigest, sha256Bytes } from "../util/canonical.js";
 import { isolatedEnvironment, runCommand } from "../util/command.js";
@@ -53,7 +54,14 @@ function prompt(mission) {
                 "Return the artifact path and kind exactly as output_contract specifies. Status success means only that those complete candidate bytes exist; the separate frozen Lean capsule owns elaboration and the axiom audit.",
                 "Use at most four shell or patch tool calls. A token-efficient handoff is part of this mission's product contract.",
             ]
-            : [];
+            : mission.target === "sidon:a24-improve"
+                ? [
+                    "The shell and apply_patch tools are active in this worker. Begin with a narrow shell call against the one registered packet; do not report a missing-tool failure without attempting that call.",
+                    `Read only current_state.tracked_unaccepted_seed, output_contract, verification, and negative_contract from ${mission.target_packet.path}. The tracked seed's encoded_points field contains every exact baseline point needed for the search; no other input file exists or is required.`,
+                    "Write search source and temporary data only inside the current workspace. On macOS compile with the exposed Xcode clang++ and TMPDIR=$PWD/tmp; do not invoke xcrun, xcodebuild, a package manager, a container, Vela, or the frozen verifier.",
+                    "Spend the bounded runtime on an exact net-positive exchange over the supplied baseline. Independently recheck a positive candidate before returning its compact witness JSON at the exact declared workspace path. Inline it when practical; for a large artifact use the workspace-backed handoff described below. A failed bounded search is null, never a universal maximality claim.",
+                ]
+                : [];
     return [
         "Execute one bounded Canopus research mission inside a fresh writable workspace containing only the exact hash-verified target packet.",
         "Use shell and apply_patch only when useful. Browser, web search, MCP, apps, memories, computer use, delegation, signing, and human keys are forbidden.",
@@ -64,7 +72,7 @@ function prompt(mission) {
         "Keep tool output narrow. Do not print or ingest the whole target packet.",
         "Worker status reports producer completion, not verifier or scientific standing. Return status success when you produced all artifact bytes required by the output contract, even though you cannot run the separate verifier. State that verification remains pending; Canopus will freeze the bytes and run the verifier after you exit.",
         "Return null only when the bounded work produced no candidate. Return failed only when you could not produce a contract-complete candidate or observed disqualifying evidence. Never turn a bounded negative search into universal nonexistence, verifier failure into success, or Git publication into scientific acceptance.",
-        "Return only the supplied engine-output JSON shape. Artifact bytes must be inline UTF-8 content at mission.allowed_paths.",
+        "Return only the supplied engine-output JSON shape. Artifact bytes must be UTF-8 at mission.allowed_paths. Inline small artifacts. For a large declared artifact, content may be the empty string only when the complete bytes exist at that exact path inside the current workspace; Canopus will bound, scan, and freeze those bytes before workspace cleanup.",
         ...execution,
         "Mission:",
         canonicalJson(mission),
@@ -134,6 +142,42 @@ function assertNoSecrets(buffers, secrets) {
         }
     }
 }
+export async function hydrateWorkspaceArtifacts(options) {
+    const workspace = await realpath(options.workspace);
+    const artifacts = await Promise.all(options.draft.artifacts.map(async (artifact) => {
+        if (artifact.content !== "")
+            return artifact;
+        const candidate = path.join(workspace, artifact.path);
+        const relative = path.relative(workspace, candidate);
+        if (relative === "" || relative === ".." || relative.startsWith(`..${path.sep}`)) {
+            throw new Error(`workspace-backed artifact escapes the native worker workspace: ${artifact.path}`);
+        }
+        let resolved;
+        try {
+            resolved = await realpath(candidate);
+        }
+        catch (error) {
+            throw new Error(`workspace-backed artifact is missing at ${artifact.path}: ${String(error)}`);
+        }
+        if (resolved !== candidate) {
+            throw new Error(`workspace-backed artifact must not traverse a symbolic link: ${artifact.path}`);
+        }
+        const bytes = await readBoundedRegularFile(resolved, options.maxArtifactBytes);
+        if (bytes.length === 0) {
+            throw new Error(`workspace-backed artifact is empty at ${artifact.path}`);
+        }
+        assertNoSecrets([bytes], options.secrets);
+        let content;
+        try {
+            content = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+        }
+        catch (error) {
+            throw new Error(`workspace-backed artifact is not valid UTF-8 at ${artifact.path}: ${String(error)}`);
+        }
+        return { ...artifact, content };
+    }));
+    return { ...options.draft, artifacts };
+}
 function workerArgv(options) {
     return [
         options.binary,
@@ -369,8 +413,14 @@ export class CodexToolsNativeEngine {
             catch (error) {
                 throw new Error(`native Codex final response is not JSON: ${String(error)}`);
             }
-            const draft = parseCandidateDraft(raw);
-            assertDraftArtifactsAllowed(draft, mission.allowed_paths);
+            const parsedDraft = parseCandidateDraft(raw);
+            assertDraftArtifactsAllowed(parsedDraft, mission.allowed_paths);
+            const draft = await hydrateWorkspaceArtifacts({
+                draft: parsedDraft,
+                workspace,
+                maxArtifactBytes: mission.budgets.max_artifact_bytes,
+                secrets,
+            });
             return {
                 draft,
                 engine: {

package/dist/src/product/doctor.js

@@ -28,10 +28,26 @@ function nonnegative(value, at) {
     }
     return value;
 }
+function noAvailableProducerTarget(offer) {
+    const leased = Array.isArray(offer.leased_targets) ? offer.leased_targets : [];
+    if (leased.length > 0) {
+        const summaries = leased.map((value, index) => {
+            const lease = objectAt(value, `vela next.leased_targets[${index}]`);
+            const target = stringAt(lease.target_id, "leased target id", { min: 1, max: 256 });
+            const actor = stringAt(lease.actor, "leased target actor", { min: 1, max: 256 });
+            const expires = lease.expires_at === undefined
+                ? "unknown expiry"
+                : stringAt(lease.expires_at, "leased target expiry", { min: 1, max: 64 });
+            return `${target} by ${actor} until ${expires}`;
+        });
+        return new Error(`no producer target is currently available; configured work is leased: ${summaries.join(", ")}`);
+    }
+    return new Error("vela next returned no producer target");
+}
 export function selectProductOffer(offer, profile, requestedTarget) {
     const targets = offer.targets;
     if (!Array.isArray(targets) || targets.length === 0) {
-        throw new Error("vela next returned no producer target");
+        throw noAvailableProducerTarget(offer);
     }
     if (requestedTarget !== undefined && requestedTarget !== profile.target) {
         throw new Error(`registered profile ${profile.name} targets ${profile.target}, not requested target ${requestedTarget}`);
@@ -62,7 +78,7 @@ export async function resolveProductProfile(offer, profileName, requestedTarget)
         return loadProductProfile(profileName);
     const targets = offer.targets;
     if (!Array.isArray(targets) || targets.length === 0) {
-        throw new Error("vela next returned no producer target");
+        throw noAvailableProducerTarget(offer);
     }
     const selectedOffer = requestedTarget === undefined
         ? objectAt(targets[0], "vela next.targets[0]")
@@ -104,8 +120,8 @@ export async function doctorProduct(options) {
             runtimeIdentity({ name: "vela", cwd: frontier, home: runtime, runner }),
             runtimeIdentity({ name: "git", cwd: frontier, home: runtime, runner }),
         ]);
-        if (vela.version !== "vela 0.910.0") {
-            throw new Error(`Canopus ${CANOPUS_VERSION} requires vela 0.910.0, observed ${vela.version}`);
+        if (vela.version !== "vela 0.911.0") {
+            throw new Error(`Canopus ${CANOPUS_VERSION} requires vela 0.911.0, observed ${vela.version}`);
         }
         const [status, offer, gitStatus] = await Promise.all([
             jsonCommand({ runner, argv: [vela.binary, "status", ".", "--json"], cwd: frontier, home: runtime, label: "vela status" }),

package/dist/src/projection/public-run.js

@@ -10,6 +10,12 @@ function publicRepository(value) {
         throw new Error("public run repository is invalid");
     return { url, directory };
 }
+function publicCaveat(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 pass shown in this projection.";
+    }
+    return value;
+}
 export function projectPublicRun(options) {
     const { record, mission } = options;
     if (mission.schema !== "canopus.mission.v1") {
@@ -54,7 +60,7 @@ export function projectPublicRun(options) {
             clean_clone_replay: "matched",
         },
         claim: record.candidate.claim,
-        caveats: [...record.candidate.caveats],
+        caveats: [...new Set(record.candidate.caveats.map(publicCaveat))],
         artifact_roots: record.candidate.artifacts.map((artifact) => artifact.digest).sort(),
         verifier_root: contentDigest(record.verifier),
         receipt_root: record.landing.receipt_root,
@@ -90,7 +96,7 @@ export function projectPublicRun(options) {
         },
         nonclaims: [
             "Verifier success is not scientific acceptance.",
-            "The bounded result does not solve its general Erdős problem.",
+            "The bounded result does not establish maximality or settle the broader scientific problem.",
             "Canopus did not sign or perform a human decision.",
         ],
     };

package/dist/src/run.d.ts

@@ -90,5 +90,6 @@ export declare function validateTargetOffer(target: string, response: VelaComman
     index: number;
     id: string;
 };
+export declare function isPrivateWorkSessionStatus(entry: string): boolean;
 export declare function runCanopus(options: CanopusNoLandOptions): Promise<CanopusDiagnosticRunResult>;
 export declare function runCanopus(options: CanopusRunOptions): Promise<CanopusRunResult>;

package/dist/src/run.js

@@ -99,6 +99,18 @@ function publicationState(land) {
     const value = land.publication.state;
     return typeof value === "string" ? value : "unknown";
 }
+export function isPrivateWorkSessionStatus(entry) {
+    if (!entry.startsWith("?? "))
+        return false;
+    const relative = entry.slice(3);
+    const parts = relative.split("/");
+    return (parts.length === 4 &&
+        parts[0] === ".vela" &&
+        parts[1] === "work" &&
+        parts[2] !== undefined &&
+        /^[a-zA-Z0-9._-]+$/u.test(parts[2]) &&
+        parts[3] === "session.json");
+}
 async function writeExclusive(file, value) {
     await writeFile(file, canonicalJson(value), { flag: "wx", mode: 0o600 });
 }
@@ -138,7 +150,17 @@ async function publishArtifactSources(options) {
     }
     const status = (await git(["status", "--porcelain=v1", "-z", "--untracked-files=all"]))
         .toString("utf8").split("\0").filter((entry) => entry.length > 0).sort();
-    const expectedStatus = paths.map((entry) => `A  ${entry}`).sort();
+    // `vela work` deliberately keeps its producer capability in one private,
+    // untracked session file until `vela land` consumes it. The worker cannot
+    // access the landing clone, and every other unstaged path remains fatal.
+    const privateWorkSessions = status.filter(isPrivateWorkSessionStatus);
+    if (privateWorkSessions.length > 1) {
+        throw new Error("artifact publication observed multiple private Vela work sessions");
+    }
+    const expectedStatus = [
+        ...paths.map((entry) => `A  ${entry}`),
+        ...privateWorkSessions,
+    ].sort();
     if (canonicalJson(status) !== canonicalJson(expectedStatus)) {
         throw new Error("artifact publication observed unrelated or unstaged repository changes");
     }

package/dist/src/vela/cli.js

@@ -432,7 +432,7 @@ export class VelaClient {
         if (replay.source_hash !== undefined) {
             assertEqual(normalizeSha256(replay.source_hash, "vela check.replay.source_hash"), checkCurrent, "Vela source snapshot");
         }
-        const proof = version === "0.900.0" || version === "0.900.1" || version === "0.900.2" || version === "0.901.0" || version === "0.910.0"
+        const proof = version === "0.900.0" || version === "0.900.1" || version === "0.900.2" || version === "0.901.0" || version === "0.910.0" || version === "0.911.0"
             ? {
                 ok: true,
                 command: "status_root_projection",

package/docs/RELEASES.md

@@ -1,5 +1,45 @@
 # Release evidence
 
+## Canopus v0.4.6
+
+Version `0.4.6` is the primary Build Week science release. It registers the
+bounded `gpt-5.6-sol` Sidon mission, securely retains the worker's declared
+large artifact before workspace teardown, packages the frozen Sidon verifier
+capsules, and publishes the sanitized public projection of the successful
+7,194-point construction.
+
+The exact run completed the full product chain: worker success, frozen
+verifier pass, Vela route `defer`, accepted-state delta zero, and matching
+clean-clone replay. The pending proposal is evidence, not scientific
+acceptance.
+
+- Source/tag: `ad72a7aca63aaa6c060f840020cca6871e4a9f11` / `v0.4.6`
+- Cross-platform CI and installed-package smoke:
+  [run 29783128714](https://github.com/vela-science/vela-research-harness/actions/runs/29783128714)
+- CodeQL:
+  [run 29783117151](https://github.com/vela-science/vela-research-harness/actions/runs/29783117151)
+- OIDC publish and GitHub build attestation:
+  [run 29783128737](https://github.com/vela-science/vela-research-harness/actions/runs/29783128737)
+- Package SHA-256: `d1c30b0c35b56cb7d874e3646a5d3ddc2abe2f61e38da0c6d2c7163d6de09300`
+- npm shasum: `ca9e9f5a8c064c749523f2e47a4936030367eed3`
+- npm integrity:
+  `sha512-Y3vL/29YEYnKt6iniPvSi5C85UHEOWZ+vtlXiqZSyyyNo5emXkC5gt8fJ4chzEMi7iTYzaRPOv0hsNuPnbUhVQ==`
+- A fresh `npm audit signatures --include-attestations` verifies the registry
+  signatures and the SLSA provenance v1 attestation.
+- A clean registry execution under Node `v24.14.0` returned `canopus 0.4.6`
+  and validated the exact packaged Sidon v3 profile root.
+- Public package and matching release:
+  [npm](https://www.npmjs.com/package/@vela-science/canopus/v/0.4.6),
+  [GitHub](https://github.com/vela-science/vela-research-harness/releases/tag/v0.4.6)
+
+The OIDC workflow published successfully, but its immediate registry
+attestation audit encountered a transient npm attestations-endpoint `404`, so
+the final GitHub-release step did not run. Once the same registry tarball
+passed both `gh attestation verify` against the exact release workflow/tag and
+the npm signature audit, the matching GitHub release was created from those
+bytes. The tag did not move and no reusable npm token was introduced. The
+workflow now retries the full audit while the registry endpoint propagates.
+
 ## Canopus v0.4.5
 
 Version `0.4.5` is a documentation-only truthfulness correction over 0.4.4.
@@ -8,6 +48,28 @@ independent verifier, while keeping the separate GPT-5.6 formal failure and
 claim-fidelity advisory explicit. Runtime behavior, mission registrations,
 evidence roots, Vela compatibility, and authority boundaries are unchanged.
 
+The correction is independently release-verifiable:
+
+- Source/tag: `eccb3975505706b12c48c372e471c34303dffbd2` / `v0.4.5`
+- Cross-platform CI and installed-package smoke:
+  [run 29772472168](https://github.com/vela-science/vela-research-harness/actions/runs/29772472168)
+- CodeQL:
+  [run 29772445358](https://github.com/vela-science/vela-research-harness/actions/runs/29772445358)
+- OIDC publish, SLSA provenance audit, and GitHub release:
+  [run 29772472340](https://github.com/vela-science/vela-research-harness/actions/runs/29772472340)
+- Package SHA-256: `b0b8f0357337b79e3dca0ef4a1c1b90a14885f3f01759666cd31f082675474c5`
+- npm shasum: `fd55cc35d22e82b1976adab2265dff09cc84a948`
+- npm integrity:
+  `sha512-J9BqSPjqfp6OMW/7odlYtluSRkY3WfQpa/5ky/nuhzCdUOa8ksb7Be8oTtu19KuqEL/9BY4PhOHyUgptr5drHQ==`
+- The npm and GitHub release tarballs are byte-identical.
+- A clean registry execution under Node `v24.18.0` returned `canopus 0.4.5`,
+  listed both packaged profiles, and validated
+  `formal-erdos-505-test-dim-one-gpt56` at the registered profile and draft
+  roots.
+- Public package and matching release:
+  [npm](https://www.npmjs.com/package/@vela-science/canopus/v/0.4.5),
+  [GitHub](https://github.com/vela-science/vela-research-harness/releases/tag/v0.4.5)
+
 ## Canopus v0.4.4
 
 Version `0.4.4` advances the product and hosted integration from Vela 0.901.0

package/evidence/build-week/run_f68e4cfc-e5c7-4c73-86cb-d79807c47ec4.public.json

@@ -0,0 +1 @@
+{"activity":{"clean_clone_replay":"matched","verifier":"pass","worker":"success"},"artifact_roots":["sha256:5eca82c582a9d3b6ae63d137cf7dadd4a01e40d52bc1bfac99932d1d8752f884","sha256:878b05e01dbc4a785e5a671f977509f0bb338dfcb58ac53bf03d47bf6465f01e","sha256:ba5da48c4f6fd744a70eb82d5e1a8291f981bf5ee4df9ec2d86d8184fde22de3"],"authority":"read_only_projection","caveats":["The worker handed off without verifier authority; Canopus subsequently recorded the separate verifier pass shown in this projection.","Declared verifier outcome: passed.","Canopus produced this record; it is not a human acceptance decision."],"claim":"Produced the exact reconstructed 7,194-point Sidon witness for {0,1}^24.","final":{"commit":"4289e05876f142e72af622672e190be26f6a6f1d","event_log_root":"sha256:11a668d1cdd9caa18f6c3c78ac8c03431bd2ab9beb71f3c62c747d8a7b6571cd","snapshot_root":"sha256:0441baf3d3c0f7f58e51d8d0b54d2e20ee94c57cfe3fd52ec0ea6dde2ee0c92d"},"mission":{"digest":"sha256:611dc75d2dce98b218deeaf68985dec961a0722446fe1d2879447997ffcfa2ba","id":"mission_sidon_a24_at_least_7194_gpt56_v3","model":"gpt-5.6-sol","registration_kind":"profile","registration_name":"sidon-a24-at-least-7194-gpt56-v3","registration_root":"sha256:3b529df4304b96890cdd7eed5f90fd862422b8b1e7b4da1cef0a478e6e7cdebe","target":"sidon:a24-improve","target_packet_root":"sha256:09977a08357cbe240c5a7f5c3ea8e5c7055d6b5d71bcfb5f947b49accee1a3a8"},"nonclaims":["Verifier success is not scientific acceptance.","The bounded result does not establish maximality or settle the broader scientific problem.","Canopus did not sign or perform a human decision."],"policy":{"accepted_state_delta":0,"proposal_id":"vpr_491cc97cfdfe98ff","route":"defer"},"receipt_root":"sha256:91b9f0c72e2934d3f98a34de93b61a168c8a9ff560a18a63ff4a1ee6ae2f897c","reproduction":{"commands":["git clone https://github.com/vela-science/sidon-frontier.git","cd sidon-frontier","git checkout 4289e05876f142e72af622672e190be26f6a6f1d","vela reproduce ."]},"run_id":"run_f68e4cfc-e5c7-4c73-86cb-d79807c47ec4","schema":"canopus.public-run.v1","source":{"commit":"6f9dca7e30ea3d9db3f440fcb4b50ece21dcf40e","event_log_root":"sha256:f063218142b0995179f751036108c94e7f368eb257be31e6807a36121f7a13aa","repository":"https://github.com/vela-science/sidon-frontier","snapshot_root":"sha256:fe5498193ab1079696af6de6f8a899334908a247fd78f7a25fb476b5b36b43b8"},"usage":{"attempts":1,"observed_tokens":105553,"research_elapsed_ms":88131,"research_processes":7},"verifier_root":"sha256:89130864b3ca4f354673416d4352616265b1e3dc25147a4ae91bbbf3874fbff8"}

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

@@ -0,0 +1,40 @@
+{
+  "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

@@ -0,0 +1,42 @@
+{
+  "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"
+  }
+}

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

@@ -0,0 +1,42 @@
+{
+  "id": "mission_sidon_a24_at_least_7194_gpt56_v2",
+  "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. This repairs the first GPT-5.6 attempt's unavailable-input defect: the exact target packet now embeds the complete mechanically verified pending 7,193-point baseline in current_state.tracked_unaccepted_seed.encoded_points. Require its encoded_points_sha256 to equal sha256:cbf35310bafabb05a610e3e4e6ff3c5f5c60c5a80cb6821a3cde165b672c643a and its witness root to equal sha256:f3712b47633a239133b5e0491e68fffc85831b761c27402ba9de8057f09252e7 before using it. The packet also records the prior exact one-removal/two-addition exchange that improved 7,192 to 7,193. Do not return that existing witness or merely replay its already-known exchange. Design, implement, and execute a stronger bounded search capable of another 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 inside the worker workspace, 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 integer 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": 600000
+  },
+  "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"
+  }
+}