@vela-science/canopus 0.6.5 → 0.8.0

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

@@ -0,0 +1,50 @@
+import { exactKeys, gitObjectAt, objectAt, sha256At, } from "../contracts/validation.js";
+import { canonicalJcs, canonicalJson, sha256Bytes } from "../util/canonical.js";
+import { parseCurrentRunRecord } from "./current-run.js";
+export function normalizeRetainedRunRoots(value, at) {
+    const roots = objectAt(value, at);
+    if (roots.vela_repository !== undefined) {
+        exactKeys(roots, ["git_commit", "git_tree", "vela_repository"], [], at);
+        return {
+            git_commit: gitObjectAt(roots.git_commit, `${at}.git_commit`),
+            git_tree: gitObjectAt(roots.git_tree, `${at}.git_tree`),
+            vela_repository: sha256At(roots.vela_repository, `${at}.vela_repository`),
+        };
+    }
+    exactKeys(roots, ["git_commit", "git_tree", "vela_event_log", "vela_snapshot"], [], at);
+    // Current writers emit vela_repository. Retained Run v2 bytes from the
+    // predecessor era instead bind event-log and snapshot roots. Readers verify
+    // those immutable roots and normalize only an in-memory copy.
+    sha256At(roots.vela_event_log, `${at}.vela_event_log`);
+    return {
+        git_commit: gitObjectAt(roots.git_commit, `${at}.git_commit`),
+        git_tree: gitObjectAt(roots.git_tree, `${at}.git_tree`),
+        vela_repository: sha256At(roots.vela_snapshot, `${at}.vela_snapshot`),
+    };
+}
+export function parseRetainedRunRecord(value) {
+    const raw = objectAt(value, "retained Run");
+    const mission = objectAt(raw.mission, "retained Run.mission");
+    const reproduction = objectAt(raw.reproduction, "retained Run.reproduction");
+    const startingRoots = objectAt(mission.starting_roots, "retained Run.mission.starting_roots");
+    const reproductionRoots = objectAt(reproduction.roots, "retained Run.reproduction.roots");
+    if (canonicalJcs(startingRoots) !== canonicalJcs(reproductionRoots)) {
+        throw new Error("retained Run starting and reproduction roots disagree");
+    }
+    const normalized = {
+        ...raw,
+        mission: {
+            ...mission,
+            starting_roots: normalizeRetainedRunRoots(startingRoots, "retained Run.mission.starting_roots"),
+        },
+        reproduction: {
+            ...reproduction,
+            roots: normalizeRetainedRunRoots(reproductionRoots, "retained Run.reproduction.roots"),
+        },
+    };
+    return {
+        record: parseCurrentRunRecord(normalized),
+        exactRoot: sha256Bytes(canonicalJson(raw)),
+        exactStartingRoots: canonicalJcs(startingRoots),
+    };
+}

package/dist/src/run.d.ts

@@ -1,20 +1,12 @@
-import type { Mission, MissionRoots, StrictBaseline } from "./contracts/mission.js";
-import type { FrozenArtifact } from "./contracts/candidate.js";
+import type { Mission, MissionRoots } from "./contracts/mission.js";
 import type { Engine } from "./engines/engine.js";
-import { type RunProjection, type RunRecord } from "./projection/run.js";
-import { type CommandRunner } from "./util/command.js";
-import type { AuthoredReceiptInput, VelaClient, VelaLandCommandObservation } from "./vela/cli.js";
-import type { LandResult, VelaCommandResponse, VelaInspection } from "./vela/types.js";
+import type { CommandRunner } from "./util/command.js";
+import type { VelaClient } from "./vela/cli.js";
+import type { VelaCommandResponse, VelaInspection } from "./vela/types.js";
 import { type WorkspacePaths } from "./workspace/prepare.js";
 export interface VelaPort {
-    assertRoots(repoRoot: string, frontier: string, expected: MissionRoots, strictBaseline?: StrictBaseline): Promise<VelaInspection>;
-    inspect(repoRoot: string, frontier: string, strictBaseline?: StrictBaseline): Promise<VelaInspection>;
+    assertRoots(repoRoot: string, frontier: string, expected: MissionRoots): Promise<VelaInspection>;
     next(mission: Mission, repoRoot: string): Promise<VelaCommandResponse>;
-    work(mission: Mission, repoRoot: string, target: string, expected: MissionRoots): Promise<VelaCommandResponse>;
-    landAuthoredCommand(mission: Mission, repoRoot: string, input: AuthoredReceiptInput, expected: MissionRoots): Promise<VelaLandCommandObservation>;
-    parseLandCommand(observation: VelaLandCommandObservation): Record<string, unknown>;
-    validateLandResult(mission: Mission, raw: Record<string, unknown>): LandResult;
-    verifyReceiptBinding(mission: Mission, repoRoot: string, landing: LandResult, input: AuthoredReceiptInput, artifacts: readonly FrozenArtifact[]): Promise<void>;
 }
 export interface CanopusRunOptions {
     mission: Mission;
@@ -25,28 +17,40 @@ export interface CanopusRunOptions {
     bundleRoot?: string;
     dockerBinary?: string;
     verifierRunner?: CommandRunner;
-    retainWithdrawalCapability?: (context: {
-        velaHome: string;
-        landingRepo: string;
-        mission: Mission;
-        landing: LandResult;
-        finalRoots: MissionRoots;
-    }) => Promise<void>;
-    noLand?: false;
 }
-export interface CanopusNoLandOptions extends Omit<CanopusRunOptions, "noLand"> {
-    noLand: true;
+export interface VerifierRun {
+    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;
+    };
 }
-export interface CanopusRunResult {
-    record: RunRecord;
-    projection: RunProjection;
-    paths: WorkspacePaths;
+export interface ReproductionResult {
+    matched: boolean;
+    roots: MissionRoots;
+    verifier_status: "passed" | "failed" | "error";
+    stdout_digest: string;
+    stderr_digest: string;
+}
+export interface RunBudget {
+    research_elapsed_ms: number;
+    research_processes: number;
+    research_output_bytes: number;
+    prompt_bytes: number;
+    artifact_bytes: number;
+    attempts: number;
+    observed_tokens: number;
 }
-export interface DiagnosticRunRecord {
-    schema: "canopus.diagnostic-run.v1";
+export interface CurrentRunRecord {
+    schema: "canopus.run.v2";
     run_id: string;
     status: "completed";
-    mode: "no_land";
+    effect: "none";
     authority: "non_authoritative";
     external_gate_credit: false;
     mission: {
@@ -67,21 +71,21 @@ export interface DiagnosticRunRecord {
         }>;
         caveats: string[];
     };
-    verifier: RunRecord["verifier"];
-    landing: null;
-    reproduction: RunRecord["reproduction"];
-    budget: RunRecord["budget"];
+    verifier: VerifierRun;
+    submission: null;
+    reproduction: ReproductionResult;
+    budget: RunBudget;
 }
-export interface CanopusDiagnosticRunResult {
-    record: DiagnosticRunRecord;
+export interface CanopusCurrentRunResult {
+    record: CurrentRunRecord;
     projection: {
-        schema: "canopus.diagnostic-projection.v1";
+        schema: "canopus.run-projection.v2";
         authority: "read_only_projection";
         run_id: string;
         target: string;
         candidate_digest: string;
         verifier_status: "passed" | "failed" | "error";
-        landed: false;
+        submitted: false;
         clean_clone_reproduced: boolean;
     };
     paths: WorkspacePaths;
@@ -90,6 +94,4 @@ 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>;
+export declare function runCanopus(options: CanopusRunOptions): Promise<CanopusCurrentRunResult>;