@tangle-network/agent-interface 0.33.0 → 0.35.0

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

@@ -3,79 +3,10 @@ import { agentCandidateBundleSchema } from "./agent-candidate-schema.js";
 import { agentCandidateLineageSchema } from "./agent-candidate-lineage-schema.js";
 import { agentCandidateBenchmarkSuiteInputsSchema } from "./agent-candidate-task-schema.js";
 import { canonicalCandidateDigest, isCanonicalJsonValue, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
+import { refineAgentExecutionWithinLimits } from "./agent-execution-limits.js";
 import { agentCandidateMaterializationReceiptSchema, agentCandidateRunReceiptSchema, } from "./agent-candidate-receipt-schema.js";
-const canonicalJsonSchema = z.custom(isCanonicalJsonValue, "value must be finite, acyclic RFC 8785 JSON");
-const canonicalJsonObjectSchema = z
-    .record(z.string(), canonicalJsonSchema)
-    .refine(isCanonicalJsonValue, "value must be finite, acyclic RFC 8785 JSON");
-const confidenceIntervalSchema = z
-    .object({
-    level: z.number().finite().gt(0).lt(1),
-    lower: z.number().finite(),
-    upper: z.number().finite(),
-    method: z.literal("paired-bootstrap"),
-    statistic: z.literal("mean"),
-    resamples: z.number().int().positive(),
-})
-    .strict();
-const measuredEstimateFields = {
-    baseline: z.number().finite(),
-    candidate: z.number().finite(),
-    delta: z.number().finite(),
-    confidenceInterval: confidenceIntervalSchema,
-    n: z.number().int().positive(),
-};
-const qualityObjectiveFields = {
-    kind: z.literal("objective"),
-    name: z.string().min(1),
-    direction: z.literal("higher-is-better"),
-    unit: z.literal("score"),
-};
-const qualityDimensionFields = {
-    kind: z.literal("dimension"),
-    objective: z.string().min(1),
-    name: z.string().min(1),
-    direction: z.literal("higher-is-better"),
-    unit: z.literal("score"),
-};
-const costObjectiveFields = {
-    kind: z.literal("cost"),
-    name: z.literal("cost"),
-    direction: z.literal("lower-is-better"),
-    unit: z.literal("usd"),
-};
-const latencyObjectiveFields = {
-    kind: z.literal("latency"),
-    name: z.literal("latency"),
-    direction: z.literal("lower-is-better"),
-    unit: z.literal("milliseconds"),
-};
-function measuredObjectiveVariant(fields) {
-    return z
-        .object({
-        ...fields,
-        availability: z.literal("measured"),
-        ...measuredEstimateFields,
-    })
-        .strict();
-}
-function unavailableObjectiveVariant(fields) {
-    return z
-        .object({
-        ...fields,
-        availability: z.literal("unavailable"),
-        reason: z.string().min(1),
-    })
-        .strict();
-}
-const measuredObjectiveSchema = z.union([
-    measuredObjectiveVariant(qualityObjectiveFields),
-    unavailableObjectiveVariant(qualityObjectiveFields),
-    measuredObjectiveVariant(qualityDimensionFields),
-    unavailableObjectiveVariant(qualityDimensionFields),
-    measuredObjectiveVariant(costObjectiveFields),
-    measuredObjectiveVariant(latencyObjectiveFields),
-]);
+import { agentCandidateEvaluationPolicySchema, canonicalJsonObjectSchema, createMeasuredComparisonIdentityRegistry, measuredComparisonCommonShape, refineMeasuredComparisonSummary, } from "./agent-improvement-measurement-schema.js";
+import { agentProfileImprovementMeasuredComparisonSchema, changedProfileImprovementSurfaces, } from "./agent-profile-improvement-schema.js";
 const improvementSurfaceSchema = z.enum([
     "prompt",
     "skills",
@@ -88,28 +19,6 @@ const improvementSurfaceSchema = z.enum([
     "code",
     "knowledge",
 ]);
-export const agentCandidateEvaluationPolicySchema = z
-    .object({
-    confidenceLevel: z.number().finite().gt(0).lt(1),
-    resamples: z.number().int().min(100),
-    bootstrapSeed: z.number().int().safe(),
-    deltaThreshold: z.number().finite().nonnegative(),
-    minProductiveRuns: z.number().int().min(3),
-    budgetUsd: z.number().finite().nonnegative().optional(),
-    criticalDimensions: z.array(z.string().min(1)),
-    regressionTolerance: z.number().finite().nonnegative(),
-})
-    .strict()
-    .superRefine((policy, ctx) => {
-    if (new Set(policy.criticalDimensions).size !== policy.criticalDimensions.length ||
-        policy.criticalDimensions.some((name, index) => index > 0 && policy.criticalDimensions[index - 1] >= name)) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["criticalDimensions"],
-            message: "critical dimensions must be sorted and unique",
-        });
-    }
-});
 export const agentCandidateExperimentSchema = z
     .object({
     kind: z.literal("agent-candidate-experiment"),
@@ -204,6 +113,14 @@ export const candidateExecutionEvidenceSchema = z
         if (!valid)
             ctx.addIssue({ code: "custom", path, message });
     }
+    refineAgentExecutionWithinLimits(plan.material.limits, {
+        durationMs: evidence.receipt.timing.durationMs,
+        steps: evidence.receipt.steps,
+        usage: evidence.receipt.modelSettlement.material.usage,
+    }, ctx, {
+        pathPrefix: ["receipt"],
+        usagePath: ["modelSettlement", "material", "usage"],
+    });
     if (!isCanonicalJsonValue(evidence)) {
         ctx.addIssue({
             code: "custom",
@@ -221,82 +138,10 @@ export const agentImprovementMeasuredComparisonSchema = z
         candidate: candidateExecutionEvidenceSchema,
     })
         .strict()),
-    overall: z
-        .object({
-        name: z.literal("composite"),
-        ...measuredEstimateFields,
-        direction: z.literal("higher-is-better"),
-        unit: z.literal("score"),
-    })
-        .strict(),
-    objectives: z.array(measuredObjectiveSchema),
-    candidate: z
-        .object({
-        label: z.string().min(1).optional(),
-        rationale: z.string().min(1).optional(),
-    })
-        .strict()
-        .refine((candidate) => candidate.label !== undefined || candidate.rationale !== undefined, "candidate metadata requires a label or rationale")
-        .optional(),
-    decision: z
-        .object({
-        outcome: z.enum([
-            "ship",
-            "hold",
-            "need_more_work",
-            "model_ceiling",
-            "arch_ceiling",
-        ]),
-        reasons: z.array(z.string().min(1)).min(1),
-        contributingChecks: z.array(z.object({ name: z.string().min(1), passed: z.boolean() }).strict()),
-    })
-        .strict(),
-    power: z
-        .object({
-        sufficient: z.boolean(),
-        n: z.number().int().positive(),
-        minimumDetectableDelta: z.number().finite().nonnegative(),
-        confidenceLevel: z.number().finite().gt(0).lt(1),
-        scaleAssumed: z.boolean(),
-        sharedScorerChannel: z.boolean(),
-        reason: z.string().min(1),
-    })
-        .strict(),
-    provenance: z
-        .object({
-        kind: z.literal("agent-eval-loop"),
-        schema: z.string().min(1),
-        runId: z.string().min(1),
-        recordDigest: sha256DigestSchema,
-        baselineContentHash: z.string().regex(/^(?:sha256:)?[a-f0-9]{64}$/),
-        candidateContentHash: z.string().regex(/^(?:sha256:)?[a-f0-9]{64}$/),
-    })
-        .strict(),
-    diff: z.string(),
-    evaluation: z
-        .object({
-        generationsExplored: z.number().int().nonnegative(),
-        searchDurationMs: z.number().finite().nonnegative(),
-        executionDurationMs: z.number().finite().nonnegative(),
-        durationMs: z.number().finite().nonnegative(),
-        searchCostUsd: z.number().finite().nonnegative(),
-        executionCostUsd: z.number().finite().nonnegative(),
-        totalCostUsd: z.number().finite().nonnegative(),
-    })
-        .strict(),
-    metadata: canonicalJsonObjectSchema.optional(),
+    ...measuredComparisonCommonShape,
 })
     .strict()
     .superRefine((comparison, ctx) => {
-    refineEstimate(comparison.overall, ["overall"], ctx);
-    if (!approximatelyEqual(comparison.evaluation.durationMs, comparison.evaluation.searchDurationMs + comparison.evaluation.executionDurationMs) ||
-        !approximatelyEqual(comparison.evaluation.totalCostUsd, comparison.evaluation.searchCostUsd + comparison.evaluation.executionCostUsd)) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["evaluation"],
-            message: "evaluation totals must equal their search and execution components",
-        });
-    }
     const { suite, tasks } = comparison.experiment.benchmark;
     const expectedN = suite.taskDigests.length * suite.reps;
     if (comparison.measurements.length !== expectedN) {
@@ -306,13 +151,10 @@ export const agentImprovementMeasuredComparisonSchema = z
             message: "measured comparison must contain every signed benchmark cell",
         });
     }
