openpond-sdk 0.11.4 → 0.11.5

package/README.md

@@ -372,3 +372,18 @@ identity and all snapshot hashes. Use `acceptanceGroupVerdict` from
 These methods only read evidence. They do not dispatch checks, bypass server-side
 acceptance, start training or activate serving. An empty page means this Job has
 no recorded independent group; its existing trainer validation is separate.
+
+### Experiment spending defaults and comparisons
+
+`OpenPondExperimentsClient.defaults()` returns the hosted global spend defaults.
+`prepareHarness()` and `run()` accept an omitted `maximumCostUsd`; explicit
+per-run limits and retained run limits take precedence. Token allocation is
+managed within model capacity and the available monetary reservation.
+
+Use `createComparisonBudget({ id, operationIds, maximumSpendUsd? })` before
+admitting any member runs to enforce one aggregate cap across a comparison.
+Register fresh, unique operation IDs and retain the returned grant. Membership
+is immutable and owner-scoped. `comparisonBudget(id)` returns each operation's
+run ID, known settled spend, pending reservations and remaining allowance.
+Registering a comparison does not start any work. Independent experiments do
+not implicitly share a spending cap.

package/dist/advanced-refiner-evaluations.js

@@ -12,18 +12,18 @@ import {
   sealAdvancedRefinerEvaluationPin,
   sealAdvancedRefinerReviewReceipt,
   verifyAdvancedRefinerEvaluationPin
-} from "./chunk-WPPHGWFA.js";
-import "./chunk-5LFLXFPT.js";
+} from "./chunk-FZH2M4G6.js";
+import "./chunk-PMBBNQ2J.js";
 import "./chunk-YCQVVFE5.js";
-import "./chunk-6ZDQ7HSA.js";
+import "./chunk-KAE7AMYE.js";
+import "./chunk-Z4JJS6KE.js";
 import "./chunk-T4APHDES.js";
-import "./chunk-GMVYYRMR.js";
-import "./chunk-RGGI5O4R.js";
-import "./chunk-Z3PPZRK2.js";
+import "./chunk-HAOPRFYQ.js";
+import "./chunk-WTHJ3H4M.js";
+import "./chunk-DUJXF7YI.js";
 import "./chunk-TCHAWJMB.js";
 import "./chunk-3KXDH6OB.js";
-import "./chunk-4NZW4LFB.js";
-import "./chunk-QUOW6URQ.js";
+import "./chunk-COPVBJPL.js";
 export {
   AdvancedRefinerEvaluationAccountingSchema,
   AdvancedRefinerEvaluationCommandSchema,

package/dist/candidate-evaluations.js

@@ -5,15 +5,14 @@ import {
   CandidateEvaluationPreparationSchema,
   CandidateEvaluationRequestSchema,
   createCandidateEvaluationClient
-} from "./chunk-OWWDSG27.js";
-import "./chunk-KJ5VENYN.js";
-import "./chunk-GMVYYRMR.js";
-import "./chunk-RGGI5O4R.js";
-import "./chunk-Z3PPZRK2.js";
+} from "./chunk-ZOXHSJWU.js";
+import "./chunk-35OVUYPI.js";
+import "./chunk-HAOPRFYQ.js";
+import "./chunk-WTHJ3H4M.js";
+import "./chunk-DUJXF7YI.js";
 import "./chunk-TCHAWJMB.js";
 import "./chunk-3KXDH6OB.js";
-import "./chunk-4NZW4LFB.js";
-import "./chunk-QUOW6URQ.js";
+import "./chunk-COPVBJPL.js";
 export {
   CandidateEvaluationControlSchema,
   CandidateEvaluationOptionSchema,

package/dist/{chunk-X64BSFXJ.js → chunk-2DLFHAGW.js}

@@ -7,10 +7,10 @@ import {
   importedPackageGraders,
   learningVerifierModule,
   projectLearningBatchGraders
-} from "./chunk-RIX56CJL.js";
+} from "./chunk-VEU3IXAQ.js";
 import {
   AuthoredTasksetFileInventorySchema
-} from "./chunk-QVCMFQKA.js";
+} from "./chunk-AQGFJLIV.js";
 import {
   TasksetDraftSchema,
   configuredTasksetDraftFiles,
@@ -18,11 +18,11 @@ import {
   createTasksetDraftWorkspace,
   decodeTasksetDraftWorkspaceFile,
   isManagedTasksetDraftFilePath
-} from "./chunk-JEUHIQWF.js";
+} from "./chunk-LQ5Q35IF.js";
 import {
   TasksetSchema,
   computeTasksetHash
-} from "./chunk-CPEOFPPF.js";
+} from "./chunk-FDHIL2CV.js";
 import {
   GraderFixtureSchema,
   TasksetEnvironmentResourceSchema,
@@ -33,7 +33,7 @@ import {
   resolveTasksetPackageExecution,
   resolveTasksetPackageInstructions,
   validateTasksetPackage
-} from "./chunk-LFH4EKWH.js";
+} from "./chunk-Z4OLAEPL.js";
 import {
   ModelTasksetDraftPreparationSchema,
   TasksetDraftFilePathSchema
@@ -41,7 +41,7 @@ import {
 import {
   contentHash,
   sha256
-} from "./chunk-QUOW6URQ.js";
+} from "./chunk-COPVBJPL.js";
 
 // src/model-ordinary-taskset-reward.ts
 import { LearningTextAssetSchema, TaskDefinitionSchema, learningRef, sealLearningContent } from "@openpond/evals/learning";
@@ -585,4 +585,4 @@ export {
   prepareTasksetDraftSource,
   materializeTasksetDraftWorkspace
 };
-//# sourceMappingURL=chunk-X64BSFXJ.js.map
+//# sourceMappingURL=chunk-2DLFHAGW.js.map

package/dist/{chunk-SX767BS2.js → chunk-2G4WBMYI.js}

@@ -1,13 +1,13 @@
 import {
   validateTasksetPackage
-} from "./chunk-LFH4EKWH.js";
+} from "./chunk-Z4OLAEPL.js";
 import {
   RunExperimentSchema
-} from "./chunk-KJ5VENYN.js";
+} from "./chunk-35OVUYPI.js";
 import {
   ExperimentScoringRequestSchema,
   verifyExperimentScoringPass
-} from "./chunk-6ZDQ7HSA.js";
+} from "./chunk-Z4JJS6KE.js";
 import {
   fetchConnectedJson
 } from "./chunk-T4APHDES.js";
