openpond-sdk 0.12.26 → 0.12.27

package/dist/types/packages/sdk/src/weight-space-sessions.d.ts

@@ -0,0 +1,4600 @@
+import { z } from "zod";
+import { ManagedModificationStartSchema, ManagedModificationCancelSchema } from "./managed-modification-executions.js";
+import { ModelModificationCapabilitiesQuerySchema } from "./model-modification-capabilities.js";
+import { type WeightSpaceCommand } from "./weight-space-programming.js";
+/** New qualified cold-bootstrap terms travel inside the hashed runtime. Old
+ * runtimes omit this profile and retain their original 300-second clock. */
+export declare const WeightSpaceQualifiedBootstrapClockSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceQualifiedBootstrapClock.v1">;
+    method: z.ZodLiteral<"weight_space_programming">;
+    validationLevel: z.ZodLiteral<"gpu_qualified">;
+    bootstrapSeconds: z.ZodLiteral<900>;
+    maximumWorkSeconds: z.ZodNumber;
+    workClock: z.ZodLiteral<"native_command_issued">;
+    cleanupSeconds: z.ZodLiteral<120>;
+    modelHash: z.ZodString;
+    runtimeTemplateHash: z.ZodString;
+    qualification: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    source: z.ZodObject<{
+        imageDigest: z.ZodString;
+        releaseHash: z.ZodString;
+        canonicalReleaseSha256: z.ZodString;
+        sourceTreeSha256: z.ZodString;
+        softwareInventorySha256: z.ZodString;
+        buildReceiptSha256: z.ZodString;
+        pythonSdkSha256: z.ZodString;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export declare const WeightSpaceCapabilityContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceCapability.v1">;
+    teamId: z.ZodString;
+    actorId: z.ZodString;
+    query: z.ZodObject<{
+        teamId: z.ZodString;
+        modelId: z.ZodString;
+        source: z.ZodEnum<{
+            builtin: "builtin";
+            local: "local";
+            managed: "managed";
+        }>;
+        revision: z.ZodOptional<z.ZodString>;
+        tokenizerRevision: z.ZodOptional<z.ZodString>;
+        chatTemplateHash: z.ZodOptional<z.ZodString>;
+        modelAssetId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    requestHash: z.ZodString;
+    checkedAt: z.ZodISODateTime;
+    expiresAt: z.ZodISODateTime;
+    validationLevel: z.ZodNullable<z.ZodEnum<{
+        gpu_qualified: "gpu_qualified";
+        source_validated: "source_validated";
+    }>>;
+    execution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        state: z.ZodLiteral<"unavailable">;
+        code: z.ZodEnum<{
+            model_not_supported: "model_not_supported";
+            runtime_not_qualified: "runtime_not_qualified";
+        }>;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"ready">;
+        model: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodString;
+            configHash: z.ZodString;
+            weightsHash: z.ZodString;
+            tokenizerHash: z.ZodString;
+            weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+            architecture: z.ZodLiteral<"dense_decoder">;
+            dtype: z.ZodEnum<{
+                bfloat16: "bfloat16";
+                float16: "float16";
+                float32: "float32";
+            }>;
+            quantization: z.ZodLiteral<"none">;
+            adapter: z.ZodNull;
+            hiddenSize: z.ZodNumber;
+            intermediateSizes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            id: z.ZodString;
+            releaseHash: z.ZodString;
+            imageDigest: z.ZodString;
+            requestSchema: z.ZodLiteral<"openpond.weightSpaceRequest.v1">;
+            bootstrapClock: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.weightSpaceQualifiedBootstrapClock.v1">;
+                method: z.ZodLiteral<"weight_space_programming">;
+                validationLevel: z.ZodLiteral<"gpu_qualified">;
+                bootstrapSeconds: z.ZodLiteral<900>;
+                maximumWorkSeconds: z.ZodNumber;
+                workClock: z.ZodLiteral<"native_command_issued">;
+                cleanupSeconds: z.ZodLiteral<120>;
+                modelHash: z.ZodString;
+                runtimeTemplateHash: z.ZodString;
+                qualification: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                source: z.ZodObject<{
+                    imageDigest: z.ZodString;
+                    releaseHash: z.ZodString;
+                    canonicalReleaseSha256: z.ZodString;
+                    sourceTreeSha256: z.ZodString;
+                    softwareInventorySha256: z.ZodString;
+                    buildReceiptSha256: z.ZodString;
+                    pythonSdkSha256: z.ZodString;
+                }, z.core.$strict>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            evidence: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        limits: z.ZodObject<{
+            maximumDurationSeconds: z.ZodNumber;
+            maximumIdleSeconds: z.ZodNumber;
+            maximumCommands: z.ZodNumber;
+            maximumCandidates: z.ZodNumber;
+            maximumPatchColumns: z.ZodNumber;
+            maximumTensorElements: z.ZodNumber;
+            maximumReturnedValues: z.ZodNumber;
+            maximumArithmeticWork: z.ZodNumber;
+            maximumForwardTokenWork: z.ZodNumber;
+            maximumCheckpointBytes: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "state">;
+}, z.core.$strict>;
+export declare const WeightSpaceCapabilitySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceCapability.v1">;
+    teamId: z.ZodString;
+    actorId: z.ZodString;
+    query: z.ZodObject<{
+        teamId: z.ZodString;
+        modelId: z.ZodString;
+        source: z.ZodEnum<{
+            builtin: "builtin";
+            local: "local";
+            managed: "managed";
+        }>;
+        revision: z.ZodOptional<z.ZodString>;
+        tokenizerRevision: z.ZodOptional<z.ZodString>;
+        chatTemplateHash: z.ZodOptional<z.ZodString>;
+        modelAssetId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    requestHash: z.ZodString;
+    checkedAt: z.ZodISODateTime;
+    expiresAt: z.ZodISODateTime;
+    validationLevel: z.ZodNullable<z.ZodEnum<{
+        gpu_qualified: "gpu_qualified";
+        source_validated: "source_validated";
+    }>>;
+    execution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        state: z.ZodLiteral<"unavailable">;
+        code: z.ZodEnum<{
+            model_not_supported: "model_not_supported";
+            runtime_not_qualified: "runtime_not_qualified";
+        }>;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"ready">;
+        model: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodString;
+            configHash: z.ZodString;
+            weightsHash: z.ZodString;
+            tokenizerHash: z.ZodString;
+            weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+            architecture: z.ZodLiteral<"dense_decoder">;
+            dtype: z.ZodEnum<{
+                bfloat16: "bfloat16";
+                float16: "float16";
+                float32: "float32";
+            }>;
+            quantization: z.ZodLiteral<"none">;
+            adapter: z.ZodNull;
+            hiddenSize: z.ZodNumber;
+            intermediateSizes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            id: z.ZodString;
+            releaseHash: z.ZodString;
+            imageDigest: z.ZodString;
+            requestSchema: z.ZodLiteral<"openpond.weightSpaceRequest.v1">;
+            bootstrapClock: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.weightSpaceQualifiedBootstrapClock.v1">;
+                method: z.ZodLiteral<"weight_space_programming">;
+                validationLevel: z.ZodLiteral<"gpu_qualified">;
+                bootstrapSeconds: z.ZodLiteral<900>;
+                maximumWorkSeconds: z.ZodNumber;
+                workClock: z.ZodLiteral<"native_command_issued">;
+                cleanupSeconds: z.ZodLiteral<120>;
+                modelHash: z.ZodString;
+                runtimeTemplateHash: z.ZodString;
+                qualification: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                source: z.ZodObject<{
+                    imageDigest: z.ZodString;
+                    releaseHash: z.ZodString;
+                    canonicalReleaseSha256: z.ZodString;
+                    sourceTreeSha256: z.ZodString;
+                    softwareInventorySha256: z.ZodString;
+                    buildReceiptSha256: z.ZodString;
+                    pythonSdkSha256: z.ZodString;
+                }, z.core.$strict>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            evidence: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        limits: z.ZodObject<{
+            maximumDurationSeconds: z.ZodNumber;
+            maximumIdleSeconds: z.ZodNumber;
+            maximumCommands: z.ZodNumber;
+            maximumCandidates: z.ZodNumber;
+            maximumPatchColumns: z.ZodNumber;
+            maximumTensorElements: z.ZodNumber;
+            maximumReturnedValues: z.ZodNumber;
+            maximumArithmeticWork: z.ZodNumber;
+            maximumForwardTokenWork: z.ZodNumber;
+            maximumCheckpointBytes: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "state">;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type WeightSpaceCapability = z.infer<typeof WeightSpaceCapabilitySchema>;
+export declare const WeightSpacePrepareSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    operationId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    method: z.ZodLiteral<"weight_space_programming">;
+    query: z.ZodObject<{
+        teamId: z.ZodString;
+        modelId: z.ZodString;
+        source: z.ZodEnum<{
+            builtin: "builtin";
+            local: "local";
+            managed: "managed";
+        }>;
+        revision: z.ZodOptional<z.ZodString>;
+        tokenizerRevision: z.ZodOptional<z.ZodString>;
+        chatTemplateHash: z.ZodOptional<z.ZodString>;
+        modelAssetId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.weightSpaceRequest.v1">;
+        model: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodString;
+            configHash: z.ZodString;
+            weightsHash: z.ZodString;
+            tokenizerHash: z.ZodString;
+            weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+            architecture: z.ZodLiteral<"dense_decoder">;
+            dtype: z.ZodEnum<{
+                bfloat16: "bfloat16";
+                float16: "float16";
+                float32: "float32";
+            }>;
+            quantization: z.ZodLiteral<"none">;
+            adapter: z.ZodNull;
+            hiddenSize: z.ZodNumber;
+            intermediateSizes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+        teacher: z.ZodObject<{
+            controller: z.ZodLiteral<"local_agent">;
+            providerId: z.ZodString;
+            modelId: z.ZodString;
+            sessionId: z.ZodString;
+        }, z.core.$strict>;
+        objective: z.ZodString;
+        panels: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>;
+            role: z.ZodEnum<{
+                development: "development";
+                preservation: "preservation";
+            }>;
+            prompts: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                text: z.ZodString;
+                system: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        frozenEvaluation: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        generation: z.ZodObject<{
+            maxOutputTokens: z.ZodNumber;
+            seed: z.ZodNumber;
+            sampling: z.ZodLiteral<"greedy_v1">;
+        }, z.core.$strict>;
+        limits: z.ZodObject<{
+            maximumDurationSeconds: z.ZodNumber;
+            maximumIdleSeconds: z.ZodNumber;
+            maximumCommands: z.ZodNumber;
+            maximumCandidates: z.ZodNumber;
+            maximumPatchColumns: z.ZodNumber;
+            maximumTensorElements: z.ZodNumber;
+            maximumReturnedValues: z.ZodNumber;
+            maximumArithmeticWork: z.ZodNumber;
+            maximumForwardTokenWork: z.ZodNumber;
+            maximumCheckpointBytes: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    maximumSpendUsd: z.ZodString;
+    sourceForm: z.ZodOptional<z.ZodNever>;
+}, z.core.$strict>;
+export type WeightSpacePrepare = z.infer<typeof WeightSpacePrepareSchema>;
+export declare const WeightSpaceSessionStateSchema: z.ZodObject<{
+    revision: z.ZodNumber;
+    candidateHash: z.ZodString;
+    historyHash: z.ZodString;
+    phase: z.ZodEnum<{
+        busy: "busy";
+        closed: "closed";
+        finalizing: "finalizing";
+        ready: "ready";
+        starting: "starting";
+    }>;
+    pendingOperationId: z.ZodNullable<z.ZodString>;
+    lastActivityAt: z.ZodISODateTime;
+    finalization: z.ZodNullable<z.ZodObject<{
+        operationId: z.ZodString;
+        resultHash: z.ZodString;
+        historyHashBefore: z.ZodString;
+        status: z.ZodEnum<{
+            rejected: "rejected";
+            succeeded: "succeeded";
+        }>;
+    }, z.core.$strict>>;
+    usage: z.ZodObject<{
+        commands: z.ZodNumber;
+        candidates: z.ZodNumber;
+        arithmeticWork: z.ZodNumber;
+        forwardTokenWork: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const WeightSpaceExecutionMetadataSchema: z.ZodObject<{
+    id: z.ZodString;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        dispatching: "dispatching";
+        failed: "failed";
+        prepared: "prepared";
+        queued: "queued";
+        stopping: "stopping";
+    }>;
+    revision: z.ZodNumber;
+    sourceContentHash: z.ZodString;
+    plan: z.ZodObject<{
+        contentHash: z.ZodString;
+        inputHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        maximumSpendUsd: z.ZodNullable<z.ZodString>;
+        computePrice: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v1">;
+            appliedPrice: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                version: z.ZodString;
+                profileHash: z.ZodString;
+                currency: z.ZodLiteral<"USD">;
+                unit: z.ZodLiteral<"resource_hour">;
+                hourlyUsd: z.ZodString;
+                service: z.ZodLiteral<"model_modification">;
+            }, z.core.$strict>;
+            billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+            startupBillable: z.ZodLiteral<true>;
+            postCompletionIdleBillable: z.ZodLiteral<false>;
+            minimumBillableSeconds: z.ZodLiteral<0>;
+            warmReuseSeconds: z.ZodLiteral<300>;
+        }, z.core.$strict>, z.ZodObject<{
+            appliedPrice: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                version: z.ZodString;
+                profileHash: z.ZodString;
+                currency: z.ZodLiteral<"USD">;
+                unit: z.ZodLiteral<"resource_hour">;
+                hourlyUsd: z.ZodString;
+                service: z.ZodLiteral<"model_modification">;
+            }, z.core.$strict>;
+            billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+            startupBillable: z.ZodLiteral<true>;
+            postCompletionIdleBillable: z.ZodLiteral<false>;
+            minimumBillableSeconds: z.ZodLiteral<0>;
+            schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v2">;
+            warmReuseSeconds: z.ZodLiteral<0>;
+        }, z.core.$strict>], "schemaVersion">>;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    updatedAt: z.ZodISODateTime;
+    method: z.ZodLiteral<"weight_space_programming">;
+    session: z.ZodNullable<z.ZodObject<{
+        revision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        historyHash: z.ZodString;
+        phase: z.ZodEnum<{
+            busy: "busy";
+            closed: "closed";
+            finalizing: "finalizing";
+            ready: "ready";
+            starting: "starting";
+        }>;
+        pendingOperationId: z.ZodNullable<z.ZodString>;
+        lastActivityAt: z.ZodISODateTime;
+        finalization: z.ZodNullable<z.ZodObject<{
+            operationId: z.ZodString;
+            resultHash: z.ZodString;
+            historyHashBefore: z.ZodString;
+            status: z.ZodEnum<{
+                rejected: "rejected";
+                succeeded: "succeeded";
+            }>;
+        }, z.core.$strict>>;
+        usage: z.ZodObject<{
+            commands: z.ZodNumber;
+            candidates: z.ZodNumber;
+            arithmeticWork: z.ZodNumber;
+            forwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const WeightSpaceExecutionContentSchema: z.ZodObject<{
+    id: z.ZodString;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        dispatching: "dispatching";
+        failed: "failed";
+        prepared: "prepared";
+        queued: "queued";
+        stopping: "stopping";
+    }>;
+    revision: z.ZodNumber;
+    sourceContentHash: z.ZodString;
+    plan: z.ZodObject<{
+        contentHash: z.ZodString;
+        inputHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        maximumSpendUsd: z.ZodNullable<z.ZodString>;
+        computePrice: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v1">;
+            appliedPrice: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                version: z.ZodString;
+                profileHash: z.ZodString;
+                currency: z.ZodLiteral<"USD">;
+                unit: z.ZodLiteral<"resource_hour">;
+                hourlyUsd: z.ZodString;
+                service: z.ZodLiteral<"model_modification">;
+            }, z.core.$strict>;
+            billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+            startupBillable: z.ZodLiteral<true>;
+            postCompletionIdleBillable: z.ZodLiteral<false>;
+            minimumBillableSeconds: z.ZodLiteral<0>;
+            warmReuseSeconds: z.ZodLiteral<300>;
+        }, z.core.$strict>, z.ZodObject<{
+            appliedPrice: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                version: z.ZodString;
+                profileHash: z.ZodString;
+                currency: z.ZodLiteral<"USD">;
+                unit: z.ZodLiteral<"resource_hour">;
+                hourlyUsd: z.ZodString;
+                service: z.ZodLiteral<"model_modification">;
+            }, z.core.$strict>;
+            billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+            startupBillable: z.ZodLiteral<true>;
+            postCompletionIdleBillable: z.ZodLiteral<false>;
+            minimumBillableSeconds: z.ZodLiteral<0>;
+            schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v2">;
+            warmReuseSeconds: z.ZodLiteral<0>;
+        }, z.core.$strict>], "schemaVersion">>;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    updatedAt: z.ZodISODateTime;
+    method: z.ZodLiteral<"weight_space_programming">;
+    session: z.ZodNullable<z.ZodObject<{
+        revision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        historyHash: z.ZodString;
+        phase: z.ZodEnum<{
+            busy: "busy";
+            closed: "closed";
+            finalizing: "finalizing";
+            ready: "ready";
+            starting: "starting";
+        }>;
+        pendingOperationId: z.ZodNullable<z.ZodString>;
+        lastActivityAt: z.ZodISODateTime;
+        finalization: z.ZodNullable<z.ZodObject<{
+            operationId: z.ZodString;
+            resultHash: z.ZodString;
+            historyHashBefore: z.ZodString;
+            status: z.ZodEnum<{
+                rejected: "rejected";
+                succeeded: "succeeded";
+            }>;
+        }, z.core.$strict>>;
+        usage: z.ZodObject<{
+            commands: z.ZodNumber;
+            candidates: z.ZodNumber;
+            arithmeticWork: z.ZodNumber;
+            forwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceExecution.v1">;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.weightSpaceRequest.v1">;
+        model: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodString;
+            configHash: z.ZodString;
+            weightsHash: z.ZodString;
+            tokenizerHash: z.ZodString;
+            weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+            architecture: z.ZodLiteral<"dense_decoder">;
+            dtype: z.ZodEnum<{
+                bfloat16: "bfloat16";
+                float16: "float16";
+                float32: "float32";
+            }>;
+            quantization: z.ZodLiteral<"none">;
+            adapter: z.ZodNull;
+            hiddenSize: z.ZodNumber;
+            intermediateSizes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+        teacher: z.ZodObject<{
+            controller: z.ZodLiteral<"local_agent">;
+            providerId: z.ZodString;
+            modelId: z.ZodString;
+            sessionId: z.ZodString;
+        }, z.core.$strict>;
+        objective: z.ZodString;
+        panels: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>;
+            role: z.ZodEnum<{
+                development: "development";
+                preservation: "preservation";
+            }>;
+            prompts: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                text: z.ZodString;
+                system: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        frozenEvaluation: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        generation: z.ZodObject<{
+            maxOutputTokens: z.ZodNumber;
+            seed: z.ZodNumber;
+            sampling: z.ZodLiteral<"greedy_v1">;
+        }, z.core.$strict>;
+        limits: z.ZodObject<{
+            maximumDurationSeconds: z.ZodNumber;
+            maximumIdleSeconds: z.ZodNumber;
+            maximumCommands: z.ZodNumber;
+            maximumCandidates: z.ZodNumber;
+            maximumPatchColumns: z.ZodNumber;
+            maximumTensorElements: z.ZodNumber;
+            maximumReturnedValues: z.ZodNumber;
+            maximumArithmeticWork: z.ZodNumber;
+            maximumForwardTokenWork: z.ZodNumber;
+            maximumCheckpointBytes: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    result: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.weightSpaceResult.v1">;
+        inputHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        candidateHash: z.ZodString;
+        historyHash: z.ZodString;
+        artifact: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            manifest: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.weightSpaceArtifact.v1">;
+                method: z.ZodLiteral<"weight_space_programming">;
+                representation: z.ZodLiteral<"exact_bf16_mlp_column_replacements_v1">;
+                model: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+                    modelId: z.ZodString;
+                    revision: z.ZodString;
+                    configHash: z.ZodString;
+                    weightsHash: z.ZodString;
+                    tokenizerHash: z.ZodString;
+                    weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+                    architecture: z.ZodLiteral<"dense_decoder">;
+                    dtype: z.ZodEnum<{
+                        bfloat16: "bfloat16";
+                        float16: "float16";
+                        float32: "float32";
+                    }>;
+                    quantization: z.ZodLiteral<"none">;
+                    adapter: z.ZodNull;
+                    hiddenSize: z.ZodNumber;
+                    intermediateSizes: z.ZodArray<z.ZodNumber>;
+                }, z.core.$strict>;
+                requestHash: z.ZodString;
+                runtimeHash: z.ZodString;
+                candidateHash: z.ZodString;
+                teacher: z.ZodObject<{
+                    controller: z.ZodLiteral<"local_agent">;
+                    providerId: z.ZodString;
+                    modelId: z.ZodString;
+                    sessionId: z.ZodString;
+                }, z.core.$strict>;
+                historyHash: z.ZodString;
+                columns: z.ZodArray<z.ZodObject<{
+                    layer: z.ZodNumber;
+                    columns: z.ZodArray<z.ZodNumber>;
+                }, z.core.$strict>>;
+                columnHashes: z.ZodArray<z.ZodString>;
+                payload: z.ZodObject<{
+                    path: z.ZodLiteral<"patch.safetensors">;
+                    sha256: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    tensors: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        dtype: z.ZodEnum<{
+                            BF16: "BF16";
+                            I64: "I64";
+                        }>;
+                        shape: z.ZodArray<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                reload: z.ZodObject<{
+                    effectiveColumnsHash: z.ZodString;
+                    reloadedColumnsHash: z.ZodString;
+                    untouchedWeightsHashBefore: z.ZodString;
+                    untouchedWeightsHashAfter: z.ZodString;
+                    equivalent: z.ZodLiteral<true>;
+                }, z.core.$strict>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodEnum<{
+                    "manifest.json": "manifest.json";
+                    "patch.safetensors": "patch.safetensors";
+                }>;
+                artifactId: z.ZodString;
+                sha256: z.ZodString;
+                sizeBytes: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        commands: z.ZodNumber;
+        candidates: z.ZodNumber;
+        forwardTokenWork: z.ZodNumber;
+        durationMs: z.ZodNumber;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    resultRecordedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export declare const WeightSpaceExecutionSchema: z.ZodObject<{
+    id: z.ZodString;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        dispatching: "dispatching";
+        failed: "failed";
+        prepared: "prepared";
+        queued: "queued";
+        stopping: "stopping";
+    }>;
+    revision: z.ZodNumber;
+    sourceContentHash: z.ZodString;
+    plan: z.ZodObject<{
+        contentHash: z.ZodString;
+        inputHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        maximumSpendUsd: z.ZodNullable<z.ZodString>;
+        computePrice: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v1">;
+            appliedPrice: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                version: z.ZodString;
+                profileHash: z.ZodString;
+                currency: z.ZodLiteral<"USD">;
+                unit: z.ZodLiteral<"resource_hour">;
+                hourlyUsd: z.ZodString;
+                service: z.ZodLiteral<"model_modification">;
+            }, z.core.$strict>;
+            billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+            startupBillable: z.ZodLiteral<true>;
+            postCompletionIdleBillable: z.ZodLiteral<false>;
+            minimumBillableSeconds: z.ZodLiteral<0>;
+            warmReuseSeconds: z.ZodLiteral<300>;
+        }, z.core.$strict>, z.ZodObject<{
+            appliedPrice: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                version: z.ZodString;
+                profileHash: z.ZodString;
+                currency: z.ZodLiteral<"USD">;
+                unit: z.ZodLiteral<"resource_hour">;
+                hourlyUsd: z.ZodString;
+                service: z.ZodLiteral<"model_modification">;
+            }, z.core.$strict>;
+            billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+            startupBillable: z.ZodLiteral<true>;
+            postCompletionIdleBillable: z.ZodLiteral<false>;
+            minimumBillableSeconds: z.ZodLiteral<0>;
+            schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v2">;
+            warmReuseSeconds: z.ZodLiteral<0>;
+        }, z.core.$strict>], "schemaVersion">>;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    updatedAt: z.ZodISODateTime;
+    method: z.ZodLiteral<"weight_space_programming">;
+    session: z.ZodNullable<z.ZodObject<{
+        revision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        historyHash: z.ZodString;
+        phase: z.ZodEnum<{
+            busy: "busy";
+            closed: "closed";
+            finalizing: "finalizing";
+            ready: "ready";
+            starting: "starting";
+        }>;
+        pendingOperationId: z.ZodNullable<z.ZodString>;
+        lastActivityAt: z.ZodISODateTime;
+        finalization: z.ZodNullable<z.ZodObject<{
+            operationId: z.ZodString;
+            resultHash: z.ZodString;
+            historyHashBefore: z.ZodString;
+            status: z.ZodEnum<{
+                rejected: "rejected";
+                succeeded: "succeeded";
+            }>;
+        }, z.core.$strict>>;
+        usage: z.ZodObject<{
+            commands: z.ZodNumber;
+            candidates: z.ZodNumber;
+            arithmeticWork: z.ZodNumber;
+            forwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceExecution.v1">;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.weightSpaceRequest.v1">;
+        model: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodString;
+            configHash: z.ZodString;
+            weightsHash: z.ZodString;
+            tokenizerHash: z.ZodString;
+            weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+            architecture: z.ZodLiteral<"dense_decoder">;
+            dtype: z.ZodEnum<{
+                bfloat16: "bfloat16";
+                float16: "float16";
+                float32: "float32";
+            }>;
+            quantization: z.ZodLiteral<"none">;
+            adapter: z.ZodNull;
+            hiddenSize: z.ZodNumber;
+            intermediateSizes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+        teacher: z.ZodObject<{
+            controller: z.ZodLiteral<"local_agent">;
+            providerId: z.ZodString;
+            modelId: z.ZodString;
+            sessionId: z.ZodString;
+        }, z.core.$strict>;
+        objective: z.ZodString;
+        panels: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>;
+            role: z.ZodEnum<{
+                development: "development";
+                preservation: "preservation";
+            }>;
+            prompts: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                text: z.ZodString;
+                system: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        frozenEvaluation: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        generation: z.ZodObject<{
+            maxOutputTokens: z.ZodNumber;
+            seed: z.ZodNumber;
+            sampling: z.ZodLiteral<"greedy_v1">;
+        }, z.core.$strict>;
+        limits: z.ZodObject<{
+            maximumDurationSeconds: z.ZodNumber;
+            maximumIdleSeconds: z.ZodNumber;
+            maximumCommands: z.ZodNumber;
+            maximumCandidates: z.ZodNumber;
+            maximumPatchColumns: z.ZodNumber;
+            maximumTensorElements: z.ZodNumber;
+            maximumReturnedValues: z.ZodNumber;
+            maximumArithmeticWork: z.ZodNumber;
+            maximumForwardTokenWork: z.ZodNumber;
+            maximumCheckpointBytes: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    result: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.weightSpaceResult.v1">;
+        inputHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        candidateHash: z.ZodString;
+        historyHash: z.ZodString;
+        artifact: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            manifest: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.weightSpaceArtifact.v1">;
+                method: z.ZodLiteral<"weight_space_programming">;
+                representation: z.ZodLiteral<"exact_bf16_mlp_column_replacements_v1">;
+                model: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+                    modelId: z.ZodString;
+                    revision: z.ZodString;
+                    configHash: z.ZodString;
+                    weightsHash: z.ZodString;
+                    tokenizerHash: z.ZodString;
+                    weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+                    architecture: z.ZodLiteral<"dense_decoder">;
+                    dtype: z.ZodEnum<{
+                        bfloat16: "bfloat16";
+                        float16: "float16";
+                        float32: "float32";
+                    }>;
+                    quantization: z.ZodLiteral<"none">;
+                    adapter: z.ZodNull;
+                    hiddenSize: z.ZodNumber;
+                    intermediateSizes: z.ZodArray<z.ZodNumber>;
+                }, z.core.$strict>;
+                requestHash: z.ZodString;
+                runtimeHash: z.ZodString;
+                candidateHash: z.ZodString;
+                teacher: z.ZodObject<{
+                    controller: z.ZodLiteral<"local_agent">;
+                    providerId: z.ZodString;
+                    modelId: z.ZodString;
+                    sessionId: z.ZodString;
+                }, z.core.$strict>;
+                historyHash: z.ZodString;
+                columns: z.ZodArray<z.ZodObject<{
+                    layer: z.ZodNumber;
+                    columns: z.ZodArray<z.ZodNumber>;
+                }, z.core.$strict>>;
+                columnHashes: z.ZodArray<z.ZodString>;
+                payload: z.ZodObject<{
+                    path: z.ZodLiteral<"patch.safetensors">;
+                    sha256: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    tensors: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        dtype: z.ZodEnum<{
+                            BF16: "BF16";
+                            I64: "I64";
+                        }>;
+                        shape: z.ZodArray<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                reload: z.ZodObject<{
+                    effectiveColumnsHash: z.ZodString;
+                    reloadedColumnsHash: z.ZodString;
+                    untouchedWeightsHashBefore: z.ZodString;
+                    untouchedWeightsHashAfter: z.ZodString;
+                    equivalent: z.ZodLiteral<true>;
+                }, z.core.$strict>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodEnum<{
+                    "manifest.json": "manifest.json";
+                    "patch.safetensors": "patch.safetensors";
+                }>;
+                artifactId: z.ZodString;
+                sha256: z.ZodString;
+                sizeBytes: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        commands: z.ZodNumber;
+        candidates: z.ZodNumber;
+        forwardTokenWork: z.ZodNumber;
+        durationMs: z.ZodNumber;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    resultRecordedAt: z.ZodNullable<z.ZodISODateTime>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type WeightSpaceExecution = z.infer<typeof WeightSpaceExecutionSchema>;
+export declare const WeightSpaceExecutionReceiptContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceExecutionReceipt.v1">;
+    operationId: z.ZodString;
+    requestHash: z.ZodString;
+    execution: z.ZodObject<{
+        id: z.ZodString;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            dispatching: "dispatching";
+            failed: "failed";
+            prepared: "prepared";
+            queued: "queued";
+            stopping: "stopping";
+        }>;
+        revision: z.ZodNumber;
+        sourceContentHash: z.ZodString;
+        plan: z.ZodObject<{
+            contentHash: z.ZodString;
+            inputHash: z.ZodString;
+            runtimeHash: z.ZodString;
+            maximumSpendUsd: z.ZodNullable<z.ZodString>;
+            computePrice: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v1">;
+                appliedPrice: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                    version: z.ZodString;
+                    profileHash: z.ZodString;
+                    currency: z.ZodLiteral<"USD">;
+                    unit: z.ZodLiteral<"resource_hour">;
+                    hourlyUsd: z.ZodString;
+                    service: z.ZodLiteral<"model_modification">;
+                }, z.core.$strict>;
+                billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+                startupBillable: z.ZodLiteral<true>;
+                postCompletionIdleBillable: z.ZodLiteral<false>;
+                minimumBillableSeconds: z.ZodLiteral<0>;
+                warmReuseSeconds: z.ZodLiteral<300>;
+            }, z.core.$strict>, z.ZodObject<{
+                appliedPrice: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                    version: z.ZodString;
+                    profileHash: z.ZodString;
+                    currency: z.ZodLiteral<"USD">;
+                    unit: z.ZodLiteral<"resource_hour">;
+                    hourlyUsd: z.ZodString;
+                    service: z.ZodLiteral<"model_modification">;
+                }, z.core.$strict>;
+                billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+                startupBillable: z.ZodLiteral<true>;
+                postCompletionIdleBillable: z.ZodLiteral<false>;
+                minimumBillableSeconds: z.ZodLiteral<0>;
+                schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v2">;
+                warmReuseSeconds: z.ZodLiteral<0>;
+            }, z.core.$strict>], "schemaVersion">>;
+            createdAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+        updatedAt: z.ZodISODateTime;
+        method: z.ZodLiteral<"weight_space_programming">;
+        session: z.ZodNullable<z.ZodObject<{
+            revision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            historyHash: z.ZodString;
+            phase: z.ZodEnum<{
+                busy: "busy";
+                closed: "closed";
+                finalizing: "finalizing";
+                ready: "ready";
+                starting: "starting";
+            }>;
+            pendingOperationId: z.ZodNullable<z.ZodString>;
+            lastActivityAt: z.ZodISODateTime;
+            finalization: z.ZodNullable<z.ZodObject<{
+                operationId: z.ZodString;
+                resultHash: z.ZodString;
+                historyHashBefore: z.ZodString;
+                status: z.ZodEnum<{
+                    rejected: "rejected";
+                    succeeded: "succeeded";
+                }>;
+            }, z.core.$strict>>;
+            usage: z.ZodObject<{
+                commands: z.ZodNumber;
+                candidates: z.ZodNumber;
+                arithmeticWork: z.ZodNumber;
+                forwardTokenWork: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const WeightSpaceExecutionReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceExecutionReceipt.v1">;
+    operationId: z.ZodString;
+    requestHash: z.ZodString;
+    execution: z.ZodObject<{
+        id: z.ZodString;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            dispatching: "dispatching";
+            failed: "failed";
+            prepared: "prepared";
+            queued: "queued";
+            stopping: "stopping";
+        }>;
+        revision: z.ZodNumber;
+        sourceContentHash: z.ZodString;
+        plan: z.ZodObject<{
+            contentHash: z.ZodString;
+            inputHash: z.ZodString;
+            runtimeHash: z.ZodString;
+            maximumSpendUsd: z.ZodNullable<z.ZodString>;
+            computePrice: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v1">;
+                appliedPrice: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                    version: z.ZodString;
+                    profileHash: z.ZodString;
+                    currency: z.ZodLiteral<"USD">;
+                    unit: z.ZodLiteral<"resource_hour">;
+                    hourlyUsd: z.ZodString;
+                    service: z.ZodLiteral<"model_modification">;
+                }, z.core.$strict>;
+                billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+                startupBillable: z.ZodLiteral<true>;
+                postCompletionIdleBillable: z.ZodLiteral<false>;
+                minimumBillableSeconds: z.ZodLiteral<0>;
+                warmReuseSeconds: z.ZodLiteral<300>;
+            }, z.core.$strict>, z.ZodObject<{
+                appliedPrice: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                    version: z.ZodString;
+                    profileHash: z.ZodString;
+                    currency: z.ZodLiteral<"USD">;
+                    unit: z.ZodLiteral<"resource_hour">;
+                    hourlyUsd: z.ZodString;
+                    service: z.ZodLiteral<"model_modification">;
+                }, z.core.$strict>;
+                billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+                startupBillable: z.ZodLiteral<true>;
+                postCompletionIdleBillable: z.ZodLiteral<false>;
+                minimumBillableSeconds: z.ZodLiteral<0>;
+                schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v2">;
+                warmReuseSeconds: z.ZodLiteral<0>;
+            }, z.core.$strict>], "schemaVersion">>;
+            createdAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+        updatedAt: z.ZodISODateTime;
+        method: z.ZodLiteral<"weight_space_programming">;
+        session: z.ZodNullable<z.ZodObject<{
+            revision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            historyHash: z.ZodString;
+            phase: z.ZodEnum<{
+                busy: "busy";
+                closed: "closed";
+                finalizing: "finalizing";
+                ready: "ready";
+                starting: "starting";
+            }>;
+            pendingOperationId: z.ZodNullable<z.ZodString>;
+            lastActivityAt: z.ZodISODateTime;
+            finalization: z.ZodNullable<z.ZodObject<{
+                operationId: z.ZodString;
+                resultHash: z.ZodString;
+                historyHashBefore: z.ZodString;
+                status: z.ZodEnum<{
+                    rejected: "rejected";
+                    succeeded: "succeeded";
+                }>;
+            }, z.core.$strict>>;
+            usage: z.ZodObject<{
+                commands: z.ZodNumber;
+                candidates: z.ZodNumber;
+                arithmeticWork: z.ZodNumber;
+                forwardTokenWork: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export declare const WeightSpaceCommandReceiptContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceCommandReceipt.v1">;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    command: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        teamId: z.ZodString;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        action: z.ZodLiteral<"catalog">;
+        offset: z.ZodNumber;
+        limit: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        layer: z.ZodNumber;
+        columns: z.ZodArray<z.ZodNumber>;
+        teamId: z.ZodString;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        action: z.ZodLiteral<"inspect">;
+    }, z.core.$strict>, z.ZodObject<{
+        teamId: z.ZodString;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        action: z.ZodLiteral<"program">;
+        program: z.ZodObject<{
+            instructions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"read_tensor">;
+                out: z.ZodString;
+                name: z.ZodString;
+                source: z.ZodEnum<{
+                    base: "base";
+                    candidate: "candidate";
+                }>;
+                ranges: z.ZodArray<z.ZodObject<{
+                    start: z.ZodNumber;
+                    stop: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                layer: z.ZodNumber;
+                columns: z.ZodArray<z.ZodNumber>;
+                op: z.ZodLiteral<"read">;
+                out: z.ZodString;
+                source: z.ZodEnum<{
+                    base: "base";
+                    candidate: "candidate";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodLiteral<"literal">;
+                out: z.ZodString;
+                shape: z.ZodArray<z.ZodNumber>;
+                values: z.ZodArray<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodLiteral<"scale">;
+                out: z.ZodString;
+                input: z.ZodString;
+                factor: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodEnum<{
+                    add: "add";
+                    matmul: "matmul";
+                    subtract: "subtract";
+                }>;
+                out: z.ZodString;
+                left: z.ZodString;
+                right: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodEnum<{
+                    mean_columns: "mean_columns";
+                    normalize_columns: "normalize_columns";
+                    singular_vectors: "singular_vectors";
+                    transpose: "transpose";
+                }>;
+                out: z.ZodString;
+                input: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodLiteral<"slice">;
+                out: z.ZodString;
+                input: z.ZodString;
+                axis: z.ZodNumber;
+                start: z.ZodNumber;
+                stop: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                layer: z.ZodNumber;
+                columns: z.ZodArray<z.ZodNumber>;
+                op: z.ZodLiteral<"write">;
+                input: z.ZodString;
+            }, z.core.$strict>], "op">>;
+            returns: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        hypothesis: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        teamId: z.ZodString;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        action: z.ZodLiteral<"code">;
+        code: z.ZodString;
+        hypothesis: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        teamId: z.ZodString;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        action: z.ZodLiteral<"evaluate">;
+        panelId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        teamId: z.ZodString;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        action: z.ZodLiteral<"select">;
+        targetCandidateHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        teamId: z.ZodString;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        action: z.ZodLiteral<"finalize">;
+    }, z.core.$strict>], "action">;
+    requestHash: z.ZodString;
+    state: z.ZodEnum<{
+        completed: "completed";
+        queued: "queued";
+    }>;
+    result: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.weightSpaceCommandResult.v1">;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        requestHash: z.ZodString;
+        revision: z.ZodNumber;
+        parentCandidateHash: z.ZodString;
+        candidateHash: z.ZodString;
+        changedColumns: z.ZodArray<z.ZodObject<{
+            layer: z.ZodNumber;
+            columns: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>>;
+        status: z.ZodEnum<{
+            rejected: "rejected";
+            succeeded: "succeeded";
+        }>;
+        code: z.ZodNullable<z.ZodString>;
+        catalog: z.ZodNullable<z.ZodObject<{
+            items: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                shape: z.ZodArray<z.ZodNumber>;
+                dtype: z.ZodLiteral<"BF16">;
+                editable: z.ZodBoolean;
+            }, z.core.$strict>>;
+            nextOffset: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>>;
+        tensors: z.ZodRecord<z.ZodString, z.ZodObject<{
+            shape: z.ZodArray<z.ZodNumber>;
+            minimum: z.ZodNumber;
+            maximum: z.ZodNumber;
+            mean: z.ZodNumber;
+            norm: z.ZodNumber;
+            values: z.ZodArray<z.ZodNumber>;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        evaluation: z.ZodNullable<z.ZodObject<{
+            panelId: z.ZodString;
+            role: z.ZodEnum<{
+                development: "development";
+                preservation: "preservation";
+            }>;
+            candidateHash: z.ZodString;
+            sampling: z.ZodLiteral<"greedy_v1">;
+            seed: z.ZodNumber;
+            rows: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                inputHash: z.ZodString;
+                outputIds: z.ZodArray<z.ZodNumber>;
+                outputText: z.ZodString;
+                reachedTokenLimit: z.ZodBoolean;
+                forwardTokenWork: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        finalEvaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            panelId: z.ZodString;
+            candidateHash: z.ZodString;
+            sampling: z.ZodLiteral<"greedy_v1">;
+            seed: z.ZodNumber;
+            rows: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                inputHash: z.ZodString;
+                outputIds: z.ZodArray<z.ZodNumber>;
+                outputText: z.ZodString;
+                reachedTokenLimit: z.ZodBoolean;
+                forwardTokenWork: z.ZodNumber;
+            }, z.core.$strict>>;
+            role: z.ZodLiteral<"frozen">;
+            source: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            baseline: z.ZodObject<{
+                candidateHash: z.ZodString;
+                rows: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    inputHash: z.ZodString;
+                    outputIds: z.ZodArray<z.ZodNumber>;
+                    outputText: z.ZodString;
+                    reachedTokenLimit: z.ZodBoolean;
+                    forwardTokenWork: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>>;
+        usage: z.ZodObject<{
+            commands: z.ZodNumber;
+            candidates: z.ZodNumber;
+            arithmeticWork: z.ZodNumber;
+            forwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const WeightSpaceCommandReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceCommandReceipt.v1">;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    command: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        teamId: z.ZodString;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        action: z.ZodLiteral<"catalog">;
+        offset: z.ZodNumber;
+        limit: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        layer: z.ZodNumber;
+        columns: z.ZodArray<z.ZodNumber>;
+        teamId: z.ZodString;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        action: z.ZodLiteral<"inspect">;
+    }, z.core.$strict>, z.ZodObject<{
+        teamId: z.ZodString;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        action: z.ZodLiteral<"program">;
+        program: z.ZodObject<{
+            instructions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"read_tensor">;
+                out: z.ZodString;
+                name: z.ZodString;
+                source: z.ZodEnum<{
+                    base: "base";
+                    candidate: "candidate";
+                }>;
+                ranges: z.ZodArray<z.ZodObject<{
+                    start: z.ZodNumber;
+                    stop: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                layer: z.ZodNumber;
+                columns: z.ZodArray<z.ZodNumber>;
+                op: z.ZodLiteral<"read">;
+                out: z.ZodString;
+                source: z.ZodEnum<{
+                    base: "base";
+                    candidate: "candidate";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodLiteral<"literal">;
+                out: z.ZodString;
+                shape: z.ZodArray<z.ZodNumber>;
+                values: z.ZodArray<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodLiteral<"scale">;
+                out: z.ZodString;
+                input: z.ZodString;
+                factor: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodEnum<{
+                    add: "add";
+                    matmul: "matmul";
+                    subtract: "subtract";
+                }>;
+                out: z.ZodString;
+                left: z.ZodString;
+                right: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodEnum<{
+                    mean_columns: "mean_columns";
+                    normalize_columns: "normalize_columns";
+                    singular_vectors: "singular_vectors";
+                    transpose: "transpose";
+                }>;
+                out: z.ZodString;
+                input: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodLiteral<"slice">;
+                out: z.ZodString;
+                input: z.ZodString;
+                axis: z.ZodNumber;
+                start: z.ZodNumber;
+                stop: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                layer: z.ZodNumber;
+                columns: z.ZodArray<z.ZodNumber>;
+                op: z.ZodLiteral<"write">;
+                input: z.ZodString;
+            }, z.core.$strict>], "op">>;
+            returns: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        hypothesis: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        teamId: z.ZodString;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        action: z.ZodLiteral<"code">;
+        code: z.ZodString;
+        hypothesis: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        teamId: z.ZodString;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        action: z.ZodLiteral<"evaluate">;
+        panelId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        teamId: z.ZodString;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        action: z.ZodLiteral<"select">;
+        targetCandidateHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        teamId: z.ZodString;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        candidateHash: z.ZodString;
+        action: z.ZodLiteral<"finalize">;
+    }, z.core.$strict>], "action">;
+    requestHash: z.ZodString;
+    state: z.ZodEnum<{
+        completed: "completed";
+        queued: "queued";
+    }>;
+    result: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.weightSpaceCommandResult.v1">;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        requestHash: z.ZodString;
+        revision: z.ZodNumber;
+        parentCandidateHash: z.ZodString;
+        candidateHash: z.ZodString;
+        changedColumns: z.ZodArray<z.ZodObject<{
+            layer: z.ZodNumber;
+            columns: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>>;
+        status: z.ZodEnum<{
+            rejected: "rejected";
+            succeeded: "succeeded";
+        }>;
+        code: z.ZodNullable<z.ZodString>;
+        catalog: z.ZodNullable<z.ZodObject<{
+            items: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                shape: z.ZodArray<z.ZodNumber>;
+                dtype: z.ZodLiteral<"BF16">;
+                editable: z.ZodBoolean;
+            }, z.core.$strict>>;
+            nextOffset: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>>;
+        tensors: z.ZodRecord<z.ZodString, z.ZodObject<{
+            shape: z.ZodArray<z.ZodNumber>;
+            minimum: z.ZodNumber;
+            maximum: z.ZodNumber;
+            mean: z.ZodNumber;
+            norm: z.ZodNumber;
+            values: z.ZodArray<z.ZodNumber>;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        evaluation: z.ZodNullable<z.ZodObject<{
+            panelId: z.ZodString;
+            role: z.ZodEnum<{
+                development: "development";
+                preservation: "preservation";
+            }>;
+            candidateHash: z.ZodString;
+            sampling: z.ZodLiteral<"greedy_v1">;
+            seed: z.ZodNumber;
+            rows: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                inputHash: z.ZodString;
+                outputIds: z.ZodArray<z.ZodNumber>;
+                outputText: z.ZodString;
+                reachedTokenLimit: z.ZodBoolean;
+                forwardTokenWork: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        finalEvaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            panelId: z.ZodString;
+            candidateHash: z.ZodString;
+            sampling: z.ZodLiteral<"greedy_v1">;
+            seed: z.ZodNumber;
+            rows: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                inputHash: z.ZodString;
+                outputIds: z.ZodArray<z.ZodNumber>;
+                outputText: z.ZodString;
+                reachedTokenLimit: z.ZodBoolean;
+                forwardTokenWork: z.ZodNumber;
+            }, z.core.$strict>>;
+            role: z.ZodLiteral<"frozen">;
+            source: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            baseline: z.ZodObject<{
+                candidateHash: z.ZodString;
+                rows: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    inputHash: z.ZodString;
+                    outputIds: z.ZodArray<z.ZodNumber>;
+                    outputText: z.ZodString;
+                    reachedTokenLimit: z.ZodBoolean;
+                    forwardTokenWork: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>>;
+        usage: z.ZodObject<{
+            commands: z.ZodNumber;
+            candidates: z.ZodNumber;
+            arithmeticWork: z.ZodNumber;
+            forwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export declare const WeightSpaceExecutionListQuerySchema: z.ZodObject<{
+    method: z.ZodDefault<z.ZodLiteral<"weight_space_programming">>;
+    projectId: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    phase: z.ZodOptional<z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        dispatching: "dispatching";
+        failed: "failed";
+        prepared: "prepared";
+        queued: "queued";
+        stopping: "stopping";
+    }>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const WeightSpaceExecutionPageContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceExecutionPage.v1">;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    query: z.ZodObject<{
+        method: z.ZodDefault<z.ZodLiteral<"weight_space_programming">>;
+        projectId: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+        phase: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            dispatching: "dispatching";
+            failed: "failed";
+            prepared: "prepared";
+            queued: "queued";
+            stopping: "stopping";
+        }>>;
+        cursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            dispatching: "dispatching";
+            failed: "failed";
+            prepared: "prepared";
+            queued: "queued";
+            stopping: "stopping";
+        }>;
+        revision: z.ZodNumber;
+        sourceContentHash: z.ZodString;
+        plan: z.ZodObject<{
+            contentHash: z.ZodString;
+            inputHash: z.ZodString;
+            runtimeHash: z.ZodString;
+            maximumSpendUsd: z.ZodNullable<z.ZodString>;
+            computePrice: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v1">;
+                appliedPrice: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                    version: z.ZodString;
+                    profileHash: z.ZodString;
+                    currency: z.ZodLiteral<"USD">;
+                    unit: z.ZodLiteral<"resource_hour">;
+                    hourlyUsd: z.ZodString;
+                    service: z.ZodLiteral<"model_modification">;
+                }, z.core.$strict>;
+                billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+                startupBillable: z.ZodLiteral<true>;
+                postCompletionIdleBillable: z.ZodLiteral<false>;
+                minimumBillableSeconds: z.ZodLiteral<0>;
+                warmReuseSeconds: z.ZodLiteral<300>;
+            }, z.core.$strict>, z.ZodObject<{
+                appliedPrice: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                    version: z.ZodString;
+                    profileHash: z.ZodString;
+                    currency: z.ZodLiteral<"USD">;
+                    unit: z.ZodLiteral<"resource_hour">;
+                    hourlyUsd: z.ZodString;
+                    service: z.ZodLiteral<"model_modification">;
+                }, z.core.$strict>;
+                billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+                startupBillable: z.ZodLiteral<true>;
+                postCompletionIdleBillable: z.ZodLiteral<false>;
+                minimumBillableSeconds: z.ZodLiteral<0>;
+                schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v2">;
+                warmReuseSeconds: z.ZodLiteral<0>;
+            }, z.core.$strict>], "schemaVersion">>;
+            createdAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+        updatedAt: z.ZodISODateTime;
+        method: z.ZodLiteral<"weight_space_programming">;
+        session: z.ZodNullable<z.ZodObject<{
+            revision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            historyHash: z.ZodString;
+            phase: z.ZodEnum<{
+                busy: "busy";
+                closed: "closed";
+                finalizing: "finalizing";
+                ready: "ready";
+                starting: "starting";
+            }>;
+            pendingOperationId: z.ZodNullable<z.ZodString>;
+            lastActivityAt: z.ZodISODateTime;
+            finalization: z.ZodNullable<z.ZodObject<{
+                operationId: z.ZodString;
+                resultHash: z.ZodString;
+                historyHashBefore: z.ZodString;
+                status: z.ZodEnum<{
+                    rejected: "rejected";
+                    succeeded: "succeeded";
+                }>;
+            }, z.core.$strict>>;
+            usage: z.ZodObject<{
+                commands: z.ZodNumber;
+                candidates: z.ZodNumber;
+                arithmeticWork: z.ZodNumber;
+                forwardTokenWork: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        model: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodString;
+            configHash: z.ZodString;
+            weightsHash: z.ZodString;
+            tokenizerHash: z.ZodString;
+            weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+            architecture: z.ZodLiteral<"dense_decoder">;
+            dtype: z.ZodEnum<{
+                bfloat16: "bfloat16";
+                float16: "float16";
+                float32: "float32";
+            }>;
+            quantization: z.ZodLiteral<"none">;
+            adapter: z.ZodNull;
+            hiddenSize: z.ZodNumber;
+            intermediateSizes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const WeightSpaceExecutionPageSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceExecutionPage.v1">;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    query: z.ZodObject<{
+        method: z.ZodDefault<z.ZodLiteral<"weight_space_programming">>;
+        projectId: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+        phase: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            dispatching: "dispatching";
+            failed: "failed";
+            prepared: "prepared";
+            queued: "queued";
+            stopping: "stopping";
+        }>>;
+        cursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            dispatching: "dispatching";
+            failed: "failed";
+            prepared: "prepared";
+            queued: "queued";
+            stopping: "stopping";
+        }>;
+        revision: z.ZodNumber;
+        sourceContentHash: z.ZodString;
+        plan: z.ZodObject<{
+            contentHash: z.ZodString;
+            inputHash: z.ZodString;
+            runtimeHash: z.ZodString;
+            maximumSpendUsd: z.ZodNullable<z.ZodString>;
+            computePrice: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v1">;
+                appliedPrice: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                    version: z.ZodString;
+                    profileHash: z.ZodString;
+                    currency: z.ZodLiteral<"USD">;
+                    unit: z.ZodLiteral<"resource_hour">;
+                    hourlyUsd: z.ZodString;
+                    service: z.ZodLiteral<"model_modification">;
+                }, z.core.$strict>;
+                billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+                startupBillable: z.ZodLiteral<true>;
+                postCompletionIdleBillable: z.ZodLiteral<false>;
+                minimumBillableSeconds: z.ZodLiteral<0>;
+                warmReuseSeconds: z.ZodLiteral<300>;
+            }, z.core.$strict>, z.ZodObject<{
+                appliedPrice: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                    version: z.ZodString;
+                    profileHash: z.ZodString;
+                    currency: z.ZodLiteral<"USD">;
+                    unit: z.ZodLiteral<"resource_hour">;
+                    hourlyUsd: z.ZodString;
+                    service: z.ZodLiteral<"model_modification">;
+                }, z.core.$strict>;
+                billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+                startupBillable: z.ZodLiteral<true>;
+                postCompletionIdleBillable: z.ZodLiteral<false>;
+                minimumBillableSeconds: z.ZodLiteral<0>;
+                schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v2">;
+                warmReuseSeconds: z.ZodLiteral<0>;
+            }, z.core.$strict>], "schemaVersion">>;
+            createdAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+        updatedAt: z.ZodISODateTime;
+        method: z.ZodLiteral<"weight_space_programming">;
+        session: z.ZodNullable<z.ZodObject<{
+            revision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            historyHash: z.ZodString;
+            phase: z.ZodEnum<{
+                busy: "busy";
+                closed: "closed";
+                finalizing: "finalizing";
+                ready: "ready";
+                starting: "starting";
+            }>;
+            pendingOperationId: z.ZodNullable<z.ZodString>;
+            lastActivityAt: z.ZodISODateTime;
+            finalization: z.ZodNullable<z.ZodObject<{
+                operationId: z.ZodString;
+                resultHash: z.ZodString;
+                historyHashBefore: z.ZodString;
+                status: z.ZodEnum<{
+                    rejected: "rejected";
+                    succeeded: "succeeded";
+                }>;
+            }, z.core.$strict>>;
+            usage: z.ZodObject<{
+                commands: z.ZodNumber;
+                candidates: z.ZodNumber;
+                arithmeticWork: z.ZodNumber;
+                forwardTokenWork: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        model: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodString;
+            configHash: z.ZodString;
+            weightsHash: z.ZodString;
+            tokenizerHash: z.ZodString;
+            weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+            architecture: z.ZodLiteral<"dense_decoder">;
+            dtype: z.ZodEnum<{
+                bfloat16: "bfloat16";
+                float16: "float16";
+                float32: "float32";
+            }>;
+            quantization: z.ZodLiteral<"none">;
+            adapter: z.ZodNull;
+            hiddenSize: z.ZodNumber;
+            intermediateSizes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type WeightSpaceExecutionPage = z.infer<typeof WeightSpaceExecutionPageSchema>;
+export declare const WeightSpaceCommandListQuerySchema: z.ZodObject<{
+    afterRevision: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const WeightSpaceCommandPageContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceCommandPage.v1">;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    sessionId: z.ZodString;
+    query: z.ZodObject<{
+        afterRevision: z.ZodDefault<z.ZodNumber>;
+        limit: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    items: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.weightSpaceCommandReceipt.v1">;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        command: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            teamId: z.ZodString;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            expectedRevision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            action: z.ZodLiteral<"catalog">;
+            offset: z.ZodNumber;
+            limit: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            layer: z.ZodNumber;
+            columns: z.ZodArray<z.ZodNumber>;
+            teamId: z.ZodString;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            expectedRevision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            action: z.ZodLiteral<"inspect">;
+        }, z.core.$strict>, z.ZodObject<{
+            teamId: z.ZodString;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            expectedRevision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            action: z.ZodLiteral<"program">;
+            program: z.ZodObject<{
+                instructions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    op: z.ZodLiteral<"read_tensor">;
+                    out: z.ZodString;
+                    name: z.ZodString;
+                    source: z.ZodEnum<{
+                        base: "base";
+                        candidate: "candidate";
+                    }>;
+                    ranges: z.ZodArray<z.ZodObject<{
+                        start: z.ZodNumber;
+                        stop: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    layer: z.ZodNumber;
+                    columns: z.ZodArray<z.ZodNumber>;
+                    op: z.ZodLiteral<"read">;
+                    out: z.ZodString;
+                    source: z.ZodEnum<{
+                        base: "base";
+                        candidate: "candidate";
+                    }>;
+                }, z.core.$strict>, z.ZodObject<{
+                    op: z.ZodLiteral<"literal">;
+                    out: z.ZodString;
+                    shape: z.ZodArray<z.ZodNumber>;
+                    values: z.ZodArray<z.ZodNumber>;
+                }, z.core.$strict>, z.ZodObject<{
+                    op: z.ZodLiteral<"scale">;
+                    out: z.ZodString;
+                    input: z.ZodString;
+                    factor: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    op: z.ZodEnum<{
+                        add: "add";
+                        matmul: "matmul";
+                        subtract: "subtract";
+                    }>;
+                    out: z.ZodString;
+                    left: z.ZodString;
+                    right: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    op: z.ZodEnum<{
+                        mean_columns: "mean_columns";
+                        normalize_columns: "normalize_columns";
+                        singular_vectors: "singular_vectors";
+                        transpose: "transpose";
+                    }>;
+                    out: z.ZodString;
+                    input: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    op: z.ZodLiteral<"slice">;
+                    out: z.ZodString;
+                    input: z.ZodString;
+                    axis: z.ZodNumber;
+                    start: z.ZodNumber;
+                    stop: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    layer: z.ZodNumber;
+                    columns: z.ZodArray<z.ZodNumber>;
+                    op: z.ZodLiteral<"write">;
+                    input: z.ZodString;
+                }, z.core.$strict>], "op">>;
+                returns: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            hypothesis: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            teamId: z.ZodString;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            expectedRevision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            action: z.ZodLiteral<"code">;
+            code: z.ZodString;
+            hypothesis: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            teamId: z.ZodString;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            expectedRevision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            action: z.ZodLiteral<"evaluate">;
+            panelId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            teamId: z.ZodString;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            expectedRevision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            action: z.ZodLiteral<"select">;
+            targetCandidateHash: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            teamId: z.ZodString;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            expectedRevision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            action: z.ZodLiteral<"finalize">;
+        }, z.core.$strict>], "action">;
+        requestHash: z.ZodString;
+        state: z.ZodEnum<{
+            completed: "completed";
+            queued: "queued";
+        }>;
+        result: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.weightSpaceCommandResult.v1">;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            requestHash: z.ZodString;
+            revision: z.ZodNumber;
+            parentCandidateHash: z.ZodString;
+            candidateHash: z.ZodString;
+            changedColumns: z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                columns: z.ZodArray<z.ZodNumber>;
+            }, z.core.$strict>>;
+            status: z.ZodEnum<{
+                rejected: "rejected";
+                succeeded: "succeeded";
+            }>;
+            code: z.ZodNullable<z.ZodString>;
+            catalog: z.ZodNullable<z.ZodObject<{
+                items: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    shape: z.ZodArray<z.ZodNumber>;
+                    dtype: z.ZodLiteral<"BF16">;
+                    editable: z.ZodBoolean;
+                }, z.core.$strict>>;
+                nextOffset: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            tensors: z.ZodRecord<z.ZodString, z.ZodObject<{
+                shape: z.ZodArray<z.ZodNumber>;
+                minimum: z.ZodNumber;
+                maximum: z.ZodNumber;
+                mean: z.ZodNumber;
+                norm: z.ZodNumber;
+                values: z.ZodArray<z.ZodNumber>;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            evaluation: z.ZodNullable<z.ZodObject<{
+                panelId: z.ZodString;
+                role: z.ZodEnum<{
+                    development: "development";
+                    preservation: "preservation";
+                }>;
+                candidateHash: z.ZodString;
+                sampling: z.ZodLiteral<"greedy_v1">;
+                seed: z.ZodNumber;
+                rows: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    inputHash: z.ZodString;
+                    outputIds: z.ZodArray<z.ZodNumber>;
+                    outputText: z.ZodString;
+                    reachedTokenLimit: z.ZodBoolean;
+                    forwardTokenWork: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            finalEvaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                panelId: z.ZodString;
+                candidateHash: z.ZodString;
+                sampling: z.ZodLiteral<"greedy_v1">;
+                seed: z.ZodNumber;
+                rows: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    inputHash: z.ZodString;
+                    outputIds: z.ZodArray<z.ZodNumber>;
+                    outputText: z.ZodString;
+                    reachedTokenLimit: z.ZodBoolean;
+                    forwardTokenWork: z.ZodNumber;
+                }, z.core.$strict>>;
+                role: z.ZodLiteral<"frozen">;
+                source: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                baseline: z.ZodObject<{
+                    candidateHash: z.ZodString;
+                    rows: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        inputHash: z.ZodString;
+                        outputIds: z.ZodArray<z.ZodNumber>;
+                        outputText: z.ZodString;
+                        reachedTokenLimit: z.ZodBoolean;
+                        forwardTokenWork: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+            usage: z.ZodObject<{
+                commands: z.ZodNumber;
+                candidates: z.ZodNumber;
+                arithmeticWork: z.ZodNumber;
+                forwardTokenWork: z.ZodNumber;
+            }, z.core.$strict>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    nextAfterRevision: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const WeightSpaceCommandPageSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceCommandPage.v1">;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    sessionId: z.ZodString;
+    query: z.ZodObject<{
+        afterRevision: z.ZodDefault<z.ZodNumber>;
+        limit: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    items: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.weightSpaceCommandReceipt.v1">;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        command: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            teamId: z.ZodString;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            expectedRevision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            action: z.ZodLiteral<"catalog">;
+            offset: z.ZodNumber;
+            limit: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            layer: z.ZodNumber;
+            columns: z.ZodArray<z.ZodNumber>;
+            teamId: z.ZodString;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            expectedRevision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            action: z.ZodLiteral<"inspect">;
+        }, z.core.$strict>, z.ZodObject<{
+            teamId: z.ZodString;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            expectedRevision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            action: z.ZodLiteral<"program">;
+            program: z.ZodObject<{
+                instructions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    op: z.ZodLiteral<"read_tensor">;
+                    out: z.ZodString;
+                    name: z.ZodString;
+                    source: z.ZodEnum<{
+                        base: "base";
+                        candidate: "candidate";
+                    }>;
+                    ranges: z.ZodArray<z.ZodObject<{
+                        start: z.ZodNumber;
+                        stop: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    layer: z.ZodNumber;
+                    columns: z.ZodArray<z.ZodNumber>;
+                    op: z.ZodLiteral<"read">;
+                    out: z.ZodString;
+                    source: z.ZodEnum<{
+                        base: "base";
+                        candidate: "candidate";
+                    }>;
+                }, z.core.$strict>, z.ZodObject<{
+                    op: z.ZodLiteral<"literal">;
+                    out: z.ZodString;
+                    shape: z.ZodArray<z.ZodNumber>;
+                    values: z.ZodArray<z.ZodNumber>;
+                }, z.core.$strict>, z.ZodObject<{
+                    op: z.ZodLiteral<"scale">;
+                    out: z.ZodString;
+                    input: z.ZodString;
+                    factor: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    op: z.ZodEnum<{
+                        add: "add";
+                        matmul: "matmul";
+                        subtract: "subtract";
+                    }>;
+                    out: z.ZodString;
+                    left: z.ZodString;
+                    right: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    op: z.ZodEnum<{
+                        mean_columns: "mean_columns";
+                        normalize_columns: "normalize_columns";
+                        singular_vectors: "singular_vectors";
+                        transpose: "transpose";
+                    }>;
+                    out: z.ZodString;
+                    input: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    op: z.ZodLiteral<"slice">;
+                    out: z.ZodString;
+                    input: z.ZodString;
+                    axis: z.ZodNumber;
+                    start: z.ZodNumber;
+                    stop: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    layer: z.ZodNumber;
+                    columns: z.ZodArray<z.ZodNumber>;
+                    op: z.ZodLiteral<"write">;
+                    input: z.ZodString;
+                }, z.core.$strict>], "op">>;
+                returns: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            hypothesis: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            teamId: z.ZodString;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            expectedRevision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            action: z.ZodLiteral<"code">;
+            code: z.ZodString;
+            hypothesis: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            teamId: z.ZodString;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            expectedRevision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            action: z.ZodLiteral<"evaluate">;
+            panelId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            teamId: z.ZodString;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            expectedRevision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            action: z.ZodLiteral<"select">;
+            targetCandidateHash: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            teamId: z.ZodString;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            expectedRevision: z.ZodNumber;
+            candidateHash: z.ZodString;
+            action: z.ZodLiteral<"finalize">;
+        }, z.core.$strict>], "action">;
+        requestHash: z.ZodString;
+        state: z.ZodEnum<{
+            completed: "completed";
+            queued: "queued";
+        }>;
+        result: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.weightSpaceCommandResult.v1">;
+            sessionId: z.ZodString;
+            operationId: z.ZodString;
+            requestHash: z.ZodString;
+            revision: z.ZodNumber;
+            parentCandidateHash: z.ZodString;
+            candidateHash: z.ZodString;
+            changedColumns: z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                columns: z.ZodArray<z.ZodNumber>;
+            }, z.core.$strict>>;
+            status: z.ZodEnum<{
+                rejected: "rejected";
+                succeeded: "succeeded";
+            }>;
+            code: z.ZodNullable<z.ZodString>;
+            catalog: z.ZodNullable<z.ZodObject<{
+                items: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    shape: z.ZodArray<z.ZodNumber>;
+                    dtype: z.ZodLiteral<"BF16">;
+                    editable: z.ZodBoolean;
+                }, z.core.$strict>>;
+                nextOffset: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            tensors: z.ZodRecord<z.ZodString, z.ZodObject<{
+                shape: z.ZodArray<z.ZodNumber>;
+                minimum: z.ZodNumber;
+                maximum: z.ZodNumber;
+                mean: z.ZodNumber;
+                norm: z.ZodNumber;
+                values: z.ZodArray<z.ZodNumber>;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+            evaluation: z.ZodNullable<z.ZodObject<{
+                panelId: z.ZodString;
+                role: z.ZodEnum<{
+                    development: "development";
+                    preservation: "preservation";
+                }>;
+                candidateHash: z.ZodString;
+                sampling: z.ZodLiteral<"greedy_v1">;
+                seed: z.ZodNumber;
+                rows: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    inputHash: z.ZodString;
+                    outputIds: z.ZodArray<z.ZodNumber>;
+                    outputText: z.ZodString;
+                    reachedTokenLimit: z.ZodBoolean;
+                    forwardTokenWork: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            finalEvaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                panelId: z.ZodString;
+                candidateHash: z.ZodString;
+                sampling: z.ZodLiteral<"greedy_v1">;
+                seed: z.ZodNumber;
+                rows: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    inputHash: z.ZodString;
+                    outputIds: z.ZodArray<z.ZodNumber>;
+                    outputText: z.ZodString;
+                    reachedTokenLimit: z.ZodBoolean;
+                    forwardTokenWork: z.ZodNumber;
+                }, z.core.$strict>>;
+                role: z.ZodLiteral<"frozen">;
+                source: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                baseline: z.ZodObject<{
+                    candidateHash: z.ZodString;
+                    rows: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        inputHash: z.ZodString;
+                        outputIds: z.ZodArray<z.ZodNumber>;
+                        outputText: z.ZodString;
+                        reachedTokenLimit: z.ZodBoolean;
+                        forwardTokenWork: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+            usage: z.ZodObject<{
+                commands: z.ZodNumber;
+                candidates: z.ZodNumber;
+                arithmeticWork: z.ZodNumber;
+                forwardTokenWork: z.ZodNumber;
+            }, z.core.$strict>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    nextAfterRevision: z.ZodNullable<z.ZodNumber>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export declare function parseAndVerifyWeightSpaceCommandPage(raw: unknown, expected: {
+    teamId: string;
+    sessionId: string;
+    query: z.infer<typeof WeightSpaceCommandListQuerySchema>;
+}): Promise<{
+    schemaVersion: "openpond.weightSpaceCommandPage.v1";
+    teamId: string;
+    ownerUserId: string;
+    sessionId: string;
+    query: {
+        afterRevision: number;
+        limit: number;
+    };
+    items: {
+        schemaVersion: "openpond.weightSpaceCommandReceipt.v1";
+        teamId: string;
+        ownerUserId: string;
+        command: {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "catalog";
+            offset: number;
+            limit: number;
+        } | {
+            layer: number;
+            columns: number[];
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "inspect";
+        } | {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "program";
+            program: {
+                instructions: ({
+                    op: "read_tensor";
+                    out: string;
+                    name: string;
+                    source: "base" | "candidate";
+                    ranges: {
+                        start: number;
+                        stop: number;
+                    }[];
+                } | {
+                    layer: number;
+                    columns: number[];
+                    op: "read";
+                    out: string;
+                    source: "base" | "candidate";
+                } | {
+                    op: "literal";
+                    out: string;
+                    shape: number[];
+                    values: number[];
+                } | {
+                    op: "scale";
+                    out: string;
+                    input: string;
+                    factor: number;
+                } | {
+                    op: "add" | "matmul" | "subtract";
+                    out: string;
+                    left: string;
+                    right: string;
+                } | {
+                    op: "mean_columns" | "normalize_columns" | "singular_vectors" | "transpose";
+                    out: string;
+                    input: string;
+                } | {
+                    op: "slice";
+                    out: string;
+                    input: string;
+                    axis: number;
+                    start: number;
+                    stop: number;
+                } | {
+                    layer: number;
+                    columns: number[];
+                    op: "write";
+                    input: string;
+                })[];
+                returns: string[];
+            };
+            hypothesis: string;
+        } | {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "code";
+            code: string;
+            hypothesis: string;
+        } | {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "evaluate";
+            panelId: string;
+        } | {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "select";
+            targetCandidateHash: string;
+        } | {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "finalize";
+        };
+        requestHash: string;
+        state: "completed" | "queued";
+        result: {
+            schemaVersion: "openpond.weightSpaceCommandResult.v1";
+            sessionId: string;
+            operationId: string;
+            requestHash: string;
+            revision: number;
+            parentCandidateHash: string;
+            candidateHash: string;
+            changedColumns: {
+                layer: number;
+                columns: number[];
+            }[];
+            status: "rejected" | "succeeded";
+            code: string | null;
+            catalog: {
+                items: {
+                    name: string;
+                    shape: number[];
+                    dtype: "BF16";
+                    editable: boolean;
+                }[];
+                nextOffset: number | null;
+            } | null;
+            tensors: Record<string, {
+                shape: number[];
+                minimum: number;
+                maximum: number;
+                mean: number;
+                norm: number;
+                values: number[];
+                truncated: boolean;
+            }>;
+            evaluation: {
+                panelId: string;
+                role: "development" | "preservation";
+                candidateHash: string;
+                sampling: "greedy_v1";
+                seed: number;
+                rows: {
+                    id: string;
+                    inputHash: string;
+                    outputIds: number[];
+                    outputText: string;
+                    reachedTokenLimit: boolean;
+                    forwardTokenWork: number;
+                }[];
+            } | null;
+            finalEvaluation?: {
+                panelId: string;
+                candidateHash: string;
+                sampling: "greedy_v1";
+                seed: number;
+                rows: {
+                    id: string;
+                    inputHash: string;
+                    outputIds: number[];
+                    outputText: string;
+                    reachedTokenLimit: boolean;
+                    forwardTokenWork: number;
+                }[];
+                role: "frozen";
+                source: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                baseline: {
+                    candidateHash: string;
+                    rows: {
+                        id: string;
+                        inputHash: string;
+                        outputIds: number[];
+                        outputText: string;
+                        reachedTokenLimit: boolean;
+                        forwardTokenWork: number;
+                    }[];
+                };
+            } | null | undefined;
+            usage: {
+                commands: number;
+                candidates: number;
+                arithmeticWork: number;
+                forwardTokenWork: number;
+            };
+            contentHash: string;
+        } | null;
+        contentHash: string;
+    }[];
+    nextAfterRevision: number | null;
+    contentHash: string;
+}>;
+export declare function parseAndVerifyWeightSpaceCapability(raw: unknown, query: z.infer<typeof ModelModificationCapabilitiesQuerySchema>, actorId?: string): Promise<{
+    schemaVersion: "openpond.weightSpaceCapability.v1";
+    teamId: string;
+    actorId: string;
+    query: {
+        teamId: string;
+        modelId: string;
+        source: "builtin" | "local" | "managed";
+        revision?: string | undefined;
+        tokenizerRevision?: string | undefined;
+        chatTemplateHash?: string | undefined;
+        modelAssetId?: string | undefined;
+    };
+    requestHash: string;
+    checkedAt: string;
+    expiresAt: string;
+    validationLevel: "gpu_qualified" | "source_validated" | null;
+    execution: {
+        state: "unavailable";
+        code: "model_not_supported" | "runtime_not_qualified";
+        reason: string;
+    } | {
+        state: "ready";
+        model: {
+            schemaVersion: "openpond.neuronSteeringModel.v1";
+            modelId: string;
+            revision: string;
+            configHash: string;
+            weightsHash: string;
+            tokenizerHash: string;
+            weightIdentity: "torch_state_dict_sha256_v1";
+            architecture: "dense_decoder";
+            dtype: "bfloat16" | "float16" | "float32";
+            quantization: "none";
+            adapter: null;
+            hiddenSize: number;
+            intermediateSizes: number[];
+        };
+        runtime: {
+            id: string;
+            releaseHash: string;
+            imageDigest: string;
+            requestSchema: "openpond.weightSpaceRequest.v1";
+            bootstrapClock?: {
+                schemaVersion: "openpond.weightSpaceQualifiedBootstrapClock.v1";
+                method: "weight_space_programming";
+                validationLevel: "gpu_qualified";
+                bootstrapSeconds: 900;
+                maximumWorkSeconds: number;
+                workClock: "native_command_issued";
+                cleanupSeconds: 120;
+                modelHash: string;
+                runtimeTemplateHash: string;
+                qualification: {
+                    id: string;
+                    contentHash: string;
+                };
+                source: {
+                    imageDigest: string;
+                    releaseHash: string;
+                    canonicalReleaseSha256: string;
+                    sourceTreeSha256: string;
+                    softwareInventorySha256: string;
+                    buildReceiptSha256: string;
+                    pythonSdkSha256: string;
+                };
+                contentHash: string;
+            } | undefined;
+            evidence: {
+                id: string;
+                contentHash: string;
+            };
+        };
+        limits: {
+            maximumDurationSeconds: number;
+            maximumIdleSeconds: number;
+            maximumCommands: number;
+            maximumCandidates: number;
+            maximumPatchColumns: number;
+            maximumTensorElements: number;
+            maximumReturnedValues: number;
+            maximumArithmeticWork: number;
+            maximumForwardTokenWork: number;
+            maximumCheckpointBytes: number;
+        };
+    };
+    contentHash: string;
+}>;
+export declare function parseAndVerifyWeightSpacePrepare(raw: unknown): Promise<{
+    teamId: string;
+    operationId: string;
+    projectId: string | null;
+    name: string;
+    method: "weight_space_programming";
+    query: {
+        teamId: string;
+        modelId: string;
+        source: "builtin" | "local" | "managed";
+        revision?: string | undefined;
+        tokenizerRevision?: string | undefined;
+        chatTemplateHash?: string | undefined;
+        modelAssetId?: string | undefined;
+    };
+    request: {
+        schemaVersion: "openpond.weightSpaceRequest.v1";
+        model: {
+            schemaVersion: "openpond.neuronSteeringModel.v1";
+            modelId: string;
+            revision: string;
+            configHash: string;
+            weightsHash: string;
+            tokenizerHash: string;
+            weightIdentity: "torch_state_dict_sha256_v1";
+            architecture: "dense_decoder";
+            dtype: "bfloat16" | "float16" | "float32";
+            quantization: "none";
+            adapter: null;
+            hiddenSize: number;
+            intermediateSizes: number[];
+        };
+        teacher: {
+            controller: "local_agent";
+            providerId: string;
+            modelId: string;
+            sessionId: string;
+        };
+        objective: string;
+        panels: {
+            id: string;
+            source: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null;
+            role: "development" | "preservation";
+            prompts: {
+                id: string;
+                text: string;
+                system?: string | undefined;
+            }[];
+        }[];
+        frozenEvaluation: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        generation: {
+            maxOutputTokens: number;
+            seed: number;
+            sampling: "greedy_v1";
+        };
+        limits: {
+            maximumDurationSeconds: number;
+            maximumIdleSeconds: number;
+            maximumCommands: number;
+            maximumCandidates: number;
+            maximumPatchColumns: number;
+            maximumTensorElements: number;
+            maximumReturnedValues: number;
+            maximumArithmeticWork: number;
+            maximumForwardTokenWork: number;
+            maximumCheckpointBytes: number;
+        };
+    };
+    maximumSpendUsd: string;
+    sourceForm?: undefined;
+}>;
+export declare function parseAndVerifyWeightSpaceExecution(raw: unknown, expected: {
+    teamId: string;
+    id: string;
+    ownerUserId?: string;
+}): Promise<{
+    id: string;
+    teamId: string;
+    ownerUserId: string;
+    projectId: string | null;
+    name: string;
+    phase: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping";
+    revision: number;
+    sourceContentHash: string;
+    plan: {
+        contentHash: string;
+        inputHash: string;
+        runtimeHash: string;
+        maximumSpendUsd: string | null;
+        computePrice?: {
+            schemaVersion: "openpond.modificationPrice.v1";
+            appliedPrice: {
+                schemaVersion: "openpond.computeAppliedPrice.v1";
+                version: string;
+                profileHash: string;
+                currency: "USD";
+                unit: "resource_hour";
+                hourlyUsd: string;
+                service: "model_modification";
+            };
+            billingBoundary: "active_allocation_until_verified_cleanup";
+            startupBillable: true;
+            postCompletionIdleBillable: false;
+            minimumBillableSeconds: 0;
+            warmReuseSeconds: 300;
+        } | {
+            appliedPrice: {
+                schemaVersion: "openpond.computeAppliedPrice.v1";
+                version: string;
+                profileHash: string;
+                currency: "USD";
+                unit: "resource_hour";
+                hourlyUsd: string;
+                service: "model_modification";
+            };
+            billingBoundary: "active_allocation_until_verified_cleanup";
+            startupBillable: true;
+            postCompletionIdleBillable: false;
+            minimumBillableSeconds: 0;
+            schemaVersion: "openpond.modificationPrice.v2";
+            warmReuseSeconds: 0;
+        } | undefined;
+        createdAt: string;
+        expiresAt: string;
+    };
+    updatedAt: string;
+    method: "weight_space_programming";
+    session: {
+        revision: number;
+        candidateHash: string;
+        historyHash: string;
+        phase: "busy" | "closed" | "finalizing" | "ready" | "starting";
+        pendingOperationId: string | null;
+        lastActivityAt: string;
+        finalization: {
+            operationId: string;
+            resultHash: string;
+            historyHashBefore: string;
+            status: "rejected" | "succeeded";
+        } | null;
+        usage: {
+            commands: number;
+            candidates: number;
+            arithmeticWork: number;
+            forwardTokenWork: number;
+        };
+    } | null;
+    schemaVersion: "openpond.weightSpaceExecution.v1";
+    request: {
+        schemaVersion: "openpond.weightSpaceRequest.v1";
+        model: {
+            schemaVersion: "openpond.neuronSteeringModel.v1";
+            modelId: string;
+            revision: string;
+            configHash: string;
+            weightsHash: string;
+            tokenizerHash: string;
+            weightIdentity: "torch_state_dict_sha256_v1";
+            architecture: "dense_decoder";
+            dtype: "bfloat16" | "float16" | "float32";
+            quantization: "none";
+            adapter: null;
+            hiddenSize: number;
+            intermediateSizes: number[];
+        };
+        teacher: {
+            controller: "local_agent";
+            providerId: string;
+            modelId: string;
+            sessionId: string;
+        };
+        objective: string;
+        panels: {
+            id: string;
+            source: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null;
+            role: "development" | "preservation";
+            prompts: {
+                id: string;
+                text: string;
+                system?: string | undefined;
+            }[];
+        }[];
+        frozenEvaluation: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        generation: {
+            maxOutputTokens: number;
+            seed: number;
+            sampling: "greedy_v1";
+        };
+        limits: {
+            maximumDurationSeconds: number;
+            maximumIdleSeconds: number;
+            maximumCommands: number;
+            maximumCandidates: number;
+            maximumPatchColumns: number;
+            maximumTensorElements: number;
+            maximumReturnedValues: number;
+            maximumArithmeticWork: number;
+            maximumForwardTokenWork: number;
+            maximumCheckpointBytes: number;
+        };
+    };
+    result: {
+        schemaVersion: "openpond.weightSpaceResult.v1";
+        inputHash: string;
+        runtimeHash: string;
+        candidateHash: string;
+        historyHash: string;
+        artifact: {
+            id: string;
+            contentHash: string;
+            manifest: {
+                schemaVersion: "openpond.weightSpaceArtifact.v1";
+                method: "weight_space_programming";
+                representation: "exact_bf16_mlp_column_replacements_v1";
+                model: {
+                    schemaVersion: "openpond.neuronSteeringModel.v1";
+                    modelId: string;
+                    revision: string;
+                    configHash: string;
+                    weightsHash: string;
+                    tokenizerHash: string;
+                    weightIdentity: "torch_state_dict_sha256_v1";
+                    architecture: "dense_decoder";
+                    dtype: "bfloat16" | "float16" | "float32";
+                    quantization: "none";
+                    adapter: null;
+                    hiddenSize: number;
+                    intermediateSizes: number[];
+                };
+                requestHash: string;
+                runtimeHash: string;
+                candidateHash: string;
+                teacher: {
+                    controller: "local_agent";
+                    providerId: string;
+                    modelId: string;
+                    sessionId: string;
+                };
+                historyHash: string;
+                columns: {
+                    layer: number;
+                    columns: number[];
+                }[];
+                columnHashes: string[];
+                payload: {
+                    path: "patch.safetensors";
+                    sha256: string;
+                    sizeBytes: number;
+                    tensors: {
+                        name: string;
+                        dtype: "BF16" | "I64";
+                        shape: number[];
+                    }[];
+                };
+                reload: {
+                    effectiveColumnsHash: string;
+                    reloadedColumnsHash: string;
+                    untouchedWeightsHashBefore: string;
+                    untouchedWeightsHashAfter: string;
+                    equivalent: true;
+                };
+                contentHash: string;
+            };
+            files: {
+                path: "manifest.json" | "patch.safetensors";
+                artifactId: string;
+                sha256: string;
+                sizeBytes: number;
+            }[];
+        };
+        commands: number;
+        candidates: number;
+        forwardTokenWork: number;
+        durationMs: number;
+        contentHash: string;
+    } | null;
+    resultRecordedAt: string | null;
+    contentHash: string;
+}>;
+export declare function parseAndVerifyWeightSpaceExecutionReceipt(raw: unknown, command: WeightSpacePrepare | z.infer<typeof ManagedModificationStartSchema> | z.infer<typeof ManagedModificationCancelSchema>): Promise<{
+    schemaVersion: "openpond.weightSpaceExecutionReceipt.v1";
+    operationId: string;
+    requestHash: string;
+    execution: {
+        id: string;
+        teamId: string;
+        ownerUserId: string;
+        projectId: string | null;
+        name: string;
+        phase: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping";
+        revision: number;
+        sourceContentHash: string;
+        plan: {
+            contentHash: string;
+            inputHash: string;
+            runtimeHash: string;
+            maximumSpendUsd: string | null;
+            computePrice?: {
+                schemaVersion: "openpond.modificationPrice.v1";
+                appliedPrice: {
+                    schemaVersion: "openpond.computeAppliedPrice.v1";
+                    version: string;
+                    profileHash: string;
+                    currency: "USD";
+                    unit: "resource_hour";
+                    hourlyUsd: string;
+                    service: "model_modification";
+                };
+                billingBoundary: "active_allocation_until_verified_cleanup";
+                startupBillable: true;
+                postCompletionIdleBillable: false;
+                minimumBillableSeconds: 0;
+                warmReuseSeconds: 300;
+            } | {
+                appliedPrice: {
+                    schemaVersion: "openpond.computeAppliedPrice.v1";
+                    version: string;
+                    profileHash: string;
+                    currency: "USD";
+                    unit: "resource_hour";
+                    hourlyUsd: string;
+                    service: "model_modification";
+                };
+                billingBoundary: "active_allocation_until_verified_cleanup";
+                startupBillable: true;
+                postCompletionIdleBillable: false;
+                minimumBillableSeconds: 0;
+                schemaVersion: "openpond.modificationPrice.v2";
+                warmReuseSeconds: 0;
+            } | undefined;
+            createdAt: string;
+            expiresAt: string;
+        };
+        updatedAt: string;
+        method: "weight_space_programming";
+        session: {
+            revision: number;
+            candidateHash: string;
+            historyHash: string;
+            phase: "busy" | "closed" | "finalizing" | "ready" | "starting";
+            pendingOperationId: string | null;
+            lastActivityAt: string;
+            finalization: {
+                operationId: string;
+                resultHash: string;
+                historyHashBefore: string;
+                status: "rejected" | "succeeded";
+            } | null;
+            usage: {
+                commands: number;
+                candidates: number;
+                arithmeticWork: number;
+                forwardTokenWork: number;
+            };
+        } | null;
+    };
+    contentHash: string;
+}>;
+export declare function parseAndVerifyWeightSpaceCommandReceipt(raw: unknown, command: WeightSpaceCommand): Promise<{
+    schemaVersion: "openpond.weightSpaceCommandReceipt.v1";
+    teamId: string;
+    ownerUserId: string;
+    command: {
+        teamId: string;
+        sessionId: string;
+        operationId: string;
+        expectedRevision: number;
+        candidateHash: string;
+        action: "catalog";
+        offset: number;
+        limit: number;
+    } | {
+        layer: number;
+        columns: number[];
+        teamId: string;
+        sessionId: string;
+        operationId: string;
+        expectedRevision: number;
+        candidateHash: string;
+        action: "inspect";
+    } | {
+        teamId: string;
+        sessionId: string;
+        operationId: string;
+        expectedRevision: number;
+        candidateHash: string;
+        action: "program";
+        program: {
+            instructions: ({
+                op: "read_tensor";
+                out: string;
+                name: string;
+                source: "base" | "candidate";
+                ranges: {
+                    start: number;
+                    stop: number;
+                }[];
+            } | {
+                layer: number;
+                columns: number[];
+                op: "read";
+                out: string;
+                source: "base" | "candidate";
+            } | {
+                op: "literal";
+                out: string;
+                shape: number[];
+                values: number[];
+            } | {
+                op: "scale";
+                out: string;
+                input: string;
+                factor: number;
+            } | {
+                op: "add" | "matmul" | "subtract";
+                out: string;
+                left: string;
+                right: string;
+            } | {
+                op: "mean_columns" | "normalize_columns" | "singular_vectors" | "transpose";
+                out: string;
+                input: string;
+            } | {
+                op: "slice";
+                out: string;
+                input: string;
+                axis: number;
+                start: number;
+                stop: number;
+            } | {
+                layer: number;
+                columns: number[];
+                op: "write";
+                input: string;
+            })[];
+            returns: string[];
+        };
+        hypothesis: string;
+    } | {
+        teamId: string;
+        sessionId: string;
+        operationId: string;
+        expectedRevision: number;
+        candidateHash: string;
+        action: "code";
+        code: string;
+        hypothesis: string;
+    } | {
+        teamId: string;
+        sessionId: string;
+        operationId: string;
+        expectedRevision: number;
+        candidateHash: string;
+        action: "evaluate";
+        panelId: string;
+    } | {
+        teamId: string;
+        sessionId: string;
+        operationId: string;
+        expectedRevision: number;
+        candidateHash: string;
+        action: "select";
+        targetCandidateHash: string;
+    } | {
+        teamId: string;
+        sessionId: string;
+        operationId: string;
+        expectedRevision: number;
+        candidateHash: string;
+        action: "finalize";
+    };
+    requestHash: string;
+    state: "completed" | "queued";
+    result: {
+        schemaVersion: "openpond.weightSpaceCommandResult.v1";
+        sessionId: string;
+        operationId: string;
+        requestHash: string;
+        revision: number;
+        parentCandidateHash: string;
+        candidateHash: string;
+        changedColumns: {
+            layer: number;
+            columns: number[];
+        }[];
+        status: "rejected" | "succeeded";
+        code: string | null;
+        catalog: {
+            items: {
+                name: string;
+                shape: number[];
+                dtype: "BF16";
+                editable: boolean;
+            }[];
+            nextOffset: number | null;
+        } | null;
+        tensors: Record<string, {
+            shape: number[];
+            minimum: number;
+            maximum: number;
+            mean: number;
+            norm: number;
+            values: number[];
+            truncated: boolean;
+        }>;
+        evaluation: {
+            panelId: string;
+            role: "development" | "preservation";
+            candidateHash: string;
+            sampling: "greedy_v1";
+            seed: number;
+            rows: {
+                id: string;
+                inputHash: string;
+                outputIds: number[];
+                outputText: string;
+                reachedTokenLimit: boolean;
+                forwardTokenWork: number;
+            }[];
+        } | null;
+        finalEvaluation?: {
+            panelId: string;
+            candidateHash: string;
+            sampling: "greedy_v1";
+            seed: number;
+            rows: {
+                id: string;
+                inputHash: string;
+                outputIds: number[];
+                outputText: string;
+                reachedTokenLimit: boolean;
+                forwardTokenWork: number;
+            }[];
+            role: "frozen";
+            source: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            baseline: {
+                candidateHash: string;
+                rows: {
+                    id: string;
+                    inputHash: string;
+                    outputIds: number[];
+                    outputText: string;
+                    reachedTokenLimit: boolean;
+                    forwardTokenWork: number;
+                }[];
+            };
+        } | null | undefined;
+        usage: {
+            commands: number;
+            candidates: number;
+            arithmeticWork: number;
+            forwardTokenWork: number;
+        };
+        contentHash: string;
+    } | null;
+    contentHash: string;
+}>;
+export declare function parseAndVerifyWeightSpaceExecutionPage(raw: unknown, expected: {
+    teamId: string;
+    ownerUserId?: string;
+    query: z.infer<typeof WeightSpaceExecutionListQuerySchema>;
+}): Promise<{
+    schemaVersion: "openpond.weightSpaceExecutionPage.v1";
+    teamId: string;
+    ownerUserId: string;
+    query: {
+        method: "weight_space_programming";
+        projectId?: string | undefined;
+        id?: string | undefined;
+        phase?: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping" | undefined;
+        cursor?: string | undefined;
+        limit: number;
+    };
+    items: {
+        id: string;
+        teamId: string;
+        ownerUserId: string;
+        projectId: string | null;
+        name: string;
+        phase: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping";
+        revision: number;
+        sourceContentHash: string;
+        plan: {
+            contentHash: string;
+            inputHash: string;
+            runtimeHash: string;
+            maximumSpendUsd: string | null;
+            computePrice?: {
+                schemaVersion: "openpond.modificationPrice.v1";
+                appliedPrice: {
+                    schemaVersion: "openpond.computeAppliedPrice.v1";
+                    version: string;
+                    profileHash: string;
+                    currency: "USD";
+                    unit: "resource_hour";
+                    hourlyUsd: string;
+                    service: "model_modification";
+                };
+                billingBoundary: "active_allocation_until_verified_cleanup";
+                startupBillable: true;
+                postCompletionIdleBillable: false;
+                minimumBillableSeconds: 0;
+                warmReuseSeconds: 300;
+            } | {
+                appliedPrice: {
+                    schemaVersion: "openpond.computeAppliedPrice.v1";
+                    version: string;
+                    profileHash: string;
+                    currency: "USD";
+                    unit: "resource_hour";
+                    hourlyUsd: string;
+                    service: "model_modification";
+                };
+                billingBoundary: "active_allocation_until_verified_cleanup";
+                startupBillable: true;
+                postCompletionIdleBillable: false;
+                minimumBillableSeconds: 0;
+                schemaVersion: "openpond.modificationPrice.v2";
+                warmReuseSeconds: 0;
+            } | undefined;
+            createdAt: string;
+            expiresAt: string;
+        };
+        updatedAt: string;
+        method: "weight_space_programming";
+        session: {
+            revision: number;
+            candidateHash: string;
+            historyHash: string;
+            phase: "busy" | "closed" | "finalizing" | "ready" | "starting";
+            pendingOperationId: string | null;
+            lastActivityAt: string;
+            finalization: {
+                operationId: string;
+                resultHash: string;
+                historyHashBefore: string;
+                status: "rejected" | "succeeded";
+            } | null;
+            usage: {
+                commands: number;
+                candidates: number;
+                arithmeticWork: number;
+                forwardTokenWork: number;
+            };
+        } | null;
+        model: {
+            schemaVersion: "openpond.neuronSteeringModel.v1";
+            modelId: string;
+            revision: string;
+            configHash: string;
+            weightsHash: string;
+            tokenizerHash: string;
+            weightIdentity: "torch_state_dict_sha256_v1";
+            architecture: "dense_decoder";
+            dtype: "bfloat16" | "float16" | "float32";
+            quantization: "none";
+            adapter: null;
+            hiddenSize: number;
+            intermediateSizes: number[];
+        };
+    }[];
+    nextCursor: string | null;
+    contentHash: string;
+}>;
+export declare function createWeightSpaceClient(request: (path: string, init?: RequestInit) => Promise<unknown>): {
+    weightSpaceCapability(query: z.infer<typeof ModelModificationCapabilitiesQuerySchema>): Promise<{
+        schemaVersion: "openpond.weightSpaceCapability.v1";
+        teamId: string;
+        actorId: string;
+        query: {
+            teamId: string;
+            modelId: string;
+            source: "builtin" | "local" | "managed";
+            revision?: string | undefined;
+            tokenizerRevision?: string | undefined;
+            chatTemplateHash?: string | undefined;
+            modelAssetId?: string | undefined;
+        };
+        requestHash: string;
+        checkedAt: string;
+        expiresAt: string;
+        validationLevel: "gpu_qualified" | "source_validated" | null;
+        execution: {
+            state: "unavailable";
+            code: "model_not_supported" | "runtime_not_qualified";
+            reason: string;
+        } | {
+            state: "ready";
+            model: {
+                schemaVersion: "openpond.neuronSteeringModel.v1";
+                modelId: string;
+                revision: string;
+                configHash: string;
+                weightsHash: string;
+                tokenizerHash: string;
+                weightIdentity: "torch_state_dict_sha256_v1";
+                architecture: "dense_decoder";
+                dtype: "bfloat16" | "float16" | "float32";
+                quantization: "none";
+                adapter: null;
+                hiddenSize: number;
+                intermediateSizes: number[];
+            };
+            runtime: {
+                id: string;
+                releaseHash: string;
+                imageDigest: string;
+                requestSchema: "openpond.weightSpaceRequest.v1";
+                bootstrapClock?: {
+                    schemaVersion: "openpond.weightSpaceQualifiedBootstrapClock.v1";
+                    method: "weight_space_programming";
+                    validationLevel: "gpu_qualified";
+                    bootstrapSeconds: 900;
+                    maximumWorkSeconds: number;
+                    workClock: "native_command_issued";
+                    cleanupSeconds: 120;
+                    modelHash: string;
+                    runtimeTemplateHash: string;
+                    qualification: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    source: {
+                        imageDigest: string;
+                        releaseHash: string;
+                        canonicalReleaseSha256: string;
+                        sourceTreeSha256: string;
+                        softwareInventorySha256: string;
+                        buildReceiptSha256: string;
+                        pythonSdkSha256: string;
+                    };
+                    contentHash: string;
+                } | undefined;
+                evidence: {
+                    id: string;
+                    contentHash: string;
+                };
+            };
+            limits: {
+                maximumDurationSeconds: number;
+                maximumIdleSeconds: number;
+                maximumCommands: number;
+                maximumCandidates: number;
+                maximumPatchColumns: number;
+                maximumTensorElements: number;
+                maximumReturnedValues: number;
+                maximumArithmeticWork: number;
+                maximumForwardTokenWork: number;
+                maximumCheckpointBytes: number;
+            };
+        };
+        contentHash: string;
+    }>;
+    prepareWeightSpaceSession(raw: WeightSpacePrepare): Promise<{
+        schemaVersion: "openpond.weightSpaceExecutionReceipt.v1";
+        operationId: string;
+        requestHash: string;
+        execution: {
+            id: string;
+            teamId: string;
+            ownerUserId: string;
+            projectId: string | null;
+            name: string;
+            phase: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping";
+            revision: number;
+            sourceContentHash: string;
+            plan: {
+                contentHash: string;
+                inputHash: string;
+                runtimeHash: string;
+                maximumSpendUsd: string | null;
+                computePrice?: {
+                    schemaVersion: "openpond.modificationPrice.v1";
+                    appliedPrice: {
+                        schemaVersion: "openpond.computeAppliedPrice.v1";
+                        version: string;
+                        profileHash: string;
+                        currency: "USD";
+                        unit: "resource_hour";
+                        hourlyUsd: string;
+                        service: "model_modification";
+                    };
+                    billingBoundary: "active_allocation_until_verified_cleanup";
+                    startupBillable: true;
+                    postCompletionIdleBillable: false;
+                    minimumBillableSeconds: 0;
+                    warmReuseSeconds: 300;
+                } | {
+                    appliedPrice: {
+                        schemaVersion: "openpond.computeAppliedPrice.v1";
+                        version: string;
+                        profileHash: string;
+                        currency: "USD";
+                        unit: "resource_hour";
+                        hourlyUsd: string;
+                        service: "model_modification";
+                    };
+                    billingBoundary: "active_allocation_until_verified_cleanup";
+                    startupBillable: true;
+                    postCompletionIdleBillable: false;
+                    minimumBillableSeconds: 0;
+                    schemaVersion: "openpond.modificationPrice.v2";
+                    warmReuseSeconds: 0;
+                } | undefined;
+                createdAt: string;
+                expiresAt: string;
+            };
+            updatedAt: string;
+            method: "weight_space_programming";
+            session: {
+                revision: number;
+                candidateHash: string;
+                historyHash: string;
+                phase: "busy" | "closed" | "finalizing" | "ready" | "starting";
+                pendingOperationId: string | null;
+                lastActivityAt: string;
+                finalization: {
+                    operationId: string;
+                    resultHash: string;
+                    historyHashBefore: string;
+                    status: "rejected" | "succeeded";
+                } | null;
+                usage: {
+                    commands: number;
+                    candidates: number;
+                    arithmeticWork: number;
+                    forwardTokenWork: number;
+                };
+            } | null;
+        };
+        contentHash: string;
+    }>;
+    startWeightSpaceSession(raw: z.infer<typeof ManagedModificationStartSchema>): Promise<{
+        schemaVersion: "openpond.weightSpaceExecutionReceipt.v1";
+        operationId: string;
+        requestHash: string;
+        execution: {
+            id: string;
+            teamId: string;
+            ownerUserId: string;
+            projectId: string | null;
+            name: string;
+            phase: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping";
+            revision: number;
+            sourceContentHash: string;
+            plan: {
+                contentHash: string;
+                inputHash: string;
+                runtimeHash: string;
+                maximumSpendUsd: string | null;
+                computePrice?: {
+                    schemaVersion: "openpond.modificationPrice.v1";
+                    appliedPrice: {
+                        schemaVersion: "openpond.computeAppliedPrice.v1";
+                        version: string;
+                        profileHash: string;
+                        currency: "USD";
+                        unit: "resource_hour";
+                        hourlyUsd: string;
+                        service: "model_modification";
+                    };
+                    billingBoundary: "active_allocation_until_verified_cleanup";
+                    startupBillable: true;
+                    postCompletionIdleBillable: false;
+                    minimumBillableSeconds: 0;
+                    warmReuseSeconds: 300;
+                } | {
+                    appliedPrice: {
+                        schemaVersion: "openpond.computeAppliedPrice.v1";
+                        version: string;
+                        profileHash: string;
+                        currency: "USD";
+                        unit: "resource_hour";
+                        hourlyUsd: string;
+                        service: "model_modification";
+                    };
+                    billingBoundary: "active_allocation_until_verified_cleanup";
+                    startupBillable: true;
+                    postCompletionIdleBillable: false;
+                    minimumBillableSeconds: 0;
+                    schemaVersion: "openpond.modificationPrice.v2";
+                    warmReuseSeconds: 0;
+                } | undefined;
+                createdAt: string;
+                expiresAt: string;
+            };
+            updatedAt: string;
+            method: "weight_space_programming";
+            session: {
+                revision: number;
+                candidateHash: string;
+                historyHash: string;
+                phase: "busy" | "closed" | "finalizing" | "ready" | "starting";
+                pendingOperationId: string | null;
+                lastActivityAt: string;
+                finalization: {
+                    operationId: string;
+                    resultHash: string;
+                    historyHashBefore: string;
+                    status: "rejected" | "succeeded";
+                } | null;
+                usage: {
+                    commands: number;
+                    candidates: number;
+                    arithmeticWork: number;
+                    forwardTokenWork: number;
+                };
+            } | null;
+        };
+        contentHash: string;
+    }>;
+    cancelWeightSpaceSession(raw: z.infer<typeof ManagedModificationCancelSchema>): Promise<{
+        schemaVersion: "openpond.weightSpaceExecutionReceipt.v1";
+        operationId: string;
+        requestHash: string;
+        execution: {
+            id: string;
+            teamId: string;
+            ownerUserId: string;
+            projectId: string | null;
+            name: string;
+            phase: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping";
+            revision: number;
+            sourceContentHash: string;
+            plan: {
+                contentHash: string;
+                inputHash: string;
+                runtimeHash: string;
+                maximumSpendUsd: string | null;
+                computePrice?: {
+                    schemaVersion: "openpond.modificationPrice.v1";
+                    appliedPrice: {
+                        schemaVersion: "openpond.computeAppliedPrice.v1";
+                        version: string;
+                        profileHash: string;
+                        currency: "USD";
+                        unit: "resource_hour";
+                        hourlyUsd: string;
+                        service: "model_modification";
+                    };
+                    billingBoundary: "active_allocation_until_verified_cleanup";
+                    startupBillable: true;
+                    postCompletionIdleBillable: false;
+                    minimumBillableSeconds: 0;
+                    warmReuseSeconds: 300;
+                } | {
+                    appliedPrice: {
+                        schemaVersion: "openpond.computeAppliedPrice.v1";
+                        version: string;
+                        profileHash: string;
+                        currency: "USD";
+                        unit: "resource_hour";
+                        hourlyUsd: string;
+                        service: "model_modification";
+                    };
+                    billingBoundary: "active_allocation_until_verified_cleanup";
+                    startupBillable: true;
+                    postCompletionIdleBillable: false;
+                    minimumBillableSeconds: 0;
+                    schemaVersion: "openpond.modificationPrice.v2";
+                    warmReuseSeconds: 0;
+                } | undefined;
+                createdAt: string;
+                expiresAt: string;
+            };
+            updatedAt: string;
+            method: "weight_space_programming";
+            session: {
+                revision: number;
+                candidateHash: string;
+                historyHash: string;
+                phase: "busy" | "closed" | "finalizing" | "ready" | "starting";
+                pendingOperationId: string | null;
+                lastActivityAt: string;
+                finalization: {
+                    operationId: string;
+                    resultHash: string;
+                    historyHashBefore: string;
+                    status: "rejected" | "succeeded";
+                } | null;
+                usage: {
+                    commands: number;
+                    candidates: number;
+                    arithmeticWork: number;
+                    forwardTokenWork: number;
+                };
+            } | null;
+        };
+        contentHash: string;
+    }>;
+    getWeightSpaceSession(teamId: string, id: string, options?: {
+        ownerUserId?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        id: string;
+        teamId: string;
+        ownerUserId: string;
+        projectId: string | null;
+        name: string;
+        phase: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping";
+        revision: number;
+        sourceContentHash: string;
+        plan: {
+            contentHash: string;
+            inputHash: string;
+            runtimeHash: string;
+            maximumSpendUsd: string | null;
+            computePrice?: {
+                schemaVersion: "openpond.modificationPrice.v1";
+                appliedPrice: {
+                    schemaVersion: "openpond.computeAppliedPrice.v1";
+                    version: string;
+                    profileHash: string;
+                    currency: "USD";
+                    unit: "resource_hour";
+                    hourlyUsd: string;
+                    service: "model_modification";
+                };
+                billingBoundary: "active_allocation_until_verified_cleanup";
+                startupBillable: true;
+                postCompletionIdleBillable: false;
+                minimumBillableSeconds: 0;
+                warmReuseSeconds: 300;
+            } | {
+                appliedPrice: {
+                    schemaVersion: "openpond.computeAppliedPrice.v1";
+                    version: string;
+                    profileHash: string;
+                    currency: "USD";
+                    unit: "resource_hour";
+                    hourlyUsd: string;
+                    service: "model_modification";
+                };
+                billingBoundary: "active_allocation_until_verified_cleanup";
+                startupBillable: true;
+                postCompletionIdleBillable: false;
+                minimumBillableSeconds: 0;
+                schemaVersion: "openpond.modificationPrice.v2";
+                warmReuseSeconds: 0;
+            } | undefined;
+            createdAt: string;
+            expiresAt: string;
+        };
+        updatedAt: string;
+        method: "weight_space_programming";
+        session: {
+            revision: number;
+            candidateHash: string;
+            historyHash: string;
+            phase: "busy" | "closed" | "finalizing" | "ready" | "starting";
+            pendingOperationId: string | null;
+            lastActivityAt: string;
+            finalization: {
+                operationId: string;
+                resultHash: string;
+                historyHashBefore: string;
+                status: "rejected" | "succeeded";
+            } | null;
+            usage: {
+                commands: number;
+                candidates: number;
+                arithmeticWork: number;
+                forwardTokenWork: number;
+            };
+        } | null;
+        schemaVersion: "openpond.weightSpaceExecution.v1";
+        request: {
+            schemaVersion: "openpond.weightSpaceRequest.v1";
+            model: {
+                schemaVersion: "openpond.neuronSteeringModel.v1";
+                modelId: string;
+                revision: string;
+                configHash: string;
+                weightsHash: string;
+                tokenizerHash: string;
+                weightIdentity: "torch_state_dict_sha256_v1";
+                architecture: "dense_decoder";
+                dtype: "bfloat16" | "float16" | "float32";
+                quantization: "none";
+                adapter: null;
+                hiddenSize: number;
+                intermediateSizes: number[];
+            };
+            teacher: {
+                controller: "local_agent";
+                providerId: string;
+                modelId: string;
+                sessionId: string;
+            };
+            objective: string;
+            panels: {
+                id: string;
+                source: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | null;
+                role: "development" | "preservation";
+                prompts: {
+                    id: string;
+                    text: string;
+                    system?: string | undefined;
+                }[];
+            }[];
+            frozenEvaluation: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null;
+            generation: {
+                maxOutputTokens: number;
+                seed: number;
+                sampling: "greedy_v1";
+            };
+            limits: {
+                maximumDurationSeconds: number;
+                maximumIdleSeconds: number;
+                maximumCommands: number;
+                maximumCandidates: number;
+                maximumPatchColumns: number;
+                maximumTensorElements: number;
+                maximumReturnedValues: number;
+                maximumArithmeticWork: number;
+                maximumForwardTokenWork: number;
+                maximumCheckpointBytes: number;
+            };
+        };
+        result: {
+            schemaVersion: "openpond.weightSpaceResult.v1";
+            inputHash: string;
+            runtimeHash: string;
+            candidateHash: string;
+            historyHash: string;
+            artifact: {
+                id: string;
+                contentHash: string;
+                manifest: {
+                    schemaVersion: "openpond.weightSpaceArtifact.v1";
+                    method: "weight_space_programming";
+                    representation: "exact_bf16_mlp_column_replacements_v1";
+                    model: {
+                        schemaVersion: "openpond.neuronSteeringModel.v1";
+                        modelId: string;
+                        revision: string;
+                        configHash: string;
+                        weightsHash: string;
+                        tokenizerHash: string;
+                        weightIdentity: "torch_state_dict_sha256_v1";
+                        architecture: "dense_decoder";
+                        dtype: "bfloat16" | "float16" | "float32";
+                        quantization: "none";
+                        adapter: null;
+                        hiddenSize: number;
+                        intermediateSizes: number[];
+                    };
+                    requestHash: string;
+                    runtimeHash: string;
+                    candidateHash: string;
+                    teacher: {
+                        controller: "local_agent";
+                        providerId: string;
+                        modelId: string;
+                        sessionId: string;
+                    };
+                    historyHash: string;
+                    columns: {
+                        layer: number;
+                        columns: number[];
+                    }[];
+                    columnHashes: string[];
+                    payload: {
+                        path: "patch.safetensors";
+                        sha256: string;
+                        sizeBytes: number;
+                        tensors: {
+                            name: string;
+                            dtype: "BF16" | "I64";
+                            shape: number[];
+                        }[];
+                    };
+                    reload: {
+                        effectiveColumnsHash: string;
+                        reloadedColumnsHash: string;
+                        untouchedWeightsHashBefore: string;
+                        untouchedWeightsHashAfter: string;
+                        equivalent: true;
+                    };
+                    contentHash: string;
+                };
+                files: {
+                    path: "manifest.json" | "patch.safetensors";
+                    artifactId: string;
+                    sha256: string;
+                    sizeBytes: number;
+                }[];
+            };
+            commands: number;
+            candidates: number;
+            forwardTokenWork: number;
+            durationMs: number;
+            contentHash: string;
+        } | null;
+        resultRecordedAt: string | null;
+        contentHash: string;
+    }>;
+    listWeightSpaceSessions(teamId: string, raw?: z.input<typeof WeightSpaceExecutionListQuerySchema>): Promise<{
+        schemaVersion: "openpond.weightSpaceExecutionPage.v1";
+        teamId: string;
+        ownerUserId: string;
+        query: {
+            method: "weight_space_programming";
+            projectId?: string | undefined;
+            id?: string | undefined;
+            phase?: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping" | undefined;
+            cursor?: string | undefined;
+            limit: number;
+        };
+        items: {
+            id: string;
+            teamId: string;
+            ownerUserId: string;
+            projectId: string | null;
+            name: string;
+            phase: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping";
+            revision: number;
+            sourceContentHash: string;
+            plan: {
+                contentHash: string;
+                inputHash: string;
+                runtimeHash: string;
+                maximumSpendUsd: string | null;
+                computePrice?: {
+                    schemaVersion: "openpond.modificationPrice.v1";
+                    appliedPrice: {
+                        schemaVersion: "openpond.computeAppliedPrice.v1";
+                        version: string;
+                        profileHash: string;
+                        currency: "USD";
+                        unit: "resource_hour";
+                        hourlyUsd: string;
+                        service: "model_modification";
+                    };
+                    billingBoundary: "active_allocation_until_verified_cleanup";
+                    startupBillable: true;
+                    postCompletionIdleBillable: false;
+                    minimumBillableSeconds: 0;
+                    warmReuseSeconds: 300;
+                } | {
+                    appliedPrice: {
+                        schemaVersion: "openpond.computeAppliedPrice.v1";
+                        version: string;
+                        profileHash: string;
+                        currency: "USD";
+                        unit: "resource_hour";
+                        hourlyUsd: string;
+                        service: "model_modification";
+                    };
+                    billingBoundary: "active_allocation_until_verified_cleanup";
+                    startupBillable: true;
+                    postCompletionIdleBillable: false;
+                    minimumBillableSeconds: 0;
+                    schemaVersion: "openpond.modificationPrice.v2";
+                    warmReuseSeconds: 0;
+                } | undefined;
+                createdAt: string;
+                expiresAt: string;
+            };
+            updatedAt: string;
+            method: "weight_space_programming";
+            session: {
+                revision: number;
+                candidateHash: string;
+                historyHash: string;
+                phase: "busy" | "closed" | "finalizing" | "ready" | "starting";
+                pendingOperationId: string | null;
+                lastActivityAt: string;
+                finalization: {
+                    operationId: string;
+                    resultHash: string;
+                    historyHashBefore: string;
+                    status: "rejected" | "succeeded";
+                } | null;
+                usage: {
+                    commands: number;
+                    candidates: number;
+                    arithmeticWork: number;
+                    forwardTokenWork: number;
+                };
+            } | null;
+            model: {
+                schemaVersion: "openpond.neuronSteeringModel.v1";
+                modelId: string;
+                revision: string;
+                configHash: string;
+                weightsHash: string;
+                tokenizerHash: string;
+                weightIdentity: "torch_state_dict_sha256_v1";
+                architecture: "dense_decoder";
+                dtype: "bfloat16" | "float16" | "float32";
+                quantization: "none";
+                adapter: null;
+                hiddenSize: number;
+                intermediateSizes: number[];
+            };
+        }[];
+        nextCursor: string | null;
+        contentHash: string;
+    }>;
+    listWeightSpaceCommands(teamId: string, id: string, raw?: z.input<typeof WeightSpaceCommandListQuerySchema>): Promise<{
+        schemaVersion: "openpond.weightSpaceCommandPage.v1";
+        teamId: string;
+        ownerUserId: string;
+        sessionId: string;
+        query: {
+            afterRevision: number;
+            limit: number;
+        };
+        items: {
+            schemaVersion: "openpond.weightSpaceCommandReceipt.v1";
+            teamId: string;
+            ownerUserId: string;
+            command: {
+                teamId: string;
+                sessionId: string;
+                operationId: string;
+                expectedRevision: number;
+                candidateHash: string;
+                action: "catalog";
+                offset: number;
+                limit: number;
+            } | {
+                layer: number;
+                columns: number[];
+                teamId: string;
+                sessionId: string;
+                operationId: string;
+                expectedRevision: number;
+                candidateHash: string;
+                action: "inspect";
+            } | {
+                teamId: string;
+                sessionId: string;
+                operationId: string;
+                expectedRevision: number;
+                candidateHash: string;
+                action: "program";
+                program: {
+                    instructions: ({
+                        op: "read_tensor";
+                        out: string;
+                        name: string;
+                        source: "base" | "candidate";
+                        ranges: {
+                            start: number;
+                            stop: number;
+                        }[];
+                    } | {
+                        layer: number;
+                        columns: number[];
+                        op: "read";
+                        out: string;
+                        source: "base" | "candidate";
+                    } | {
+                        op: "literal";
+                        out: string;
+                        shape: number[];
+                        values: number[];
+                    } | {
+                        op: "scale";
+                        out: string;
+                        input: string;
+                        factor: number;
+                    } | {
+                        op: "add" | "matmul" | "subtract";
+                        out: string;
+                        left: string;
+                        right: string;
+                    } | {
+                        op: "mean_columns" | "normalize_columns" | "singular_vectors" | "transpose";
+                        out: string;
+                        input: string;
+                    } | {
+                        op: "slice";
+                        out: string;
+                        input: string;
+                        axis: number;
+                        start: number;
+                        stop: number;
+                    } | {
+                        layer: number;
+                        columns: number[];
+                        op: "write";
+                        input: string;
+                    })[];
+                    returns: string[];
+                };
+                hypothesis: string;
+            } | {
+                teamId: string;
+                sessionId: string;
+                operationId: string;
+                expectedRevision: number;
+                candidateHash: string;
+                action: "code";
+                code: string;
+                hypothesis: string;
+            } | {
+                teamId: string;
+                sessionId: string;
+                operationId: string;
+                expectedRevision: number;
+                candidateHash: string;
+                action: "evaluate";
+                panelId: string;
+            } | {
+                teamId: string;
+                sessionId: string;
+                operationId: string;
+                expectedRevision: number;
+                candidateHash: string;
+                action: "select";
+                targetCandidateHash: string;
+            } | {
+                teamId: string;
+                sessionId: string;
+                operationId: string;
+                expectedRevision: number;
+                candidateHash: string;
+                action: "finalize";
+            };
+            requestHash: string;
+            state: "completed" | "queued";
+            result: {
+                schemaVersion: "openpond.weightSpaceCommandResult.v1";
+                sessionId: string;
+                operationId: string;
+                requestHash: string;
+                revision: number;
+                parentCandidateHash: string;
+                candidateHash: string;
+                changedColumns: {
+                    layer: number;
+                    columns: number[];
+                }[];
+                status: "rejected" | "succeeded";
+                code: string | null;
+                catalog: {
+                    items: {
+                        name: string;
+                        shape: number[];
+                        dtype: "BF16";
+                        editable: boolean;
+                    }[];
+                    nextOffset: number | null;
+                } | null;
+                tensors: Record<string, {
+                    shape: number[];
+                    minimum: number;
+                    maximum: number;
+                    mean: number;
+                    norm: number;
+                    values: number[];
+                    truncated: boolean;
+                }>;
+                evaluation: {
+                    panelId: string;
+                    role: "development" | "preservation";
+                    candidateHash: string;
+                    sampling: "greedy_v1";
+                    seed: number;
+                    rows: {
+                        id: string;
+                        inputHash: string;
+                        outputIds: number[];
+                        outputText: string;
+                        reachedTokenLimit: boolean;
+                        forwardTokenWork: number;
+                    }[];
+                } | null;
+                finalEvaluation?: {
+                    panelId: string;
+                    candidateHash: string;
+                    sampling: "greedy_v1";
+                    seed: number;
+                    rows: {
+                        id: string;
+                        inputHash: string;
+                        outputIds: number[];
+                        outputText: string;
+                        reachedTokenLimit: boolean;
+                        forwardTokenWork: number;
+                    }[];
+                    role: "frozen";
+                    source: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    baseline: {
+                        candidateHash: string;
+                        rows: {
+                            id: string;
+                            inputHash: string;
+                            outputIds: number[];
+                            outputText: string;
+                            reachedTokenLimit: boolean;
+                            forwardTokenWork: number;
+                        }[];
+                    };
+                } | null | undefined;
+                usage: {
+                    commands: number;
+                    candidates: number;
+                    arithmeticWork: number;
+                    forwardTokenWork: number;
+                };
+                contentHash: string;
+            } | null;
+            contentHash: string;
+        }[];
+        nextAfterRevision: number | null;
+        contentHash: string;
+    }>;
+    commandWeightSpaceSession(raw: WeightSpaceCommand): Promise<{
+        schemaVersion: "openpond.weightSpaceCommandReceipt.v1";
+        teamId: string;
+        ownerUserId: string;
+        command: {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "catalog";
+            offset: number;
+            limit: number;
+        } | {
+            layer: number;
+            columns: number[];
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "inspect";
+        } | {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "program";
+            program: {
+                instructions: ({
+                    op: "read_tensor";
+                    out: string;
+                    name: string;
+                    source: "base" | "candidate";
+                    ranges: {
+                        start: number;
+                        stop: number;
+                    }[];
+                } | {
+                    layer: number;
+                    columns: number[];
+                    op: "read";
+                    out: string;
+                    source: "base" | "candidate";
+                } | {
+                    op: "literal";
+                    out: string;
+                    shape: number[];
+                    values: number[];
+                } | {
+                    op: "scale";
+                    out: string;
+                    input: string;
+                    factor: number;
+                } | {
+                    op: "add" | "matmul" | "subtract";
+                    out: string;
+                    left: string;
+                    right: string;
+                } | {
+                    op: "mean_columns" | "normalize_columns" | "singular_vectors" | "transpose";
+                    out: string;
+                    input: string;
+                } | {
+                    op: "slice";
+                    out: string;
+                    input: string;
+                    axis: number;
+                    start: number;
+                    stop: number;
+                } | {
+                    layer: number;
+                    columns: number[];
+                    op: "write";
+                    input: string;
+                })[];
+                returns: string[];
+            };
+            hypothesis: string;
+        } | {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "code";
+            code: string;
+            hypothesis: string;
+        } | {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "evaluate";
+            panelId: string;
+        } | {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "select";
+            targetCandidateHash: string;
+        } | {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "finalize";
+        };
+        requestHash: string;
+        state: "completed" | "queued";
+        result: {
+            schemaVersion: "openpond.weightSpaceCommandResult.v1";
+            sessionId: string;
+            operationId: string;
+            requestHash: string;
+            revision: number;
+            parentCandidateHash: string;
+            candidateHash: string;
+            changedColumns: {
+                layer: number;
+                columns: number[];
+            }[];
+            status: "rejected" | "succeeded";
+            code: string | null;
+            catalog: {
+                items: {
+                    name: string;
+                    shape: number[];
+                    dtype: "BF16";
+                    editable: boolean;
+                }[];
+                nextOffset: number | null;
+            } | null;
+            tensors: Record<string, {
+                shape: number[];
+                minimum: number;
+                maximum: number;
+                mean: number;
+                norm: number;
+                values: number[];
+                truncated: boolean;
+            }>;
+            evaluation: {
+                panelId: string;
+                role: "development" | "preservation";
+                candidateHash: string;
+                sampling: "greedy_v1";
+                seed: number;
+                rows: {
+                    id: string;
+                    inputHash: string;
+                    outputIds: number[];
+                    outputText: string;
+                    reachedTokenLimit: boolean;
+                    forwardTokenWork: number;
+                }[];
+            } | null;
+            finalEvaluation?: {
+                panelId: string;
+                candidateHash: string;
+                sampling: "greedy_v1";
+                seed: number;
+                rows: {
+                    id: string;
+                    inputHash: string;
+                    outputIds: number[];
+                    outputText: string;
+                    reachedTokenLimit: boolean;
+                    forwardTokenWork: number;
+                }[];
+                role: "frozen";
+                source: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                baseline: {
+                    candidateHash: string;
+                    rows: {
+                        id: string;
+                        inputHash: string;
+                        outputIds: number[];
+                        outputText: string;
+                        reachedTokenLimit: boolean;
+                        forwardTokenWork: number;
+                    }[];
+                };
+            } | null | undefined;
+            usage: {
+                commands: number;
+                candidates: number;
+                arithmeticWork: number;
+                forwardTokenWork: number;
+            };
+            contentHash: string;
+        } | null;
+        contentHash: string;
+    }>;
+    getWeightSpaceCommand(teamId: string, sessionId: string, operationId: string): Promise<{
+        schemaVersion: "openpond.weightSpaceCommandReceipt.v1";
+        teamId: string;
+        ownerUserId: string;
+        command: {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "catalog";
+            offset: number;
+            limit: number;
+        } | {
+            layer: number;
+            columns: number[];
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "inspect";
+        } | {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "program";
+            program: {
+                instructions: ({
+                    op: "read_tensor";
+                    out: string;
+                    name: string;
+                    source: "base" | "candidate";
+                    ranges: {
+                        start: number;
+                        stop: number;
+                    }[];
+                } | {
+                    layer: number;
+                    columns: number[];
+                    op: "read";
+                    out: string;
+                    source: "base" | "candidate";
+                } | {
+                    op: "literal";
+                    out: string;
+                    shape: number[];
+                    values: number[];
+                } | {
+                    op: "scale";
+                    out: string;
+                    input: string;
+                    factor: number;
+                } | {
+                    op: "add" | "matmul" | "subtract";
+                    out: string;
+                    left: string;
+                    right: string;
+                } | {
+                    op: "mean_columns" | "normalize_columns" | "singular_vectors" | "transpose";
+                    out: string;
+                    input: string;
+                } | {
+                    op: "slice";
+                    out: string;
+                    input: string;
+                    axis: number;
+                    start: number;
+                    stop: number;
+                } | {
+                    layer: number;
+                    columns: number[];
+                    op: "write";
+                    input: string;
+                })[];
+                returns: string[];
+            };
+            hypothesis: string;
+        } | {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "code";
+            code: string;
+            hypothesis: string;
+        } | {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "evaluate";
+            panelId: string;
+        } | {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "select";
+            targetCandidateHash: string;
+        } | {
+            teamId: string;
+            sessionId: string;
+            operationId: string;
+            expectedRevision: number;
+            candidateHash: string;
+            action: "finalize";
+        };
+        requestHash: string;
+        state: "completed" | "queued";
+        result: {
+            schemaVersion: "openpond.weightSpaceCommandResult.v1";
+            sessionId: string;
+            operationId: string;
+            requestHash: string;
+            revision: number;
+            parentCandidateHash: string;
+            candidateHash: string;
+            changedColumns: {
+                layer: number;
+                columns: number[];
+            }[];
+            status: "rejected" | "succeeded";
+            code: string | null;
+            catalog: {
+                items: {
+                    name: string;
+                    shape: number[];
+                    dtype: "BF16";
+                    editable: boolean;
+                }[];
+                nextOffset: number | null;
+            } | null;
+            tensors: Record<string, {
+                shape: number[];
+                minimum: number;
+                maximum: number;
+                mean: number;
+                norm: number;
+                values: number[];
+                truncated: boolean;
+            }>;
+            evaluation: {
+                panelId: string;
+                role: "development" | "preservation";
+                candidateHash: string;
+                sampling: "greedy_v1";
+                seed: number;
+                rows: {
+                    id: string;
+                    inputHash: string;
+                    outputIds: number[];
+                    outputText: string;
+                    reachedTokenLimit: boolean;
+                    forwardTokenWork: number;
+                }[];
+            } | null;
+            finalEvaluation?: {
+                panelId: string;
+                candidateHash: string;
+                sampling: "greedy_v1";
+                seed: number;
+                rows: {
+                    id: string;
+                    inputHash: string;
+                    outputIds: number[];
+                    outputText: string;
+                    reachedTokenLimit: boolean;
+                    forwardTokenWork: number;
+                }[];
+                role: "frozen";
+                source: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                baseline: {
+                    candidateHash: string;
+                    rows: {
+                        id: string;
+                        inputHash: string;
+                        outputIds: number[];
+                        outputText: string;
+                        reachedTokenLimit: boolean;
+                        forwardTokenWork: number;
+                    }[];
+                };
+            } | null | undefined;
+            usage: {
+                commands: number;
+                candidates: number;
+                arithmeticWork: number;
+                forwardTokenWork: number;
+            };
+            contentHash: string;
+        } | null;
+        contentHash: string;
+    }>;
+};
+//# sourceMappingURL=weight-space-sessions.d.ts.map