-    const executionIdentities = {
-        execution: new Set(),
-        runCell: new Set(),
-        materialization: new Set(),
-        receipt: new Set(),
-        evidence: new Set(),
-    };
+    const recordExecutionIdentities = createMeasuredComparisonIdentityRegistry({
+        ctx,
+        identityLabel: "measured executions",
+    });
     for (let taskIndex = 0; taskIndex < suite.taskDigests.length; taskIndex += 1) {
         const task = tasks[taskIndex];
         if (!task)
@@ -509,138 +351,22 @@ export const agentImprovementMeasuredComparisonSchema = z
                     if (!valid)
                         ctx.addIssue({ code: "custom", path, message });
                 }
-                const identitiesForRun = {
-                    execution: plan.material.executionId,
-                    runCell: runCell.digest,
-                    materialization: materialization.digest,
-                    receipt: evidence.receipt.digest,
-                    evidence: evidence.digest,
-                };
-                for (const [kind, identity] of Object.entries(identitiesForRun)) {
-                    if (executionIdentities[kind].has(identity)) {
-                        ctx.addIssue({
-                            code: "custom",
-                            path: armPath,
-                            message: `measured executions must not reuse ${kind} identity`,
-                        });
-                    }
-                    executionIdentities[kind].add(identity);
-                }
+                recordExecutionIdentities([
+                    { kind: "execution", value: plan.material.executionId },
+                    { kind: "runCell", value: runCell.digest },
+                    { kind: "materialization", value: materialization.digest },
+                    { kind: "receipt", value: evidence.receipt.digest },
+                    { kind: "evidence", value: evidence.digest },
+                ], armPath);
             }
         }
     }
