@tangle-network/agent-interface 1.8.0 → 2.0.0

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

@@ -1,5 +1,7 @@
 import { z } from "zod";
 import type { Sha256Digest } from "./agent-candidate.js";
+export type RelativePathSafetyIssue = "empty" | "control-character" | "malformed-unicode" | "absolute" | "backslash" | "parent-traversal";
+export type PathSafetyIssue = "control-character" | "malformed-unicode";
 export declare const sha256DigestSchema: z.ZodType<Sha256Digest>;
 export declare const gitObjectSchema: z.ZodString;
 export declare const environmentNameSchema: z.ZodString;
@@ -15,6 +17,10 @@ export declare function omitTopLevelDigest<T extends {
     digest: Sha256Digest;
 }>(value: T): Omit<T, "digest">;
 export declare function isWellFormedUnicode(value: string): boolean;
+/** Return shared boundary violations for path strings. */
+export declare function pathSafetyIssues(value: string): PathSafetyIssue[];
+/** Return shared boundary violations for paths that must stay inside a workspace. */
+export declare function relativePathSafetyIssues(value: string): RelativePathSafetyIssue[];
 export declare function isSafeRelativePath(value: string, allowDot: boolean): boolean;
 export declare function isSafeExecutable(value: string): boolean;
 export declare function isObviouslyPrivateHostname(rawHostname: string): boolean;

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

@@ -1,4 +1,4 @@
-import { sha256 } from "@noble/hashes/sha256";
+import { sha256 } from "@noble/hashes/sha2.js";
 import { z } from "zod";
 const sha256Pattern = /^sha256:[a-f0-9]{64}$/;
 const gitObjectPattern = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
@@ -86,20 +86,35 @@ export function isWellFormedUnicode(value) {
     }
     return true;
 }
