@tangle-network/agent-interface 0.25.0 → 0.26.0

package/README.md

@@ -66,13 +66,13 @@ const provider: AgentEnvironmentProvider = {
 
 `AgentCandidateBundle` is the portable output of an improvement run: a recursively strict profile, an explicit disabled/no-op/changed code result, a shell-free launch, optional knowledge, isolated memory, ancestry, and spend.
 Execution either pins a candidate-selected container in the bundle or delegates container selection to the benchmark evaluator.
-For evaluator-owned task images, the protected runtime creates a separate plan for every candidate/task pair and binds the root repository, exact Git base, exact UTF-8 instruction bytes, selected OCI index, manifest, platform, task workspace, model, launch, counted attempt, retry policy, and tool-step limit before execution.
+For evaluator-owned task images, the protected runtime creates a separate plan for every candidate/task pair and binds the exact result shape (workspace change or bounded typed output), UTF-8 instruction bytes, selected OCI index, manifest, platform, task workspace, model, launch, counted attempt, retry policy, and tool-step limit before execution.
 Instruction delivery is closed to one final argv element, exact stdin bytes followed by EOF, or a fixed file path exposed through `TANGLE_CANDIDATE_TASK_PATH`.
 That plan also binds the profile target workspace and every mounted path; benchmark adapters must restore or exclude task-targeted profile paths before capturing the submitted solution patch.
 Resources are embedded, addressed through closed S3/IPFS locators, or pinned to a full GitHub commit plus content digest.
 Candidate-authored process configuration is explicitly public; model authorization is evaluator-mediated and secret values never belong in the bundle.
 Because prompts and inline files are arbitrary text, producers must also run their normal secret scanner before persistence.
-Candidate v1 rejects unregistered backend extensions instead of accepting an untyped behavior or credential channel.
+Candidate bundles reject unregistered backend extensions instead of accepting an untyped behavior or credential channel.
 
 `agentCandidateBundleSchema.parse()` proves only that the wire shape is valid.
 Before execution, an integrity verifier must omit only the top-level `digest`, canonicalize the rest with RFC 8785, hash the UTF-8 bytes to lowercase `sha256:<hex>`, verify every artifact, apply any Git patch to the declared base tree, and emit an `AgentCandidateMaterializationReceipt`.

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

@@ -60,25 +60,25 @@ export declare const agentCandidateCapturedArtifactSchema: z.ZodUnion<readonly [
     byteLength: z.ZodNumber;
 }, z.core.$strict>]>;
 export declare const agentCandidateWorkspaceManifestMaterialSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodLiteral<2>;
     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>]>;
+        mode: z.ZodNumber;
         sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
         byteLength: z.ZodNumber;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const agentCandidateWorkspaceSnapshotEvidenceSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodLiteral<2>;
     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>;
+        schemaVersion: z.ZodLiteral<2>;
         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>]>;
+            mode: z.ZodNumber;
             sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
             byteLength: z.ZodNumber;
         }, z.core.$strict>>;

package/dist/agent-candidate-artifact-schema.js

@@ -65,14 +65,14 @@ export const agentCandidateCapturedArtifactSchema = z.union([
 ]);
 export const agentCandidateWorkspaceManifestMaterialSchema = z
     .object({
-    schemaVersion: z.literal(1),
+    schemaVersion: z.literal(2),
     kind: z.literal("agent-candidate-workspace-manifest"),
     files: z.array(z
         .object({
         path: z
             .string()
             .refine((value) => isSafeRelativePath(value, false), "workspace manifest paths must be canonical and relative"),
-        mode: z.union([z.literal(0o644), z.literal(0o755)]),
+        mode: z.number().int().min(0).max(0o777),
         sha256: sha256DigestSchema,
         byteLength: z.number().int().nonnegative(),
     })
@@ -94,7 +94,7 @@ export const agentCandidateWorkspaceManifestMaterialSchema = z
 });
 export const agentCandidateWorkspaceSnapshotEvidenceSchema = z
     .object({
-    schemaVersion: z.literal(1),
+    schemaVersion: z.literal(2),
     kind: z.literal("agent-candidate-workspace-snapshot"),
     digest: sha256DigestSchema,
     material: agentCandidateWorkspaceManifestMaterialSchema,

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

@@ -235,15 +235,15 @@ export declare const agentCandidateExecutionSchema: z.ZodObject<{
         kind: z.ZodLiteral<"evaluator-task-container">;
     }, z.core.$strict>], "kind">;
     workspace: z.ZodOptional<z.ZodObject<{
-        schemaVersion: z.ZodLiteral<1>;
+        schemaVersion: z.ZodLiteral<2>;
         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>;
+            schemaVersion: z.ZodLiteral<2>;
             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>]>;
+                mode: z.ZodNumber;
                 sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
                 byteLength: z.ZodNumber;
             }, z.core.$strict>>;

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

@@ -88,15 +88,15 @@ export declare const agentCandidateEffectiveMemorySchema: z.ZodDiscriminatedUnio
         emptyStateDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     }, z.core.$strict>;
     beforeState: z.ZodObject<{
-        schemaVersion: z.ZodLiteral<1>;
+        schemaVersion: z.ZodLiteral<2>;
         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>;
+            schemaVersion: z.ZodLiteral<2>;
             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>]>;
