@tangle-network/agent-interface 0.28.0 → 0.29.0

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

@@ -0,0 +1,191 @@
+import { z } from "zod";
+import { agentCandidateArtifactRefSchema, agentCandidateWorkspaceSnapshotEvidenceSchema, } from "./agent-candidate-artifact-schema.js";
+import { agentCandidateBenchmarkGraderIdentitySchema, agentCandidateBenchmarkCellRefSchema, agentCandidateExecutionLimitsSchema, agentCandidateResolvedModelSchema, agentCandidateResolvedTaskContainerSchema, agentCandidateRetryPolicySchema, agentCandidateTaskRepositorySchema, agentCandidateTaskOutcomeSpecSchema, } from "./agent-candidate-execution-plan-schema.js";
+import { isCanonicalJsonValue, isWellFormedUnicode, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
+export const agentCandidateBenchmarkTaskMaterialSchema = z
+    .object({
+    kind: z.literal("agent-candidate-benchmark-task"),
+    digestAlgorithm: z.literal("rfc8785-sha256"),
+    benchmark: z
+        .object({
+        name: z.string().min(1).max(512),
+        version: z.string().min(1).max(256),
+        splitDigest: sha256DigestSchema,
+    })
+        .strict(),
+    scenario: z
+        .object({
+        id: z.string().min(1).max(512),
+        kind: z.string().min(1).max(512),
+        scenarioDigest: sha256DigestSchema,
+    })
+        .strict(),
+    datasetSnapshot: agentCandidateArtifactRefSchema.optional(),
+    instruction: z
+        .string()
+        .min(1)
+        .max(4 * 1024 * 1024)
+        .refine(isWellFormedUnicode, "task instruction must be well-formed Unicode"),
+    repository: agentCandidateTaskRepositorySchema.optional(),
+    outcome: agentCandidateTaskOutcomeSpecSchema,
+    workspace: agentCandidateWorkspaceSnapshotEvidenceSchema,
+    grader: agentCandidateBenchmarkGraderIdentitySchema,
+    model: agentCandidateResolvedModelSchema,
+    attempt: z
+        .object({
+        maxAttempts: z.number().int().min(1),
+        retryPolicy: agentCandidateRetryPolicySchema,
+    })
+        .strict(),
+    evaluatorTaskContainer: agentCandidateResolvedTaskContainerSchema.optional(),
+    limits: agentCandidateExecutionLimitsSchema,
+})
+    .strict()
+    .superRefine((task, ctx) => {
+    if (!isCanonicalJsonValue(task)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "candidate benchmark task must contain finite, acyclic canonical JSON",
+        });
+    }
+    if (task.outcome.kind === "workspace" && task.repository === undefined) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["repository"],
+            message: "workspace outcomes require an exact source repository",
+        });
+    }
+    if (task.attempt.retryPolicy === "none" && task.attempt.maxAttempts !== 1) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["attempt", "maxAttempts"],
+            message: "a no-retry task must allow exactly one attempt",
+        });
+    }
+    if (task.datasetSnapshot?.byteLength === 0) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["datasetSnapshot", "byteLength"],
+            message: "dataset snapshot provenance must contain bytes",
+        });
+    }
+});
+/** Structural parse only; Runtime recomputes the canonical digest before use. */
+export const agentCandidateBenchmarkTaskSchema = agentCandidateBenchmarkTaskMaterialSchema
+    .extend({ digest: sha256DigestSchema })
+    .strict();
+export const agentCandidateBenchmarkSuiteMaterialSchema = z
+    .object({
+    kind: z.literal("agent-candidate-benchmark-suite"),
+    digestAlgorithm: z.literal("rfc8785-sha256"),
+    taskDigests: z
+        .tuple([sha256DigestSchema])
+        .rest(sha256DigestSchema),
+    reps: z.number().int().positive(),
+    seeds: z
+        .tuple([
+        z
+            .number()
+            .int()
+            .min(Number.MIN_SAFE_INTEGER)
+            .max(Number.MAX_SAFE_INTEGER),
+    ])
+        .rest(z
+        .number()
+        .int()
+        .min(Number.MIN_SAFE_INTEGER)
+        .max(Number.MAX_SAFE_INTEGER)),
+})
+    .strict()
+    .superRefine((suite, ctx) => {
+    const taskDigests = new Set();
+    for (const [index, digest] of suite.taskDigests.entries()) {
+        if (taskDigests.has(digest)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["taskDigests", index],
+                message: "benchmark suite task digests must be unique",
+            });
+        }
+        taskDigests.add(digest);
+    }
+    const expectedSeeds = suite.taskDigests.length * suite.reps;
+    if (suite.seeds.length !== expectedSeeds) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["seeds"],
+            message: "benchmark suite must provide one seed per task repetition",
+        });
+    }
+    if (!isCanonicalJsonValue(suite)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "benchmark suite must contain finite, acyclic canonical JSON",
+        });
+    }
+});
+export const agentCandidateBenchmarkSuiteSchema = agentCandidateBenchmarkSuiteMaterialSchema
+    .extend({ digest: sha256DigestSchema })
+    .strict();
+export const agentCandidateBenchmarkSuiteInputsSchema = z
+    .object({
+    suite: agentCandidateBenchmarkSuiteSchema,
+    tasks: z
+        .tuple([agentCandidateBenchmarkTaskSchema])
+        .rest(agentCandidateBenchmarkTaskSchema),
+})
+    .strict()
+    .superRefine((input, ctx) => {
+    if (input.tasks.length !== input.suite.taskDigests.length) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["tasks"],
+            message: "benchmark suite inputs must contain every signed task exactly once",
+        });
+    }
+    const taskIds = new Set();
+    const scenarioDigests = new Set();
+    const benchmark = input.tasks[0]?.benchmark;
+    for (const [index, task] of input.tasks.entries()) {
+        if (task.digest !== input.suite.taskDigests[index]) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["tasks", index, "digest"],
+                message: "benchmark task order must match the signed suite",
+            });
+        }
+        if (taskIds.has(task.scenario.id)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["tasks", index, "scenario", "id"],
+                message: "benchmark suite task ids must be unique",
+            });
+        }
+        taskIds.add(task.scenario.id);
+        if (scenarioDigests.has(task.scenario.scenarioDigest)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["tasks", index, "scenario", "scenarioDigest"],
+                message: "benchmark suite scenario digests must be unique",
+            });
+        }
+        scenarioDigests.add(task.scenario.scenarioDigest);
+        if (benchmark &&
+            (task.benchmark.name !== benchmark.name ||
+                task.benchmark.version !== benchmark.version ||
+                task.benchmark.splitDigest !== benchmark.splitDigest)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["tasks", index, "benchmark"],
+                message: "benchmark suite tasks must share one benchmark identity",
+            });
+        }
+    }
+    if (!isCanonicalJsonValue(input)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "benchmark suite inputs must contain finite, acyclic canonical JSON",
+        });
+    }
+});
+export { agentCandidateBenchmarkCellRefSchema };