@@ -18,20 +18,20 @@ import {
   ExperimentListQuerySchema,
   PrepareHarnessExperimentSchema,
   PreparedHarnessExperimentSchema
-} from "./chunk-GMVYYRMR.js";
+} from "./chunk-HAOPRFYQ.js";
 import {
   ModelTasksetRunDetailsSchema,
   ModelTasksetRunRequestSchema,
   verifyHarnessExperimentManifest,
   verifyModelTasksetRunDetails
-} from "./chunk-RGGI5O4R.js";
+} from "./chunk-WTHJ3H4M.js";
 import {
   ImmutableReleaseRefSchema,
   contentHash
-} from "./chunk-QUOW6URQ.js";
+} from "./chunk-COPVBJPL.js";
 
 // src/experiment-client.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 import { compareExperiments, verifyExperimentEvidence } from "@openpond/evals/experiments";
 
 // src/experiment-run-details.ts
@@ -91,8 +91,184 @@ var ExperimentHarnessCatalogSchema = z2.object({
   nextCursor: z2.string().min(1).max(8192).nullable()
 }).strict();
 
+// src/run-diagnostics.ts
+import { z as z3 } from "zod";
+var Id = z3.string().min(1).max(500);
+var Hash2 = z3.string().regex(/^[a-f0-9]{64}$/);
+var Time = z3.iso.datetime();
+var Amount = z3.number().finite().nonnegative().nullable();
+var Count = z3.number().int().nonnegative().nullable();
+var DiagnosticEventSchema = z3.object({
+  id: Id,
+  sequence: z3.number().int().nonnegative(),
+  at: Time.nullable(),
+  type: z3.string().max(160),
+  action: z3.string().max(160).nullable(),
+  correlationId: Id.nullable(),
+  attempt: Count,
+  taskId: Id.nullable(),
+  status: z3.string().max(100).nullable(),
+  errorCode: z3.string().max(200).nullable(),
+  cleanupComplete: z3.boolean().nullable()
+}).strict();
+var DiagnosticCallSchema = z3.object({
+  id: Id,
+  kind: z3.string().max(100),
+  status: z3.string().max(100),
+  receiptId: Id.nullable(),
+  maximumUsd: Amount,
+  settledUsd: Amount,
+  model: z3.string().max(200).nullable(),
+  durationMs: Count,
+  inputTokens: Count,
+  outputTokens: Count,
+  totalTokens: Count
+}).strict();
+var Content = z3.object({
+  schemaVersion: z3.literal("openpond.runDiagnostics.v1"),
+  teamId: Id,
+  runId: Id,
+  location: z3.enum(["local", "hosted"]),
+  manifestHash: Hash2,
+  observedAt: Time,
+  status: z3.string().max(100),
+  startedAt: Time.nullable(),
+  completedAt: Time.nullable(),
+  error: z3.string().max(8192).nullable(),
+  resultAvailable: z3.boolean(),
+  parent: z3.object({
+    id: Id,
+    status: z3.string().max(100),
+    attempt: Count,
+    heartbeatAt: Time.nullable(),
+    leaseExpiresAt: Time.nullable(),
+    releasedAt: Time.nullable(),
+    errorCode: z3.string().max(200).nullable()
+  }).strict().nullable(),
+  accounting: z3.object({
+    maximumUsd: Amount,
+    settledUsd: Amount,
+    outstandingUsd: Amount,
+    outstandingCount: Count,
+    final: z3.boolean(),
+    receiptCount: Count
+  }).strict(),
+  events: z3.array(DiagnosticEventSchema).max(100),
+  nextEventCursor: z3.number().int().nonnegative().nullable(),
+  eventCount: z3.number().int().nonnegative(),
+  calls: z3.array(DiagnosticCallSchema).max(100),
+  nextCallCursor: Id.nullable(),
+  callCount: z3.number().int().nonnegative(),
+  limitations: z3.array(z3.string().max(1e3)).max(30)
+}).strict();
+var RunDiagnosticsSchema = Content.extend({ contentHash: Hash2 }).strict();
+var RunDiagnosticsQuerySchema = z3.object({
+  afterSequence: z3.number().int().nonnegative().optional(),
+  afterCallId: Id.optional()
+}).strict();
+function sealRunDiagnostics(value) {
+  const content = Content.parse(value);
+  return { ...content, contentHash: contentHash(content) };
+}
+function verifyRunDiagnostics(raw, scope) {
+  const value = RunDiagnosticsSchema.parse(raw);
+  const { contentHash: hash, ...content } = value;
+  if (hash !== contentHash(content) || value.teamId !== scope.teamId || value.runId !== scope.runId || scope.manifestHash && value.manifestHash !== scope.manifestHash)
+    throw new Error("Diagnostics differ from the selected workspace, run or retained evidence.");
+  if (value.events.length > value.eventCount || value.calls.length > value.callCount || new Set(value.events.map((event) => event.id)).size !== value.events.length || value.events.some(
+    (event, index) => event.sequence <= (index ? value.events[index - 1].sequence : scope.afterSequence ?? -1)
+  ) || value.calls.some(
+    (call, index) => call.id <= (index ? value.calls[index - 1].id : scope.afterCallId ?? "")
+  ) || value.nextEventCursor !== null && value.nextEventCursor !== value.events.at(-1)?.sequence || value.nextCallCursor !== null && value.nextCallCursor !== value.calls.at(-1)?.id || value.accounting.final && (value.accounting.outstandingCount !== 0 || value.accounting.settledUsd === null || !value.accounting.receiptCount))
+    throw new Error("Diagnostic evidence pagination or final accounting is inconsistent.");
+  return value;
+}
+function diagnosticEvent(input) {
+  const record = (raw) => raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  const payload = record(input.payload), data = record(payload.data);
+  const token = (raw, maximum) => typeof raw === "string" && /^[a-zA-Z0-9_.:/-]+$/.test(raw) ? raw.slice(0, maximum) : null;
+  return DiagnosticEventSchema.parse({
+    id: input.id,
+    sequence: input.sequence,
+    at: input.at,
+    type: input.type.slice(0, 160),
+    action: token(payload.action, 160),
+    correlationId: token(data.callId ?? data.toolCallId, 500),
+    attempt: typeof payload.attempt === "number" && Number.isInteger(payload.attempt) && payload.attempt >= 0 ? payload.attempt : null,
+    taskId: token(payload.taskId ?? data.taskId, 500),
+    status: token(payload.status, 100),
+    errorCode: token(payload.errorCode ?? payload.code, 200),
+    cleanupComplete: typeof payload.complete === "boolean" && input.type === "experiment.harness.cleanup" ? payload.complete : null
+  });
+}
+function diagnosticSpans(events) {
+  const spans = [], active = /* @__PURE__ */ new Map();
+  for (const event of [...events].sort((a, b) => a.sequence - b.sequence)) {
+    if (event.type.startsWith("training.")) {
+      spans.push({
+        id: event.id,
+        label: event.action ?? event.type,
+        taskId: event.taskId,
+        startedAt: event.at,
+        completedAt: null,
+        durationMs: null,
+        status: "observed",
+        evidenceIds: [event.id]
+      });
+      continue;
+    }
+    if (!["tool.started", "tool.completed", "tool.failed"].includes(event.type)) continue;
+    const key = JSON.stringify([event.correlationId ?? event.action, event.taskId, event.attempt]);
+    if (event.type === "tool.started") {
+      const span = {
+        id: event.id,
+        label: event.action ?? "Operation",
+        taskId: event.taskId,
+        startedAt: event.at,
+        completedAt: null,
+        durationMs: null,
+        status: "running",
+        evidenceIds: [event.id]
+      };
+      active.set(key, span);
+      spans.push(span);
+    } else {
+      const span = active.get(key);
+      if (span) {
+        span.completedAt = event.at;
+        span.status = event.type === "tool.failed" ? "failed" : "completed";
+        span.durationMs = span.startedAt && event.at ? Math.max(0, Date.parse(event.at) - Date.parse(span.startedAt)) : null;
+        span.evidenceIds.push(event.id);
+        active.delete(key);
+      } else
+        spans.push({
+          id: event.id,
+          label: event.action ?? "Operation",
+          taskId: event.taskId,
+          startedAt: null,
+          completedAt: event.at,
+          durationMs: null,
+          status: event.type === "tool.failed" ? "failed" : "completed",
+          evidenceIds: [event.id]
+        });
+    }
+  }
+  return spans;
+}
+function diagnosticAnalysisPrompt(value, events = value.events, calls = value.calls) {
+  const { contentHash: pageHash, ...metadata } = value;
+  return `Investigate this OpenPond run using the retained metadata below. Start read-only. Separate observed facts, hypotheses, missing evidence and recommended investigations. Cite event/call IDs. Do not infer zero costs or successful grading from missing evidence; gateway duration is not pure inference. Do not replay, regrade, edit source, change configuration, restart or deploy without a separate user instruction. Never request credentials or private grader content. This snapshot may be partial.
+
+${JSON.stringify({ ...metadata, sourcePageHash: pageHash, error: diagnosticFailure(value.error), events: events.slice(0, 100), calls: calls.slice(0, 100), analysisCoverage: { eventCount: events.length, callCount: calls.length, maximumIncluded: 100 } }, null, 2)}`;
+}
+function diagnosticFailure(value) {
+  if (!value) return null;
+  const codes = value.match(/\b[a-z][a-z0-9]+(?:_[a-z0-9]+){1,12}\b/g);
+  return codes?.slice(0, 6).join(" / ") || "Failure recorded. Inspect the authorized run for its exact message.";
+}
+
 // src/experiment-client.ts