+/** Return shared boundary violations for path strings. */
+export function pathSafetyIssues(value) {
+    const issues = [];
+    if (controlCharacterPattern.test(value))
+        issues.push("control-character");
+    if (!isWellFormedUnicode(value))
+        issues.push("malformed-unicode");
+    return issues;
+}
+/** Return shared boundary violations for paths that must stay inside a workspace. */
+export function relativePathSafetyIssues(value) {
+    const issues = [...pathSafetyIssues(value)];
+    if (value.length === 0)
+        issues.push("empty");
+    if (value.startsWith("/") || /^[A-Za-z]:/.test(value))
+        issues.push("absolute");
+    if (value.includes("\\"))
+        issues.push("backslash");
+    if (value.split("/").includes(".."))
+        issues.push("parent-traversal");
+    return issues;
+}
 export function isSafeRelativePath(value, allowDot) {
-    if (value.length === 0 ||
-        controlCharacterPattern.test(value) ||
-        !isWellFormedUnicode(value) ||
-        value.startsWith("/") ||
-        value.startsWith("\\") ||
-        value.includes("\\") ||
-        /^[A-Za-z]:/.test(value)) {
+    if (relativePathSafetyIssues(value).length > 0)
         return false;
-    }
     if (value === ".")
         return allowDot;
     const parts = value.split("/");
-    return (parts.every((part) => part.length > 0 && part !== "." && part !== "..") &&
+    return (parts.every((part) => part.length > 0 && part !== ".") &&
         !parts.some((part) => reservedWorkspaceRoots.has(part)));
 }
 export function isSafeExecutable(value) {

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

@@ -22,13 +22,13 @@ export declare const agentCandidateBundleSchema: z.ZodObject<{
         }, z.core.$strict>>;
         model: z.ZodOptional<z.ZodObject<{
             reasoningEffort: z.ZodOptional<z.ZodEnum<{
-                none: "none";
-                minimal: "minimal";
+                high: "high";
                 low: "low";
                 medium: "medium";
-                high: "high";
-                xhigh: "xhigh";
+                minimal: "minimal";
+                none: "none";
                 ultracode: "ultracode";
+                xhigh: "xhigh";
             }>>;
             maxVisibleOutputTokens: z.ZodOptional<z.ZodNumber>;
             maxReasoningTokens: z.ZodOptional<z.ZodNumber>;
@@ -38,22 +38,22 @@ export declare const agentCandidateBundleSchema: z.ZodObject<{
             provider: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         harness: z.ZodOptional<z.ZodEnum<{
+            acp: "acp";
+            amp: "amp";
             "claude-code": "claude-code";
-            nanoclaw: "nanoclaw";
+            "cli-base": "cli-base";
             codex: "codex";
-            opencode: "opencode";
-            "kimi-code": "kimi-code";
-            pi: "pi";
-            prime: "prime";
+            cursor: "cursor";
+            "factory-droids": "factory-droids";
+            forge: "forge";
             gemini: "gemini";
             hermes: "hermes";
+            "kimi-code": "kimi-code";
+            nanoclaw: "nanoclaw";
             openclaw: "openclaw";
-            amp: "amp";
-            "factory-droids": "factory-droids";
-            forge: "forge";
-            cursor: "cursor";
-            acp: "acp";
-            "cli-base": "cli-base";
+            opencode: "opencode";
+            pi: "pi";
+            prime: "prime";
         }>>;
         permissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
             allow: "allow";
@@ -63,9 +63,9 @@ export declare const agentCandidateBundleSchema: z.ZodObject<{
         tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
         mcp: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./agent-candidate.js").AgentCandidateMcpServer, unknown, z.core.$ZodTypeInternals<import("./agent-candidate.js").AgentCandidateMcpServer, unknown>>>>;
         subagents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
             prompt: z.ZodOptional<z.ZodString>;
             tools: z.ZodOptional<z.ZodType<Record<string, boolean>, unknown, z.core.$ZodTypeInternals<Record<string, boolean>, unknown>>>;
-            description: z.ZodOptional<z.ZodString>;
             permissions: z.ZodOptional<z.ZodType<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown, z.core.$ZodTypeInternals<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown>>>;
             model: z.ZodOptional<z.ZodString>;
             maxSteps: z.ZodOptional<z.ZodNumber>;
@@ -542,9 +542,9 @@ export declare const agentCandidateBundleSchema: z.ZodObject<{
             }, z.core.$strict>>>;
         }, z.core.$strict>>>>;
         modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
             prompt: z.ZodOptional<z.ZodString>;
             tools: z.ZodOptional<z.ZodType<Record<string, boolean>, unknown, z.core.$ZodTypeInternals<Record<string, boolean>, unknown>>>;
-            description: z.ZodOptional<z.ZodString>;
             permissions: z.ZodOptional<z.ZodType<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown, z.core.$ZodTypeInternals<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown>>>;
             model: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
@@ -589,22 +589,22 @@ export declare const agentCandidateBundleSchema: z.ZodObject<{
     }, z.core.$strict>], "kind">;
     execution: z.ZodObject<{
         harness: z.ZodEnum<{
+            acp: "acp";
+            amp: "amp";
             "claude-code": "claude-code";
-            nanoclaw: "nanoclaw";
+            "cli-base": "cli-base";
             codex: "codex";
-            opencode: "opencode";
-            "kimi-code": "kimi-code";
-            pi: "pi";
-            prime: "prime";
+            cursor: "cursor";
+            "factory-droids": "factory-droids";
+            forge: "forge";
             gemini: "gemini";
             hermes: "hermes";
+            "kimi-code": "kimi-code";
+            nanoclaw: "nanoclaw";
             openclaw: "openclaw";
-            amp: "amp";
-            "factory-droids": "factory-droids";
-            forge: "forge";
-            cursor: "cursor";
-            acp: "acp";
-            "cli-base": "cli-base";
+            opencode: "opencode";
+            pi: "pi";
+            prime: "prime";
         }>;
         harnessVersion: z.ZodString;
         launch: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -618,11 +618,11 @@ export declare const agentCandidateBundleSchema: z.ZodObject<{
             kind: z.ZodLiteral<"candidate-entrypoint">;
             entrypoint: z.ZodString;
             interpreter: z.ZodOptional<z.ZodEnum<{
+                bun: "bun";
+                deno: "deno";
                 node: "node";
                 python: "python";
                 python3: "python3";
-                bun: "bun";
-                deno: "deno";
                 tsx: "tsx";
                 uv: "uv";
             }>>;

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

@@ -117,13 +117,13 @@ export declare const agentCandidateBenchmarkTaskMaterialSchema: z.ZodObject<{
         model: z.ZodString;
         snapshot: z.ZodString;
         reasoningEffort: z.ZodEnum<{
-            none: "none";
-            minimal: "minimal";
+            high: "high";
             low: "low";
             medium: "medium";
-            high: "high";
-            xhigh: "xhigh";
+            minimal: "minimal";
+            none: "none";
             ultracode: "ultracode";
+            xhigh: "xhigh";
         }>;
     }, z.core.$strict>;
     attempt: z.ZodObject<{
@@ -272,13 +272,13 @@ export declare const agentCandidateBenchmarkTaskSchema: z.ZodObject<{
         model: z.ZodString;
         snapshot: z.ZodString;
         reasoningEffort: z.ZodEnum<{
-            none: "none";
-            minimal: "minimal";
+            high: "high";
             low: "low";
             medium: "medium";
-            high: "high";
-            xhigh: "xhigh";
+            minimal: "minimal";
+            none: "none";
             ultracode: "ultracode";
+            xhigh: "xhigh";
         }>;
     }, z.core.$strict>;
     attempt: z.ZodObject<{
@@ -451,13 +451,13 @@ export declare const agentCandidateBenchmarkSuiteInputsSchema: z.ZodObject<{
             model: z.ZodString;
             snapshot: z.ZodString;
             reasoningEffort: z.ZodEnum<{
-                none: "none";
-                minimal: "minimal";
+                high: "high";
                 low: "low";
                 medium: "medium";
-                high: "high";
-                xhigh: "xhigh";
+                minimal: "minimal";
+                none: "none";
                 ultracode: "ultracode";
+                xhigh: "xhigh";
             }>;
         }, z.core.$strict>;
         attempt: z.ZodObject<{
@@ -605,13 +605,13 @@ export declare const agentCandidateBenchmarkSuiteInputsSchema: z.ZodObject<{
             model: z.ZodString;
             snapshot: z.ZodString;
             reasoningEffort: z.ZodEnum<{
-                none: "none";
-                minimal: "minimal";
+                high: "high";
                 low: "low";
                 medium: "medium";
-                high: "high";
-                xhigh: "xhigh";
+                minimal: "minimal";
+                none: "none";
                 ultracode: "ultracode";
+                xhigh: "xhigh";
             }>;
         }, z.core.$strict>;
         attempt: z.ZodObject<{

package/dist/agent-execution-limits.d.ts

@@ -17,8 +17,8 @@ export declare const agentExecutionLimitObservationSchema: z.ZodObject<{
         modelCalls: z.ZodNumber;
         costUsdNanos: z.ZodNumber;
         costProvenance: z.ZodEnum<{
-            observed: "observed";
             estimated: "estimated";
+            observed: "observed";
         }>;
     }, z.core.$strict>;
 }, z.core.$strict>;

package/dist/agent-execution-preparation-receipt.d.ts

@@ -98,46 +98,46 @@ export interface AgentExecutionPreparationReceipt {
 }
 export declare const agentExecutionPreparationAxisResultSchema: z.ZodObject<{
     axis: z.ZodEnum<{
-        name: "name";
-        systemPrompt: "systemPrompt";
         appendSystemPrompt: "appendSystemPrompt";
-        instructions: "instructions";
-        files: "files";
-        tools: "tools";
-        skills: "skills";
         commands: "commands";
+        confidential: "confidential";
+        connections: "connections";
         description: "description";
-        version: "version";
-        tags: "tags";
+        extensions: "extensions";
+        files: "files";
         harness: "harness";
-        permissions: "permissions";
-        mcp: "mcp";
-        connections: "connections";
-        subagents: "subagents";
         hooks: "hooks";
-        modes: "modes";
-        confidential: "confidential";
+        instructions: "instructions";
+        mcp: "mcp";
         metadata: "metadata";
-        extensions: "extensions";
         modelDefault: "modelDefault";
-        modelSmall: "modelSmall";
+        modelMetadata: "modelMetadata";
         modelProvider: "modelProvider";
         modelReasoningEffort: "modelReasoningEffort";
-        modelMetadata: "modelMetadata";
-        resourceTools: "resourceTools";
+        modelSmall: "modelSmall";
+        modes: "modes";
+        name: "name";
+        permissions: "permissions";
         resourceAgents: "resourceAgents";
-        resourceInstructions: "resourceInstructions";
         resourceFailOnError: "resourceFailOnError";
+        resourceInstructions: "resourceInstructions";
+        resourceTools: "resourceTools";
+        skills: "skills";
+        subagents: "subagents";
+        systemPrompt: "systemPrompt";
+        tags: "tags";
+        tools: "tools";
+        version: "version";
     }>;
     disposition: z.ZodEnum<{
-        unsupported: "unsupported";
         behavior: "behavior";
         control: "control";
         overridden: "overridden";
+        unsupported: "unsupported";
     }>;
     owner: z.ZodEnum<{
-        runtime: "runtime";
         executor: "executor";
+        runtime: "runtime";
     }>;
     mechanism: z.ZodString;
     evidenceDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
@@ -146,27 +146,27 @@ export declare const agentExecutionPreparationAxisResultSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const agentExecutionPreparationReasoningEffortSchema: z.ZodObject<{
     requested: z.ZodEnum<{
-        none: "none";
-        minimal: "minimal";
+        high: "high";
         low: "low";
         medium: "medium";
-        high: "high";
-        xhigh: "xhigh";
+        minimal: "minimal";
+        none: "none";
         ultracode: "ultracode";
+        xhigh: "xhigh";
     }>;
     resolved: z.ZodOptional<z.ZodEnum<{
-        none: "none";
-        minimal: "minimal";
+        high: "high";
         low: "low";
         medium: "medium";
-        high: "high";
-        xhigh: "xhigh";
+        minimal: "minimal";
+        none: "none";
         ultracode: "ultracode";
+        xhigh: "xhigh";
     }>>;
     fidelity: z.ZodEnum<{
+        clamped: "clamped";
         exact: "exact";
         unsupported: "unsupported";
-        clamped: "clamped";
     }>;
 }, z.core.$strict>;
 export declare const agentExecutionPreparationReceiptSchema: z.ZodObject<{
@@ -178,22 +178,22 @@ export declare const agentExecutionPreparationReceiptSchema: z.ZodObject<{
     effectiveProfileDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     backend: z.ZodString;
     harness: z.ZodEnum<{
+        acp: "acp";
+        amp: "amp";
         "claude-code": "claude-code";
-        nanoclaw: "nanoclaw";
+        "cli-base": "cli-base";
         codex: "codex";
-        opencode: "opencode";
-        "kimi-code": "kimi-code";
-        pi: "pi";
-        prime: "prime";
+        cursor: "cursor";
+        "factory-droids": "factory-droids";
+        forge: "forge";
         gemini: "gemini";
         hermes: "hermes";
+        "kimi-code": "kimi-code";
+        nanoclaw: "nanoclaw";
         openclaw: "openclaw";
-        amp: "amp";
-        "factory-droids": "factory-droids";
-        forge: "forge";
-        cursor: "cursor";
-        acp: "acp";
-        "cli-base": "cli-base";
+        opencode: "opencode";
+        pi: "pi";
+        prime: "prime";
     }>;
     harnessVersion: z.ZodString;
     resolvedModel: z.ZodObject<{
@@ -202,27 +202,27 @@ export declare const agentExecutionPreparationReceiptSchema: z.ZodObject<{
         provider: z.ZodOptional<z.ZodString>;
         reasoningEffort: z.ZodOptional<z.ZodObject<{
             requested: z.ZodEnum<{
-                none: "none";
-                minimal: "minimal";
+                high: "high";
                 low: "low";
                 medium: "medium";
-                high: "high";
-                xhigh: "xhigh";
+                minimal: "minimal";
+                none: "none";
                 ultracode: "ultracode";
+                xhigh: "xhigh";
             }>;
             resolved: z.ZodOptional<z.ZodEnum<{
-                none: "none";
-                minimal: "minimal";
+                high: "high";
                 low: "low";
                 medium: "medium";
-                high: "high";
-                xhigh: "xhigh";
+                minimal: "minimal";
+                none: "none";
                 ultracode: "ultracode";
+                xhigh: "xhigh";
             }>>;
             fidelity: z.ZodEnum<{
+                clamped: "clamped";
                 exact: "exact";
                 unsupported: "unsupported";
-                clamped: "clamped";
             }>;
         }, z.core.$strict>>;
     }, z.core.$strict>;
@@ -246,46 +246,46 @@ export declare const agentExecutionPreparationReceiptSchema: z.ZodObject<{
     }, z.core.$strict>;
     axisResults: z.ZodArray<z.ZodObject<{
         axis: z.ZodEnum<{
-            name: "name";
-            systemPrompt: "systemPrompt";
             appendSystemPrompt: "appendSystemPrompt";
-            instructions: "instructions";
-            files: "files";
-            tools: "tools";
-            skills: "skills";
             commands: "commands";
+            confidential: "confidential";
+            connections: "connections";
             description: "description";
-            version: "version";
-            tags: "tags";
+            extensions: "extensions";
+            files: "files";
             harness: "harness";
-            permissions: "permissions";
-            mcp: "mcp";
-            connections: "connections";
-            subagents: "subagents";
             hooks: "hooks";
-            modes: "modes";
-            confidential: "confidential";
+            instructions: "instructions";
+            mcp: "mcp";
             metadata: "metadata";
-            extensions: "extensions";
             modelDefault: "modelDefault";
-            modelSmall: "modelSmall";
+            modelMetadata: "modelMetadata";
             modelProvider: "modelProvider";
             modelReasoningEffort: "modelReasoningEffort";
-            modelMetadata: "modelMetadata";
-            resourceTools: "resourceTools";
+            modelSmall: "modelSmall";
+            modes: "modes";
+            name: "name";
+            permissions: "permissions";
             resourceAgents: "resourceAgents";
-            resourceInstructions: "resourceInstructions";
             resourceFailOnError: "resourceFailOnError";
+            resourceInstructions: "resourceInstructions";
+            resourceTools: "resourceTools";
+            skills: "skills";
+            subagents: "subagents";
+            systemPrompt: "systemPrompt";
+            tags: "tags";
+            tools: "tools";
+            version: "version";
         }>;
         disposition: z.ZodEnum<{
-            unsupported: "unsupported";
             behavior: "behavior";
             control: "control";
             overridden: "overridden";
+            unsupported: "unsupported";
         }>;
         owner: z.ZodEnum<{
-            runtime: "runtime";
             executor: "executor";
+            runtime: "runtime";
         }>;
         mechanism: z.ZodString;
         evidenceDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;

package/dist/agent-improvement-measurement-schema.d.ts

@@ -15,14 +15,12 @@ export declare const agentCandidateEvaluationPolicySchema: z.ZodObject<{
 export declare const agentImprovementCostSchema: z.ZodObject<{
     usd: z.ZodNumber;
     provenance: z.ZodEnum<{
-        observed: "observed";
         estimated: "estimated";
+        observed: "observed";
     }>;
 }, z.core.$strict>;
 export declare const measuredComparisonCommonShape: {
     overall: z.ZodObject<{
-        direction: z.ZodLiteral<"higher-is-better">;
-        unit: z.ZodLiteral<"score">;
         baseline: z.ZodNumber;
         candidate: z.ZodNumber;
         delta: z.ZodNumber;
@@ -36,12 +34,10 @@ export declare const measuredComparisonCommonShape: {
         }, z.core.$strict>;
         n: z.ZodNumber;
         name: z.ZodLiteral<"composite">;
-    }, z.core.$strict>;
-    objectives: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        kind: z.ZodLiteral<"objective">;
-        name: z.ZodString;
         direction: z.ZodLiteral<"higher-is-better">;
         unit: z.ZodLiteral<"score">;
+    }, z.core.$strict>;
+    objectives: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         baseline: z.ZodNumber;
         candidate: z.ZodNumber;
         delta: z.ZodNumber;
@@ -54,6 +50,10 @@ export declare const measuredComparisonCommonShape: {
             resamples: z.ZodNumber;
         }, z.core.$strict>;
         n: z.ZodNumber;
+        kind: z.ZodLiteral<"objective">;
+        name: z.ZodString;
+        direction: z.ZodLiteral<"higher-is-better">;
+        unit: z.ZodLiteral<"score">;
         availability: z.ZodLiteral<"measured">;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"objective">;
@@ -63,11 +63,6 @@ export declare const measuredComparisonCommonShape: {
         availability: z.ZodLiteral<"unavailable">;
         reason: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"dimension">;
-        objective: z.ZodString;
-        name: z.ZodString;
-        direction: z.ZodLiteral<"higher-is-better">;
-        unit: z.ZodLiteral<"score">;
         baseline: z.ZodNumber;
         candidate: z.ZodNumber;
         delta: z.ZodNumber;
@@ -80,6 +75,11 @@ export declare const measuredComparisonCommonShape: {
             resamples: z.ZodNumber;
         }, z.core.$strict>;
         n: z.ZodNumber;
+        kind: z.ZodLiteral<"dimension">;
+        objective: z.ZodString;
+        name: z.ZodString;
+        direction: z.ZodLiteral<"higher-is-better">;
+        unit: z.ZodLiteral<"score">;
         availability: z.ZodLiteral<"measured">;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"dimension">;
@@ -90,10 +90,6 @@ export declare const measuredComparisonCommonShape: {
         availability: z.ZodLiteral<"unavailable">;
         reason: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"cost">;
-        name: z.ZodLiteral<"cost">;
-        direction: z.ZodLiteral<"lower-is-better">;
-        unit: z.ZodLiteral<"usd">;
         baseline: z.ZodNumber;
         candidate: z.ZodNumber;
         delta: z.ZodNumber;
@@ -106,12 +102,12 @@ export declare const measuredComparisonCommonShape: {
             resamples: z.ZodNumber;
         }, z.core.$strict>;
         n: z.ZodNumber;
+        kind: z.ZodLiteral<"cost">;
+        name: z.ZodLiteral<"cost">;
+        direction: z.ZodLiteral<"lower-is-better">;
+        unit: z.ZodLiteral<"usd">;
         availability: z.ZodLiteral<"measured">;
     }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"latency">;
-        name: z.ZodLiteral<"latency">;
-        direction: z.ZodLiteral<"lower-is-better">;
-        unit: z.ZodLiteral<"milliseconds">;
         baseline: z.ZodNumber;
         candidate: z.ZodNumber;
         delta: z.ZodNumber;
@@ -124,6 +120,10 @@ export declare const measuredComparisonCommonShape: {
             resamples: z.ZodNumber;
         }, z.core.$strict>;
         n: z.ZodNumber;
+        kind: z.ZodLiteral<"latency">;
+        name: z.ZodLiteral<"latency">;
+        direction: z.ZodLiteral<"lower-is-better">;
+        unit: z.ZodLiteral<"milliseconds">;
         availability: z.ZodLiteral<"measured">;
     }, z.core.$strict>]>>;
     candidate: z.ZodOptional<z.ZodObject<{
@@ -132,11 +132,11 @@ export declare const measuredComparisonCommonShape: {
     }, z.core.$strict>>;
     decision: z.ZodObject<{
         outcome: z.ZodEnum<{
-            ship: "ship";
+            arch_ceiling: "arch_ceiling";
             hold: "hold";
-            need_more_work: "need_more_work";
             model_ceiling: "model_ceiling";
-            arch_ceiling: "arch_ceiling";
+            need_more_work: "need_more_work";
+            ship: "ship";
         }>;
         reasons: z.ZodArray<z.ZodString>;
         contributingChecks: z.ZodArray<z.ZodObject<{
@@ -169,8 +169,8 @@ export declare const measuredComparisonCommonShape: {
             cost: z.ZodObject<{
                 usd: z.ZodNumber;
                 provenance: z.ZodEnum<{
-                    observed: "observed";
                     estimated: "estimated";
+                    observed: "observed";
                 }>;
             }, z.core.$strict>;
         }, z.core.$strict>;
@@ -180,8 +180,8 @@ export declare const measuredComparisonCommonShape: {
             cost: z.ZodObject<{
                 usd: z.ZodNumber;
                 provenance: z.ZodEnum<{
-                    observed: "observed";
                     estimated: "estimated";
+                    observed: "observed";
                 }>;
             }, z.core.$strict>;
         }, z.core.$strict>;
@@ -190,8 +190,8 @@ export declare const measuredComparisonCommonShape: {
             cost: z.ZodObject<{
                 usd: z.ZodNumber;
                 provenance: z.ZodEnum<{
-                    observed: "observed";
                     estimated: "estimated";
+                    observed: "observed";
                 }>;
             }, z.core.$strict>;
         }, z.core.$strict>;