package/dist/agent-candidate.d.ts

@@ -106,8 +106,6 @@ export interface AgentCandidateProfile extends Omit<AgentProfile, "model" | "mcp
 }
 export interface AgentCandidateCodeDisabled {
     kind: "disabled";
-    /** `control` marks a comparison arm; `not-applicable` disables only the code surface. */
-    reason: "control" | "not-applicable";
 }
 /** A code proposer ran against this exact tree and returned no change. */
 export interface AgentCandidateCodeNoOp {
@@ -224,14 +222,6 @@ export type AgentCandidateMemoryPolicy = {
     scope: "task";
     seed?: AgentCandidateArtifactRef;
 };
-/** Captured model spend for one phase of candidate production. */
-export interface AgentCandidateSpend {
-    costUsd: number;
-    inputTokens: number;
-    outputTokens: number;
-    cachedInputTokens?: number;
-    modelCalls: number;
-}
 /** Lossless evaluator-owned usage totals for one candidate execution. */
 export interface AgentCandidateFixedSpend {
     inputTokens: number;
@@ -249,15 +239,8 @@ export interface AgentCandidateLineage {
     runIds?: string[];
     profileDiffIds?: string[];
     modelSnapshots?: string[];
-    benchmark?: {
-        name: string;
-        version: string;
-        splitDigest: Sha256Digest;
-    };
-    spend?: {
-        proposal: AgentCandidateSpend;
-        evaluation: AgentCandidateSpend;
-    };
+    /** Exact development split used to produce a generated candidate. */
+    developmentSplitDigest?: Sha256Digest;
 }
 /**
  * Portable, immutable output of agent improvement.
@@ -275,7 +258,6 @@ export interface AgentCandidateBundle {
     execution: AgentCandidateExecution;
     knowledge?: AgentCandidateKnowledge;
     memory: AgentCandidateMemoryPolicy;
-    lineage: AgentCandidateLineage;
     digest: Sha256Digest;
 }
 export interface AgentCandidateEntrypointReceipt {
@@ -288,6 +270,14 @@ export interface AgentCandidateOciPlatform {
     architecture: string;
     variant?: string;
 }
+/** Exact evaluator-selected task image used when the candidate does not pin one. */
+export interface AgentCandidateResolvedTaskContainer {
+    source: "evaluator-task-container";
+    image: string;
+    indexDigest: Sha256Digest;
+    manifestDigest: Sha256Digest;
+    platform: AgentCandidateOciPlatform;
+}
 export interface AgentCandidateResolvedModel {
     requested: string;
     provider: string;
@@ -297,6 +287,8 @@ export interface AgentCandidateResolvedModel {
 }
 /** Canonical, digest-free profile-plan identity document. */
 export interface AgentCandidateProfilePlanMaterial {
+    /** Canonical digest of the complete frozen profile that produced this plan. */
+    sourceProfileDigest: Sha256Digest;
     harness: HarnessType;
     files: Array<{
         relPath: string;
@@ -390,6 +382,103 @@ export type AgentCandidateTaskOutcomeSpec = {
 } | ({
     kind: "output";
 } & AgentCandidateTaskOutputSpec);
+/** Immutable grader identity admitted for one benchmark task. */
+export interface AgentCandidateBenchmarkGraderIdentity {
+    name: string;
+    version: string;
+    format: "tangle-grader";
+    artifact: AgentCandidateArtifactRef;
+}
+/** Portable task bytes shared by evaluation, approval, and execution. */
+export interface AgentCandidateBenchmarkTaskMaterial {
+    kind: "agent-candidate-benchmark-task";
+    digestAlgorithm: AgentCandidateDigestAlgorithm;
+    benchmark: {
+        name: string;
+        version: string;
+        splitDigest: Sha256Digest;
+    };
+    scenario: {
+        id: string;
+        kind: string;
+        scenarioDigest: Sha256Digest;
+    };
+    datasetSnapshot?: AgentCandidateArtifactRef;
+    instruction: string;
+    repository?: AgentCandidateTaskRepository;
+    outcome: AgentCandidateTaskOutcomeSpec;
+    workspace: AgentCandidateWorkspaceSnapshotEvidence;
+    grader: AgentCandidateBenchmarkGraderIdentity;
+    model: AgentCandidateResolvedModel;
+    attempt: Omit<AgentCandidateAttemptPolicy, "number">;
+    evaluatorTaskContainer?: AgentCandidateResolvedTaskContainer;
+    limits: AgentCandidateExecutionLimits;
+}
+/** Content-addressed benchmark task approved and executed without reinterpretation. */
+export interface AgentCandidateBenchmarkTask extends AgentCandidateBenchmarkTaskMaterial {
+    digest: Sha256Digest;
+}
+/** Complete measured denominator shared by evaluation and execution. */
+export interface AgentCandidateBenchmarkSuiteMaterial {
+    kind: "agent-candidate-benchmark-suite";
+    digestAlgorithm: AgentCandidateDigestAlgorithm;
+    taskDigests: [Sha256Digest, ...Sha256Digest[]];
+    reps: number;
+    /** Task-major, then repetition-major: seeds[taskIndex * reps + repetition]. */
+    seeds: [number, ...number[]];
+}
+export interface AgentCandidateBenchmarkSuite extends AgentCandidateBenchmarkSuiteMaterial {
+    digest: Sha256Digest;
+}
+/** Canonical task documents transported alongside their signed suite. */
+export interface AgentCandidateBenchmarkSuiteInputs {
+    suite: AgentCandidateBenchmarkSuite;
+    tasks: [AgentCandidateBenchmarkTask, ...AgentCandidateBenchmarkTask[]];
+}
+/** One cell in a signed suite; task identity and seed are derived by position. */
+export interface AgentCandidateBenchmarkCellRef {
+    suiteDigest: Sha256Digest;
+    taskIndex: number;
+    repetition: number;
+}
+/** Decision rules frozen before either experiment arm executes. */
+export interface AgentCandidateEvaluationPolicy {
+    confidenceLevel: number;
+    resamples: number;
+    bootstrapSeed: number;
+    deltaThreshold: number;
+    minProductiveRuns: number;
+    budgetUsd?: number;
+    criticalDimensions: string[];
+    regressionTolerance: number;
+}
+/** Both complete agent states and the exact held-out work used to compare them. */
+export interface AgentCandidateExperimentMaterial {
+    kind: "agent-candidate-experiment";
+    digestAlgorithm: AgentCandidateDigestAlgorithm;
+    baseline: AgentCandidateBundle;
+    candidate: AgentCandidateBundle;
+    candidateLineage: AgentCandidateLineage;
+    benchmark: AgentCandidateBenchmarkSuiteInputs;
+    policy: AgentCandidateEvaluationPolicy;
+}
+export interface AgentCandidateExperiment extends AgentCandidateExperimentMaterial {
+    digest: Sha256Digest;
+}
+/** Digest-free identity of one exact attempt in a frozen experiment. */
+export interface AgentCandidateRunCellMaterial extends AgentCandidateBenchmarkCellRef {
+    kind: "agent-candidate-run-cell";
+    experimentDigest: Sha256Digest;
+    arm: "baseline" | "candidate";
+    bundleDigest: Sha256Digest;
+    taskDigest: Sha256Digest;
+    seed: number;
+    attempt: number;
+}
+/** One immutable experiment attempt used by plans, receipts, traces, and results. */
+export interface AgentCandidateRunCell extends AgentCandidateRunCellMaterial {
+    digest: Sha256Digest;
+}
 /**
  * Canonical, digest-free per-task execution identity document.
  *
@@ -398,24 +487,8 @@ export type AgentCandidateTaskOutcomeSpec = {
  */
 export interface AgentCandidateExecutionPlanMaterial {
     kind: "agent-candidate-execution-plan-material";
-    bundleDigest: Sha256Digest;
+    runCell: AgentCandidateRunCell;
     executionId: string;
-    attempt: AgentCandidateAttemptPolicy;
-    task: {
-        benchmark: string;
-        benchmarkVersion: string;
-        taskId: string;
-        splitDigest: Sha256Digest;
-        instruction: {
-            encoding: "utf8";
-            sha256: Sha256Digest;
-            byteLength: number;
-            delivery: AgentCandidateInstructionDelivery;
-        };
-        repository?: AgentCandidateTaskRepository;
-        outcome: AgentCandidateTaskOutcomeSpec;
-        workspace: AgentCandidateWorkspaceSnapshotEvidence;
-    };
     workspaces: {
         taskRoot: string;
         candidateRoot?: string;
@@ -425,6 +498,8 @@ export interface AgentCandidateExecutionPlanMaterial {
     profile: AgentCandidateProfileApplication;
     harness: HarnessType;
     harnessVersion: string;
+    instructionDelivery: AgentCandidateInstructionDelivery;
+    limits: AgentCandidateExecutionLimits;
     container: {
         source: AgentCandidateExecutionEnvironment["kind"];
         image: string;
@@ -456,12 +531,6 @@ export interface AgentCandidateExecutionPlanMaterial {
             requested: string;
         }>;
     };
-    /** Exact evaluator grader implementation admitted for this plan. */
-    grader: {
-        name: string;
-        version: string;
-        artifact: AgentCandidateArtifactRef;
-    };
     launch: {
         executable: string;
         args: AgentCandidateConfigValue[];
@@ -470,7 +539,6 @@ export interface AgentCandidateExecutionPlanMaterial {
     };
     knowledgeManifestDigest?: Sha256Digest;
     memory: AgentCandidateEffectiveMemory;
-    limits: AgentCandidateExecutionLimits;
     network: {
         mode: "disabled";
     };
@@ -498,6 +566,17 @@ export interface AgentCandidateExecutionPlanEvidence {
     material: AgentCandidateExecutionPlanMaterial;
     artifact: AgentCandidateCapturedArtifact;
 }
+/** Exact suite and task material selected for one execution plan. */
+export interface AgentCandidateBenchmarkInputEvidence {
+    suite: {
+        digest: Sha256Digest;
+        material: AgentCandidateCapturedArtifact;
+    };
+    task: {
+        digest: Sha256Digest;
+        material: AgentCandidateCapturedArtifact;
+    };
+}
 export interface AgentCandidateTraceEvidence {
     artifact: AgentCandidateCapturedArtifact;
     eventCount: number;
@@ -518,7 +597,8 @@ export interface AgentCandidateMaterializationReceipt {
     kind: "agent-candidate-materialization";
     digestAlgorithm: AgentCandidateDigestAlgorithm;
     bundleDigest: Sha256Digest;
-    profilePlan: AgentCandidateProfilePlanEvidence;
+    benchmark: AgentCandidateBenchmarkInputEvidence;
+    profileActivation: AgentCandidateProfileActivation;
     executionPlan: AgentCandidateExecutionPlanEvidence;
     candidateWorkspace?: AgentCandidateWorkspaceSnapshotEvidence;
     codeKind: AgentCandidateCode["kind"];
@@ -555,8 +635,14 @@ export interface AgentCandidateRunReceipt {
     kind: "agent-candidate-run";
     digestAlgorithm: AgentCandidateDigestAlgorithm;
     bundleDigest: Sha256Digest;
+    runCellDigest: Sha256Digest;
     materializationReceiptDigest: Sha256Digest;
     executionPlanDigest: Sha256Digest;
+    timing: {
+        startedAtMs: number;
+        endedAtMs: number;
+        durationMs: number;
+    };
     memory: AgentCandidateMemoryReceipt;
     trace: AgentCandidateTraceEvidence;
     termination: AgentCandidateTermination;
@@ -567,16 +653,16 @@ export interface AgentCandidateRunReceipt {
     digest: Sha256Digest;
 }
 export type AgentImprovementSurface = "prompt" | "skills" | "tools" | "mcp" | "hooks" | "subagents" | "agent-profile" | "memory" | "code" | "knowledge";
+/** One paired Runtime execution from the exact signed experiment. */
+export interface AgentCandidateExperimentMeasurement {
+    baseline: CandidateExecutionEvidence;
+    candidate: CandidateExecutionEvidence;
+}
 /** Portable paired held-out comparison produced by an evaluation package. */
 export interface AgentImprovementMeasuredComparison {
     kind: "agent-improvement-measured-comparison";
-    benchmark: {
-        name: string;
-        version: string;
-        splitDigest: Sha256Digest;
-    };
-    baselineProfileDigest: Sha256Digest;
-    candidateBundleDigest: Sha256Digest;
+    experiment: AgentCandidateExperiment;
+    measurements: AgentCandidateExperimentMeasurement[];
     overall: {
         name: "composite";
         baseline: number;
@@ -665,7 +751,11 @@ export interface AgentImprovementMeasuredComparison {
     diff: string;
     evaluation: {
         generationsExplored: number;
+        searchDurationMs: number;
+        executionDurationMs: number;
         durationMs: number;
+        searchCostUsd: number;
+        executionCostUsd: number;
         totalCostUsd: number;
     };
     metadata?: {
@@ -677,12 +767,10 @@ export interface AgentImprovementProposal {
     runId: string;
     changedSurfaces: [AgentImprovementSurface, ...AgentImprovementSurface[]];
     proposedAt: string;
-    baselineProfile: AgentProfile;
     findings: {
         [key: string]: AgentCandidateJsonValue;
     }[];
     evaluation: AgentImprovementMeasuredComparison;
-    candidateBundle: AgentCandidateBundle;
     digest: Sha256Digest;
 }
 export type AgentImprovementReviewDecision = "approve" | "reject" | "request-changes";
@@ -690,7 +778,6 @@ export type AgentImprovementReviewDecision = "approve" | "reject" | "request-cha
 export interface AgentImprovementReview {
     kind: "agent-improvement-review";
     proposalDigest: Sha256Digest;
-    candidateBundleDigest: Sha256Digest;
     decision: AgentImprovementReviewDecision;
     reviewedBy: string;
     reviewedAt: string;
@@ -698,15 +785,30 @@ export interface AgentImprovementReview {
     feedback?: string;
     digest: Sha256Digest;
 }
-/** Successful post-approval execution, carrying the exact Runtime receipt. */
-export interface CandidateExecutionEvidence {
-    kind: "agent-candidate-execution-evidence";
+export interface AgentImprovementActivationTarget {
+    surface: AgentImprovementSurface;
+    /** Product-owned stable identity, such as an agent profile, repository, or knowledge base. */
+    identity: string;
+    /** Current target state that activation is allowed to replace. */
+    expectedBaseDigest: Sha256Digest;
+}
+/** Authority receipt permitting activation of one already-measured candidate. */
+export interface AgentImprovementActivation {
+    kind: "agent-improvement-activation";
     proposalDigest: Sha256Digest;
     reviewDigest: Sha256Digest;
-    executionId: string;
-    succeeded: true;
+    experimentDigest: Sha256Digest;
+    candidateBundleDigest: Sha256Digest;
+    targets: [AgentImprovementActivationTarget, ...AgentImprovementActivationTarget[]];
+    fundingOwner: string;
+    authorizedBy: string;
+    authorizedAt: string;
+    digest: Sha256Digest;
+}
+/** Complete execution of one exact experiment attempt. */
+export interface CandidateExecutionEvidence {
+    kind: "agent-candidate-execution-evidence";
     materializationReceipt: AgentCandidateMaterializationReceipt;
-    profileActivation: AgentCandidateProfileActivation;
     receipt: AgentCandidateRunReceipt;
     digest: Sha256Digest;
 }
@@ -783,19 +885,18 @@ export interface AgentCandidateBenchmarkResultMaterial {
     kind: "agent-candidate-benchmark-result-material";
     executionPlanDigest: Sha256Digest;
     taskOutcomeDigest: Sha256Digest;
-    benchmark: {
-        name: string;
-        version: string;
-        taskId: string;
-        splitDigest: Sha256Digest;
-    };
-    grader: {
-        name: string;
-        version: string;
-        artifact: AgentCandidateArtifactRef;
-    };
+    grader: AgentCandidateBenchmarkGraderIdentity;
     /** Raw grader output required to independently audit the reported verdict. */
     evidence: AgentCandidateArtifactRef;
+    /** Evaluator-owned model usage and elapsed time, separate from candidate usage. */
+    grading: {
+        usage: AgentCandidateFixedSpend;
+        timing: {
+            startedAtMs: number;
+            endedAtMs: number;
+            durationMs: number;
+        };
+    };
     score: number;
     passed: boolean;
     dimensions: AgentCandidateBenchmarkDimension[];

package/dist/agent-candidate.test-fixture.d.ts

@@ -158,31 +158,5 @@ export declare function candidateFixture(): {
         mode: "isolated";
         scope: "task";
     };
-    lineage: {
-        source: "optimizer";
-        parentDigests: `sha256:${string}`[];
-        runIds: string[];
-        profileDiffIds: string[];
-        modelSnapshots: string[];
-        benchmark: {
-            name: string;
-            version: string;
-            splitDigest: `sha256:${string}`;
-        };
-        spend: {
-            proposal: {
-                costUsd: number;
-                inputTokens: number;
-                outputTokens: number;
-                modelCalls: number;
-            };
-            evaluation: {
-                costUsd: number;
-                inputTokens: number;
-                outputTokens: number;
-                modelCalls: number;
-            };
-        };
-    };
     digest: `sha256:${string}`;
 };

package/dist/agent-candidate.test-fixture.js

@@ -148,32 +148,6 @@ export function candidateFixture() {
             mode: "isolated",
             scope: "task",
         },
-        lineage: {
-            source: "optimizer",
-            parentDigests: [candidateSha("8")],
-            runIds: ["r360-search"],
-            profileDiffIds: ["profile-diff-3"],
-            modelSnapshots: ["openai/gpt-5.4-2026-06-15"],
-            benchmark: {
-                name: "pier",
-                version: "0.3",
-                splitDigest: candidateSha("9"),
-            },
-            spend: {
-                proposal: {
-                    costUsd: 3.5,
-                    inputTokens: 100,
-                    outputTokens: 20,
-                    modelCalls: 2,
-                },
-                evaluation: {
-                    costUsd: 9,
-                    inputTokens: 900,
-                    outputTokens: 200,
-                    modelCalls: 8,
-                },
-            },
-        },
         digest: candidateSha("a"),
     });
 }

package/dist/profile-schema.d.ts

@@ -115,6 +115,15 @@ export declare const agentProfileResourcesSchema: z.ZodObject<{
     }, z.core.$strip>]>]>>;
     failOnError: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
+export declare const reasoningEffortSchema: z.ZodEnum<{
+    none: "none";
+    minimal: "minimal";
+    low: "low";
+    medium: "medium";
+    high: "high";
+    xhigh: "xhigh";
+    ultracode: "ultracode";
+}>;
 export declare const agentProfileModelHintsSchema: z.ZodObject<{
     default: z.ZodOptional<z.ZodString>;
     small: z.ZodOptional<z.ZodString>;

package/dist/profile-schema.js

@@ -39,13 +39,20 @@ export const agentProfileResourcesSchema = z.object({
     instructions: z.union([z.string(), agentProfileResourceRefSchema]).optional(),
     failOnError: z.boolean().optional(),
 });
+export const reasoningEffortSchema = z.enum([
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "ultracode",
+]);
 export const agentProfileModelHintsSchema = z.object({
     default: z.string().optional(),
     small: z.string().optional(),
     provider: z.string().optional(),
-    reasoningEffort: z
-        .enum(["none", "minimal", "low", "medium", "high", "xhigh", "ultracode"])
-        .optional(),
+    reasoningEffort: reasoningEffortSchema.optional(),
     metadata: z.record(z.string(), z.unknown()).optional(),
 });
 export const agentProfilePromptSchema = z.object({