+                mode: z.ZodNumber;
                 sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
                 byteLength: z.ZodNumber;
             }, z.core.$strict>>;
@@ -150,8 +150,15 @@ export declare const agentCandidateExecutionLimitsSchema: z.ZodObject<{
     maxOutputTokens: z.ZodNumber;
     maxCostUsd: z.ZodNumber;
 }, z.core.$strict>;
+export declare const agentCandidateTaskOutcomeSpecSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"workspace">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"output">;
+    mediaType: z.ZodString;
+    maxBytes: z.ZodNumber;
+}, z.core.$strict>], "kind">;
 export declare const agentCandidateExecutionPlanMaterialSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodLiteral<2>;
     kind: z.ZodLiteral<"agent-candidate-execution-plan-material">;
     bundleDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     executionId: z.ZodString;
@@ -182,22 +189,29 @@ export declare const agentCandidateExecutionPlanMaterialSchema: z.ZodObject<{
                 path: z.ZodLiteral<"/tangle/input/task.txt">;
             }, z.core.$strict>], "kind">;
         }, z.core.$strict>;
-        repository: z.ZodObject<{
+        repository: z.ZodOptional<z.ZodObject<{
             identity: z.ZodString;
             rootIdentity: z.ZodString;
             baseCommit: z.ZodString;
             baseTree: z.ZodString;
-        }, z.core.$strict>;
+        }, z.core.$strict>>;
+        outcome: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"workspace">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"output">;
+            mediaType: z.ZodString;
+            maxBytes: z.ZodNumber;
+        }, z.core.$strict>], "kind">;
         workspace: z.ZodObject<{
-            schemaVersion: z.ZodLiteral<1>;
+            schemaVersion: z.ZodLiteral<2>;
             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>;
+                schemaVersion: z.ZodLiteral<2>;
                 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>]>;
+                    mode: z.ZodNumber;
                     sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
                     byteLength: z.ZodNumber;
                 }, z.core.$strict>>;
@@ -252,15 +266,15 @@ export declare const agentCandidateExecutionPlanMaterialSchema: z.ZodObject<{
         "git-patch": "git-patch";
     }>;
     candidateWorkspace: z.ZodOptional<z.ZodObject<{
-        schemaVersion: z.ZodLiteral<1>;
+        schemaVersion: z.ZodLiteral<2>;
         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>;
+            schemaVersion: z.ZodLiteral<2>;
             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>]>;
+                mode: z.ZodNumber;
                 sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
                 byteLength: z.ZodNumber;
             }, z.core.$strict>>;
@@ -455,15 +469,15 @@ export declare const agentCandidateExecutionPlanMaterialSchema: z.ZodObject<{
             emptyStateDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
         }, z.core.$strict>;
         beforeState: z.ZodObject<{
-            schemaVersion: z.ZodLiteral<1>;
+            schemaVersion: z.ZodLiteral<2>;
             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>;
+                schemaVersion: z.ZodLiteral<2>;
                 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>]>;
+                    mode: z.ZodNumber;
                     sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
                     byteLength: z.ZodNumber;
                 }, z.core.$strict>>;
@@ -586,12 +600,87 @@ export declare const agentCandidateProfilePlanEvidenceSchema: z.ZodObject<{
         byteLength: z.ZodNumber;
     }, z.core.$strict>]>;
 }, z.core.$strict>;
