npm - openpond-sdk - Versions diffs - 0.12.13 → 0.12.15 - Mend

openpond-sdk 0.12.13 → 0.12.15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (301) hide show

package/dist/types/packages/sdk/src/managed-neuron-training-executions.d.ts ADDED Viewed

@@ -0,0 +1,3447 @@
+import { z } from "zod";
+import { NeuronTrainingExperimentFormDraftSchema } from "./neuron-training-experiment-draft.js";
+declare const 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>;
+export declare const NeuronTrainingExecutionCapabilityContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronTrainingExecutionCapability.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.selectiveNeuronTrainingRequest.v1">;
+            evidence: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        limits: z.ZodObject<{
+            maximumExamples: z.ZodNumber;
+            maximumDataBytes: z.ZodNumber;
+            maximumSteps: z.ZodNumber;
+            maximumSequenceLength: z.ZodNumber;
+            maximumDurationSeconds: z.ZodNumber;
+            maximumCheckpointBytes: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "state">;
+}, z.core.$strict>;
+export declare const NeuronTrainingExecutionCapabilitySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronTrainingExecutionCapability.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.selectiveNeuronTrainingRequest.v1">;
+            evidence: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        limits: z.ZodObject<{
+            maximumExamples: z.ZodNumber;
+            maximumDataBytes: z.ZodNumber;
+            maximumSteps: z.ZodNumber;
+            maximumSequenceLength: z.ZodNumber;
+            maximumDurationSeconds: z.ZodNumber;
+            maximumCheckpointBytes: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "state">;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type NeuronTrainingExecutionCapability = z.infer<typeof NeuronTrainingExecutionCapabilitySchema>;
+export declare const ManagedNeuronTrainingCompileSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    method: z.ZodLiteral<"selective_neuron_training">;
+    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>;
+    form: z.ZodObject<{
+        baseModel: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+        }, z.core.$strict>>;
+        targetBatch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        background: z.ZodArray<z.ZodObject<{
+            domain: z.ZodString;
+            batch: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        preservationBatch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        name: z.ZodString;
+        maximumSpendUsd: z.ZodString;
+        selection: z.ZodObject<{
+            count: z.ZodString;
+            span: z.ZodEnum<{
+                prompt: "prompt";
+                reply_prediction: "reply_prediction";
+                reply_start: "reply_start";
+            }>;
+            backgroundStatistic: z.ZodEnum<{
+                max_domains: "max_domains";
+                mean_domains: "mean_domains";
+            }>;
+            maximumBackgroundTargetRatio: z.ZodString;
+            gradientExamples: z.ZodString;
+            coordinates: z.ZodString;
+        }, z.core.$strict>;
+        training: z.ZodObject<{
+            learningRate: z.ZodString;
+            maxSteps: z.ZodString;
+            gradientAccumulationSteps: z.ZodString;
+            maxSequenceLength: z.ZodString;
+            preservationWeight: z.ZodString;
+            preservationExamplesPerStep: z.ZodString;
+            seed: z.ZodString;
+            maxDurationSeconds: z.ZodString;
+            maxCheckpointBytes: z.ZodString;
+            maximumForwardTokenWork: z.ZodString;
+        }, z.core.$strict>;
+        parentArtifact: z.ZodNull;
+        inspectionSource: z.ZodOptional<z.ZodObject<{
+            result: z.ZodObject<{
+                location: z.ZodLiteral<"cloud">;
+                apiOrigin: z.ZodURL;
+                owner: z.ZodObject<{
+                    teamId: z.ZodString;
+                    actorId: z.ZodString;
+                }, z.core.$strict>;
+                projectId: z.ZodNullable<z.ZodString>;
+                kind: z.ZodLiteral<"managed_modification_result">;
+                executionId: z.ZodString;
+                method: z.ZodEnum<{
+                    inspect_activations: "inspect_activations";
+                    neuron_steering: "neuron_steering";
+                }>;
+                inputHash: z.ZodString;
+                runtimeHash: z.ZodString;
+                resultHash: z.ZodString;
+            }, z.core.$strict>;
+            modelHash: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ManagedNeuronTrainingCompile = z.infer<typeof ManagedNeuronTrainingCompileSchema>;
+export declare const ManagedNeuronTrainingCompilationContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.managedNeuronTrainingCompilation.v1">;
+    teamId: z.ZodString;
+    actorId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    method: z.ZodLiteral<"selective_neuron_training">;
+    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>;
+    formHash: z.ZodString;
+    inputHash: z.ZodString;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.selectiveNeuronTrainingRequest.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>;
+        data: z.ZodObject<{
+            target: z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>;
+            background: z.ZodArray<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+                domain: z.ZodString;
+            }, z.core.$strict>>;
+            preservation: z.ZodNullable<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        selection: z.ZodObject<{
+            count: z.ZodNumber;
+            span: z.ZodEnum<{
+                prompt: "prompt";
+                reply_prediction: "reply_prediction";
+                reply_start: "reply_start";
+            }>;
+            backgroundStatistic: z.ZodEnum<{
+                max_domains: "max_domains";
+                mean_domains: "mean_domains";
+            }>;
+            maximumBackgroundTargetRatio: z.ZodNumber;
+            gradientExamples: z.ZodNumber;
+            explicitCoordinates: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                neuron: z.ZodNumber;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        training: z.ZodObject<{
+            learningRate: z.ZodNumber;
+            maxSteps: z.ZodNumber;
+            gradientAccumulationSteps: z.ZodNumber;
+            maxSequenceLength: z.ZodNumber;
+            preservationWeight: z.ZodNumber;
+            preservationExamplesPerStep: z.ZodNumber;
+            seed: z.ZodNumber;
+            maxDurationSeconds: z.ZodNumber;
+            maxCheckpointBytes: z.ZodNumber;
+            maximumForwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>;
+        parentArtifact: z.ZodNull;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ManagedNeuronTrainingCompilationSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.managedNeuronTrainingCompilation.v1">;
+    teamId: z.ZodString;
+    actorId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    method: z.ZodLiteral<"selective_neuron_training">;
+    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>;
+    formHash: z.ZodString;
+    inputHash: z.ZodString;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.selectiveNeuronTrainingRequest.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>;
+        data: z.ZodObject<{
+            target: z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>;
+            background: z.ZodArray<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+                domain: z.ZodString;
+            }, z.core.$strict>>;
+            preservation: z.ZodNullable<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        selection: z.ZodObject<{
+            count: z.ZodNumber;
+            span: z.ZodEnum<{
+                prompt: "prompt";
+                reply_prediction: "reply_prediction";
+                reply_start: "reply_start";
+            }>;
+            backgroundStatistic: z.ZodEnum<{
+                max_domains: "max_domains";
+                mean_domains: "mean_domains";
+            }>;
+            maximumBackgroundTargetRatio: z.ZodNumber;
+            gradientExamples: z.ZodNumber;
+            explicitCoordinates: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                neuron: z.ZodNumber;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        training: z.ZodObject<{
+            learningRate: z.ZodNumber;
+            maxSteps: z.ZodNumber;
+            gradientAccumulationSteps: z.ZodNumber;
+            maxSequenceLength: z.ZodNumber;
+            preservationWeight: z.ZodNumber;
+            preservationExamplesPerStep: z.ZodNumber;
+            seed: z.ZodNumber;
+            maxDurationSeconds: z.ZodNumber;
+            maxCheckpointBytes: z.ZodNumber;
+            maximumForwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>;
+        parentArtifact: z.ZodNull;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type ManagedNeuronTrainingCompilation = z.infer<typeof ManagedNeuronTrainingCompilationSchema>;
+export declare const ManagedNeuronTrainingPrepareSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    operationId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    method: z.ZodLiteral<"selective_neuron_training">;
+    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.selectiveNeuronTrainingRequest.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>;
+        data: z.ZodObject<{
+            target: z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>;
+            background: z.ZodArray<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+                domain: z.ZodString;
+            }, z.core.$strict>>;
+            preservation: z.ZodNullable<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        selection: z.ZodObject<{
+            count: z.ZodNumber;
+            span: z.ZodEnum<{
+                prompt: "prompt";
+                reply_prediction: "reply_prediction";
+                reply_start: "reply_start";
+            }>;
+            backgroundStatistic: z.ZodEnum<{
+                max_domains: "max_domains";
+                mean_domains: "mean_domains";
+            }>;
+            maximumBackgroundTargetRatio: z.ZodNumber;
+            gradientExamples: z.ZodNumber;
+            explicitCoordinates: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                neuron: z.ZodNumber;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        training: z.ZodObject<{
+            learningRate: z.ZodNumber;
+            maxSteps: z.ZodNumber;
+            gradientAccumulationSteps: z.ZodNumber;
+            maxSequenceLength: z.ZodNumber;
+            preservationWeight: z.ZodNumber;
+            preservationExamplesPerStep: z.ZodNumber;
+            seed: z.ZodNumber;
+            maxDurationSeconds: z.ZodNumber;
+            maxCheckpointBytes: z.ZodNumber;
+            maximumForwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>;
+        parentArtifact: z.ZodNull;
+    }, z.core.$strict>;
+    maximumSpendUsd: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sourceForm: z.ZodOptional<z.ZodObject<{
+        baseModel: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+        }, z.core.$strict>>;
+        targetBatch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        background: z.ZodArray<z.ZodObject<{
+            domain: z.ZodString;
+            batch: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        preservationBatch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        name: z.ZodString;
+        maximumSpendUsd: z.ZodString;
+        selection: z.ZodObject<{
+            count: z.ZodString;
+            span: z.ZodEnum<{
+                prompt: "prompt";
+                reply_prediction: "reply_prediction";
+                reply_start: "reply_start";
+            }>;
+            backgroundStatistic: z.ZodEnum<{
+                max_domains: "max_domains";
+                mean_domains: "mean_domains";
+            }>;
+            maximumBackgroundTargetRatio: z.ZodString;
+            gradientExamples: z.ZodString;
+            coordinates: z.ZodString;
+        }, z.core.$strict>;
+        training: z.ZodObject<{
+            learningRate: z.ZodString;
+            maxSteps: z.ZodString;
+            gradientAccumulationSteps: z.ZodString;
+            maxSequenceLength: z.ZodString;
+            preservationWeight: z.ZodString;
+            preservationExamplesPerStep: z.ZodString;
+            seed: z.ZodString;
+            maxDurationSeconds: z.ZodString;
+            maxCheckpointBytes: z.ZodString;
+            maximumForwardTokenWork: z.ZodString;
+        }, z.core.$strict>;
+        parentArtifact: z.ZodNull;
+        inspectionSource: z.ZodOptional<z.ZodObject<{
+            result: z.ZodObject<{
+                location: z.ZodLiteral<"cloud">;
+                apiOrigin: z.ZodURL;
+                owner: z.ZodObject<{
+                    teamId: z.ZodString;
+                    actorId: z.ZodString;
+                }, z.core.$strict>;
+                projectId: z.ZodNullable<z.ZodString>;
+                kind: z.ZodLiteral<"managed_modification_result">;
+                executionId: z.ZodString;
+                method: z.ZodEnum<{
+                    inspect_activations: "inspect_activations";
+                    neuron_steering: "neuron_steering";
+                }>;
+                inputHash: z.ZodString;
+                runtimeHash: z.ZodString;
+                resultHash: z.ZodString;
+            }, z.core.$strict>;
+            modelHash: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ManagedNeuronTrainingPrepare = z.infer<typeof ManagedNeuronTrainingPrepareSchema>;
+export declare const ManagedNeuronTrainingStartSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    id: z.ZodString;
+    operationId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    planHash: z.ZodString;
+    action: z.ZodLiteral<"start">;
+    approvedMaximumSpendUsd: z.ZodNullable<z.ZodString>;
+    approvedPriceHash: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ManagedNeuronTrainingCancelSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    id: z.ZodString;
+    operationId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    planHash: z.ZodString;
+    action: z.ZodLiteral<"cancel">;
+}, z.core.$strict>;
+export type ManagedNeuronTrainingStart = z.infer<typeof ManagedNeuronTrainingStartSchema>;
+export type ManagedNeuronTrainingCancel = z.infer<typeof ManagedNeuronTrainingCancelSchema>;
+export declare const ManagedNeuronTrainingExecutionMetadataSchema: 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.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>>;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    updatedAt: z.ZodISODateTime;
+    method: z.ZodLiteral<"selective_neuron_training">;
+}, z.core.$strict>;
+export declare const ManagedNeuronTrainingExecutionContentSchema: 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.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>>;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    updatedAt: z.ZodISODateTime;
+    method: z.ZodLiteral<"selective_neuron_training">;
+    schemaVersion: z.ZodLiteral<"openpond.managedNeuronTrainingExecution.v1">;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.selectiveNeuronTrainingRequest.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>;
+        data: z.ZodObject<{
+            target: z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>;
+            background: z.ZodArray<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+                domain: z.ZodString;
+            }, z.core.$strict>>;
+            preservation: z.ZodNullable<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        selection: z.ZodObject<{
+            count: z.ZodNumber;
+            span: z.ZodEnum<{
+                prompt: "prompt";
+                reply_prediction: "reply_prediction";
+                reply_start: "reply_start";
+            }>;
+            backgroundStatistic: z.ZodEnum<{
+                max_domains: "max_domains";
+                mean_domains: "mean_domains";
+            }>;
+            maximumBackgroundTargetRatio: z.ZodNumber;
+            gradientExamples: z.ZodNumber;
+            explicitCoordinates: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                neuron: z.ZodNumber;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        training: z.ZodObject<{
+            learningRate: z.ZodNumber;
+            maxSteps: z.ZodNumber;
+            gradientAccumulationSteps: z.ZodNumber;
+            maxSequenceLength: z.ZodNumber;
+            preservationWeight: z.ZodNumber;
+            preservationExamplesPerStep: z.ZodNumber;
+            seed: z.ZodNumber;
+            maxDurationSeconds: z.ZodNumber;
+            maxCheckpointBytes: z.ZodNumber;
+            maximumForwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>;
+        parentArtifact: z.ZodNull;
+    }, z.core.$strict>;
+    sourceForm: z.ZodOptional<z.ZodObject<{
+        baseModel: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+        }, z.core.$strict>>;
+        targetBatch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        background: z.ZodArray<z.ZodObject<{
+            domain: z.ZodString;
+            batch: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        preservationBatch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        name: z.ZodString;
+        maximumSpendUsd: z.ZodString;
+        selection: z.ZodObject<{
+            count: z.ZodString;
+            span: z.ZodEnum<{
+                prompt: "prompt";
+                reply_prediction: "reply_prediction";
+                reply_start: "reply_start";
+            }>;
+            backgroundStatistic: z.ZodEnum<{
+                max_domains: "max_domains";
+                mean_domains: "mean_domains";
+            }>;
+            maximumBackgroundTargetRatio: z.ZodString;
+            gradientExamples: z.ZodString;
+            coordinates: z.ZodString;
+        }, z.core.$strict>;
+        training: z.ZodObject<{
+            learningRate: z.ZodString;
+            maxSteps: z.ZodString;
+            gradientAccumulationSteps: z.ZodString;
+            maxSequenceLength: z.ZodString;
+            preservationWeight: z.ZodString;
+            preservationExamplesPerStep: z.ZodString;
+            seed: z.ZodString;
+            maxDurationSeconds: z.ZodString;
+            maxCheckpointBytes: z.ZodString;
+            maximumForwardTokenWork: z.ZodString;
+        }, z.core.$strict>;
+        parentArtifact: z.ZodNull;
+        inspectionSource: z.ZodOptional<z.ZodObject<{
+            result: z.ZodObject<{
+                location: z.ZodLiteral<"cloud">;
+                apiOrigin: z.ZodURL;
+                owner: z.ZodObject<{
+                    teamId: z.ZodString;
+                    actorId: z.ZodString;
+                }, z.core.$strict>;
+                projectId: z.ZodNullable<z.ZodString>;
+                kind: z.ZodLiteral<"managed_modification_result">;
+                executionId: z.ZodString;
+                method: z.ZodEnum<{
+                    inspect_activations: "inspect_activations";
+                    neuron_steering: "neuron_steering";
+                }>;
+                inputHash: z.ZodString;
+                runtimeHash: z.ZodString;
+                resultHash: z.ZodString;
+            }, z.core.$strict>;
+            modelHash: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    result: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronTrainingResult.v1">;
+        inputHash: z.ZodString;
+        modelHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        dataHash: z.ZodString;
+        preparedRowsHash: z.ZodString;
+        selection: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
+            modelHash: z.ZodString;
+            dataHash: z.ZodString;
+            selectionConfigHash: z.ZodString;
+            preparedRowsHash: z.ZodString;
+            source: z.ZodEnum<{
+                automatic: "automatic";
+                explicit: "explicit";
+            }>;
+            targetExampleIds: z.ZodArray<z.ZodString>;
+            eligibleCount: z.ZodNumber;
+            entries: z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                neuron: z.ZodNumber;
+                targetMeanAbsolute: z.ZodNumber;
+                backgroundMeanAbsolute: z.ZodNumber;
+                backgroundTargetRatio: z.ZodNumber;
+                gradientNorm: z.ZodNumber;
+                score: z.ZodNumber;
+                targetActivityThreshold: z.ZodNumber;
+                backgroundByDomain: z.ZodArray<z.ZodObject<{
+                    domainIndex: z.ZodNumber;
+                    meanAbsolute: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        optimizerSteps: z.ZodNumber;
+        examplesProcessed: z.ZodNumber;
+        targetTokens: z.ZodNumber;
+        preservationTokens: z.ZodNumber;
+        work: z.ZodObject<{
+            selectionTarget: z.ZodNumber;
+            selectionBackground: z.ZodNumber;
+            selectionGradient: z.ZodNumber;
+            training: z.ZodNumber;
+            preservationOriginal: z.ZodNumber;
+            preservationEdited: z.ZodNumber;
+            verification: z.ZodNumber;
+        }, z.core.$strict>;
+        forwardTokenWork: z.ZodNumber;
+        backwardTokenWork: z.ZodNumber;
+        durationMs: z.ZodNumber;
+        meanLoss: z.ZodNumber;
+        finalLoss: z.ZodNumber;
+        meanPreservationKl: z.ZodNullable<z.ZodNumber>;
+        baseWeightsHashBefore: z.ZodString;
+        baseWeightsHashAfter: z.ZodString;
+        baseOptimizerParameterCount: z.ZodLiteral<0>;
+        baseGradientParameterCount: z.ZodLiteral<0>;
+        trainableParameterCount: z.ZodNumber;
+        artifact: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            manifest: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.neuronTrainingArtifact.v1">;
+                method: z.ZodLiteral<"selective_neuron_training">;
+                algorithm: z.ZodObject<{
+                    implementation: z.ZodLiteral<"openpond_qwen3_selective_columns_v1">;
+                    upstream: z.ZodLiteral<"changjonathanc/neuron-tuning">;
+                    revision: z.ZodLiteral<"8a55f3159f735eb0823d7a894f67f632bf568bb3">;
+                    license: z.ZodLiteral<"Apache-2.0">;
+                    hook: z.ZodLiteral<"mlp.down_proj">;
+                    operation: z.ZodLiteral<"output_plus_selected_input_times_delta_v1">;
+                    parameterization: z.ZodLiteral<"column_gain_rms_direction_v1">;
+                    activityQuantile: z.ZodLiteral<0.9>;
+                    backgroundFloor: z.ZodLiteral<0.000001>;
+                    gradientSubsetSeed: z.ZodLiteral<0>;
+                    optimizer: z.ZodLiteral<"Adam">;
+                    betas: z.ZodTuple<[z.ZodLiteral<0.9>, z.ZodLiteral<0.999>], null>;
+                    epsilon: z.ZodLiteral<1e-8>;
+                    weightDecay: z.ZodLiteral<0>;
+                    gradientClipNorm: z.ZodLiteral<1>;
+                    batchSize: z.ZodLiteral<1>;
+                    parameterDtype: z.ZodLiteral<"float32">;
+                    resume: z.ZodLiteral<"unsupported">;
+                }, z.core.$strict>;
+                pins: z.ZodObject<{
+                    baseModel: 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>;
+                    inputHash: z.ZodString;
+                    data: z.ZodObject<{
+                        target: z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                            encodingHash: z.ZodString;
+                        }, z.core.$strict>;
+                        background: z.ZodArray<z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                            encodingHash: z.ZodString;
+                            domain: z.ZodString;
+                        }, z.core.$strict>>;
+                        preservation: z.ZodNullable<z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                            encodingHash: z.ZodString;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>;
+                    dataHash: z.ZodString;
+                    selectionConfigHash: z.ZodString;
+                    trainingConfigHash: z.ZodString;
+                    runtimeHash: z.ZodString;
+                    parentArtifactHash: z.ZodNull;
+                }, z.core.$strict>;
+                selection: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
+                    modelHash: z.ZodString;
+                    dataHash: z.ZodString;
+                    selectionConfigHash: z.ZodString;
+                    preparedRowsHash: z.ZodString;
+                    source: z.ZodEnum<{
+                        automatic: "automatic";
+                        explicit: "explicit";
+                    }>;
+                    targetExampleIds: z.ZodArray<z.ZodString>;
+                    eligibleCount: z.ZodNumber;
+                    entries: z.ZodArray<z.ZodObject<{
+                        layer: z.ZodNumber;
+                        neuron: z.ZodNumber;
+                        targetMeanAbsolute: z.ZodNumber;
+                        backgroundMeanAbsolute: z.ZodNumber;
+                        backgroundTargetRatio: z.ZodNumber;
+                        gradientNorm: z.ZodNumber;
+                        score: z.ZodNumber;
+                        targetActivityThreshold: z.ZodNumber;
+                        backgroundByDomain: z.ZodArray<z.ZodObject<{
+                            domainIndex: z.ZodNumber;
+                            meanAbsolute: z.ZodNumber;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                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<{
+                            F32: "F32";
+                            I64: "I64";
+                        }>;
+                        shape: z.ZodArray<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, 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>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    resultRecordedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export declare const ManagedNeuronTrainingExecutionSchema: 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.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>>;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    updatedAt: z.ZodISODateTime;
+    method: z.ZodLiteral<"selective_neuron_training">;
+    schemaVersion: z.ZodLiteral<"openpond.managedNeuronTrainingExecution.v1">;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.selectiveNeuronTrainingRequest.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>;
+        data: z.ZodObject<{
+            target: z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>;
+            background: z.ZodArray<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+                domain: z.ZodString;
+            }, z.core.$strict>>;
+            preservation: z.ZodNullable<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        selection: z.ZodObject<{
+            count: z.ZodNumber;
+            span: z.ZodEnum<{
+                prompt: "prompt";
+                reply_prediction: "reply_prediction";
+                reply_start: "reply_start";
+            }>;
+            backgroundStatistic: z.ZodEnum<{
+                max_domains: "max_domains";
+                mean_domains: "mean_domains";
+            }>;
+            maximumBackgroundTargetRatio: z.ZodNumber;
+            gradientExamples: z.ZodNumber;
+            explicitCoordinates: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                neuron: z.ZodNumber;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        training: z.ZodObject<{
+            learningRate: z.ZodNumber;
+            maxSteps: z.ZodNumber;
+            gradientAccumulationSteps: z.ZodNumber;
+            maxSequenceLength: z.ZodNumber;
+            preservationWeight: z.ZodNumber;
+            preservationExamplesPerStep: z.ZodNumber;
+            seed: z.ZodNumber;
+            maxDurationSeconds: z.ZodNumber;
+            maxCheckpointBytes: z.ZodNumber;
+            maximumForwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>;
+        parentArtifact: z.ZodNull;
+    }, z.core.$strict>;
+    sourceForm: z.ZodOptional<z.ZodObject<{
+        baseModel: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+        }, z.core.$strict>>;
+        targetBatch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        background: z.ZodArray<z.ZodObject<{
+            domain: z.ZodString;
+            batch: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        preservationBatch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        name: z.ZodString;
+        maximumSpendUsd: z.ZodString;
+        selection: z.ZodObject<{
+            count: z.ZodString;
+            span: z.ZodEnum<{
+                prompt: "prompt";
+                reply_prediction: "reply_prediction";
+                reply_start: "reply_start";
+            }>;
+            backgroundStatistic: z.ZodEnum<{
+                max_domains: "max_domains";
+                mean_domains: "mean_domains";
+            }>;
+            maximumBackgroundTargetRatio: z.ZodString;
+            gradientExamples: z.ZodString;
+            coordinates: z.ZodString;
+        }, z.core.$strict>;
+        training: z.ZodObject<{
+            learningRate: z.ZodString;
+            maxSteps: z.ZodString;
+            gradientAccumulationSteps: z.ZodString;
+            maxSequenceLength: z.ZodString;
+            preservationWeight: z.ZodString;
+            preservationExamplesPerStep: z.ZodString;
+            seed: z.ZodString;
+            maxDurationSeconds: z.ZodString;
+            maxCheckpointBytes: z.ZodString;
+            maximumForwardTokenWork: z.ZodString;
+        }, z.core.$strict>;
+        parentArtifact: z.ZodNull;
+        inspectionSource: z.ZodOptional<z.ZodObject<{
+            result: z.ZodObject<{
+                location: z.ZodLiteral<"cloud">;
+                apiOrigin: z.ZodURL;
+                owner: z.ZodObject<{
+                    teamId: z.ZodString;
+                    actorId: z.ZodString;
+                }, z.core.$strict>;
+                projectId: z.ZodNullable<z.ZodString>;
+                kind: z.ZodLiteral<"managed_modification_result">;
+                executionId: z.ZodString;
+                method: z.ZodEnum<{
+                    inspect_activations: "inspect_activations";
+                    neuron_steering: "neuron_steering";
+                }>;
+                inputHash: z.ZodString;
+                runtimeHash: z.ZodString;
+                resultHash: z.ZodString;
+            }, z.core.$strict>;
+            modelHash: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    result: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronTrainingResult.v1">;
+        inputHash: z.ZodString;
+        modelHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        dataHash: z.ZodString;
+        preparedRowsHash: z.ZodString;
+        selection: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
+            modelHash: z.ZodString;
+            dataHash: z.ZodString;
+            selectionConfigHash: z.ZodString;
+            preparedRowsHash: z.ZodString;
+            source: z.ZodEnum<{
+                automatic: "automatic";
+                explicit: "explicit";
+            }>;
+            targetExampleIds: z.ZodArray<z.ZodString>;
+            eligibleCount: z.ZodNumber;
+            entries: z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                neuron: z.ZodNumber;
+                targetMeanAbsolute: z.ZodNumber;
+                backgroundMeanAbsolute: z.ZodNumber;
+                backgroundTargetRatio: z.ZodNumber;
+                gradientNorm: z.ZodNumber;
+                score: z.ZodNumber;
+                targetActivityThreshold: z.ZodNumber;
+                backgroundByDomain: z.ZodArray<z.ZodObject<{
+                    domainIndex: z.ZodNumber;
+                    meanAbsolute: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        optimizerSteps: z.ZodNumber;
+        examplesProcessed: z.ZodNumber;
+        targetTokens: z.ZodNumber;
+        preservationTokens: z.ZodNumber;
+        work: z.ZodObject<{
+            selectionTarget: z.ZodNumber;
+            selectionBackground: z.ZodNumber;
+            selectionGradient: z.ZodNumber;
+            training: z.ZodNumber;
+            preservationOriginal: z.ZodNumber;
+            preservationEdited: z.ZodNumber;
+            verification: z.ZodNumber;
+        }, z.core.$strict>;
+        forwardTokenWork: z.ZodNumber;
+        backwardTokenWork: z.ZodNumber;
+        durationMs: z.ZodNumber;
+        meanLoss: z.ZodNumber;
+        finalLoss: z.ZodNumber;
+        meanPreservationKl: z.ZodNullable<z.ZodNumber>;
+        baseWeightsHashBefore: z.ZodString;
+        baseWeightsHashAfter: z.ZodString;
+        baseOptimizerParameterCount: z.ZodLiteral<0>;
+        baseGradientParameterCount: z.ZodLiteral<0>;
+        trainableParameterCount: z.ZodNumber;
+        artifact: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            manifest: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.neuronTrainingArtifact.v1">;
+                method: z.ZodLiteral<"selective_neuron_training">;
+                algorithm: z.ZodObject<{
+                    implementation: z.ZodLiteral<"openpond_qwen3_selective_columns_v1">;
+                    upstream: z.ZodLiteral<"changjonathanc/neuron-tuning">;
+                    revision: z.ZodLiteral<"8a55f3159f735eb0823d7a894f67f632bf568bb3">;
+                    license: z.ZodLiteral<"Apache-2.0">;
+                    hook: z.ZodLiteral<"mlp.down_proj">;
+                    operation: z.ZodLiteral<"output_plus_selected_input_times_delta_v1">;
+                    parameterization: z.ZodLiteral<"column_gain_rms_direction_v1">;
+                    activityQuantile: z.ZodLiteral<0.9>;
+                    backgroundFloor: z.ZodLiteral<0.000001>;
+                    gradientSubsetSeed: z.ZodLiteral<0>;
+                    optimizer: z.ZodLiteral<"Adam">;
+                    betas: z.ZodTuple<[z.ZodLiteral<0.9>, z.ZodLiteral<0.999>], null>;
+                    epsilon: z.ZodLiteral<1e-8>;
+                    weightDecay: z.ZodLiteral<0>;
+                    gradientClipNorm: z.ZodLiteral<1>;
+                    batchSize: z.ZodLiteral<1>;
+                    parameterDtype: z.ZodLiteral<"float32">;
+                    resume: z.ZodLiteral<"unsupported">;
+                }, z.core.$strict>;
+                pins: z.ZodObject<{
+                    baseModel: 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>;
+                    inputHash: z.ZodString;
+                    data: z.ZodObject<{
+                        target: z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                            encodingHash: z.ZodString;
+                        }, z.core.$strict>;
+                        background: z.ZodArray<z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                            encodingHash: z.ZodString;
+                            domain: z.ZodString;
+                        }, z.core.$strict>>;
+                        preservation: z.ZodNullable<z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                            encodingHash: z.ZodString;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>;
+                    dataHash: z.ZodString;
+                    selectionConfigHash: z.ZodString;
+                    trainingConfigHash: z.ZodString;
+                    runtimeHash: z.ZodString;
+                    parentArtifactHash: z.ZodNull;
+                }, z.core.$strict>;
+                selection: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
+                    modelHash: z.ZodString;
+                    dataHash: z.ZodString;
+                    selectionConfigHash: z.ZodString;
+                    preparedRowsHash: z.ZodString;
+                    source: z.ZodEnum<{
+                        automatic: "automatic";
+                        explicit: "explicit";
+                    }>;
+                    targetExampleIds: z.ZodArray<z.ZodString>;
+                    eligibleCount: z.ZodNumber;
+                    entries: z.ZodArray<z.ZodObject<{
+                        layer: z.ZodNumber;
+                        neuron: z.ZodNumber;
+                        targetMeanAbsolute: z.ZodNumber;
+                        backgroundMeanAbsolute: z.ZodNumber;
+                        backgroundTargetRatio: z.ZodNumber;
+                        gradientNorm: z.ZodNumber;
+                        score: z.ZodNumber;
+                        targetActivityThreshold: z.ZodNumber;
+                        backgroundByDomain: z.ZodArray<z.ZodObject<{
+                            domainIndex: z.ZodNumber;
+                            meanAbsolute: z.ZodNumber;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                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<{
+                            F32: "F32";
+                            I64: "I64";
+                        }>;
+                        shape: z.ZodArray<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, 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>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    resultRecordedAt: z.ZodNullable<z.ZodISODateTime>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type ManagedNeuronTrainingExecution = z.infer<typeof ManagedNeuronTrainingExecutionSchema>;
+export declare const ManagedNeuronTrainingExecutionReceiptContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.managedNeuronTrainingExecutionReceipt.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.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>>;
+            createdAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+        updatedAt: z.ZodISODateTime;
+        method: z.ZodLiteral<"selective_neuron_training">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ManagedNeuronTrainingExecutionReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.managedNeuronTrainingExecutionReceipt.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.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>>;
+            createdAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+        updatedAt: z.ZodISODateTime;
+        method: z.ZodLiteral<"selective_neuron_training">;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type ManagedNeuronTrainingExecutionReceipt = z.infer<typeof ManagedNeuronTrainingExecutionReceiptSchema>;
+export declare const ManagedNeuronTrainingExecutionListQuerySchema: z.ZodObject<{
+    method: z.ZodDefault<z.ZodLiteral<"selective_neuron_training">>;
+    id: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    phase: z.ZodOptional<z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        dispatching: "dispatching";
+        failed: "failed";
+        prepared: "prepared";
+        queued: "queued";
+        stopping: "stopping";
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ManagedNeuronTrainingExecutionListQuery = z.input<typeof ManagedNeuronTrainingExecutionListQuerySchema>;
+export declare const ManagedNeuronTrainingExecutionSummarySchema: 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.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>>;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    updatedAt: z.ZodISODateTime;
+    method: z.ZodLiteral<"selective_neuron_training">;
+    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>;
+export declare const ManagedNeuronTrainingExecutionPageContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.managedNeuronTrainingExecutionPage.v1">;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    query: z.ZodObject<{
+        method: z.ZodDefault<z.ZodLiteral<"selective_neuron_training">>;
+        id: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        phase: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            dispatching: "dispatching";
+            failed: "failed";
+            prepared: "prepared";
+            queued: "queued";
+            stopping: "stopping";
+        }>>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    }, 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.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>>;
+            createdAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+        updatedAt: z.ZodISODateTime;
+        method: z.ZodLiteral<"selective_neuron_training">;
+        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 ManagedNeuronTrainingExecutionPageSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.managedNeuronTrainingExecutionPage.v1">;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    query: z.ZodObject<{
+        method: z.ZodDefault<z.ZodLiteral<"selective_neuron_training">>;
+        id: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        phase: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            dispatching: "dispatching";
+            failed: "failed";
+            prepared: "prepared";
+            queued: "queued";
+            stopping: "stopping";
+        }>>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    }, 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.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>>;
+            createdAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+        updatedAt: z.ZodISODateTime;
+        method: z.ZodLiteral<"selective_neuron_training">;
+        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 ManagedNeuronTrainingExecutionPage = z.infer<typeof ManagedNeuronTrainingExecutionPageSchema>;
+export declare function parseNeuronTrainingFormTraining(raw: z.infer<typeof NeuronTrainingExperimentFormDraftSchema>["training"]): {
+    learningRate: number;
+    maxSteps: number;
+    gradientAccumulationSteps: number;
+    maxSequenceLength: number;
+    preservationWeight: number;
+    preservationExamplesPerStep: number;
+    seed: number;
+    maxDurationSeconds: number;
+    maxCheckpointBytes: number;
+    maximumForwardTokenWork: number;
+};
+export declare function parseNeuronTrainingFormSelection(form: z.infer<typeof NeuronTrainingExperimentFormDraftSchema>["selection"]): {
+    count: number;
+    span: "prompt" | "reply_prediction" | "reply_start";
+    backgroundStatistic: "max_domains" | "mean_domains";
+    maximumBackgroundTargetRatio: number;
+    gradientExamples: number;
+    explicitCoordinates: {
+        layer: number;
+        neuron: number;
+    }[] | null;
+};
+export declare function parseAndVerifyNeuronTrainingExecutionCapability(raw: unknown, queryInput: z.infer<typeof Query>, actorId?: string): Promise<{
+    schemaVersion: "openpond.neuronTrainingExecutionCapability.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.selectiveNeuronTrainingRequest.v1";
+            evidence: {
+                id: string;
+                contentHash: string;
+            };
+        };
+        limits: {
+            maximumExamples: number;
+            maximumDataBytes: number;
+            maximumSteps: number;
+            maximumSequenceLength: number;
+            maximumDurationSeconds: number;
+            maximumCheckpointBytes: number;
+        };
+    };
+    contentHash: string;
+}>;
+export declare function parseAndVerifyManagedNeuronTrainingCompilation(raw: unknown, input: ManagedNeuronTrainingCompile): Promise<{
+    schemaVersion: "openpond.managedNeuronTrainingCompilation.v1";
+    teamId: string;
+    actorId: string;
+    projectId: string | null;
+    method: "selective_neuron_training";
+    query: {
+        teamId: string;
+        modelId: string;
+        source: "builtin" | "local" | "managed";
+        revision?: string | undefined;
+        tokenizerRevision?: string | undefined;
+        chatTemplateHash?: string | undefined;
+        modelAssetId?: string | undefined;
+    };
+    formHash: string;
+    inputHash: string;
+    request: {
+        schemaVersion: "openpond.selectiveNeuronTrainingRequest.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[];
+        };
+        data: {
+            target: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+            };
+            background: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+                domain: string;
+            }[];
+            preservation: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+            } | null;
+        };
+        selection: {
+            count: number;
+            span: "prompt" | "reply_prediction" | "reply_start";
+            backgroundStatistic: "max_domains" | "mean_domains";
+            maximumBackgroundTargetRatio: number;
+            gradientExamples: number;
+            explicitCoordinates: {
+                layer: number;
+                neuron: number;
+            }[] | null;
+        };
+        training: {
+            learningRate: number;
+            maxSteps: number;
+            gradientAccumulationSteps: number;
+            maxSequenceLength: number;
+            preservationWeight: number;
+            preservationExamplesPerStep: number;
+            seed: number;
+            maxDurationSeconds: number;
+            maxCheckpointBytes: number;
+            maximumForwardTokenWork: number;
+        };
+        parentArtifact: null;
+    };
+    contentHash: string;
+}>;
+export declare function parseAndVerifyManagedNeuronTrainingExecution(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;
+        } | undefined;
+        createdAt: string;
+        expiresAt: string;
+    };
+    updatedAt: string;
+    method: "selective_neuron_training";
+    schemaVersion: "openpond.managedNeuronTrainingExecution.v1";
+    request: {
+        schemaVersion: "openpond.selectiveNeuronTrainingRequest.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[];
+        };
+        data: {
+            target: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+            };
+            background: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+                domain: string;
+            }[];
+            preservation: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+            } | null;
+        };
+        selection: {
+            count: number;
+            span: "prompt" | "reply_prediction" | "reply_start";
+            backgroundStatistic: "max_domains" | "mean_domains";
+            maximumBackgroundTargetRatio: number;
+            gradientExamples: number;
+            explicitCoordinates: {
+                layer: number;
+                neuron: number;
+            }[] | null;
+        };
+        training: {
+            learningRate: number;
+            maxSteps: number;
+            gradientAccumulationSteps: number;
+            maxSequenceLength: number;
+            preservationWeight: number;
+            preservationExamplesPerStep: number;
+            seed: number;
+            maxDurationSeconds: number;
+            maxCheckpointBytes: number;
+            maximumForwardTokenWork: number;
+        };
+        parentArtifact: null;
+    };
+    sourceForm?: {
+        baseModel: {
+            schemaVersion: "openpond.baseModelPreference.v1";
+            modelId: string;
+            revision: string | null;
+            tokenizerRevision: string | null;
+            chatTemplateHash: string | null;
+            modelAssetId: string | null;
+            source: "builtin" | "local" | "managed";
+        } | null;
+        targetBatch: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        background: {
+            domain: string;
+            batch: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null;
+        }[];
+        preservationBatch: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        name: string;
+        maximumSpendUsd: string;
+        selection: {
+            count: string;
+            span: "prompt" | "reply_prediction" | "reply_start";
+            backgroundStatistic: "max_domains" | "mean_domains";
+            maximumBackgroundTargetRatio: string;
+            gradientExamples: string;
+            coordinates: string;
+        };
+        training: {
+            learningRate: string;
+            maxSteps: string;
+            gradientAccumulationSteps: string;
+            maxSequenceLength: string;
+            preservationWeight: string;
+            preservationExamplesPerStep: string;
+            seed: string;
+            maxDurationSeconds: string;
+            maxCheckpointBytes: string;
+            maximumForwardTokenWork: string;
+        };
+        parentArtifact: null;
+        inspectionSource?: {
+            result: {
+                location: "cloud";
+                apiOrigin: string;
+                owner: {
+                    teamId: string;
+                    actorId: string;
+                };
+                projectId: string | null;
+                kind: "managed_modification_result";
+                executionId: string;
+                method: "inspect_activations" | "neuron_steering";
+                inputHash: string;
+                runtimeHash: string;
+                resultHash: string;
+            };
+            modelHash: string;
+        } | undefined;
+    } | undefined;
+    result: {
+        schemaVersion: "openpond.neuronTrainingResult.v1";
+        inputHash: string;
+        modelHash: string;
+        runtimeHash: string;
+        dataHash: string;
+        preparedRowsHash: string;
+        selection: {
+            schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
+            modelHash: string;
+            dataHash: string;
+            selectionConfigHash: string;
+            preparedRowsHash: string;
+            source: "automatic" | "explicit";
+            targetExampleIds: string[];
+            eligibleCount: number;
+            entries: {
+                layer: number;
+                neuron: number;
+                targetMeanAbsolute: number;
+                backgroundMeanAbsolute: number;
+                backgroundTargetRatio: number;
+                gradientNorm: number;
+                score: number;
+                targetActivityThreshold: number;
+                backgroundByDomain: {
+                    domainIndex: number;
+                    meanAbsolute: number;
+                }[];
+            }[];
+            contentHash: string;
+        };
+        optimizerSteps: number;
+        examplesProcessed: number;
+        targetTokens: number;
+        preservationTokens: number;
+        work: {
+            selectionTarget: number;
+            selectionBackground: number;
+            selectionGradient: number;
+            training: number;
+            preservationOriginal: number;
+            preservationEdited: number;
+            verification: number;
+        };
+        forwardTokenWork: number;
+        backwardTokenWork: number;
+        durationMs: number;
+        meanLoss: number;
+        finalLoss: number;
+        meanPreservationKl: number | null;
+        baseWeightsHashBefore: string;
+        baseWeightsHashAfter: string;
+        baseOptimizerParameterCount: 0;
+        baseGradientParameterCount: 0;
+        trainableParameterCount: number;
+        artifact: {
+            id: string;
+            contentHash: string;
+            manifest: {
+                schemaVersion: "openpond.neuronTrainingArtifact.v1";
+                method: "selective_neuron_training";
+                algorithm: {
+                    implementation: "openpond_qwen3_selective_columns_v1";
+                    upstream: "changjonathanc/neuron-tuning";
+                    revision: "8a55f3159f735eb0823d7a894f67f632bf568bb3";
+                    license: "Apache-2.0";
+                    hook: "mlp.down_proj";
+                    operation: "output_plus_selected_input_times_delta_v1";
+                    parameterization: "column_gain_rms_direction_v1";
+                    activityQuantile: 0.9;
+                    backgroundFloor: 0.000001;
+                    gradientSubsetSeed: 0;
+                    optimizer: "Adam";
+                    betas: [0.9, 0.999];
+                    epsilon: 1e-8;
+                    weightDecay: 0;
+                    gradientClipNorm: 1;
+                    batchSize: 1;
+                    parameterDtype: "float32";
+                    resume: "unsupported";
+                };
+                pins: {
+                    baseModel: {
+                        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[];
+                    };
+                    inputHash: string;
+                    data: {
+                        target: {
+                            batch: {
+                                id: string;
+                                contentHash: string;
+                                revision: number;
+                            };
+                            examplesSha256: string;
+                            encodingHash: string;
+                        };
+                        background: {
+                            batch: {
+                                id: string;
+                                contentHash: string;
+                                revision: number;
+                            };
+                            examplesSha256: string;
+                            encodingHash: string;
+                            domain: string;
+                        }[];
+                        preservation: {
+                            batch: {
+                                id: string;
+                                contentHash: string;
+                                revision: number;
+                            };
+                            examplesSha256: string;
+                            encodingHash: string;
+                        } | null;
+                    };
+                    dataHash: string;
+                    selectionConfigHash: string;
+                    trainingConfigHash: string;
+                    runtimeHash: string;
+                    parentArtifactHash: null;
+                };
+                selection: {
+                    schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
+                    modelHash: string;
+                    dataHash: string;
+                    selectionConfigHash: string;
+                    preparedRowsHash: string;
+                    source: "automatic" | "explicit";
+                    targetExampleIds: string[];
+                    eligibleCount: number;
+                    entries: {
+                        layer: number;
+                        neuron: number;
+                        targetMeanAbsolute: number;
+                        backgroundMeanAbsolute: number;
+                        backgroundTargetRatio: number;
+                        gradientNorm: number;
+                        score: number;
+                        targetActivityThreshold: number;
+                        backgroundByDomain: {
+                            domainIndex: number;
+                            meanAbsolute: number;
+                        }[];
+                    }[];
+                    contentHash: string;
+                };
+                payload: {
+                    path: "patch.safetensors";
+                    sha256: string;
+                    sizeBytes: number;
+                    tensors: {
+                        name: string;
+                        dtype: "F32" | "I64";
+                        shape: number[];
+                    }[];
+                };
+                contentHash: string;
+            };
+            files: {
+                path: "manifest.json" | "patch.safetensors";
+                artifactId: string;
+                sha256: string;
+                sizeBytes: number;
+            }[];
+        };
+        contentHash: string;
+    } | null;
+    resultRecordedAt: string | null;
+    contentHash: string;
+}>;
+export declare function parseAndVerifyManagedNeuronTrainingPrepare(raw: unknown): Promise<{
+    teamId: string;
+    operationId: string;
+    projectId: string | null;
+    name: string;
+    method: "selective_neuron_training";
+    query: {
+        teamId: string;
+        modelId: string;
+        source: "builtin" | "local" | "managed";
+        revision?: string | undefined;
+        tokenizerRevision?: string | undefined;
+        chatTemplateHash?: string | undefined;
+        modelAssetId?: string | undefined;
+    };
+    request: {
+        schemaVersion: "openpond.selectiveNeuronTrainingRequest.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[];
+        };
+        data: {
+            target: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+            };
+            background: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+                domain: string;
+            }[];
+            preservation: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+            } | null;
+        };
+        selection: {
+            count: number;
+            span: "prompt" | "reply_prediction" | "reply_start";
+            backgroundStatistic: "max_domains" | "mean_domains";
+            maximumBackgroundTargetRatio: number;
+            gradientExamples: number;
+            explicitCoordinates: {
+                layer: number;
+                neuron: number;
+            }[] | null;
+        };
+        training: {
+            learningRate: number;
+            maxSteps: number;
+            gradientAccumulationSteps: number;
+            maxSequenceLength: number;
+            preservationWeight: number;
+            preservationExamplesPerStep: number;
+            seed: number;
+            maxDurationSeconds: number;
+            maxCheckpointBytes: number;
+            maximumForwardTokenWork: number;
+        };
+        parentArtifact: null;
+    };
+    maximumSpendUsd?: string | null | undefined;
+    sourceForm?: {
+        baseModel: {
+            schemaVersion: "openpond.baseModelPreference.v1";
+            modelId: string;
+            revision: string | null;
+            tokenizerRevision: string | null;
+            chatTemplateHash: string | null;
+            modelAssetId: string | null;
+            source: "builtin" | "local" | "managed";
+        } | null;
+        targetBatch: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        background: {
+            domain: string;
+            batch: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null;
+        }[];
+        preservationBatch: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        name: string;
+        maximumSpendUsd: string;
+        selection: {
+            count: string;
+            span: "prompt" | "reply_prediction" | "reply_start";
+            backgroundStatistic: "max_domains" | "mean_domains";
+            maximumBackgroundTargetRatio: string;
+            gradientExamples: string;
+            coordinates: string;
+        };
+        training: {
+            learningRate: string;
+            maxSteps: string;
+            gradientAccumulationSteps: string;
+            maxSequenceLength: string;
+            preservationWeight: string;
+            preservationExamplesPerStep: string;
+            seed: string;
+            maxDurationSeconds: string;
+            maxCheckpointBytes: string;
+            maximumForwardTokenWork: string;
+        };
+        parentArtifact: null;
+        inspectionSource?: {
+            result: {
+                location: "cloud";
+                apiOrigin: string;
+                owner: {
+                    teamId: string;
+                    actorId: string;
+                };
+                projectId: string | null;
+                kind: "managed_modification_result";
+                executionId: string;
+                method: "inspect_activations" | "neuron_steering";
+                inputHash: string;
+                runtimeHash: string;
+                resultHash: string;
+            };
+            modelHash: string;
+        } | undefined;
+    } | undefined;
+}>;
+export declare function parseAndVerifyManagedNeuronTrainingExecutionReceipt(raw: unknown, command: ManagedNeuronTrainingPrepare | ManagedNeuronTrainingStart | ManagedNeuronTrainingCancel): Promise<{
+    schemaVersion: "openpond.managedNeuronTrainingExecutionReceipt.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;
+            } | undefined;
+            createdAt: string;
+            expiresAt: string;
+        };
+        updatedAt: string;
+        method: "selective_neuron_training";
+    };
+    contentHash: string;
+}>;
+export declare function parseAndVerifyManagedNeuronTrainingExecutionPage(raw: unknown, expected: {
+    teamId: string;
+    ownerUserId?: string;
+    query?: ManagedNeuronTrainingExecutionListQuery;
+}): Promise<{
+    schemaVersion: "openpond.managedNeuronTrainingExecutionPage.v1";
+    teamId: string;
+    ownerUserId: string;
+    query: {
+        method: "selective_neuron_training";
+        id?: string | undefined;
+        projectId?: string | undefined;
+        phase?: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping" | undefined;
+        limit: number;
+        cursor?: string | undefined;
+    };
+    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;
+            } | undefined;
+            createdAt: string;
+            expiresAt: string;
+        };
+        updatedAt: string;
+        method: "selective_neuron_training";
+        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;
+}>;
+/** Uses the same configured transport and existing execution endpoints. Typed
+ * NeuronTraining parsing never coerces a module into an activation or LoRA result. */
+export declare function createManagedNeuronTrainingExecutionClient(request: (path: string, init?: RequestInit) => Promise<unknown>): {
+    neuronTrainingExecutionCapability(raw: z.infer<typeof Query>, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        schemaVersion: "openpond.neuronTrainingExecutionCapability.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.selectiveNeuronTrainingRequest.v1";
+                evidence: {
+                    id: string;
+                    contentHash: string;
+                };
+            };
+            limits: {
+                maximumExamples: number;
+                maximumDataBytes: number;
+                maximumSteps: number;
+                maximumSequenceLength: number;
+                maximumDurationSeconds: number;
+                maximumCheckpointBytes: number;
+            };
+        };
+        contentHash: string;
+    }>;
+    compileNeuronTrainingExecution(raw: ManagedNeuronTrainingCompile): Promise<{
+        schemaVersion: "openpond.managedNeuronTrainingCompilation.v1";
+        teamId: string;
+        actorId: string;
+        projectId: string | null;
+        method: "selective_neuron_training";
+        query: {
+            teamId: string;
+            modelId: string;
+            source: "builtin" | "local" | "managed";
+            revision?: string | undefined;
+            tokenizerRevision?: string | undefined;
+            chatTemplateHash?: string | undefined;
+            modelAssetId?: string | undefined;
+        };
+        formHash: string;
+        inputHash: string;
+        request: {
+            schemaVersion: "openpond.selectiveNeuronTrainingRequest.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[];
+            };
+            data: {
+                target: {
+                    batch: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    examplesSha256: string;
+                    encodingHash: string;
+                };
+                background: {
+                    batch: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    examplesSha256: string;
+                    encodingHash: string;
+                    domain: string;
+                }[];
+                preservation: {
+                    batch: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    examplesSha256: string;
+                    encodingHash: string;
+                } | null;
+            };
+            selection: {
+                count: number;
+                span: "prompt" | "reply_prediction" | "reply_start";
+                backgroundStatistic: "max_domains" | "mean_domains";
+                maximumBackgroundTargetRatio: number;
+                gradientExamples: number;
+                explicitCoordinates: {
+                    layer: number;
+                    neuron: number;
+                }[] | null;
+            };
+            training: {
+                learningRate: number;
+                maxSteps: number;
+                gradientAccumulationSteps: number;
+                maxSequenceLength: number;
+                preservationWeight: number;
+                preservationExamplesPerStep: number;
+                seed: number;
+                maxDurationSeconds: number;
+                maxCheckpointBytes: number;
+                maximumForwardTokenWork: number;
+            };
+            parentArtifact: null;
+        };
+        contentHash: string;
+    }>;
+    prepareNeuronTrainingExecution(raw: ManagedNeuronTrainingPrepare): Promise<{
+        schemaVersion: "openpond.managedNeuronTrainingExecutionReceipt.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;
+                } | undefined;
+                createdAt: string;
+                expiresAt: string;
+            };
+            updatedAt: string;
+            method: "selective_neuron_training";
+        };
+        contentHash: string;
+    }>;
+    startNeuronTrainingExecution(raw: ManagedNeuronTrainingStart): Promise<{
+        schemaVersion: "openpond.managedNeuronTrainingExecutionReceipt.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;
+                } | undefined;
+                createdAt: string;
+                expiresAt: string;
+            };
+            updatedAt: string;
+            method: "selective_neuron_training";
+        };
+        contentHash: string;
+    }>;
+    cancelNeuronTrainingExecution(raw: ManagedNeuronTrainingCancel): Promise<{
+        schemaVersion: "openpond.managedNeuronTrainingExecutionReceipt.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;
+                } | undefined;
+                createdAt: string;
+                expiresAt: string;
+            };
+            updatedAt: string;
+            method: "selective_neuron_training";
+        };
+        contentHash: string;
+    }>;
+    getNeuronTrainingExecution(teamId: string, id: string, options?: {
+        signal?: AbortSignal;
+        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;
+            } | undefined;
+            createdAt: string;
+            expiresAt: string;
+        };
+        updatedAt: string;
+        method: "selective_neuron_training";
+        schemaVersion: "openpond.managedNeuronTrainingExecution.v1";
+        request: {
+            schemaVersion: "openpond.selectiveNeuronTrainingRequest.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[];
+            };
+            data: {
+                target: {
+                    batch: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    examplesSha256: string;
+                    encodingHash: string;
+                };
+                background: {
+                    batch: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    examplesSha256: string;
+                    encodingHash: string;
+                    domain: string;
+                }[];
+                preservation: {
+                    batch: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    examplesSha256: string;
+                    encodingHash: string;
+                } | null;
+            };
+            selection: {
+                count: number;
+                span: "prompt" | "reply_prediction" | "reply_start";
+                backgroundStatistic: "max_domains" | "mean_domains";
+                maximumBackgroundTargetRatio: number;
+                gradientExamples: number;
+                explicitCoordinates: {
+                    layer: number;
+                    neuron: number;
+                }[] | null;
+            };
+            training: {
+                learningRate: number;
+                maxSteps: number;
+                gradientAccumulationSteps: number;
+                maxSequenceLength: number;
+                preservationWeight: number;
+                preservationExamplesPerStep: number;
+                seed: number;
+                maxDurationSeconds: number;
+                maxCheckpointBytes: number;
+                maximumForwardTokenWork: number;
+            };
+            parentArtifact: null;
+        };
+        sourceForm?: {
+            baseModel: {
+                schemaVersion: "openpond.baseModelPreference.v1";
+                modelId: string;
+                revision: string | null;
+                tokenizerRevision: string | null;
+                chatTemplateHash: string | null;
+                modelAssetId: string | null;
+                source: "builtin" | "local" | "managed";
+            } | null;
+            targetBatch: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null;
+            background: {
+                domain: string;
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | null;
+            }[];
+            preservationBatch: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null;
+            name: string;
+            maximumSpendUsd: string;
+            selection: {
+                count: string;
+                span: "prompt" | "reply_prediction" | "reply_start";
+                backgroundStatistic: "max_domains" | "mean_domains";
+                maximumBackgroundTargetRatio: string;
+                gradientExamples: string;
+                coordinates: string;
+            };
+            training: {
+                learningRate: string;
+                maxSteps: string;
+                gradientAccumulationSteps: string;
+                maxSequenceLength: string;
+                preservationWeight: string;
+                preservationExamplesPerStep: string;
+                seed: string;
+                maxDurationSeconds: string;
+                maxCheckpointBytes: string;
+                maximumForwardTokenWork: string;
+            };
+            parentArtifact: null;
+            inspectionSource?: {
+                result: {
+                    location: "cloud";
+                    apiOrigin: string;
+                    owner: {
+                        teamId: string;
+                        actorId: string;
+                    };
+                    projectId: string | null;
+                    kind: "managed_modification_result";
+                    executionId: string;
+                    method: "inspect_activations" | "neuron_steering";
+                    inputHash: string;
+                    runtimeHash: string;
+                    resultHash: string;
+                };
+                modelHash: string;
+            } | undefined;
+        } | undefined;
+        result: {
+            schemaVersion: "openpond.neuronTrainingResult.v1";
+            inputHash: string;
+            modelHash: string;
+            runtimeHash: string;
+            dataHash: string;
+            preparedRowsHash: string;
+            selection: {
+                schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
+                modelHash: string;
+                dataHash: string;
+                selectionConfigHash: string;
+                preparedRowsHash: string;
+                source: "automatic" | "explicit";
+                targetExampleIds: string[];
+                eligibleCount: number;
+                entries: {
+                    layer: number;
+                    neuron: number;
+                    targetMeanAbsolute: number;
+                    backgroundMeanAbsolute: number;
+                    backgroundTargetRatio: number;
+                    gradientNorm: number;
+                    score: number;
+                    targetActivityThreshold: number;
+                    backgroundByDomain: {
+                        domainIndex: number;
+                        meanAbsolute: number;
+                    }[];
+                }[];
+                contentHash: string;
+            };
+            optimizerSteps: number;
+            examplesProcessed: number;
+            targetTokens: number;
+            preservationTokens: number;
+            work: {
+                selectionTarget: number;
+                selectionBackground: number;
+                selectionGradient: number;
+                training: number;
+                preservationOriginal: number;
+                preservationEdited: number;
+                verification: number;
+            };
+            forwardTokenWork: number;
+            backwardTokenWork: number;
+            durationMs: number;
+            meanLoss: number;
+            finalLoss: number;
+            meanPreservationKl: number | null;
+            baseWeightsHashBefore: string;
+            baseWeightsHashAfter: string;
+            baseOptimizerParameterCount: 0;
+            baseGradientParameterCount: 0;
+            trainableParameterCount: number;
+            artifact: {
+                id: string;
+                contentHash: string;
+                manifest: {
+                    schemaVersion: "openpond.neuronTrainingArtifact.v1";
+                    method: "selective_neuron_training";
+                    algorithm: {
+                        implementation: "openpond_qwen3_selective_columns_v1";
+                        upstream: "changjonathanc/neuron-tuning";
+                        revision: "8a55f3159f735eb0823d7a894f67f632bf568bb3";
+                        license: "Apache-2.0";
+                        hook: "mlp.down_proj";
+                        operation: "output_plus_selected_input_times_delta_v1";
+                        parameterization: "column_gain_rms_direction_v1";
+                        activityQuantile: 0.9;
+                        backgroundFloor: 0.000001;
+                        gradientSubsetSeed: 0;
+                        optimizer: "Adam";
+                        betas: [0.9, 0.999];
+                        epsilon: 1e-8;
+                        weightDecay: 0;
+                        gradientClipNorm: 1;
+                        batchSize: 1;
+                        parameterDtype: "float32";
+                        resume: "unsupported";
+                    };
+                    pins: {
+                        baseModel: {
+                            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[];
+                        };
+                        inputHash: string;
+                        data: {
+                            target: {
+                                batch: {
+                                    id: string;
+                                    contentHash: string;
+                                    revision: number;
+                                };
+                                examplesSha256: string;
+                                encodingHash: string;
+                            };
+                            background: {
+                                batch: {
+                                    id: string;
+                                    contentHash: string;
+                                    revision: number;
+                                };
+                                examplesSha256: string;
+                                encodingHash: string;
+                                domain: string;
+                            }[];
+                            preservation: {
+                                batch: {
+                                    id: string;
+                                    contentHash: string;
+                                    revision: number;
+                                };
+                                examplesSha256: string;
+                                encodingHash: string;
+                            } | null;
+                        };
+                        dataHash: string;
+                        selectionConfigHash: string;
+                        trainingConfigHash: string;
+                        runtimeHash: string;
+                        parentArtifactHash: null;
+                    };
+                    selection: {
+                        schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
+                        modelHash: string;
+                        dataHash: string;
+                        selectionConfigHash: string;
+                        preparedRowsHash: string;
+                        source: "automatic" | "explicit";
+                        targetExampleIds: string[];
+                        eligibleCount: number;
+                        entries: {
+                            layer: number;
+                            neuron: number;
+                            targetMeanAbsolute: number;
+                            backgroundMeanAbsolute: number;
+                            backgroundTargetRatio: number;
+                            gradientNorm: number;
+                            score: number;
+                            targetActivityThreshold: number;
+                            backgroundByDomain: {
+                                domainIndex: number;
+                                meanAbsolute: number;
+                            }[];
+                        }[];
+                        contentHash: string;
+                    };
+                    payload: {
+                        path: "patch.safetensors";
+                        sha256: string;
+                        sizeBytes: number;
+                        tensors: {
+                            name: string;
+                            dtype: "F32" | "I64";
+                            shape: number[];
+                        }[];
+                    };
+                    contentHash: string;
+                };
+                files: {
+                    path: "manifest.json" | "patch.safetensors";
+                    artifactId: string;
+                    sha256: string;
+                    sizeBytes: number;
+                }[];
+            };
+            contentHash: string;
+        } | null;
+        resultRecordedAt: string | null;
+        contentHash: string;
+    }>;
+    listNeuronTrainingExecutions(teamId: string, raw?: ManagedNeuronTrainingExecutionListQuery, options?: {
+        signal?: AbortSignal;
+        ownerUserId?: string;
+    }): Promise<{
+        schemaVersion: "openpond.managedNeuronTrainingExecutionPage.v1";
+        teamId: string;
+        ownerUserId: string;
+        query: {
+            method: "selective_neuron_training";
+            id?: string | undefined;
+            projectId?: string | undefined;
+            phase?: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping" | undefined;
+            limit: number;
+            cursor?: string | undefined;
+        };
+        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;
+                } | undefined;
+                createdAt: string;
+                expiresAt: string;
+            };
+            updatedAt: string;
+            method: "selective_neuron_training";
+            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 {};
+//# sourceMappingURL=managed-neuron-training-executions.d.ts.map