-    if (comparison.overall.n !== expectedN) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["overall", "n"],
-            message: "measured sample count must equal the complete benchmark suite",
-        });
-    }
-    if (comparison.measurements.length > 0) {
-        refineMeasuredMean(comparison.overall.baseline, comparison.measurements.map((row) => row.baseline.receipt.benchmarkResult.material.score), ["overall", "baseline"], ctx);
-        refineMeasuredMean(comparison.overall.candidate, comparison.measurements.map((row) => row.candidate.receipt.benchmarkResult.material.score), ["overall", "candidate"], ctx);
-    }
-    const identities = new Set();
-    const qualityObjectives = new Set();
-    const dimensionParents = [];
-    let costCount = 0;
-    let latencyCount = 0;
-    for (const [index, objective] of comparison.objectives.entries()) {
-        if (objective.availability === "measured") {
-            refineEstimate(objective, ["objectives", index], ctx);
-            if (objective.n !== expectedN) {
-                ctx.addIssue({
-                    code: "custom",
-                    path: ["objectives", index, "n"],
-                    message: "measured objective count must equal the complete benchmark suite",
-                });
-            }
-            if (comparison.measurements.length > 0 && objective.kind === "cost") {
-                refineMeasuredMean(objective.baseline, comparison.measurements.map((row) => executionCostUsd(row.baseline)), ["objectives", index, "baseline"], ctx);
-                refineMeasuredMean(objective.candidate, comparison.measurements.map((row) => executionCostUsd(row.candidate)), ["objectives", index, "candidate"], ctx);
-            }
-            if (comparison.measurements.length > 0 && objective.kind === "latency") {
-                refineMeasuredMean(objective.baseline, comparison.measurements.map((row) => executionLatencyMs(row.baseline)), ["objectives", index, "baseline"], ctx);
-                refineMeasuredMean(objective.candidate, comparison.measurements.map((row) => executionLatencyMs(row.candidate)), ["objectives", index, "candidate"], ctx);
-            }
-        }
-        const identity = objective.kind === "dimension"
-            ? `${objective.kind}:${objective.objective}:${objective.name}`
-            : `${objective.kind}:${objective.name}`;
-        if (identities.has(identity)) {
-            ctx.addIssue({
-                code: "custom",
-                path: ["objectives", index, "name"],
-                message: "measured objective identities must be unique",
-            });
-        }
-        identities.add(identity);
-        if (objective.kind === "objective") {
-            qualityObjectives.add(objective.name);
-        }
-        else if (objective.kind === "dimension") {
-            dimensionParents.push({ index, objective: objective.objective });
-        }
-        else if (objective.kind === "cost") {
-            costCount += 1;
-        }
-        else if (objective.kind === "latency") {
-            latencyCount += 1;
-        }
-    }
-    if (costCount !== 1 || latencyCount !== 1) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["objectives"],
-            message: "measured comparison must contain exactly one cost and latency objective",
-        });
-    }
-    if (qualityObjectives.size === 0) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["objectives"],
-            message: "measured comparison must contain at least one quality objective",
-        });
-    }
-    for (const parent of dimensionParents) {
-        if (!qualityObjectives.has(parent.objective)) {
-            ctx.addIssue({
-                code: "custom",
-                path: ["objectives", parent.index, "objective"],
-                message: "measured dimension must name a present quality objective",
-            });
-        }
-    }
-    if (comparison.power.n !== comparison.overall.n) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["power", "n"],
-            message: "power analysis must use the paired held-out sample",
-        });
-    }
-    if (comparison.overall.confidenceInterval.level !==
-        comparison.experiment.policy.confidenceLevel ||
-        comparison.overall.confidenceInterval.resamples !==
-            comparison.experiment.policy.resamples ||
-        comparison.power.confidenceLevel !== comparison.experiment.policy.confidenceLevel) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["experiment", "policy"],
-            message: "reported uncertainty must use the frozen evaluation policy",
-        });
-    }
-    for (const [index, objective] of comparison.objectives.entries()) {
-        if (objective.availability === "measured" &&
-            (objective.confidenceInterval.level !==
-                comparison.experiment.policy.confidenceLevel ||
-                objective.confidenceInterval.resamples !== comparison.experiment.policy.resamples)) {
-            ctx.addIssue({
-                code: "custom",
-                path: ["objectives", index, "confidenceInterval"],
-                message: "objective uncertainty must use the frozen evaluation policy",
-            });
-        }
-    }
+    refineMeasuredComparisonSummary(comparison, comparison.experiment.policy, expectedN, comparison.measurements, {
+        score: (evidence) => evidence.receipt.benchmarkResult.material.score,
+        dimension: (evidence, name) => evidence.receipt.benchmarkResult.material.dimensions.find((dimension) => dimension.name === name)?.score,
+        cost: executionCostUsd,
+        latency: executionLatencyMs,
+    }, ctx);
     if (!isCanonicalJsonValue(comparison)) {
         ctx.addIssue({
             code: "custom",
@@ -658,7 +384,10 @@ export const agentImprovementProposalSchema = z
         .refine((surfaces) => new Set(surfaces).size === surfaces.length, "changed surfaces must be unique"),
     proposedAt: z.iso.datetime(),
     findings: z.array(canonicalJsonObjectSchema),
-    evaluation: agentImprovementMeasuredComparisonSchema,
+    evaluation: z.discriminatedUnion("kind", [
+        agentImprovementMeasuredComparisonSchema,
+        agentProfileImprovementMeasuredComparisonSchema,
+    ]),
     digest: sha256DigestSchema,
 })
     .strict()
@@ -679,13 +408,25 @@ export const agentImprovementProposalSchema = z
             message: "an improvement proposal requires sufficient pre-registered power",
         });
     }