-export declare const agentCandidateExecutionPlanEvidenceSchema: z.ZodObject<{
+export declare const agentCandidateProfileActivationSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"agent-candidate-profile-activation">;
+    profilePlan: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        kind: z.ZodLiteral<"agent-profile-workspace-plan">;
+        digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        material: z.ZodType<{
+            version: 1;
+            harness: "claude-code" | "claude" | "claudish" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "kimi" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
+            files: {
+                relPath: string;
+                mode: number;
+                contentSha256: `sha256:${string}`;
+            }[];
+            env: Record<string, {
+                kind: "public";
+                value: string;
+            }>;
+            flags: {
+                kind: "public";
+                value: string;
+            }[];
+            unsupported: {
+                dimension: string;
+                reason: string;
+            }[];
+        }, unknown, z.core.$ZodTypeInternals<{
+            version: 1;
+            harness: "claude-code" | "claude" | "claudish" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "kimi" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
+            files: {
+                relPath: string;
+                mode: number;
+                contentSha256: `sha256:${string}`;
+            }[];
+            env: Record<string, {
+                kind: "public";
+                value: string;
+            }>;
+            flags: {
+                kind: "public";
+                value: string;
+            }[];
+            unsupported: {
+                dimension: string;
+                reason: string;
+            }[];
+        }, unknown>>;
+        artifact: 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>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        mode: z.ZodNumber;
+        content: z.ZodString;
+    }, z.core.$strict>>;
+    digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>;
+export declare const agentCandidateExecutionPlanEvidenceSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
     kind: z.ZodLiteral<"agent-candidate-execution-plan">;
     digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     material: z.ZodType<{
-        schemaVersion: 1;
+        schemaVersion: 2;
         kind: "agent-candidate-execution-plan-material";
         bundleDigest: `sha256:${string}`;
         executionId: string;
@@ -619,22 +708,23 @@ export declare const agentCandidateExecutionPlanEvidenceSchema: z.ZodObject<{
                     path: "/tangle/input/task.txt";
                 };
             };
