@tangle-network/agent-interface 0.19.0 → 0.21.0

package/dist/agent-candidate-schema.d.ts

@@ -0,0 +1,498 @@
+import { z } from "zod";
+/**
+ * Structural parser for a frozen candidate.
+ *
+ * This does not verify any carried digest or fetch any artifact. The runtime
+ * verifier removes only the top-level `digest` field, serializes the remaining
+ * object with RFC 8785 to UTF-8 bytes, hashes those bytes with SHA-256, and
+ * compares lowercase `sha256:<hex>` identities before materialization.
+ */
+export declare const agentCandidateBundleSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"agent-candidate-bundle">;
+    digestAlgorithm: z.ZodLiteral<"rfc8785-sha256">;
+    profile: z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        prompt: z.ZodOptional<z.ZodObject<{
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            instructions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        model: z.ZodOptional<z.ZodObject<{
+            reasoningEffort: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                minimal: "minimal";
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+                ultracode: "ultracode";
+            }>>;
+            default: z.ZodOptional<z.ZodString>;
+            small: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        harness: z.ZodOptional<z.ZodEnum<{
+            "claude-code": "claude-code";
+            claude: "claude";
+            claudish: "claudish";
+            nanoclaw: "nanoclaw";
+            codex: "codex";
+            opencode: "opencode";
+            "kimi-code": "kimi-code";
+            kimi: "kimi";
+            pi: "pi";
+            gemini: "gemini";
+            hermes: "hermes";
+            openclaw: "openclaw";
+            amp: "amp";
+            "factory-droids": "factory-droids";
+            acp: "acp";
+            "cli-base": "cli-base";
+        }>>;
+        permissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            deny: "deny";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            deny: "deny";
+        }>>]>>>;
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        mcp: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            transport: z.ZodOptional<z.ZodLiteral<"stdio">>;
+            command: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                kind: z.ZodLiteral<"public">;
+                value: z.ZodString;
+            }, z.core.$strict>>>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                kind: z.ZodLiteral<"public">;
+                value: z.ZodString;
+            }, z.core.$strict>>>;
+            cwd: z.ZodOptional<z.ZodString>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+        subagents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            prompt: z.ZodOptional<z.ZodString>;
+            permissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                deny: "deny";
+            }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                deny: "deny";
+            }>>]>>>;
+            tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+            description: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            maxSteps: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        resources: z.ZodOptional<z.ZodObject<{
+            files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                resource: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"inline">;
+                    name: z.ZodString;
+                    content: z.ZodString;
+                    sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                    byteLength: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"github">;
+                    repository: z.ZodObject<{
+                        kind: z.ZodLiteral<"github">;
+                        owner: z.ZodString;
+                        repo: z.ZodString;
+                    }, z.core.$strict>;
+                    path: z.ZodString;
+                    commit: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                    sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                    byteLength: z.ZodNumber;
+                }, z.core.$strict>], "kind">;
+                executable: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>>;
+            tools: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"inline">;
+                name: z.ZodString;
+                content: z.ZodString;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"github">;
+                repository: z.ZodObject<{
+                    kind: z.ZodLiteral<"github">;
+                    owner: z.ZodString;
+                    repo: z.ZodString;
+                }, z.core.$strict>;
+                path: z.ZodString;
+                commit: z.ZodString;
+                name: z.ZodOptional<z.ZodString>;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>], "kind">>>;
+            skills: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"inline">;
+                name: z.ZodString;
+                content: z.ZodString;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"github">;
+                repository: z.ZodObject<{
+                    kind: z.ZodLiteral<"github">;
+                    owner: z.ZodString;
+                    repo: z.ZodString;
+                }, z.core.$strict>;
+                path: z.ZodString;
+                commit: z.ZodString;
+                name: z.ZodOptional<z.ZodString>;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>], "kind">>>;
+            agents: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"inline">;
+                name: z.ZodString;
+                content: z.ZodString;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"github">;
+                repository: z.ZodObject<{
+                    kind: z.ZodLiteral<"github">;
+                    owner: z.ZodString;
+                    repo: z.ZodString;
+                }, z.core.$strict>;
+                path: z.ZodString;
+                commit: z.ZodString;
+                name: z.ZodOptional<z.ZodString>;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>], "kind">>>;
+            commands: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"inline">;
+                name: z.ZodString;
+                content: z.ZodString;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"github">;
+                repository: z.ZodObject<{
+                    kind: z.ZodLiteral<"github">;
+                    owner: z.ZodString;
+                    repo: z.ZodString;
+                }, z.core.$strict>;
+                path: z.ZodString;
+                commit: z.ZodString;
+                name: z.ZodOptional<z.ZodString>;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>], "kind">>>;
+            instructions: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"inline">;
+                name: z.ZodString;
+                content: z.ZodString;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"github">;
+                repository: z.ZodObject<{
+                    kind: z.ZodLiteral<"github">;
+                    owner: z.ZodString;
+                    repo: z.ZodString;
+                }, z.core.$strict>;
+                path: z.ZodString;
+                commit: z.ZodString;
+                name: z.ZodOptional<z.ZodString>;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>], "kind">]>>;
+            failOnError: z.ZodLiteral<true>;
+        }, z.core.$strict>>;
+        hooks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+            executable: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                kind: z.ZodLiteral<"public">;
+                value: z.ZodString;
+            }, z.core.$strict>>>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            blocking: z.ZodOptional<z.ZodBoolean>;
+            matcher: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                kind: z.ZodLiteral<"public">;
+                value: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>>;
+        modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            prompt: z.ZodOptional<z.ZodString>;
+            permissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                deny: "deny";
+            }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                deny: "deny";
+            }>>]>>>;
+            tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+            description: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        confidential: z.ZodOptional<z.ZodObject<{
+            tee: z.ZodOptional<z.ZodString>;
+            attestationNonce: z.ZodOptional<z.ZodString>;
+            sealed: z.ZodOptional<z.ZodBoolean>;
+            attestationRefresh: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    code: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"disabled">;
+        reason: z.ZodEnum<{
+            control: "control";
+            "not-applicable": "not-applicable";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"no-op">;
+        reason: z.ZodLiteral<"proposer-no-change">;
+        repository: z.ZodObject<{
+            kind: z.ZodLiteral<"github">;
+            owner: z.ZodString;
+            repo: z.ZodString;
+        }, z.core.$strict>;
+        baseCommit: z.ZodString;
+        baseTree: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"git-patch">;
+        repository: z.ZodObject<{
+            kind: z.ZodLiteral<"github">;
+            owner: z.ZodString;
+            repo: z.ZodString;
+        }, z.core.$strict>;
+        baseCommit: z.ZodString;
+        baseTree: z.ZodString;
+        candidateTree: z.ZodString;
+        patch: z.ZodObject<{
+            format: z.ZodLiteral<"git-diff-binary">;
+            artifact: z.ZodObject<{
+                encoding: z.ZodLiteral<"base64">;
+                content: z.ZodString;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "kind">;
+    execution: z.ZodObject<{
+        harness: z.ZodEnum<{
+            "claude-code": "claude-code";
+            claude: "claude";
+            claudish: "claudish";
+            nanoclaw: "nanoclaw";
+            codex: "codex";
+            opencode: "opencode";
+            "kimi-code": "kimi-code";
+            kimi: "kimi";
+            pi: "pi";
+            gemini: "gemini";
+            hermes: "hermes";
+            openclaw: "openclaw";
+            amp: "amp";
+            "factory-droids": "factory-droids";
+            acp: "acp";
+            "cli-base": "cli-base";
+        }>;
+        harnessVersion: z.ZodString;
+        launch: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"container-command">;
+            executable: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                kind: z.ZodLiteral<"public">;
+                value: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"candidate-entrypoint">;
+            entrypoint: z.ZodString;
+            interpreter: z.ZodOptional<z.ZodEnum<{
+                node: "node";
+                python: "python";
+                python3: "python3";
+                bun: "bun";
+                deno: "deno";
+                tsx: "tsx";
+                uv: "uv";
+            }>>;
+            args: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                kind: z.ZodLiteral<"public">;
+                value: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>], "kind">;
+        instructionDelivery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"argv-append">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"stdin-utf8">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"utf8-file">;
+            env: z.ZodLiteral<"TANGLE_CANDIDATE_TASK_PATH">;
+            path: z.ZodLiteral<"/tangle/input/task.txt">;
+        }, z.core.$strict>], "kind">;
+        cwd: z.ZodObject<{
+            workspace: z.ZodEnum<{
+                candidate: "candidate";
+                task: "task";
+            }>;
+            path: z.ZodString;
+        }, z.core.$strict>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            kind: z.ZodLiteral<"public">;
+            value: z.ZodString;
+        }, z.core.$strict>>>;
+        environment: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"pinned-container">;
+            container: z.ZodObject<{
+                image: z.ZodString;
+                indexDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"evaluator-task-container">;
+        }, z.core.$strict>], "kind">;
+        workspace: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            kind: z.ZodLiteral<"agent-candidate-workspace-snapshot">;
+            digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            material: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                kind: z.ZodLiteral<"agent-candidate-workspace-manifest">;
+                files: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    mode: z.ZodUnion<readonly [z.ZodLiteral<420>, z.ZodLiteral<493>]>;
+                    sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                    byteLength: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            manifest: z.ZodUnion<readonly [z.ZodObject<{
+                locator: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"s3">;
+                    bucket: z.ZodString;
+                    key: z.ZodString;
+                    region: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"ipfs">;
+                    cid: z.ZodString;
+                    path: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>], "kind">;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                encoding: z.ZodLiteral<"base64">;
+                content: z.ZodString;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>]>;
+            archive: z.ZodUnion<readonly [z.ZodObject<{
+                locator: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"s3">;
+                    bucket: z.ZodString;
+                    key: z.ZodString;
+                    region: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"ipfs">;
+                    cid: z.ZodString;
+                    path: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>], "kind">;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                encoding: z.ZodLiteral<"base64">;
+                content: z.ZodString;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>>;
+        isolation: z.ZodObject<{
+            network: z.ZodLiteral<"disabled">;
+            remoteIntegrations: z.ZodLiteral<"disabled">;
+            candidateSecrets: z.ZodLiteral<"disabled">;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    knowledge: z.ZodOptional<z.ZodObject<{
+        snapshotId: z.ZodString;
+        manifest: z.ZodObject<{
+            locator: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"s3">;
+                bucket: z.ZodString;
+                key: z.ZodString;
+                region: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"ipfs">;
+                cid: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>], "kind">;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    memory: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"disabled">;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"isolated">;
+        scope: z.ZodLiteral<"task">;
+        seed: z.ZodOptional<z.ZodObject<{
+            locator: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"s3">;
+                bucket: z.ZodString;
+                key: z.ZodString;
+                region: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"ipfs">;
+                cid: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>], "kind">;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "mode">;
+    lineage: z.ZodObject<{
+        source: z.ZodEnum<{
+            optimizer: "optimizer";
+            human: "human";
+            import: "import";
+            compound: "compound";
+        }>;
+        parentDigests: z.ZodOptional<z.ZodArray<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>>;
+        runIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        profileDiffIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        modelSnapshots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        benchmark: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+            splitDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        }, z.core.$strict>>;
+        spend: z.ZodOptional<z.ZodObject<{
+            proposal: z.ZodObject<{
+                costUsd: z.ZodNumber;
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                cachedInputTokens: z.ZodOptional<z.ZodNumber>;
+                modelCalls: z.ZodNumber;
+            }, z.core.$strict>;
+            evaluation: z.ZodObject<{
+                costUsd: z.ZodNumber;
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                cachedInputTokens: z.ZodOptional<z.ZodNumber>;
+                modelCalls: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>;
+export * from "./agent-candidate-artifact-schema.js";
+export * from "./agent-candidate-code-schema.js";
+export * from "./agent-candidate-execution-plan-schema.js";
+export * from "./agent-candidate-lineage-schema.js";
+export * from "./agent-candidate-profile-schema.js";
+export * from "./agent-candidate-receipt-schema.js";
+export { sha256DigestSchema } from "./agent-candidate-schema-common.js";

package/dist/agent-candidate-schema.js

@@ -0,0 +1,144 @@
+import { z } from "zod";
+import { agentCandidateCodeSchema, agentCandidateExecutionSchema } from "./agent-candidate-code-schema.js";
+import { agentCandidateProfileSchema } from "./agent-candidate-profile-schema.js";
+import { agentCandidateKnowledgeSchema, agentCandidateLineageSchema, agentCandidateMemoryPolicySchema, } from "./agent-candidate-lineage-schema.js";
+import { isCanonicalJsonValue, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
+import { canonicalizeHarness } from "./harness.js";
+/**
+ * Structural parser for a frozen candidate.
+ *
+ * This does not verify any carried digest or fetch any artifact. The runtime
+ * verifier removes only the top-level `digest` field, serializes the remaining
+ * object with RFC 8785 to UTF-8 bytes, hashes those bytes with SHA-256, and
+ * compares lowercase `sha256:<hex>` identities before materialization.
+ */
+export const agentCandidateBundleSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    kind: z.literal("agent-candidate-bundle"),
+    digestAlgorithm: z.literal("rfc8785-sha256"),
+    profile: agentCandidateProfileSchema,
+    code: agentCandidateCodeSchema,
+    execution: agentCandidateExecutionSchema,
+    knowledge: agentCandidateKnowledgeSchema.optional(),
+    memory: agentCandidateMemoryPolicySchema,
+    lineage: agentCandidateLineageSchema,
+    digest: sha256DigestSchema,
+})
+    .strict()
+    .superRefine((bundle, ctx) => {
+    if (!isCanonicalJsonValue(bundle)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "candidate bundle must contain only finite, acyclic RFC 8785 JSON values",
+        });
+    }
+    if (bundle.profile.harness !== undefined &&
+        canonicalizeHarness(bundle.profile.harness) !==
+            canonicalizeHarness(bundle.execution.harness)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["execution", "harness"],
+            message: "execution harness must match the candidate profile preference",
+        });
+    }
+    if (bundle.lineage.parentDigests?.includes(bundle.digest)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["lineage", "parentDigests"],
+            message: "a candidate cannot name itself as a parent",
+        });
+    }
+    if (bundle.code.kind === "disabled") {
+        if (bundle.execution.cwd.workspace !== "task") {
+            ctx.addIssue({
+                code: "custom",
+                path: ["execution", "cwd", "workspace"],
+                message: "disabled code controls must execute in the task workspace",
+            });
+        }
+        if (bundle.execution.launch.kind !== "container-command") {
+            ctx.addIssue({
+                code: "custom",
+                path: ["execution", "launch"],
+                message: "disabled code controls must use a container command",
+            });
+        }
+        if (bundle.execution.workspace !== undefined) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["execution", "workspace"],
+                message: "disabled code cannot carry a candidate workspace",
+            });
+        }
+        if (bundle.code.reason === "control" &&
+            (bundle.lineage.source === "optimizer" ||
+                bundle.lineage.source === "compound")) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["lineage", "source"],
+                message: "fixed controls cannot claim proposer lineage",
+            });
+        }
+    }
+    else {
+        const launch = bundle.execution.launch;
+        if (launch.kind !== "candidate-entrypoint") {
+            ctx.addIssue({
+                code: "custom",
+                path: ["execution", "launch"],
+                message: "an active code surface must launch its candidate entrypoint",
+            });
+        }
+        if (bundle.execution.workspace === undefined) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["execution", "workspace"],
+                message: "active code requires a complete candidate workspace",
+            });
+        }
+        else if (bundle.execution.workspace.material.files.length === 0) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["execution", "workspace", "material", "files"],
+                message: "active candidate workspaces cannot be empty",
+            });
+        }
+        else if (launch.kind === "candidate-entrypoint" &&
+            !bundle.execution.workspace.material.files.some((file) => file.path === launch.entrypoint)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["execution", "launch", "entrypoint"],
+                message: "candidate entrypoint must exist in the pinned workspace manifest",
+            });
+        }
+        else if (launch.kind === "candidate-entrypoint") {
+            const entrypoint = bundle.execution.workspace.material.files.find((file) => file.path === launch.entrypoint);
+            if (launch.interpreter === undefined && entrypoint?.mode !== 0o755) {
+                ctx.addIssue({
+                    code: "custom",
+                    path: ["execution", "launch", "entrypoint"],
+                    message: "a directly launched candidate entrypoint must be executable",
+                });
+            }
+        }
+        if (bundle.code.kind === "no-op" &&
+            bundle.lineage.source !== "optimizer" &&
+            bundle.lineage.source !== "compound") {
+            ctx.addIssue({
+                code: "custom",
+                path: ["lineage", "source"],
+                message: "proposer no-op candidates require optimizer or compound lineage",
+            });
+        }
+    }
+});
+const _bundleSchemaMatchesType = true;
+void _bundleSchemaMatchesType;
+export * from "./agent-candidate-artifact-schema.js";
+export * from "./agent-candidate-code-schema.js";
+export * from "./agent-candidate-execution-plan-schema.js";
+export * from "./agent-candidate-lineage-schema.js";
+export * from "./agent-candidate-profile-schema.js";
+export * from "./agent-candidate-receipt-schema.js";
+export { sha256DigestSchema } from "./agent-candidate-schema-common.js";