-var Id = z3.string().trim().min(1).max(200);
+var Id2 = z4.string().trim().min(1).max(200);
 var OpenPondExperimentError = class extends Error {
   constructor(status, code, message) {
     super(message);
@@ -113,9 +289,27 @@ var OpenPondExperimentsClient = class {
   }
   options;
   baseUrl;
+  async defaults(signal) {
+    return z4.object({ maximumSpendUsd: z4.number().finite().min(1e-6).max(1e4), maximumComparisonSpendUsd: z4.number().finite().min(1e-6).max(1e4), initialOutputTokens: z4.number().int().positive() }).strict().parse(await this.request("/defaults", "GET", void 0, signal));
+  }
+  async createComparisonBudget(value, signal) {
+    const request = z4.object({ id: Id2, operationIds: z4.array(Id2).min(1).max(100), maximumSpendUsd: z4.number().finite().min(1e-6).max(1e4).optional() }).strict().parse(value);
+    const result = this.comparisonBudgetResult(await this.request("/comparison-budgets", "POST", request, signal), request.id);
+    if (contentHash(result.operations.map((item) => item.operationId).sort()) !== contentHash([...request.operationIds].sort()) || request.maximumSpendUsd !== void 0 && result.maximumSpendUsd !== request.maximumSpendUsd)
+      throw new Error("Comparison admission differs from its requested operations or ceiling.");
+    return result;
+  }
+  async comparisonBudget(id, signal) {
+    return this.comparisonBudgetResult(await this.request(`/comparison-budgets/${encodeURIComponent(Id2.parse(id))}`, "GET", void 0, signal), id);
+  }
+  comparisonBudgetResult(value, id) {
+    const result = z4.object({ id: Id2, teamId: Id2, maximumSpendUsd: z4.number().finite().positive(), settledUsd: z4.number().finite().nonnegative(), reservedUsd: z4.number().finite().nonnegative(), remainingUsd: z4.number().finite().nonnegative(), operations: z4.array(z4.object({ operationId: Id2, runId: Id2.nullable() }).strict()).min(1).max(100) }).strict().parse(value);
+    if (result.id !== id || result.teamId !== this.options.teamId) throw new Error("Comparison budget scope mismatch.");
+    return result;
+  }
   /** Discover released workspace Harnesses independently of Project targets. */
   async harnessSources(options = {}) {
-    const cursor = options.cursor === void 0 ? void 0 : z3.string().min(1).max(8192).parse(options.cursor);
+    const cursor = options.cursor === void 0 ? void 0 : z4.string().min(1).max(8192).parse(options.cursor);
     const query = new URLSearchParams(cursor ? { cursor } : {});
     const page = ExperimentHarnessCatalogSchema.parse(await this.request(`/harness-sources?${query}`, "GET", void 0, options.signal));
     if (page.teamId !== this.options.teamId || new Set(page.items.map((item) => contentHash(item.source))).size !== page.items.length || page.nextCursor !== null && page.nextCursor === cursor || page.items.some((item) => item.ready !== (item.reason === null)))
@@ -124,7 +318,7 @@ var OpenPondExperimentsClient = class {
   }
   /** Resolves a released target without saving a definition or dispatching it. */
   async prepareHarness(value, signal) {
-    const request = PrepareHarnessExperimentSchema.parse(value);
+    const request = PrepareHarnessExperimentSchema.parse({ ...value, maximumCostUsd: value.maximumCostUsd ?? (await this.defaults(signal)).maximumSpendUsd });
     const result = PreparedHarnessExperimentSchema.parse(await this.request("/harness-setup", "POST", request, signal));
     verifyHarnessExperimentManifest(result.request, result.manifest);
     const policy = result.request.policy;
@@ -133,9 +327,10 @@ var OpenPondExperimentsClient = class {
     return result;
   }
   async run(value, signal) {
-    const request = RunExperimentSchema.parse(value);
+    const request = RunExperimentSchema.parse({ ...value, maximumCostUsd: value.maximumCostUsd ?? (await this.defaults(signal)).maximumSpendUsd });
     if (request.request.teamId !== this.options.teamId) throw new Error("Experiment workspace mismatch.");
-    const result = await this.details(await this.request("", "POST", request, signal));
+    const result = await this.details(await this.request("", "POST", { ...request, maximumCostUsd: value.maximumCostUsd }, signal));
+    if (value.maximumCostUsd === void 0) request.maximumCostUsd = result.configuration.maximumCostUsd;
     if (contentHash(experimentConfigurationRequest(result.request)) !== contentHash(experimentConfigurationRequest(request.request)) || result.configuration.maximumCostUsd !== request.maximumCostUsd || result.configuration.sourceExperimentId !== request.sourceExperimentId || result.configuration.admissionRequestHash !== contentHash(request))
       throw new Error("Experiment admission differs from its submitted configuration.");
     if (request.graders && contentHash(request.graders) !== contentHash(result.configuration.graders.map((grader) => ({
@@ -147,29 +342,34 @@ var OpenPondExperimentsClient = class {
     return result;
   }
   async get(id, options = {}) {
-    return this.details(await this.request(`/${encodeURIComponent(Id.parse(id))}`, "GET", void 0, options.signal), id);
+    return this.details(await this.request(`/${encodeURIComponent(Id2.parse(id))}`, "GET", void 0, options.signal), id);
+  }
+  async diagnostics(id, options = {}) {
+    const query = RunDiagnosticsQuerySchema.parse({ afterSequence: options.afterSequence, afterCallId: options.afterCallId });
+    const params = new URLSearchParams(Object.entries(query).filter(([, value]) => value !== void 0).map(([key, value]) => [key, String(value)]));
+    return verifyRunDiagnostics(await this.request(`/${encodeURIComponent(Id2.parse(id))}/diagnostics?${params}`, "GET", void 0, options.signal), { teamId: this.options.teamId, runId: id, manifestHash: options.manifestHash, afterSequence: options.afterSequence, afterCallId: options.afterCallId });
   }
   async list(value = {}, signal) {
     const query = ExperimentListQuerySchema.parse(value);
     const params = new URLSearchParams(Object.entries(query).filter(([, value2]) => value2 !== void 0).map(([key, value2]) => [key, String(value2)]));
-    const page = z3.object({ items: z3.array(z3.unknown()).max(100), nextCursor: Id.nullable() }).strict().parse(await this.request(`?${params}`, "GET", void 0, signal));
+    const page = z4.object({ items: z4.array(z4.unknown()).max(100), nextCursor: Id2.nullable() }).strict().parse(await this.request(`?${params}`, "GET", void 0, signal));
     const items = await Promise.all(page.items.map((value2) => this.details(value2)));
     if (items.length > query.limit || new Set(items.map((item) => item.summary.id)).size !== items.length || page.nextCursor !== null && page.nextCursor !== items.at(-1)?.summary.id || items.some((item) => query.projectId && item.request.project?.id !== query.projectId || query.datasetHash && item.request.taskset.contentHash !== query.datasetHash || query.status && item.summary.status !== query.status))
       throw new Error("Experiment page differs from its selected scope.");
     return { items, nextCursor: page.nextCursor };
   }
   async result(executionId, signal) {
-    const value = z3.object({ executionId: Id, passId: Id.nullable(), manifest: z3.unknown(), result: z3.unknown() }).strict().parse(await this.request(`/${encodeURIComponent(Id.parse(executionId))}/result`, "GET", void 0, signal));
+    const value = z4.object({ executionId: Id2, passId: Id2.nullable(), manifest: z4.unknown(), result: z4.unknown() }).strict().parse(await this.request(`/${encodeURIComponent(Id2.parse(executionId))}/result`, "GET", void 0, signal));
     const evidence = verifyExperimentEvidence(value);
     if (value.executionId !== executionId || evidence.manifest.teamId !== this.options.teamId || evidence.manifest.lineage?.execution.id !== executionId || evidence.manifest.lineage.scoringPassId !== value.passId) throw new Error("Experiment result identity mismatch.");
     return { ...evidence, executionId, passId: value.passId };
   }
   async cancel(id, signal) {
-    return this.details(await this.request(`/${encodeURIComponent(Id.parse(id))}/cancel`, "POST", {}, signal), id);
+    return this.details(await this.request(`/${encodeURIComponent(Id2.parse(id))}/cancel`, "POST", {}, signal), id);
   }
   /** Duplicate uses the original run snapshot; edits are submitted with run(). */
   async duplicate(id, operationId, signal) {
-    const result = await this.details(await this.request(`/${encodeURIComponent(Id.parse(id))}/duplicate`, "POST", { operationId: Id.parse(operationId) }, signal));
+    const result = await this.details(await this.request(`/${encodeURIComponent(Id2.parse(id))}/duplicate`, "POST", { operationId: Id2.parse(operationId) }, signal));
     if (result.request.operationId !== operationId || result.configuration.sourceExperimentId !== id || result.summary.id === id)
       throw new Error("Duplicate Experiment admission differs from its source or operation.");
     return result;
@@ -181,13 +381,13 @@ var OpenPondExperimentsClient = class {
     return pass;
   }
   async scoringPass(id, signal) {
-    return this.pass(await this.request(`/scoring-passes/${encodeURIComponent(Id.parse(id))}`, "GET", void 0, signal), id);
+    return this.pass(await this.request(`/scoring-passes/${encodeURIComponent(Id2.parse(id))}`, "GET", void 0, signal), id);
   }
   async scoringPasses(executionId, options = {}) {
-    const params = new URLSearchParams(options.afterId ? { afterId: Id.parse(options.afterId) } : {});
-    if (options.executionKind) params.set("executionKind", z3.literal("recorded_evidence").parse(options.executionKind));
-    const page = z3.object({ items: z3.array(z3.unknown()).max(30), nextCursor: Id.nullable() }).strict().parse(
-      await this.request(`/${encodeURIComponent(Id.parse(executionId))}/scoring-passes?${params}`, "GET", void 0, options.signal)
+    const params = new URLSearchParams(options.afterId ? { afterId: Id2.parse(options.afterId) } : {});
+    if (options.executionKind) params.set("executionKind", z4.literal("recorded_evidence").parse(options.executionKind));
+    const page = z4.object({ items: z4.array(z4.unknown()).max(30), nextCursor: Id2.nullable() }).strict().parse(
+      await this.request(`/${encodeURIComponent(Id2.parse(executionId))}/scoring-passes?${params}`, "GET", void 0, options.signal)
     );
     const items = page.items.map((value) => this.pass(value));
     if (items.some((item) => item.request.execution.id !== executionId || item.request.executionKind !== options.executionKind) || new Set(items.map((item) => item.id)).size !== items.length)
@@ -195,11 +395,11 @@ var OpenPondExperimentsClient = class {
     return { items, nextCursor: page.nextCursor };
   }
   async cancelScoringPass(id, signal) {
-    return this.pass(await this.request(`/scoring-passes/${encodeURIComponent(Id.parse(id))}/cancel`, "POST", {}, signal), id);
+    return this.pass(await this.request(`/scoring-passes/${encodeURIComponent(Id2.parse(id))}/cancel`, "POST", {}, signal), id);
   }
   async scoringResult(id, signal) {
-    const value = z3.object({ executionId: Id, passId: Id, manifest: z3.unknown(), result: z3.unknown() }).strict().parse(
-      await this.request(`/scoring-passes/${encodeURIComponent(Id.parse(id))}/result`, "GET", void 0, signal)
+    const value = z4.object({ executionId: Id2, passId: Id2, manifest: z4.unknown(), result: z4.unknown() }).strict().parse(
+      await this.request(`/scoring-passes/${encodeURIComponent(Id2.parse(id))}/result`, "GET", void 0, signal)
     );
     const evidence = verifyExperimentEvidence(value);
     if (value.passId !== id || evidence.manifest.teamId !== this.options.teamId || evidence.manifest.id !== id || evidence.manifest.lineage?.execution.id !== value.executionId || evidence.manifest.lineage.scoringPassId !== id)
@@ -232,7 +432,7 @@ var OpenPondExperimentsClient = class {
     });
     const value = await response.json();
     if (!response.ok) {
-      const parsed = z3.object({ code: z3.string(), message: z3.string() }).safeParse(value);
+      const parsed = z4.object({ code: z4.string(), message: z4.string() }).safeParse(value);
       throw new OpenPondExperimentError(response.status, parsed.success ? parsed.data.code : "experiment_request_failed", parsed.success ? parsed.data.message : "Experiment request failed.");
     }
     return value;
@@ -240,11 +440,11 @@ var OpenPondExperimentsClient = class {
 };
 
 // src/experiment-inspection.ts
-import { z as z4 } from "zod";
-var Id2 = z4.string().trim().min(1).max(500);
-var Hash2 = z4.string().regex(/^[a-f0-9]{64}$/);
-var Content = z4.object({ schemaVersion: z4.literal("openpond.experimentCaseInspection.v1"), teamId: Id2, executionId: Id2, manifestHash: Hash2, receiptId: Id2, taskId: Id2, seed: z4.string().min(1), input: z4.record(z4.string(), z4.unknown()).nullable(), output: z4.unknown().nullable(), error: z4.string().nullable(), events: z4.array(z4.record(z4.string(), z4.unknown())).max(25), nextEventCursor: Id2.nullable(), eventCount: z4.number().int().nonnegative() }).strict();
-var ExperimentCaseInspectionSchema = Content.extend({ contentHash: Hash2 }).strict();
+import { z as z5 } from "zod";
+var Id3 = z5.string().trim().min(1).max(500);
+var Hash3 = z5.string().regex(/^[a-f0-9]{64}$/);
+var Content2 = z5.object({ schemaVersion: z5.literal("openpond.experimentCaseInspection.v1"), teamId: Id3, executionId: Id3, manifestHash: Hash3, receiptId: Id3, taskId: Id3, seed: z5.string().min(1), input: z5.record(z5.string(), z5.unknown()).nullable(), output: z5.unknown().nullable(), error: z5.string().nullable(), events: z5.array(z5.record(z5.string(), z5.unknown())).max(25), nextEventCursor: Id3.nullable(), eventCount: z5.number().int().nonnegative() }).strict();
+var ExperimentCaseInspectionSchema = Content2.extend({ contentHash: Hash3 }).strict();
 var OpenPondExperimentInspectionClient = class {
   constructor(options) {
     this.options = options;
@@ -256,10 +456,10 @@ var OpenPondExperimentInspectionClient = class {
   baseUrl;
   /** Retained, policy-facing evidence only. Reading a page never dispatches. */
   async case(executionId, receiptId, options = {}) {
-    const params = new URLSearchParams(options.afterId ? { afterId: Id2.parse(options.afterId) } : {});
-    const response = await (this.options.fetch ?? fetch)(`${this.baseUrl}/v1/experiments/${encodeURIComponent(Id2.parse(executionId))}/cases/${encodeURIComponent(Id2.parse(receiptId))}?${params}`, { signal: options.signal, redirect: "error", headers: { Authorization: `Bearer ${this.options.apiKey}`, "X-OpenPond-Team-Id": this.options.teamId, Accept: "application/json" } });
+    const params = new URLSearchParams(options.afterId ? { afterId: Id3.parse(options.afterId) } : {});
+    const response = await (this.options.fetch ?? fetch)(`${this.baseUrl}/v1/experiments/${encodeURIComponent(Id3.parse(executionId))}/cases/${encodeURIComponent(Id3.parse(receiptId))}?${params}`, { signal: options.signal, redirect: "error", headers: { Authorization: `Bearer ${this.options.apiKey}`, "X-OpenPond-Team-Id": this.options.teamId, Accept: "application/json" } });
     const value = await response.json();
-    if (!response.ok) throw new Error(z4.object({ message: z4.string() }).parse(value).message);
+    if (!response.ok) throw new Error(z5.object({ message: z5.string() }).parse(value).message);
     const result = ExperimentCaseInspectionSchema.parse(value);
     const { contentHash: actual, ...content } = result;
     if (contentHash(content) !== actual || result.teamId !== this.options.teamId || result.executionId !== executionId || result.receiptId !== receiptId || options.manifestHash && result.manifestHash !== options.manifestHash || result.events.length > result.eventCount) throw new Error("Case inspection differs from its requested workspace, execution or retained content.");
@@ -318,7 +518,7 @@ function experimentExecutionSelection(policy) {
 }
 
 // src/profile-external-dataset-package.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 import { verifyExperimentEvidence as verifyExperimentEvidence2 } from "@openpond/evals/experiments";
 import { verifyProfileExternalDatasetBinding } from "@openpond/evals";
 function verifyExternalDatasetPackage(input) {
@@ -333,7 +533,7 @@ function verifyExternalDatasetPackage(input) {
   }
   if (binding.gradingSource) {
     if (!input.actualGrading) throw new Error("The actual selected scoring owner is required for this recipe.");
-    const pass = verifyExperimentScoringPass(input.actualGrading.pass), evidence = verifyExperimentEvidence2(z5.object({ manifest: z5.unknown(), result: z5.unknown() }).strict().parse(input.actualGrading.evidence));
+    const pass = verifyExperimentScoringPass(input.actualGrading.pass), evidence = verifyExperimentEvidence2(z6.object({ manifest: z6.unknown(), result: z6.unknown() }).strict().parse(input.actualGrading.evidence));
     if (pass.status !== "completed" || pass.id !== binding.gradingSource.pass.id || pass.contentHash !== binding.gradingSource.pass.contentHash || evidence.manifest.id !== binding.gradingSource.evidence.id || evidence.result.contentHash !== binding.gradingSource.evidence.contentHash || evidence.manifest.lineage?.scoringPassId !== pass.id || contentHash(evidence.manifest.dataset) !== contentHash(binding.dataset) || contentHash(evidence.manifest.evaluators) !== contentHash(binding.evaluators) || contentHash(binding.fieldMappings) !== contentHash(pass.graders.map((pin) => ({ graderId: pin.id, fields: pin.mappings ?? [] })))) throw new Error("The selected scoring owner changed its exact Dataset, measurements or mappings.");
     const actual = evidence.manifest.population, expected = binding.recordedOrigin ? binding.recordedOrigin.members.map((member) => ({ caseId: member.caseId, seed: member.seed, fixtureId: member.fixtureId })) : binding.population.map((member) => ({ caseId: member.taskId, seed: member.seed, fixtureId: member.fixtureId }));
     if (actual.length !== expected.length || actual.some((member, index) => contentHash(member) !== contentHash(expected[index]))) throw new Error("The selected scoring population differs from the exact ordered original cases and cutoffs.");
@@ -361,7 +561,7 @@ function verifyExternalDatasetPackage(input) {
 }
 
 // src/profile-evaluation-discovery.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 import {
   ProfileEvaluationDefinitionSchema,
   ProfileEvaluationSuiteSchema,
@@ -371,33 +571,33 @@ import {
   TasksetRunManifestSchema,
   TasksetMetricResultSchema
 } from "@openpond/evals";
-var Id3 = z6.string().trim().min(1).max(240);
-var ProfileEvaluationDiscoverySchema = z6.object({
-  profileRef: z6.object({ source: z6.enum(["local", "github", "openpond_git"]), repositoryId: Id3, profileId: Id3 }).strict(),
-  sourceRevision: z6.string().min(1).max(500),
+var Id4 = z7.string().trim().min(1).max(240);
+var ProfileEvaluationDiscoverySchema = z7.object({
+  profileRef: z7.object({ source: z7.enum(["local", "github", "openpond_git"]), repositoryId: Id4, profileId: Id4 }).strict(),
+  sourceRevision: z7.string().min(1).max(500),
   harnessRelease: ImmutableReleaseRefSchema,
-  catalogHash: z6.string().regex(/^[a-f0-9]{64}$/).nullable(),
-  definitions: z6.array(ProfileEvaluationDefinitionSchema).max(1e3),
-  suites: z6.array(ProfileEvaluationSuiteSchema).max(100),
-  runs: z6.array(z6.object({
-    profileRef: z6.object({ source: z6.enum(["local", "github", "openpond_git"]), repositoryId: Id3, profileId: Id3 }).strict(),
+  catalogHash: z7.string().regex(/^[a-f0-9]{64}$/).nullable(),
+  definitions: z7.array(ProfileEvaluationDefinitionSchema).max(1e3),
+  suites: z7.array(ProfileEvaluationSuiteSchema).max(100),
+  runs: z7.array(z7.object({
+    profileRef: z7.object({ source: z7.enum(["local", "github", "openpond_git"]), repositoryId: Id4, profileId: Id4 }).strict(),
     manifest: TasksetRunManifestSchema,
     metric: TasksetMetricResultSchema,
-    gradeRefs: z6.array(ImmutableReleaseRefSchema),
-    receiptRefs: z6.array(ImmutableReleaseRefSchema),
-    passRate: z6.number().min(0).max(1),
-    passed: z6.boolean(),
-    completedAt: z6.iso.datetime(),
-    contentHash: z6.string().regex(/^[a-f0-9]{64}$/)
+    gradeRefs: z7.array(ImmutableReleaseRefSchema),
+    receiptRefs: z7.array(ImmutableReleaseRefSchema),
+    passRate: z7.number().min(0).max(1),
+    passed: z7.boolean(),
+    completedAt: z7.iso.datetime(),
+    contentHash: z7.string().regex(/^[a-f0-9]{64}$/)
   }).strict()).max(1e3),
-  comparisons: z6.array(ProfileEvaluationComparisonSchema).max(1e3),
-  suiteRuns: z6.array(ProfileEvaluationSuiteRunSchema).max(1e3),
-  reports: z6.array(ProfileEvaluationReportSchema).max(1e3)
+  comparisons: z7.array(ProfileEvaluationComparisonSchema).max(1e3),
+  suiteRuns: z7.array(ProfileEvaluationSuiteRunSchema).max(1e3),
+  reports: z7.array(ProfileEvaluationReportSchema).max(1e3)
 }).strict();
-var ProfileEvaluationDiscoveryRequestSchema = z6.object({
-  teamId: Id3,
-  profileRepositoryId: Id3,
-  trainingProjectId: Id3.optional()
+var ProfileEvaluationDiscoveryRequestSchema = z7.object({
+  teamId: Id4,
+  profileRepositoryId: Id4,
+  trainingProjectId: Id4.optional()
 }).strict();
 var OpenPondProfileEvaluationDiscoveryClient = class {
   constructor(options) {
@@ -429,6 +629,16 @@ export {
   experimentRunConfigurationHash,
   verifyExperimentRunDetails,
   ExperimentHarnessCatalogSchema,
+  DiagnosticEventSchema,
+  DiagnosticCallSchema,
+  RunDiagnosticsSchema,
+  RunDiagnosticsQuerySchema,
+  sealRunDiagnostics,
+  verifyRunDiagnostics,
+  diagnosticEvent,
+  diagnosticSpans,
+  diagnosticAnalysisPrompt,
+  diagnosticFailure,
   OpenPondExperimentError,
   OpenPondExperimentsClient,
   ExperimentCaseInspectionSchema,
@@ -442,4 +652,4 @@ export {
   ProfileEvaluationDiscoveryRequestSchema,
   OpenPondProfileEvaluationDiscoveryClient
 };
-//# sourceMappingURL=chunk-SX767BS2.js.map
+//# sourceMappingURL=chunk-2G4WBMYI.js.map