-            repository: {
-                identity: string;
-                rootIdentity: string;
-                baseCommit: string;
-                baseTree: string;
+            outcome: {
+                kind: "workspace";
+            } | {
+                kind: "output";
+                mediaType: string;
+                maxBytes: number;
             };
             workspace: {
-                schemaVersion: 1;
+                schemaVersion: 2;
                 kind: "agent-candidate-workspace-snapshot";
                 digest: `sha256:${string}`;
                 material: {
-                    schemaVersion: 1;
+                    schemaVersion: 2;
                     kind: "agent-candidate-workspace-manifest";
                     files: {
                         path: string;
-                        mode: 420 | 493;
+                        mode: number;
                         sha256: `sha256:${string}`;
                         byteLength: number;
                     }[];
@@ -678,6 +768,12 @@ export declare const agentCandidateExecutionPlanEvidenceSchema: z.ZodObject<{
                     byteLength: number;
                 };
             };
+            repository?: {
+                identity: string;
+                rootIdentity: string;
+                baseCommit: string;
+                baseTree: string;
+            } | undefined;
         };
         workspaces: {
             taskRoot: string;
@@ -798,15 +894,15 @@ export declare const agentCandidateExecutionPlanEvidenceSchema: z.ZodObject<{
                 emptyStateDigest: `sha256:${string}`;
             };
             beforeState: {
-                schemaVersion: 1;
+                schemaVersion: 2;
                 kind: "agent-candidate-workspace-snapshot";
                 digest: `sha256:${string}`;
                 material: {
-                    schemaVersion: 1;
+                    schemaVersion: 2;
                     kind: "agent-candidate-workspace-manifest";
                     files: {
                         path: string;
-                        mode: 420 | 493;
+                        mode: number;
                         sha256: `sha256:${string}`;
                         byteLength: number;
                     }[];
@@ -866,15 +962,15 @@ export declare const agentCandidateExecutionPlanEvidenceSchema: z.ZodObject<{
             mode: "disabled";
         };
         candidateWorkspace?: {
-            schemaVersion: 1;
+            schemaVersion: 2;
             kind: "agent-candidate-workspace-snapshot";
             digest: `sha256:${string}`;
             material: {
-                schemaVersion: 1;
+                schemaVersion: 2;
                 kind: "agent-candidate-workspace-manifest";
                 files: {
                     path: string;
-                    mode: 420 | 493;
+                    mode: number;
                     sha256: `sha256:${string}`;
                     byteLength: number;
                 }[];
@@ -920,7 +1016,7 @@ export declare const agentCandidateExecutionPlanEvidenceSchema: z.ZodObject<{
         } | undefined;
         knowledgeManifestDigest?: `sha256:${string}` | undefined;
     }, unknown, z.core.$ZodTypeInternals<{
-        schemaVersion: 1;
+        schemaVersion: 2;
         kind: "agent-candidate-execution-plan-material";
         bundleDigest: `sha256:${string}`;
         executionId: string;
@@ -948,22 +1044,23 @@ export declare const agentCandidateExecutionPlanEvidenceSchema: z.ZodObject<{
                     path: "/tangle/input/task.txt";
                 };
             };
-            repository: {
-                identity: string;
-                rootIdentity: string;
-                baseCommit: string;
-                baseTree: string;
+            outcome: {
+                kind: "workspace";
+            } | {
+                kind: "output";
+                mediaType: string;
+                maxBytes: number;
             };
             workspace: {
-                schemaVersion: 1;
+                schemaVersion: 2;
                 kind: "agent-candidate-workspace-snapshot";
                 digest: `sha256:${string}`;
                 material: {
-                    schemaVersion: 1;
+                    schemaVersion: 2;
                     kind: "agent-candidate-workspace-manifest";
                     files: {
                         path: string;
-                        mode: 420 | 493;
+                        mode: number;
                         sha256: `sha256:${string}`;
                         byteLength: number;
                     }[];
@@ -1007,6 +1104,12 @@ export declare const agentCandidateExecutionPlanEvidenceSchema: z.ZodObject<{
                     byteLength: number;
                 };
             };
+            repository?: {
+                identity: string;
+                rootIdentity: string;
+                baseCommit: string;
+                baseTree: string;
+            } | undefined;
         };
         workspaces: {
             taskRoot: string;
@@ -1127,15 +1230,15 @@ export declare const agentCandidateExecutionPlanEvidenceSchema: z.ZodObject<{
                 emptyStateDigest: `sha256:${string}`;
             };
             beforeState: {
-                schemaVersion: 1;
+                schemaVersion: 2;
                 kind: "agent-candidate-workspace-snapshot";
                 digest: `sha256:${string}`;
                 material: {
-                    schemaVersion: 1;
+                    schemaVersion: 2;
                     kind: "agent-candidate-workspace-manifest";
                     files: {
                         path: string;
-                        mode: 420 | 493;
+                        mode: number;
                         sha256: `sha256:${string}`;
                         byteLength: number;
                     }[];
@@ -1195,15 +1298,15 @@ export declare const agentCandidateExecutionPlanEvidenceSchema: z.ZodObject<{
             mode: "disabled";
         };
         candidateWorkspace?: {
-            schemaVersion: 1;
+            schemaVersion: 2;
             kind: "agent-candidate-workspace-snapshot";
             digest: `sha256:${string}`;
             material: {
-                schemaVersion: 1;
+                schemaVersion: 2;
                 kind: "agent-candidate-workspace-manifest";
                 files: {
                     path: string;
-                    mode: 420 | 493;
+                    mode: number;
                     sha256: `sha256:${string}`;
                     byteLength: number;
                 }[];

package/dist/agent-candidate-execution-plan-schema.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { agentCandidateArtifactRefSchema, agentCandidateCapturedArtifactSchema, agentCandidateWorkspaceSnapshotEvidenceSchema, } from "./agent-candidate-artifact-schema.js";
 import { agentCandidateContainerSchema, agentCandidateInstructionDeliverySchema, agentCandidateWorkingDirectorySchema, } from "./agent-candidate-code-schema.js";
-import { addDuplicateIssues, agentCandidateConfigValueSchema, environmentConfigSchema, gitObjectSchema, isCanonicalJsonValue, isObviouslyPrivateHostname, isSafeExecutable, isSafeRelativePath, sameGitObjectFormat, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
+import { addDuplicateIssues, agentCandidateConfigValueSchema, agentCandidateMediaTypeSchema, environmentConfigSchema, gitObjectSchema, isCanonicalJsonValue, isObviouslyPrivateHostname, isSafeExecutable, isSafeRelativePath, isWellFormedUnicode, sameGitObjectFormat, sha256Utf8, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
 import { harnessTypeSchema } from "./harness.js";
 const reasoningEffortSchema = z.enum([
     "none",
@@ -140,9 +140,19 @@ export const agentCandidateExecutionLimitsSchema = z
     maxCostUsd: z.number().finite().nonnegative(),
 })
     .strict();
+export const agentCandidateTaskOutcomeSpecSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("workspace") }).strict(),
+    z
+        .object({
+        kind: z.literal("output"),
+        mediaType: agentCandidateMediaTypeSchema,
+        maxBytes: z.number().int().positive().max(64 * 1024 * 1024),
+    })
+        .strict(),
+]);
 export const agentCandidateExecutionPlanMaterialSchema = z
     .object({
-    schemaVersion: z.literal(1),
+    schemaVersion: z.literal(2),
     kind: z.literal("agent-candidate-execution-plan-material"),
     bundleDigest: sha256DigestSchema,
     executionId: z.string().min(1),
@@ -174,7 +184,9 @@ export const agentCandidateExecutionPlanMaterialSchema = z
             baseCommit: gitObjectSchema,
             baseTree: gitObjectSchema,
         })
-            .strict(),
+            .strict()
+            .optional(),
+        outcome: agentCandidateTaskOutcomeSpecSchema,
         workspace: agentCandidateWorkspaceSnapshotEvidenceSchema,
     })
         .strict(),
@@ -282,13 +294,22 @@ export const agentCandidateExecutionPlanMaterialSchema = z
 })
     .strict()
     .superRefine((material, ctx) => {
-    if (!sameGitObjectFormat(material.task.repository.baseCommit, material.task.repository.baseTree)) {
+    if (material.task.repository !== undefined &&
+        !sameGitObjectFormat(material.task.repository.baseCommit, material.task.repository.baseTree)) {
         ctx.addIssue({
             code: "custom",
             path: ["task", "repository"],
             message: "task Git object ids must use one object format",
         });
     }
+    if (material.task.outcome.kind === "workspace" &&
+        material.task.repository === undefined) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["task", "repository"],
+            message: "workspace outcomes require task repository provenance",
+        });
+    }
     if (material.attempt.number > material.attempt.maxAttempts) {
         ctx.addIssue({
             code: "custom",
@@ -436,7 +457,8 @@ export const agentCandidateExecutionPlanMaterialSchema = z
             message: "active candidate workspaces cannot be empty",
         });
     }
-    if (material.task.workspace.material.files.length === 0) {
+    if (material.task.outcome.kind === "workspace" &&
+        material.task.workspace.material.files.length === 0) {
         ctx.addIssue({
             code: "custom",
             path: ["task", "workspace", "material", "files"],
@@ -450,10 +472,10 @@ export const agentCandidateExecutionPlanMaterialSchema = z
         });
     }
 });
-function planEvidenceSchema(kind, material) {
+function planEvidenceSchema(schemaVersion, kind, material) {
     return z
         .object({
-        schemaVersion: z.literal(1),
+        schemaVersion: z.literal(schemaVersion),
         kind: z.literal(kind),
         digest: sha256DigestSchema,
         material,
@@ -477,5 +499,55 @@ function planEvidenceSchema(kind, material) {
         }
     });
 }
-export const agentCandidateProfilePlanEvidenceSchema = planEvidenceSchema("agent-profile-workspace-plan", agentCandidateProfilePlanMaterialSchema);
-export const agentCandidateExecutionPlanEvidenceSchema = planEvidenceSchema("agent-candidate-execution-plan", agentCandidateExecutionPlanMaterialSchema);
+export const agentCandidateProfilePlanEvidenceSchema = planEvidenceSchema(1, "agent-profile-workspace-plan", agentCandidateProfilePlanMaterialSchema);
+export const agentCandidateProfileActivationSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    kind: z.literal("agent-candidate-profile-activation"),
+    profilePlan: agentCandidateProfilePlanEvidenceSchema,
+    files: z.array(z
+        .object({
+        path: z
+            .string()
+            .refine((value) => isSafeRelativePath(value, false), "profile activation file must use a canonical relative path"),
+        mode: z.number().int().min(0).max(0o777),
+        content: z
+            .string()
+            .refine(isWellFormedUnicode, "profile activation content must be valid Unicode"),
+    })
+        .strict()),
+    digest: sha256DigestSchema,
+})
+    .strict()
+    .superRefine((activation, ctx) => {
+    const planned = activation.profilePlan.material.files;
+    if (activation.files.length !== planned.length) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["files"],
+            message: "profile activation must contain every planned native file",
+        });
+    }
+    for (let index = 0; index < planned.length; index++) {
+        const expected = planned[index];
+        const actual = activation.files[index];
+        if (expected === undefined ||
+            actual === undefined ||
+            actual.path !== expected.relPath ||
+            actual.mode !== expected.mode ||
+            sha256Utf8(actual.content) !== expected.contentSha256) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["files", index],
+                message: "profile activation file path, mode, and content must match the canonical plan",
+            });
+        }
+    }
+    if (!isCanonicalJsonValue(activation)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "profile activation must contain only RFC 8785 JSON values",
+        });
+    }
+});
+export const agentCandidateExecutionPlanEvidenceSchema = planEvidenceSchema(2, "agent-candidate-execution-plan", agentCandidateExecutionPlanMaterialSchema);