-    if (proposal.evaluation.experiment.baseline.digest ===
-        proposal.evaluation.experiment.candidate.digest) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["evaluation", "experiment", "candidate", "digest"],
-            message: "an improvement proposal requires a changed candidate bundle",
-        });
+    if (proposal.evaluation.kind === "agent-improvement-measured-comparison") {
+        if (proposal.evaluation.experiment.baseline.digest ===
+            proposal.evaluation.experiment.candidate.digest) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["evaluation", "experiment", "candidate", "digest"],
+                message: "an improvement proposal requires a changed candidate bundle",
+            });
+        }
+    }
+    else {
+        const changed = changedProfileImprovementSurfaces(proposal.evaluation.experiment.change);
+        if (!sameSurfaces(proposal.changedSurfaces, changed)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["changedSurfaces"],
+                message: "proposal changed surfaces must equal the measured profile changes",
+            });
+        }
     }
     if (!isCanonicalJsonValue(proposal)) {
         ctx.addIssue({
@@ -694,40 +435,8 @@ export const agentImprovementProposalSchema = z
         });
     }
 });
-function refineEstimate(estimate, path, ctx) {
-    const expectedDelta = estimate.candidate - estimate.baseline;
-    const tolerance = Number.EPSILON * Math.max(1, Math.abs(expectedDelta)) * 8;
-    if (Math.abs(estimate.delta - expectedDelta) > tolerance) {
-        ctx.addIssue({
-            code: "custom",
-            path: [...path, "delta"],
-            message: "measured delta must equal candidate minus baseline",
-        });
-    }
-    if (estimate.confidenceInterval.lower > estimate.confidenceInterval.upper ||
-        estimate.delta < estimate.confidenceInterval.lower ||
-        estimate.delta > estimate.confidenceInterval.upper) {
-        ctx.addIssue({
-            code: "custom",
-            path: [...path, "confidenceInterval"],
-            message: "confidence interval must be ordered and contain the measured delta",
-        });
-    }
-}
-function refineMeasuredMean(reported, values, path, ctx) {
-    const measured = values.reduce((sum, value) => sum + value, 0) / values.length;
-    const tolerance = Number.EPSILON * Math.max(1, Math.abs(measured)) * values.length * 8;
-    if (Math.abs(reported - measured) > tolerance) {
-        ctx.addIssue({
-            code: "custom",
-            path,
-            message: "reported mean must equal the signed per-cell results",
-        });
-    }
-}
-function approximatelyEqual(left, right) {
-    const tolerance = Number.EPSILON * Math.max(1, Math.abs(left), Math.abs(right)) * 16;
-    return Math.abs(left - right) <= tolerance;
+function sameSurfaces(left, right) {
+    return left.length === right.length && left.every((surface) => right.includes(surface));
 }
 function executionCostUsd(evidence) {
     return (evidence.receipt.modelSettlement.material.usage.costUsdNanos +
@@ -763,7 +472,7 @@ export const agentImprovementActivationSchema = z
     proposalDigest: sha256DigestSchema,
     reviewDigest: sha256DigestSchema,
     experimentDigest: sha256DigestSchema,
-    candidateBundleDigest: sha256DigestSchema,
+    candidateDigest: sha256DigestSchema,
     intent: z.enum(["activate-candidate", "restore-baseline"]),
     targets: z
         .tuple([improvementActivationTargetSchema])

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

@@ -197,7 +197,7 @@ export declare const agentCandidateMaterializationReceiptSchema: z.ZodObject<{
             digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
             material: z.ZodType<{
                 sourceProfileDigest: `sha256:${string}`;
-                harness: "claude-code" | "claude" | "claudish" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "kimi" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
+                harness: "claude-code" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
                 files: {
                     relPath: string;
                     mode: number;
@@ -221,7 +221,7 @@ export declare const agentCandidateMaterializationReceiptSchema: z.ZodObject<{
                 } | undefined;
             }, unknown, z.core.$ZodTypeInternals<{
                 sourceProfileDigest: `sha256:${string}`;
-                harness: "claude-code" | "claude" | "claudish" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "kimi" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
+                harness: "claude-code" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
                 files: {
                     relPath: string;
                     mode: number;
@@ -279,7 +279,7 @@ export declare const agentCandidateMaterializationReceiptSchema: z.ZodObject<{
             runCell: {
                 kind: "agent-candidate-run-cell";
                 experimentDigest: `sha256:${string}`;
-                arm: "candidate" | "baseline";
+                arm: "baseline" | "candidate";
                 bundleDigest: `sha256:${string}`;
                 suiteDigest: `sha256:${string}`;
                 taskDigest: `sha256:${string}`;
@@ -300,7 +300,7 @@ export declare const agentCandidateMaterializationReceiptSchema: z.ZodObject<{
                 targetWorkspace: "candidate" | "task";
                 mountPaths: string[];
             };
-            harness: "claude-code" | "claude" | "claudish" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "kimi" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
+            harness: "claude-code" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
             harnessVersion: string;
             instructionDelivery: {
                 kind: "argv-append";
@@ -522,7 +522,7 @@ export declare const agentCandidateMaterializationReceiptSchema: z.ZodObject<{
             runCell: {
                 kind: "agent-candidate-run-cell";
                 experimentDigest: `sha256:${string}`;
-                arm: "candidate" | "baseline";
+                arm: "baseline" | "candidate";
                 bundleDigest: `sha256:${string}`;
                 suiteDigest: `sha256:${string}`;
                 taskDigest: `sha256:${string}`;
@@ -543,7 +543,7 @@ export declare const agentCandidateMaterializationReceiptSchema: z.ZodObject<{
                 targetWorkspace: "candidate" | "task";
                 mountPaths: string[];
             };
-            harness: "claude-code" | "claude" | "claudish" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "kimi" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
+            harness: "claude-code" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
             harnessVersion: string;
             instructionDelivery: {
                 kind: "argv-append";
@@ -840,13 +840,10 @@ export declare const agentCandidateMaterializationReceiptSchema: z.ZodObject<{
     materializedTree: z.ZodOptional<z.ZodString>;
     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";
@@ -906,6 +903,7 @@ export declare const agentCandidateRunReceiptSchema: z.ZodObject<{
         endedAtMs: z.ZodNumber;
         durationMs: z.ZodNumber;
     }, z.core.$strict>;
+    steps: z.ZodNumber;
     memory: z.ZodDiscriminatedUnion<[z.ZodObject<{
         mode: z.ZodLiteral<"disabled">;
     }, z.core.$strict>, z.ZodObject<{
@@ -1023,7 +1021,7 @@ export declare const agentCandidateRunReceiptSchema: z.ZodObject<{
                 callId: string;
                 generationId: string;
                 traceSpanId: string;
-                status: "failed" | "succeeded";
+                status: "succeeded" | "failed";
                 model: string;
                 startedAtMs: number;
                 endedAtMs: number;
@@ -1058,7 +1056,7 @@ export declare const agentCandidateRunReceiptSchema: z.ZodObject<{
                 callId: string;
                 generationId: string;
                 traceSpanId: string;
-                status: "failed" | "succeeded";
+                status: "succeeded" | "failed";
                 model: string;
                 startedAtMs: number;
                 endedAtMs: number;

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

@@ -259,6 +259,7 @@ export const agentCandidateRunReceiptSchema = z
         durationMs: z.number().int().nonnegative().safe(),
     })
         .strict(),
+    steps: z.number().int().nonnegative().safe(),
     memory: agentCandidateMemoryReceiptSchema,
     trace: agentCandidateTraceEvidenceSchema,
     termination: agentCandidateTerminationSchema,

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

@@ -35,13 +35,10 @@ export declare const agentCandidateBundleSchema: z.ZodObject<{
         }, 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";
@@ -270,13 +267,10 @@ export declare const agentCandidateBundleSchema: z.ZodObject<{
     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";

package/dist/agent-candidate-schema.js

@@ -3,7 +3,6 @@ import { agentCandidateCodeSchema, agentCandidateExecutionSchema } from "./agent
 import { agentCandidateProfileSchema } from "./agent-candidate-profile-schema.js";
 import { agentCandidateKnowledgeSchema, 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.
  *
@@ -32,8 +31,7 @@ export const agentCandidateBundleSchema = z
         });
     }
     if (bundle.profile.harness !== undefined &&
-        canonicalizeHarness(bundle.profile.harness) !==
-            canonicalizeHarness(bundle.execution.harness)) {
+        bundle.profile.harness !== bundle.execution.harness) {
         ctx.addIssue({
             code: "custom",
             path: ["execution", "harness"],