openpond-sdk 0.1.3 → 0.1.5

package/dist/index.js

@@ -2710,129 +2710,35 @@ var learning_exports = {};
 __export(learning_exports, {
   LearningBatchPublicationResultSchema: () => LearningBatchPublicationResultSchema,
   LearningBatchPublicationSchema: () => LearningBatchPublicationSchema,
+  LearningSourceConfigurationRequestSchema: () => LearningSourceConfigurationRequestSchema,
+  LearningSourceConfigurationSchema: () => LearningSourceConfigurationSchema,
+  LearningSourceCredentialCreatedSchema: () => LearningSourceCredentialCreatedSchema,
+  LearningSourceCredentialPageSchema: () => LearningSourceCredentialPageSchema,
+  LearningSourceCredentialRequestSchema: () => LearningSourceCredentialRequestSchema,
+  LearningSourceCredentialSchema: () => LearningSourceCredentialSchema,
+  LearningSourceCredentialSecretSchema: () => LearningSourceCredentialSecretSchema,
   OpenPondLearningClient: () => OpenPondLearningClient,
-  OpenPondLearningError: () => OpenPondLearningError
+  OpenPondLearningError: () => OpenPondLearningError,
+  assertLearningCredentialExpiry: () => assertLearningCredentialExpiry,
+  createSourceCredentialRequest: () => createSourceCredentialRequest
 });
-__reExport(learning_exports, learning_star);
-__reExport(learning_exports, rewards_star);
-import { z } from "zod";
+import { z as z12 } from "zod";
 import {
   LearningCommandRequestSchema,
   LearningOperationResultSchema,
   LearningReadRequestSchema,
+  TaskEvidenceInspectionResultSchema,
+  sameLearningRef,
   assertLearningRequestJson,
   learningResourceSchemas
 } from "@openpond/evals/learning";
 import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
-import * as learning_star from "@openpond/evals/learning";
-import * as rewards_star from "@openpond/evals/rewards";
-var LearningBatchPublicationSchema = z.object({
-  batchId: z.string().trim().min(1).max(500),
-  modelProjectId: z.string().trim().min(1).max(500)
-}).strict();
-var LearningBatchPublicationResultSchema = z.object({
-  batchId: z.string().min(1),
-  projectId: z.string().min(1),
-  tasksetId: z.string().min(1),
-  releaseId: z.string().min(1),
-  revision: z.number().int().positive(),
-  contentHash: z.string().regex(/^[a-f0-9]{64}$/)
-}).strict();
-var OpenPondLearningError = class extends Error {
-  constructor(status, code, message, details) {
-    super(message);
-    this.status = status;
-    this.code = code;
-    this.details = details;
-    this.name = "OpenPondLearningError";
-  }
-  status;
-  code;
-  details;
-};
-var OpenPondLearningClient = class {
-  #options;
-  constructor(options) {
-    if (!options.apiKey.trim() || !options.scope.trim()) throw new Error("Learning API key and scope are required.");
-    const url = new URL(options.baseUrl);
-    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) throw new Error("Learning base URL must be an HTTP(S) endpoint without credentials, query, or fragment.");
-    this.#options = { ...options, baseUrl: url.toString().replace(/\/+$/, "") };
-  }
-  async command(command, options = {}) {
-    assertLearningRequestJson(command);
-    const request = LearningCommandRequestSchema.parse({ scope: this.#options.scope, command });
-    const result = LearningOperationResultSchema.parse(await this.#request("commands", request, options));
-    if (result.operationId !== command.operationId) throw new OpenPondLearningError(502, "operation_identity_mismatch", "Learning response did not match the submitted operation.", null);
-    return result;
-  }
-  submitExample(example, options = {}) {
-    return this.command({ action: "submit_example", operationId: example.idempotencyKey, example }, options);
-  }
-  submitFeedback(feedback, options = {}) {
-    return this.command({ action: "submit_feedback", operationId: feedback.idempotencyKey, feedback }, options);
-  }
-  async get(kind, id, revision, options = {}) {
-    const request = LearningReadRequestSchema.parse({ action: "get", scope: this.#options.scope, kind, id, ...revision === void 0 ? {} : { revision } });
-    return learningResourceSchemas[kind].parse(await this.#request("read", request, options));
-  }
-  async list(kind, query = {}, options = {}) {
-    const request = LearningReadRequestSchema.parse({ action: "list", scope: this.#options.scope, kind, ...query });
-    return z.object({ items: z.array(learningResourceSchemas[kind]).max(100), nextCursor: z.string().nullable() }).strict().parse(await this.#request("read", request, options));
-  }
-  /** Hosted publication only: stores an immutable package and attaches it, without starting training. */
-  async publishBatch(input, options = {}) {
-    const request = LearningBatchPublicationSchema.parse(input);
-    const result = LearningBatchPublicationResultSchema.parse(await this.#request("publish-batch", { ...request, scope: this.#options.scope }, options));
-    if (result.batchId !== request.batchId) throw new OpenPondLearningError(502, "batch_identity_mismatch", "Published batch response did not match the requested batch.", null);
-    return result;
-  }
-  async #request(endpoint, body, options) {
-    assertBoundedTaskJson(body, 16777216);
-    const response = await (this.#options.fetch ?? globalThis.fetch)(`${this.#options.baseUrl}/v1/learning/${endpoint}`, {
-      method: "POST",
-      headers: { Authorization: `Bearer ${this.#options.apiKey}`, "Content-Type": "application/json", Accept: "application/json", "X-OpenPond-Team-Id": this.#options.scope },
-      body: JSON.stringify(body),
-      signal: options.signal,
-      redirect: "error"
-    });
-    const payload = await readBoundedLearningResponse(response);
-    if (!response.ok) {
-      const error = z.object({ code: z.string().optional(), error: z.string().optional() }).passthrough().safeParse(payload);
-      throw new OpenPondLearningError(response.status, error.success ? error.data.code ?? "learning_request_failed" : "learning_request_failed", error.success ? error.data.error ?? `Learning request failed (${response.status}).` : `Learning request failed (${response.status}).`, payload);
-    }
-    return payload;
-  }
-};
-async function readBoundedLearningResponse(response) {
-  const maximumBytes = 16777216;
-  const reader = response.body?.getReader();
-  if (!reader) throw new OpenPondLearningError(response.status, "empty_response", "Learning response was empty.", null);
-  const decoder = new TextDecoder();
-  let bytes = 0;
-  let text = "";
-  try {
-    while (true) {
-      const next = await reader.read();
-      if (next.done) break;
-      bytes += next.value.byteLength;
-      if (bytes > maximumBytes) throw new OpenPondLearningError(response.status, "response_too_large", "Learning response exceeded 16 MiB; request a smaller page.", null);
-      text += decoder.decode(next.value, { stream: true });
-    }
-    text += decoder.decode();
-    const value = JSON.parse(text);
-    assertBoundedTaskJson(value, maximumBytes);
-    return value;
-  } finally {
-    await reader.cancel();
-    reader.releaseLock();
-  }
-}
 
-// ../harness/dist/refiner.js
-import { z as z4 } from "zod";
+// src/learning-credentials.ts
+import { z as z11 } from "zod";
 
 // ../harness/dist/common.js
-import { z as z2 } from "zod";
+import { z } from "zod";
 
 // ../harness/dist/sha256.js
 var INITIAL_STATE = new Uint32Array([
@@ -2976,29 +2882,29 @@ function rotateRight(value, bits) {
 // ../harness/dist/common.js
 var MAX_PORTABLE_PATH_BYTES = 2e3;
 var MAX_PORTABLE_ASSET_BYTES = 25e7;
-var ReleaseIdSchema = z2.string().trim().min(1).max(240);
-var ReleaseHashSchema = z2.string().regex(/^[a-f0-9]{64}$/);
-var ReleaseTimestampSchema = z2.string().datetime({ offset: true });
-var MetadataSchema = z2.record(z2.string(), z2.unknown()).default({});
-var ImmutableReleaseRefSchema = z2.object({
+var ReleaseIdSchema = z.string().trim().min(1).max(240);
+var ReleaseHashSchema = z.string().regex(/^[a-f0-9]{64}$/);
+var ReleaseTimestampSchema = z.string().datetime({ offset: true });
+var MetadataSchema = z.record(z.string(), z.unknown()).default({});
+var ImmutableReleaseRefSchema = z.object({
   id: ReleaseIdSchema,
   contentHash: ReleaseHashSchema
 }).strict();
-var ImmutableAssetRefSchema = z2.object({
+var ImmutableAssetRefSchema = z.object({
   id: ReleaseIdSchema,
-  path: z2.string().trim().min(1).max(MAX_PORTABLE_PATH_BYTES).refine(safeRelativePath),
+  path: z.string().trim().min(1).max(MAX_PORTABLE_PATH_BYTES).refine(safeRelativePath),
   contentHash: ReleaseHashSchema,
-  sizeBytes: z2.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES),
-  mediaType: z2.string().trim().min(1).max(200),
-  visibility: z2.enum(["policy", "verifier", "host_private"])
+  sizeBytes: z.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES),
+  mediaType: z.string().trim().min(1).max(200),
+  visibility: z.enum(["policy", "verifier", "host_private"])
 }).strict();
-var ImmutableArtifactRefSchema = z2.object({
+var ImmutableArtifactRefSchema = z.object({
   id: ReleaseIdSchema,
   contentHash: ReleaseHashSchema,
-  mediaType: z2.string().trim().min(1).max(200).nullable().default(null),
-  sizeBytes: z2.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES).nullable().default(null)
+  mediaType: z.string().trim().min(1).max(200).nullable().default(null),
+  sizeBytes: z.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES).nullable().default(null)
 }).strict();
-var FailureClassSchema = z2.enum([
+var FailureClassSchema = z.enum([
   "policy_failure",
   "grader_failure",
   "environment_failure",
@@ -3030,359 +2936,1889 @@ function sortValue(value) {
   return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortValue(child)]));
 }
 
-// ../harness/dist/refiner-profiles.js
-import { z as z3 } from "zod";
-var RefinerProposalRouteSchema = z3.enum(["memory", "prompt", "skill", "agent"]);
-var RefinerExternalRouteSchema = z3.enum(["runtime", "product", "taskset", "training"]);
-var RefinerReviewInstructionSchema = z3.object({
-  id: z3.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
-  text: z3.string().trim().min(1).max(1e4)
-}).strict();
-var RefinerReviewProfileSchema = z3.object({
-  schemaVersion: z3.literal("openpond.refinerReviewProfile.v1"),
-  id: z3.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
-  version: z3.string().trim().min(1).max(120),
-  name: z3.string().trim().min(1).max(200),
-  objective: z3.string().trim().min(1).max(1e4),
-  instructions: z3.array(RefinerReviewInstructionSchema).max(100),
-  allowedProposalRoutes: z3.array(RefinerProposalRouteSchema).max(4),
-  allowedExternalRoutes: z3.array(RefinerExternalRouteSchema).max(4)
-}).strict().superRefine((profile, context) => {
-  const instructionIds = profile.instructions.map((instruction) => instruction.id);
-  if (new Set(instructionIds).size !== instructionIds.length) {
-    context.addIssue({ code: "custom", message: "instruction IDs must be unique", path: ["instructions"] });
-  }
-  if (new Set(profile.allowedProposalRoutes).size !== profile.allowedProposalRoutes.length) {
-    context.addIssue({ code: "custom", message: "proposal routes must be unique", path: ["allowedProposalRoutes"] });
-  }
-  if (new Set(profile.allowedExternalRoutes).size !== profile.allowedExternalRoutes.length) {
-    context.addIssue({ code: "custom", message: "external routes must be unique", path: ["allowedExternalRoutes"] });
-  }
-});
-var DEFAULT_REFINER_REVIEW_PROFILE = {
-  schemaVersion: "openpond.refinerReviewProfile.v1",
-  id: "openpond.default",
-  version: "1",
-  name: "OpenPond default review",
-  objective: "Find the smallest reusable change that improves future work without learning task-specific facts.",
-  instructions: [],
-  allowedProposalRoutes: ["memory", "prompt", "skill", "agent"],
-  allowedExternalRoutes: ["runtime", "product", "taskset", "training"]
-};
-var RefinerReleaseSchema = z3.object({
-  schemaVersion: z3.literal("openpond.refinerRelease.v1"),
-  id: z3.string().trim().min(1).max(240),
-  coreVersion: z3.string().trim().min(1).max(120),
-  coreHash: ReleaseHashSchema,
-  profile: RefinerReviewProfileSchema,
-  profileHash: ReleaseHashSchema,
-  composedPromptHash: ReleaseHashSchema,
-  createdAt: ReleaseTimestampSchema,
-  contentHash: ReleaseHashSchema
+// ../harness/dist/evaluation-review.js
+import { z as z2 } from "zod";
+var BoundedTextSchema = z2.string().trim().min(1).max(1e5);
+var HarnessEvaluationReviewClassificationSchema = z2.enum([
+  "no_action",
+  "harness_maintenance",
+  "runtime",
+  "product",
+  "taskset",
+  "model_improvement"
+]);
+var HarnessEvaluationReviewAuthoritySchema = z2.enum([
+  "none",
+  "runtime_service",
+  "product_team",
+  "human_review",
+  "evaluation_system",
+  "training_system"
+]);
+var HarnessReviewEvidenceKindSchema = z2.enum([
+  "observation",
+  "trigger",
+  "route_decision",
+  "refiner_outcome",
+  "proposal",
+  "validation",
+  "apply_receipt",
+  "harness_advance",
+  "rollback",
+  "work_outcome",
+  "taskset",
+  "evaluation",
+  "training_qualification",
+  "model_candidate"
+]);
+var HarnessReviewOwnerScopeSchema = z2.object({
+  kind: z2.enum(["personal", "team"]),
+  id: ReleaseIdSchema
 }).strict();
-var RefinerBindingSchema = z3.object({
-  schemaVersion: z3.literal("openpond.refinerBinding.v1"),
-  channel: z3.literal("active"),
-  revision: z3.number().int().nonnegative(),
-  release: ImmutableReleaseRefSchema,
-  updatedAt: ReleaseTimestampSchema
+var HarnessReviewSourcePolicyRefSchema = z2.object({
+  policy: ImmutableReleaseRefSchema,
+  state: z2.enum(["authorized", "revoked", "deleted", "expired"]),
+  checkedAt: ReleaseTimestampSchema
 }).strict();
-var RefinerTransitionReceiptSchema = z3.object({
-  schemaVersion: z3.literal("openpond.refinerTransitionReceipt.v1"),
-  id: z3.string().trim().min(1).max(240),
-  operation: z3.enum(["initialize", "update", "activate", "rollback"]),
-  bindingChanged: z3.boolean(),
-  previousRelease: ImmutableReleaseRefSchema.nullable(),
-  nextRelease: ImmutableReleaseRefSchema,
-  actor: z3.string().trim().min(1).max(240),
-  reason: z3.string().trim().min(1).max(1e4),
-  authoringSkillHash: ReleaseHashSchema.nullable(),
-  validation: z3.object({ valid: z3.boolean(), messages: z3.array(z3.string().max(2e3)).max(100) }).strict(),
-  createdAt: ReleaseTimestampSchema,
-  contentHash: ReleaseHashSchema
+var HarnessReviewEvidenceRefSchema = z2.object({
+  evidence: ImmutableReleaseRefSchema,
+  kind: HarnessReviewEvidenceKindSchema,
+  sourceRef: ReleaseIdSchema,
+  sourcePolicy: HarnessReviewSourcePolicyRefSchema,
+  occurrenceKey: ReleaseHashSchema,
+  occurredAt: ReleaseTimestampSchema
 }).strict();
-function defineReviewProfile(profile) {
-  return RefinerReviewProfileSchema.parse(profile);
-}
-function createRefinerRelease(input) {
-  const profile = RefinerReviewProfileSchema.parse(input.profile);
-  const createdAt = input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
-  const coreHash = contentHash({ coreVersion: input.coreVersion, corePrompt: input.corePrompt });
-  const profileHash = contentHash(profile);
-  const composedPromptHash = contentHash({ coreHash, profile });
-  const releaseWithoutHash = {
-    schemaVersion: "openpond.refinerRelease.v1",
-    id: `refiner-${composedPromptHash.slice(0, 24)}`,
-    coreVersion: input.coreVersion,
-    coreHash,
-    profile,
-    profileHash,
-    composedPromptHash,
-    createdAt
-  };
-  return RefinerReleaseSchema.parse({
-    ...releaseWithoutHash,
-    contentHash: contentHash(releaseWithoutHash)
-  });
-}
-function refinerProfilePrompt(profile) {
-  const parsed = RefinerReviewProfileSchema.parse(profile);
-  return [
-    `Review profile: ${parsed.name} (${parsed.id}@${parsed.version})`,
-    `Objective: ${parsed.objective}`,
-    `Allowed Harness proposal routes: ${parsed.allowedProposalRoutes.join(", ")}.`,
-    `Allowed external routes: ${parsed.allowedExternalRoutes.join(", ")}.`,
-    ...parsed.instructions.map((instruction) => `[${instruction.id}] ${instruction.text}`)
-  ].join("\n");
-}
-function serializeReviewProfile(profile) {
-  return canonicalJson(RefinerReviewProfileSchema.parse(profile));
-}
-
-// ../harness/dist/refiner.js
-var RefinerNoActionDecisionSchema = z4.object({
-  schemaVersion: z4.literal("openpond.localHarnessRefinerDecision.v1"),
-  decision: z4.literal("no_action"),
-  reason: z4.string().trim().min(1).max(1e4)
-}).strip();
-var RefinerExternalRouteDecisionSchema = z4.object({
-  schemaVersion: z4.literal("openpond.localHarnessRefinerDecision.v1"),
-  decision: z4.literal("route"),
-  route: z4.enum(["runtime", "product", "taskset", "training"]),
-  summary: z4.string().trim().min(1).max(2e3),
-  expectedOutcome: z4.string().trim().min(1).max(1e4),
-  reason: z4.string().trim().min(1).max(1e4)
-}).strip();
-var RefinerProposalDecisionSchema = z4.object({
-  schemaVersion: z4.literal("openpond.localHarnessRefinerDecision.v1"),
-  decision: z4.literal("propose"),
-  route: z4.enum(["memory", "prompt", "skill", "agent"]),
-  operation: z4.enum(["create", "update", "delete"]),
-  target: z4.string().trim().min(1).max(2e3),
-  summary: z4.string().trim().min(1).max(2e3),
-  createContent: z4.string().min(1).max(2e4).nullable(),
-  find: z4.string().min(1).max(8e3).nullable(),
-  replace: z4.string().max(8e3).nullable(),
-  expectedOutcome: z4.string().trim().min(1).max(1e4),
-  reason: z4.string().trim().min(1).max(1e4)
-}).strip().superRefine((decision, context) => {
-  if (decision.operation === "create" && (decision.createContent === null || decision.find !== null || decision.replace !== null)) {
+var HarnessReviewExcludedEvidenceSchema = z2.object({
+  evidence: ImmutableReleaseRefSchema,
+  sourcePolicy: HarnessReviewSourcePolicyRefSchema.nullable(),
+  reason: z2.enum([
+    "outside_scope",
+    "before_watermark",
+    "duplicate",
+    "resolved",
+    "revoked",
+    "deleted",
+    "expired",
+    "sensitive",
+    "unverified",
+    "budget"
+  ])
+}).strict();
+var HarnessReviewWatermarkSchema = z2.object({
+  cursor: ReleaseHashSchema,
+  throughCreatedAt: ReleaseTimestampSchema
+}).strict();
+var HarnessReviewClaimSchema = z2.object({
+  fingerprint: ReleaseHashSchema,
+  recurrenceFamily: z2.string().trim().min(1).max(1e3),
+  statement: BoundedTextSchema,
+  candidateDisposition: z2.enum(["observe", "confirm"]).optional(),
+  independentOccurrences: z2.number().int().positive().max(1e6),
+  unresolvedOccurrences: z2.number().int().positive().max(1e6)
+}).strict().refine((claim) => claim.unresolvedOccurrences <= claim.independentOccurrences, "unresolved occurrences cannot exceed independent occurrences");
+var HarnessReviewTriageLayerSchema = z2.enum([
+  "harness",
+  "runtime",
+  "product",
+  "retrieval",
+  "tools",
+  "evaluation",
+  "model"
+]);
+var HarnessReviewTriageDecisionSchema = z2.object({
+  layer: HarnessReviewTriageLayerSchema,
+  status: z2.enum(["not_applicable", "unresolved", "resolved", "blocked"]),
+  reason: BoundedTextSchema,
+  evidenceRefs: z2.array(ImmutableReleaseRefSchema).max(1e3)
+}).strict();
+var HarnessEvaluationReviewReceiptContentSchema = z2.object({
+  schemaVersion: z2.literal("openpond.harnessEvaluationReviewReceipt.v1"),
+  id: ReleaseIdSchema,
+  ownerScope: HarnessReviewOwnerScopeSchema,
+  workspaceRef: ReleaseIdSchema,
+  harnessRelease: ImmutableReleaseRefSchema,
+  previousWatermark: HarnessReviewWatermarkSchema.nullable(),
+  nextWatermark: HarnessReviewWatermarkSchema,
+  selectedEvidence: z2.array(HarnessReviewEvidenceRefSchema).max(1e4),
+  excludedEvidence: z2.array(HarnessReviewExcludedEvidenceSchema).max(1e4),
+  claim: HarnessReviewClaimSchema.nullable(),
+  classification: HarnessEvaluationReviewClassificationSchema,
+  triage: z2.array(HarnessReviewTriageDecisionSchema).max(16),
+  reason: BoundedTextSchema,
+  nextAuthority: HarnessEvaluationReviewAuthoritySchema,
+  maxEstimatedCostUsd: z2.number().finite().nonnegative(),
+  tasksetProposal: ImmutableReleaseRefSchema.nullable(),
+  evaluation: ImmutableReleaseRefSchema.nullable(),
+  trainingQualification: ImmutableReleaseRefSchema.nullable(),
+  policyVersion: ReleaseIdSchema,
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema
+}).strict().superRefine((receipt, context) => {
+  const selectedKeys = receipt.selectedEvidence.map((item) => `${item.evidence.id}:${item.evidence.contentHash}`);
+  if (new Set(selectedKeys).size !== selectedKeys.length) {
     context.addIssue({
       code: "custom",
-      message: "create proposals require createContent and null find/replace",
-      path: ["createContent"]
+      message: "selected review evidence must be unique",
+      path: ["selectedEvidence"]
     });
   }
-  if (decision.operation === "update" && (decision.createContent !== null || decision.find === null || decision.replace === null)) {
+  if (receipt.selectedEvidence.some((item) => item.sourcePolicy.state !== "authorized")) {
     context.addIssue({
       code: "custom",
-      message: "update proposals require one exact find/replace edit and null createContent",
-      path: ["find"]
+      message: "selected review evidence must be authorized at review time",
+      path: ["selectedEvidence"]
     });
   }
-  if (decision.operation === "delete" && (decision.createContent !== null || decision.find !== null || decision.replace !== null)) {
+  if (receipt.classification === "no_action") {
+    if (receipt.nextAuthority !== "none") {
+      context.addIssue({
+        code: "custom",
+        message: "no-action review receipts require no next authority",
+        path: ["nextAuthority"]
+      });
+    }
+    if (receipt.tasksetProposal || receipt.evaluation || receipt.trainingQualification) {
+      context.addIssue({
+        code: "custom",
+        message: "no-action review receipts cannot carry downstream refs"
+      });
+    }
+  } else if (!receipt.claim || receipt.selectedEvidence.length === 0) {
     context.addIssue({
       code: "custom",
-      message: "delete proposals require null createContent/find/replace",
-      path: ["createContent"]
+      message: "actionable review receipts require a claim and selected evidence"
     });
   }
-});
-var LocalHarnessRefinerDecisionSchema = z4.discriminatedUnion("decision", [
-  RefinerNoActionDecisionSchema,
-  RefinerExternalRouteDecisionSchema,
-  RefinerProposalDecisionSchema
-]);
-var LocalHarnessRefinerDecisionV1Schema = LocalHarnessRefinerDecisionSchema;
-var HarnessRefinerEvidenceBasisSchema = z4.object({
-  kind: z4.enum(["single_deterministic", "recurrent_independent"]),
-  supportingEvidenceIds: z4.array(z4.string().trim().min(1).max(2e3)).min(1).max(100),
-  counterevidence: z4.array(z4.string().trim().min(1).max(2e3)).max(20)
-}).strict().superRefine((basis, context) => {
-  if (new Set(basis.supportingEvidenceIds).size !== basis.supportingEvidenceIds.length) {
+  if (receipt.classification === "runtime" && receipt.nextAuthority !== "runtime_service") {
     context.addIssue({
       code: "custom",
-      message: "supporting evidence IDs must be unique",
-      path: ["supportingEvidenceIds"]
+      message: "runtime classifications route to runtime-service authority",
+      path: ["nextAuthority"]
     });
   }
-  if (basis.kind === "recurrent_independent" && basis.supportingEvidenceIds.length < 2) {
+  if (receipt.classification === "product" && receipt.nextAuthority !== "product_team") {
     context.addIssue({
       code: "custom",
-      message: "recurrent independent evidence requires at least two supplied incidents",
-      path: ["supportingEvidenceIds"]
+      message: "product classifications route to product-team authority",
+      path: ["nextAuthority"]
     });
   }
-});
-var RefinerNoActionDecisionV2Schema = z4.object({
-  schemaVersion: z4.literal("openpond.localHarnessRefinerDecision.v2"),
-  decision: z4.literal("no_action"),
-  reason: z4.string().trim().min(1).max(1e4)
-}).strict();
-var RefinerExternalRouteDecisionV2Schema = z4.object({
-  schemaVersion: z4.literal("openpond.localHarnessRefinerDecision.v2"),
-  decision: z4.literal("route"),
-  route: z4.enum(["runtime", "product", "taskset", "training"]),
-  summary: z4.string().trim().min(1).max(2e3),
-  evidenceBasis: HarnessRefinerEvidenceBasisSchema,
-  expectedOutcome: z4.string().trim().min(1).max(1e4),
-  reason: z4.string().trim().min(1).max(1e4)
-}).strict();
-var RefinerProposalDecisionV2Schema = z4.object({
-  schemaVersion: z4.literal("openpond.localHarnessRefinerDecision.v2"),
-  decision: z4.literal("propose"),
-  route: z4.enum(["memory", "prompt", "skill", "agent"]),
-  operation: z4.enum(["create", "update", "delete"]),
-  target: z4.string().trim().min(1).max(2e3),
-  summary: z4.string().trim().min(1).max(2e3),
-  evidenceBasis: HarnessRefinerEvidenceBasisSchema,
-  createContent: z4.string().min(1).max(2e4).nullable(),
-  find: z4.string().min(1).max(8e3).nullable(),
-  replace: z4.string().max(8e3).nullable(),
-  expectedOutcome: z4.string().trim().min(1).max(1e4),
-  reason: z4.string().trim().min(1).max(1e4)
-}).strict().superRefine((decision, context) => {
-  if (decision.operation === "create" && (decision.createContent === null || decision.find !== null || decision.replace !== null)) {
+  if (receipt.classification === "taskset" && receipt.nextAuthority !== "human_review") {
     context.addIssue({
       code: "custom",
-      message: "create proposals require createContent and null find/replace",
-      path: ["createContent"]
+      message: "Taskset classifications require human review"
     });
   }
-  if (decision.operation === "update" && (decision.createContent !== null || decision.find === null || decision.replace === null)) {
+  if (receipt.classification === "model_improvement" && (!receipt.evaluation || !receipt.trainingQualification || !["human_review", "training_system"].includes(receipt.nextAuthority))) {
     context.addIssue({
       code: "custom",
-      message: "update proposals require one exact find/replace edit and null createContent",
-      path: ["find"]
+      message: "model-improvement classifications require Evaluation and qualification refs plus explicit authority"
     });
   }
-  if (decision.operation === "delete" && (decision.createContent !== null || decision.find !== null || decision.replace !== null)) {
+});
+var HarnessEvaluationReviewReceiptSchema = HarnessEvaluationReviewReceiptContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessEvaluationReviewModelEvidenceSchema = z2.object({
+  id: ReleaseIdSchema,
+  evidence: ImmutableReleaseRefSchema,
+  kind: HarnessReviewEvidenceKindSchema,
+  sourceRef: ReleaseIdSchema,
+  occurredAt: ReleaseTimestampSchema,
+  payload: z2.record(z2.string(), z2.unknown())
+}).strict();
+var HarnessEvaluationReviewModelNoActionSchema = z2.object({
+  schemaVersion: z2.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
+  decision: z2.literal("no_action"),
+  reason: BoundedTextSchema,
+  ignoredEvidence: z2.array(z2.object({
+    id: ReleaseIdSchema,
+    reason: z2.string().trim().min(1).max(2e3)
+  }).strict()).max(1e3)
+}).strict();
+var HarnessEvaluationReviewModelActionSchema = z2.object({
+  schemaVersion: z2.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
+  decision: z2.literal("review"),
+  classification: z2.enum([
+    "harness_maintenance",
+    "runtime",
+    "product",
+    "taskset"
+  ]),
+  selectedEvidenceIds: z2.array(ReleaseIdSchema).min(1).max(1e3),
+  ignoredEvidence: z2.array(z2.object({
+    id: ReleaseIdSchema,
+    reason: z2.string().trim().min(1).max(2e3)
+  }).strict()).max(1e3),
+  recurrenceFamily: z2.string().trim().min(1).max(1e3),
+  statement: BoundedTextSchema,
+  triageLayer: HarnessReviewTriageLayerSchema,
+  expectedOutcome: BoundedTextSchema,
+  counterevidence: z2.string().trim().max(1e4),
+  confidence: z2.number().min(0).max(1),
+  candidateDisposition: z2.enum(["observe", "confirm"]).nullable(),
+  reason: BoundedTextSchema
+}).strict().superRefine((decision, context) => {
+  const requiresDisposition = decision.classification === "harness_maintenance";
+  if (requiresDisposition !== (decision.candidateDisposition !== null)) {
     context.addIssue({
       code: "custom",
-      message: "delete proposals require null createContent/find/replace",
-      path: ["createContent"]
+      message: "Harness maintenance requires a candidate disposition; external routes require null",
+      path: ["candidateDisposition"]
     });
   }
 });
-var LocalHarnessRefinerDecisionV2Schema = z4.discriminatedUnion("decision", [
-  RefinerNoActionDecisionV2Schema,
-  RefinerExternalRouteDecisionV2Schema,
-  RefinerProposalDecisionV2Schema
-]);
-var LocalHarnessRefinerDecisionAnySchema = z4.union([
-  LocalHarnessRefinerDecisionV1Schema,
-  LocalHarnessRefinerDecisionV2Schema
+var HarnessEvaluationReviewModelResolutionSchema = z2.object({
+  schemaVersion: z2.literal("openpond.harnessEvaluationReviewModelDecision.v2"),
+  decision: z2.literal("resolve_candidate"),
+  candidateId: ReleaseIdSchema,
+  candidateFingerprint: ReleaseHashSchema,
+  selectedEvidenceIds: z2.array(ReleaseIdSchema).min(1).max(1e3),
+  ignoredEvidence: z2.array(z2.object({
+    id: ReleaseIdSchema,
+    reason: z2.string().trim().min(1).max(2e3)
+  }).strict()).max(1e3),
+  confidence: z2.number().min(0).max(1),
+  reason: BoundedTextSchema
+}).strict();
+var HarnessEvaluationReviewModelDecisionSchema = z2.discriminatedUnion("decision", [
+  HarnessEvaluationReviewModelNoActionSchema,
+  HarnessEvaluationReviewModelActionSchema,
+  HarnessEvaluationReviewModelResolutionSchema
 ]);
-var HarnessRefinerCapabilitiesSchema = z4.object({
-  memory: z4.boolean(),
-  prompt: z4.boolean(),
-  skill: z4.boolean(),
-  agent: z4.boolean()
-}).strict();
-var SourceKindSchema = z4.enum(["memory", "instruction", "skill", "agent"]);
-var RefinerSourceFileSchema = z4.object({
-  path: z4.string().trim().min(1).max(2e3),
-  kind: SourceKindSchema,
-  content: z4.string().max(6e4),
-  loaded: z4.boolean()
+var HarnessEvaluationReviewNavigationDecisionSchema = z2.object({
+  schemaVersion: z2.literal("openpond.harnessEvaluationReviewNavigationDecision.v1"),
+  selectedEvidenceIds: z2.array(ReleaseIdSchema).min(1).max(50),
+  reason: BoundedTextSchema
 }).strict();
-var RefinerSourceCatalogEntrySchema = z4.object({
-  path: z4.string().trim().min(1).max(2e3),
-  kind: SourceKindSchema,
-  loaded: z4.boolean()
+
+// ../harness/dist/harness.js
+import { z as z4 } from "zod";
+
+// ../harness/dist/tools.js
+import { z as z3 } from "zod";
+var ToolDeclarationSchema = z3.object({
+  name: z3.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+  description: z3.string().trim().min(1).max(2e3),
+  inputSchema: z3.record(z3.string(), z3.unknown()),
+  inputSchemaHash: ReleaseHashSchema,
+  sideEffect: z3.enum(["read", "write"]),
+  timeoutMs: z3.number().int().positive().max(36e5)
 }).strict();
-var LocalHarnessRefinerEvidenceSchema = z4.object({
-  capabilities: HarnessRefinerCapabilitiesSchema,
-  trigger: z4.record(z4.string(), z4.unknown()),
-  observations: z4.array(z4.record(z4.string(), z4.unknown())).max(20),
-  admissibleEvidenceIds: z4.array(z4.string().trim().min(1).max(2e3)).max(1e4),
-  reviewPacket: z4.object({
-    currentTurn: z4.object({
-      id: z4.string().trim().min(1).max(2e3),
-      status: z4.string().trim().min(1).max(100).nullable(),
-      error: z4.string().max(2100).nullable(),
-      prompt: z4.string().max(8100).nullable(),
-      assistantOutput: z4.string().max(8100).nullable(),
-      assistantOutputLinkCount: z4.number().int().nonnegative()
-    }).strict(),
-    priorConversation: z4.array(z4.object({
-      turnId: z4.string().trim().min(1).max(2e3),
-      status: z4.string().trim().min(1).max(100).nullable(),
-      prompt: z4.string().max(3100).nullable(),
-      assistantOutput: z4.string().max(3100).nullable()
-    }).strict()).max(3),
-    timeline: z4.array(z4.record(z4.string(), z4.unknown())).max(60),
-    artifacts: z4.array(z4.record(z4.string(), z4.unknown())).max(30),
-    artifactDiagnostics: z4.array(z4.record(z4.string(), z4.unknown())).max(20),
-    executionProfile: z4.object({
-      modelRequestCount: z4.number().int().nonnegative(),
-      failedModelRequestCount: z4.number().int().nonnegative(),
-      promptTokens: z4.number().int().nonnegative(),
-      completionTokens: z4.number().int().nonnegative(),
-      totalTokens: z4.number().int().nonnegative(),
-      toolFailureCount: z4.number().int().nonnegative(),
-      retryCount: z4.number().int().nonnegative(),
-      recoveryCount: z4.number().int().nonnegative()
-    }).strict(),
-    priorIncidents: z4.array(z4.record(z4.string(), z4.unknown())).max(3),
-    truncation: z4.object({
-      timelineEventCount: z4.number().int().nonnegative(),
-      includedTimelineEventCount: z4.number().int().nonnegative(),
-      timelineTruncated: z4.boolean()
-    }).strict()
-  }).strict(),
-  runtimeActivation: z4.object({
-    admittedRelease: ImmutableReleaseRefSchema,
-    currentRelease: ImmutableReleaseRefSchema,
-    rebasedOntoCurrent: z4.boolean(),
-    admittedSourceFiles: z4.array(RefinerSourceFileSchema).max(100),
-    admittedSourceCatalog: z4.array(RefinerSourceCatalogEntrySchema).max(1e3)
-  }).strict(),
-  sourceFiles: z4.array(RefinerSourceFileSchema).max(100),
-  sourceCatalog: z4.array(RefinerSourceCatalogEntrySchema).max(1e3),
-  additionalEvidence: z4.unknown().nullable().optional()
+var CapabilityRequirementSchema = z3.object({
+  id: ReleaseIdSchema,
+  required: z3.boolean(),
+  scopes: z3.array(z3.string().trim().min(1).max(500)).max(100).default([]),
+  portability: z3.enum(["portable", "host_adapter", "local_only", "hosted_only"])
 }).strict();
-var REFINER_CORE_VERSION = "openpond.refinerCore.v2";
-var OverlayRefSchema = z4.object({
-  id: z4.string().trim().min(1).max(240),
-  revision: z4.number().int().nonnegative(),
+
+// ../harness/dist/harness.js
+var PortabilityReportSchema = z4.object({
+  portable: z4.boolean(),
+  blockers: z4.array(z4.string().trim().min(1).max(2e3)).max(1e3),
+  localOnlyAssetRefs: z4.array(ReleaseIdSchema).max(1e4),
+  hostPrivateAssetRefs: z4.array(ReleaseIdSchema).max(1e4)
+}).strict();
+var AgentSnapshotContentSchema = z4.object({
+  schemaVersion: z4.literal("openpond.agentSnapshot.v2"),
+  id: ReleaseIdSchema,
+  sourceRelease: ImmutableReleaseRefSchema.nullable(),
+  instructions: z4.array(ImmutableAssetRefSchema).max(1e4),
+  skills: z4.array(ImmutableAssetRefSchema).max(1e4),
+  agents: z4.array(ImmutableAssetRefSchema).max(1e4),
+  toolDeclarations: z4.array(ToolDeclarationSchema).max(200),
+  capabilityRequirements: z4.array(CapabilityRequirementSchema).max(200),
+  dependencyLock: ImmutableAssetRefSchema,
+  portability: PortabilityReportSchema,
+  metadata: MetadataSchema
+}).strict();
+var AgentSnapshotSchema = AgentSnapshotContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
+var LifecycleContractSchema = z4.object({
+  create: z4.literal(true),
+  reset: z4.literal(true),
+  step: z4.literal(true),
+  collect: z4.literal(true),
+  destroy: z4.literal(true),
+  resetScope: z4.enum(["task", "attempt"])
+}).strict();
+var GraderInterfaceContractSchema = z4.object({
+  visibleEvidence: z4.array(ReleaseIdSchema).max(1e3),
+  privilegedEvidence: z4.array(ReleaseIdSchema).max(1e3),
+  privateVerifierIsolation: z4.boolean()
+}).strict();
+var HarnessReleaseContentSchema = z4.object({
+  schemaVersion: z4.literal("openpond.harnessRelease.v2"),
+  id: ReleaseIdSchema,
+  agentSnapshot: ImmutableReleaseRefSchema,
+  program: ImmutableAssetRefSchema,
+  tools: z4.array(ToolDeclarationSchema).max(200),
+  lifecycle: LifecycleContractSchema,
+  graderInterface: GraderInterfaceContractSchema,
+  files: z4.array(ImmutableAssetRefSchema).max(1e5),
+  metadata: MetadataSchema
+}).strict();
+var HarnessReleaseSchema = HarnessReleaseContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
+var ModelActionSchema = z4.object({
+  id: ReleaseIdSchema,
+  turn: z4.number().int().nonnegative(),
+  kind: z4.enum(["message", "tool_call", "terminal"]),
+  name: ReleaseIdSchema.nullable(),
+  arguments: z4.record(z4.string(), z4.unknown()),
+  content: z4.string().max(1e6).nullable()
+}).strict();
+var ToolObservationSchema = z4.object({
+  actionId: ReleaseIdSchema,
+  turn: z4.number().int().nonnegative(),
+  terminal: z4.boolean(),
+  output: z4.record(z4.string(), z4.unknown()),
+  artifactRefs: z4.array(ImmutableArtifactRefSchema).max(1e5)
+}).strict();
+var HarnessLifecycleEventSchema = z4.object({
+  sequence: z4.number().int().nonnegative(),
+  type: z4.enum(["created", "reset", "action", "observation", "terminal", "failure", "collected", "destroyed"]),
+  payloadHash: ReleaseHashSchema,
+  metadata: MetadataSchema
+}).strict();
+var HarnessTraceSchema = z4.object({
+  schemaVersion: z4.literal("openpond.harnessTrace.v1"),
+  manifest: ImmutableReleaseRefSchema,
+  taskId: ReleaseIdSchema,
+  seed: z4.string().trim().min(1).max(500),
+  events: z4.array(HarnessLifecycleEventSchema).max(1e6),
+  actions: z4.array(ModelActionSchema).max(1e5),
+  observations: z4.array(ToolObservationSchema).max(1e5),
+  terminal: z4.boolean(),
+  failureClass: FailureClassSchema.nullable(),
+  output: z4.record(z4.string(), z4.unknown()),
+  contentHash: ReleaseHashSchema
+}).strict();
+
+// ../harness/dist/harness-improvements.js
+import { z as z6 } from "zod";
+
+// ../harness/dist/harness-workspaces.js
+import { z as z5 } from "zod";
+var MetadataSchema2 = z5.record(z5.string(), z5.unknown()).default({});
+var RevisionSchema = z5.number().int().nonnegative();
+var BoundedTextSchema2 = z5.string().trim().min(1).max(1e5);
+var HarnessOwnerScopeSchema = z5.object({
+  kind: z5.enum(["personal", "team"]),
+  id: ReleaseIdSchema
+}).strict();
+var HarnessCurrentChannelSchema = z5.object({
+  name: ReleaseIdSchema,
+  release: ImmutableReleaseRefSchema.nullable(),
+  revision: RevisionSchema
+}).strict();
+var HarnessWorkspaceSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessWorkspace.v1"),
+  id: ReleaseIdSchema,
+  ownerScope: HarnessOwnerScopeSchema,
+  name: z5.string().trim().min(1).max(240),
+  location: z5.enum(["local", "hosted"]),
+  sourceRevision: z5.string().trim().min(1).max(500),
+  revision: RevisionSchema,
+  dirty: z5.boolean(),
+  currentChannel: HarnessCurrentChannelSchema,
+  createdAt: ReleaseTimestampSchema,
+  updatedAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema2
+}).strict();
+var HarnessImprovementRouteSchema = z5.enum([
+  "runtime",
+  "memory",
+  "prompt",
+  "skill",
+  "agent",
+  "product",
+  "taskset",
+  "training"
+]);
+var HarnessChangeEffectSchema = z5.enum([
+  "text_instruction",
+  "memory",
+  "dependency_selection",
+  "executable_code",
+  "business_logic",
+  "financial_logic",
+  "permission",
+  "connected_app",
+  "publication",
+  "deployment",
+  "training",
+  "model_binding",
+  "team_or_global"
+]);
+var HarnessOverlayEditSchema = z5.object({
+  id: ReleaseIdSchema,
+  route: HarnessImprovementRouteSchema,
+  operation: z5.enum(["create", "update", "delete"]),
+  target: z5.string().trim().min(1).max(2e3),
+  summary: z5.string().trim().min(1).max(2e3),
+  content: z5.string().max(1e6).nullable(),
+  contentHash: ReleaseHashSchema.nullable(),
+  effects: z5.array(HarnessChangeEffectSchema).min(1).max(20)
+}).strict().superRefine((edit, context) => {
+  if (edit.operation === "delete") {
+    if (edit.content !== null || edit.contentHash !== null) {
+      context.addIssue({
+        code: "custom",
+        message: "delete edits cannot include replacement content",
+        path: ["content"]
+      });
+    }
+    return;
+  }
+  if (edit.content === null || edit.contentHash === null) {
+    context.addIssue({
+      code: "custom",
+      message: "create and update edits require content and contentHash",
+      path: ["content"]
+    });
+    return;
+  }
+  const expected = contentHash(edit.content);
+  if (edit.contentHash !== expected) {
+    context.addIssue({
+      code: "custom",
+      message: `edit contentHash is ${edit.contentHash}; expected ${expected}`,
+      path: ["contentHash"]
+    });
+  }
+});
+var HarnessWorkspaceRevisionRefSchema = z5.object({
+  workspaceId: ReleaseIdSchema,
+  revision: RevisionSchema,
+  sourceRevision: z5.string().trim().min(1).max(500),
+  channelRevision: RevisionSchema
+}).strict();
+var HarnessOverlaySnapshotRefSchema = z5.object({
+  id: ReleaseIdSchema,
+  revision: RevisionSchema,
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessTurnSnapshotSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessTurnSnapshot.v1"),
+  workspaceId: ReleaseIdSchema,
+  workspaceRevision: RevisionSchema,
+  sourceRevision: z5.string().trim().min(1).max(500),
+  channelName: ReleaseIdSchema,
+  channelRevision: RevisionSchema,
+  harnessRelease: ImmutableReleaseRefSchema,
+  toolCatalogHash: ReleaseHashSchema.nullable().optional(),
+  overlay: HarnessOverlaySnapshotRefSchema.nullable().optional().default(null)
+}).strict();
+var HarnessRunOverlayContentSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessRunOverlay.v1"),
+  id: ReleaseIdSchema,
+  runId: ReleaseIdSchema,
+  baseHarnessRelease: ImmutableReleaseRefSchema,
+  workspace: HarnessWorkspaceRevisionRefSchema,
+  revision: RevisionSchema,
+  status: z5.enum(["active", "frozen", "abandoned"]),
+  edits: z5.array(HarnessOverlayEditSchema).max(1e3),
+  createdAt: ReleaseTimestampSchema,
+  updatedAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema2
+}).strict();
+var HarnessRunOverlaySchema = HarnessRunOverlayContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessProposalEvidenceRefSchema = z5.object({
+  kind: z5.enum([
+    "tool_event",
+    "recovery",
+    "validation",
+    "user_turn",
+    "work_output",
+    "work_receipt"
+  ]),
+  id: ReleaseIdSchema,
+  contentHash: ReleaseHashSchema.nullable()
+}).strict();
+var HarnessValidationPlanItemSchema = z5.object({
+  id: ReleaseIdSchema,
+  kind: z5.enum([
+    "dependency",
+    "schema",
+    "package",
+    "file_render",
+    "skill",
+    "prompt",
+    "business_formula",
+    "targeted_evaluation",
+    "observed_recovery",
+    "memory",
+    "component_activation"
+  ]),
+  description: BoundedTextSchema2,
+  required: z5.boolean()
+}).strict();
+var HarnessImprovementProposalContentSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessImprovementProposal.v1"),
+  id: ReleaseIdSchema,
+  overlay: HarnessOverlaySnapshotRefSchema,
+  baseHarnessRelease: ImmutableReleaseRefSchema,
+  expectedWorkspace: HarnessWorkspaceRevisionRefSchema,
+  requestedScope: z5.enum(["personal", "team", "global"]),
+  route: HarnessImprovementRouteSchema,
+  risk: z5.enum(["low", "review", "restricted"]),
+  effects: z5.array(HarnessChangeEffectSchema).min(1).max(20),
+  evidence: z5.array(HarnessProposalEvidenceRefSchema).min(1).max(1e3),
+  edits: z5.array(HarnessOverlayEditSchema).min(1).max(1e3),
+  validationPlan: z5.array(HarnessValidationPlanItemSchema).min(1).max(100),
+  expectedOutcome: BoundedTextSchema2,
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema2
+}).strict().superRefine((proposal, context) => {
+  const declaredEffects = new Set(proposal.effects);
+  for (const [index, edit] of proposal.edits.entries()) {
+    if (edit.route !== proposal.route) {
+      context.addIssue({
+        code: "custom",
+        message: "every edit route must match the proposal route",
+        path: ["edits", index, "route"]
+      });
+    }
+    for (const effect of edit.effects) {
+      if (!declaredEffects.has(effect)) {
+        context.addIssue({
+          code: "custom",
+          message: `edit effect ${effect} is missing from proposal effects`,
+          path: ["edits", index, "effects"]
+        });
+      }
+    }
+  }
+  if (new Set(proposal.validationPlan.map((item) => item.id)).size !== proposal.validationPlan.length) {
+    context.addIssue({
+      code: "custom",
+      message: "validation plan ids must be unique",
+      path: ["validationPlan"]
+    });
+  }
+});
+var HarnessImprovementProposalSchema = HarnessImprovementProposalContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessTargetedValidationReceiptContentSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessTargetedValidationReceipt.v1"),
+  id: ReleaseIdSchema,
+  proposal: ImmutableReleaseRefSchema,
+  validationId: ReleaseIdSchema,
+  kind: HarnessValidationPlanItemSchema.shape.kind,
+  status: z5.enum(["passed", "failed", "blocked", "skipped"]),
+  summary: BoundedTextSchema2,
+  evidenceRefs: z5.array(HarnessProposalEvidenceRefSchema).max(1e3),
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema2
+}).strict();
+var HarnessTargetedValidationReceiptSchema = HarnessTargetedValidationReceiptContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessAdvanceDecisionSchema = z5.enum([
+  "advanced",
+  "retained",
+  "conflict",
+  "rolled_back"
+]);
+var HarnessAdvanceReceiptContentSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessAdvanceReceipt.v1"),
+  id: ReleaseIdSchema,
+  workspaceId: ReleaseIdSchema,
+  ownerScope: HarnessOwnerScopeSchema,
+  proposal: ImmutableReleaseRefSchema.nullable(),
+  expectedWorkspaceRevision: RevisionSchema,
+  observedWorkspaceRevision: RevisionSchema,
+  previousChannelRevision: RevisionSchema,
+  nextChannelRevision: RevisionSchema,
+  previousRelease: ImmutableReleaseRefSchema.nullable(),
+  nextRelease: ImmutableReleaseRefSchema.nullable(),
+  validationReceipts: z5.array(ImmutableReleaseRefSchema).max(100),
+  decision: HarnessAdvanceDecisionSchema,
+  reason: BoundedTextSchema2,
+  rollbackOf: ImmutableReleaseRefSchema.nullable(),
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema2
+}).strict().superRefine((receipt, context) => {
+  const changed = receipt.nextChannelRevision === receipt.previousChannelRevision + 1;
+  if (["advanced", "rolled_back"].includes(receipt.decision) !== changed) {
+    context.addIssue({
+      code: "custom",
+      message: "only successful advancement or rollback increments the channel revision",
+      path: ["nextChannelRevision"]
+    });
+  }
+  if (receipt.decision === "rolled_back" && receipt.rollbackOf === null) {
+    context.addIssue({
+      code: "custom",
+      message: "rollback receipts require rollbackOf",
+      path: ["rollbackOf"]
+    });
+  }
+  if (receipt.decision !== "rolled_back" && receipt.rollbackOf !== null) {
+    context.addIssue({
+      code: "custom",
+      message: "rollbackOf is only valid for rollback receipts",
+      path: ["rollbackOf"]
+    });
+  }
+});
+var HarnessAdvanceReceiptSchema = HarnessAdvanceReceiptContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessOverlayMergeReceiptContentSchema = z5.object({
+  schemaVersion: z5.literal("openpond.harnessOverlayMergeReceipt.v1"),
+  id: ReleaseIdSchema,
+  workspaceId: ReleaseIdSchema,
+  baseHarnessRelease: ImmutableReleaseRefSchema,
+  leftOverlay: HarnessOverlaySnapshotRefSchema,
+  rightOverlay: HarnessOverlaySnapshotRefSchema,
+  decision: z5.enum(["merged", "conflict"]),
+  mergedOverlay: HarnessOverlaySnapshotRefSchema.nullable(),
+  conflictTargets: z5.array(z5.string().trim().min(1).max(2e3)).max(1e3),
+  requiresRevalidation: z5.literal(true),
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema2
+}).strict().superRefine((receipt, context) => {
+  if (receipt.decision === "merged" !== (receipt.mergedOverlay !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "merged decisions require a merged overlay; conflicts cannot provide one",
+      path: ["mergedOverlay"]
+    });
+  }
+  if (receipt.decision === "conflict" !== receipt.conflictTargets.length > 0) {
+    context.addIssue({
+      code: "custom",
+      message: "conflict decisions require conflict targets and merged decisions cannot include them",
+      path: ["conflictTargets"]
+    });
+  }
+});
+var HarnessOverlayMergeReceiptSchema = HarnessOverlayMergeReceiptContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+
+// ../harness/dist/harness-improvements.js
+var BoundedTextSchema3 = z6.string().trim().min(1).max(1e5);
+var MetadataSchema3 = z6.record(z6.string(), z6.unknown()).default({});
+var ImprovementSafeBoundaryKindSchema = z6.enum([
+  "completed_tool_batch",
+  "before_model_step",
+  "turn_completed",
+  "turn_paused"
+]);
+var ImprovementSafeBoundarySchema = z6.object({
+  kind: ImprovementSafeBoundaryKindSchema,
+  eventSequence: z6.number().int().nonnegative(),
+  occurredAt: ReleaseTimestampSchema
+}).strict();
+var ImprovementEventRefSchema = z6.object({
+  id: ReleaseIdSchema,
+  sequence: z6.number().int().nonnegative().nullable(),
+  contentHash: ReleaseHashSchema
+}).strict();
+var ImprovementObservationKindSchema = z6.enum([
+  "tool_failure",
+  "retry",
+  "recovery",
+  "validation",
+  "user_turn",
+  "reusable_success",
+  "completion_detour"
+]);
+var ImprovementObservationStateSchema = z6.enum([
+  "open",
+  "recovered",
+  "terminal"
+]);
+var ImprovementToolIdentitySchema = z6.object({
+  name: z6.string().trim().min(1).max(500),
+  invocationKey: ReleaseHashSchema
+}).strict();
+var ImprovementObservationContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.improvementObservation.v1"),
+  id: ReleaseIdSchema,
+  runRef: ReleaseIdSchema,
+  turnId: ReleaseIdSchema,
+  harnessRelease: ImmutableReleaseRefSchema,
+  overlay: HarnessOverlaySnapshotRefSchema.nullable(),
+  eventRefs: z6.array(ImprovementEventRefSchema).min(1).max(100),
+  kind: ImprovementObservationKindSchema,
+  state: ImprovementObservationStateSchema,
+  tool: ImprovementToolIdentitySchema.nullable(),
+  deterministicClass: z6.string().trim().min(1).max(500).nullable(),
+  summary: BoundedTextSchema3,
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema3
+}).strict().superRefine((observation, context) => {
+  if (new Set(observation.eventRefs.map((reference) => reference.id)).size !== observation.eventRefs.length) {
+    context.addIssue({
+      code: "custom",
+      message: "observation event refs must be unique",
+      path: ["eventRefs"]
+    });
+  }
+  if (["tool_failure", "retry", "recovery", "completion_detour"].includes(observation.kind) && observation.tool === null) {
+    context.addIssue({
+      code: "custom",
+      message: `${observation.kind} observations require a tool identity`,
+      path: ["tool"]
+    });
+  }
+});
+var ImprovementObservationSchema = ImprovementObservationContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var RefinementTriggerPolicySchema = z6.object({
+  schemaVersion: z6.literal("openpond.refinementTriggerPolicy.v1"),
+  maxEstimatedCostUsd: z6.number().finite().nonnegative(),
+  cooldownMs: z6.number().int().nonnegative(),
+  maxPendingPlans: z6.number().int().min(1).max(100),
+  maxEvidenceEvents: z6.number().int().min(1).max(1e3),
+  maxProposalEdits: z6.number().int().min(1).max(1e3),
+  maxProposalBytes: z6.number().int().min(1).max(1e7)
+}).strict();
+var RefinementTriggerDecisionKindSchema = z6.enum([
+  "no_action",
+  "route_deterministically",
+  "queue_refiner"
+]);
+var RefinementTriggerDecisionContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.refinementTriggerDecision.v1"),
+  id: ReleaseIdSchema,
+  runRef: ReleaseIdSchema,
+  turnId: ReleaseIdSchema,
+  harnessRelease: ImmutableReleaseRefSchema,
+  overlay: HarnessOverlaySnapshotRefSchema.nullable(),
+  observations: z6.array(ImmutableReleaseRefSchema).max(100),
+  decision: RefinementTriggerDecisionKindSchema,
+  deterministicRoute: HarnessImprovementRouteSchema.nullable(),
+  suggestedRoutes: z6.array(HarnessImprovementRouteSchema).max(8),
+  reason: BoundedTextSchema3,
+  deduplicationKey: ReleaseHashSchema,
+  policy: RefinementTriggerPolicySchema,
+  estimatedMaxCostUsd: z6.number().finite().nonnegative(),
+  pendingPlanCount: z6.number().int().nonnegative(),
+  boundary: ImprovementSafeBoundarySchema,
+  cooldownUntil: ReleaseTimestampSchema.nullable(),
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema3
+}).strict().superRefine((trigger, context) => {
+  if (trigger.estimatedMaxCostUsd > trigger.policy.maxEstimatedCostUsd) {
+    context.addIssue({
+      code: "custom",
+      message: "estimated Refiner cost exceeds the trigger policy budget",
+      path: ["estimatedMaxCostUsd"]
+    });
+  }
+  if (trigger.pendingPlanCount > trigger.policy.maxPendingPlans) {
+    context.addIssue({
+      code: "custom",
+      message: "pending plan count exceeds the trigger policy limit",
+      path: ["pendingPlanCount"]
+    });
+  }
+  if (trigger.observations.length > trigger.policy.maxEvidenceEvents) {
+    context.addIssue({
+      code: "custom",
+      message: "trigger observations exceed the evidence budget",
+      path: ["observations"]
+    });
+  }
+  if (trigger.decision === "route_deterministically" && trigger.deterministicRoute === null) {
+    context.addIssue({
+      code: "custom",
+      message: "deterministic decisions require a route",
+      path: ["deterministicRoute"]
+    });
+  }
+  if (trigger.decision !== "route_deterministically" && trigger.deterministicRoute !== null) {
+    context.addIssue({
+      code: "custom",
+      message: "only deterministic decisions may declare a deterministic route",
+      path: ["deterministicRoute"]
+    });
+  }
+  if (trigger.decision === "no_action" && trigger.suggestedRoutes.length > 0) {
+    context.addIssue({
+      code: "custom",
+      message: "no-action decisions cannot suggest routes",
+      path: ["suggestedRoutes"]
+    });
+  }
+  if (trigger.decision !== "no_action" && trigger.observations.length === 0) {
+    context.addIssue({
+      code: "custom",
+      message: "actionable trigger decisions require observations",
+      path: ["observations"]
+    });
+  }
+});
+var RefinementTriggerDecisionSchema = RefinementTriggerDecisionContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var ImprovementRouteAuthoritySchema = z6.enum([
+  "runtime_service",
+  "refiner_model",
+  "human_review",
+  "evaluation_system",
+  "training_system"
+]);
+var ImprovementRouteDecisionContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.improvementRouteDecision.v1"),
+  id: ReleaseIdSchema,
+  trigger: ImmutableReleaseRefSchema,
+  route: HarnessImprovementRouteSchema,
+  authority: ImprovementRouteAuthoritySchema,
+  automatic: z6.boolean(),
+  reason: BoundedTextSchema3,
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema3
+}).strict().superRefine((decision, context) => {
+  if (decision.automatic && ["human_review", "evaluation_system", "training_system"].includes(decision.authority)) {
+    context.addIssue({
+      code: "custom",
+      message: `${decision.authority} routes cannot be marked automatic`,
+      path: ["automatic"]
+    });
+  }
+  if (decision.route === "training" && decision.automatic && decision.authority !== "training_system") {
+    context.addIssue({
+      code: "custom",
+      message: "automatic training routes require training-system authority",
+      path: ["authority"]
+    });
+  }
+});
+var ImprovementRouteDecisionSchema = ImprovementRouteDecisionContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessRefinerOutcomeContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.harnessRefinerOutcome.v1"),
+  id: ReleaseIdSchema,
+  trigger: ImmutableReleaseRefSchema,
+  decision: z6.enum(["no_action", "proposed"]),
+  proposal: ImmutableReleaseRefSchema.nullable(),
+  reason: BoundedTextSchema3,
+  evidenceRefs: z6.array(ImmutableReleaseRefSchema).max(100),
+  estimatedCostUsd: z6.number().finite().nonnegative(),
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema3
+}).strict().superRefine((outcome, context) => {
+  if (outcome.decision === "proposed" !== (outcome.proposal !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "proposed Refiner outcomes require a proposal; no-action outcomes cannot include one",
+      path: ["proposal"]
+    });
+  }
+});
+var HarnessRefinerOutcomeSchema = HarnessRefinerOutcomeContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var ImprovementApplyDecisionSchema = z6.enum([
+  "applied",
+  "retained",
+  "declined",
+  "conflict",
+  "rolled_back"
+]);
+var ImprovementApplyReceiptContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.improvementApplyReceipt.v1"),
+  id: ReleaseIdSchema,
+  proposal: ImmutableReleaseRefSchema,
+  beforeOverlay: HarnessOverlaySnapshotRefSchema,
+  afterOverlay: HarnessOverlaySnapshotRefSchema.nullable(),
+  decision: ImprovementApplyDecisionSchema,
+  boundary: ImprovementSafeBoundarySchema,
+  validationRefs: z6.array(ImmutableReleaseRefSchema).max(100),
+  outcomeEvidenceRefs: z6.array(ImprovementEventRefSchema).max(1e3),
+  rollbackOf: ImmutableReleaseRefSchema.nullable(),
+  createdAt: ReleaseTimestampSchema,
+  metadata: MetadataSchema3
+}).strict().superRefine((receipt, context) => {
+  if (receipt.decision === "applied" !== (receipt.afterOverlay !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "applied receipts require an after-overlay; other decisions cannot include one",
+      path: ["afterOverlay"]
+    });
+  }
+  if (receipt.decision === "rolled_back" !== (receipt.rollbackOf !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "only rollback receipts require rollbackOf",
+      path: ["rollbackOf"]
+    });
+  }
+});
+var ImprovementApplyReceiptSchema = ImprovementApplyReceiptContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+
+// ../harness/dist/models.js
+import { z as z7 } from "zod";
+var ModelRefSchema = z7.object({
+  provider: ReleaseIdSchema,
+  model: ReleaseIdSchema,
+  revision: z7.string().trim().min(1).max(500).nullable().default(null),
+  artifactHash: ReleaseHashSchema.nullable().default(null),
+  tokenizerRevision: z7.string().trim().min(1).max(500).nullable().default(null),
+  chatTemplateHash: ReleaseHashSchema.nullable().default(null)
+}).strict();
+
+// ../harness/dist/refiner.js
+import { z as z9 } from "zod";
+
+// ../harness/dist/refiner-profiles.js
+import { z as z8 } from "zod";
+var RefinerProposalRouteSchema = z8.enum(["memory", "prompt", "skill", "agent"]);
+var RefinerExternalRouteSchema = z8.enum(["runtime", "product", "taskset", "training"]);
+var RefinerReviewInstructionSchema = z8.object({
+  id: z8.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
+  text: z8.string().trim().min(1).max(1e4)
+}).strict();
+var RefinerReviewProfileSchema = z8.object({
+  schemaVersion: z8.literal("openpond.refinerReviewProfile.v1"),
+  id: z8.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
+  version: z8.string().trim().min(1).max(120),
+  name: z8.string().trim().min(1).max(200),
+  objective: z8.string().trim().min(1).max(1e4),
+  instructions: z8.array(RefinerReviewInstructionSchema).max(100),
+  allowedProposalRoutes: z8.array(RefinerProposalRouteSchema).max(4),
+  allowedExternalRoutes: z8.array(RefinerExternalRouteSchema).max(4)
+}).strict().superRefine((profile, context) => {
+  const instructionIds = profile.instructions.map((instruction) => instruction.id);
+  if (new Set(instructionIds).size !== instructionIds.length) {
+    context.addIssue({ code: "custom", message: "instruction IDs must be unique", path: ["instructions"] });
+  }
+  if (new Set(profile.allowedProposalRoutes).size !== profile.allowedProposalRoutes.length) {
+    context.addIssue({ code: "custom", message: "proposal routes must be unique", path: ["allowedProposalRoutes"] });
+  }
+  if (new Set(profile.allowedExternalRoutes).size !== profile.allowedExternalRoutes.length) {
+    context.addIssue({ code: "custom", message: "external routes must be unique", path: ["allowedExternalRoutes"] });
+  }
+});
+var DEFAULT_REFINER_REVIEW_PROFILE = {
+  schemaVersion: "openpond.refinerReviewProfile.v1",
+  id: "openpond.default",
+  version: "1",
+  name: "OpenPond default review",
+  objective: "Find the smallest reusable change that improves future work without learning task-specific facts.",
+  instructions: [],
+  allowedProposalRoutes: ["memory", "prompt", "skill", "agent"],
+  allowedExternalRoutes: ["runtime", "product", "taskset", "training"]
+};
+var RefinerReleaseSchema = z8.object({
+  schemaVersion: z8.literal("openpond.refinerRelease.v1"),
+  id: z8.string().trim().min(1).max(240),
+  coreVersion: z8.string().trim().min(1).max(120),
+  coreHash: ReleaseHashSchema,
+  profile: RefinerReviewProfileSchema,
+  profileHash: ReleaseHashSchema,
+  composedPromptHash: ReleaseHashSchema,
+  createdAt: ReleaseTimestampSchema,
+  contentHash: ReleaseHashSchema
+}).strict();
+var RefinerBindingSchema = z8.object({
+  schemaVersion: z8.literal("openpond.refinerBinding.v1"),
+  channel: z8.literal("active"),
+  revision: z8.number().int().nonnegative(),
+  release: ImmutableReleaseRefSchema,
+  updatedAt: ReleaseTimestampSchema
+}).strict();
+var RefinerTransitionReceiptSchema = z8.object({
+  schemaVersion: z8.literal("openpond.refinerTransitionReceipt.v1"),
+  id: z8.string().trim().min(1).max(240),
+  operation: z8.enum(["initialize", "update", "activate", "rollback"]),
+  bindingChanged: z8.boolean(),
+  previousRelease: ImmutableReleaseRefSchema.nullable(),
+  nextRelease: ImmutableReleaseRefSchema,
+  actor: z8.string().trim().min(1).max(240),
+  reason: z8.string().trim().min(1).max(1e4),
+  authoringSkillHash: ReleaseHashSchema.nullable(),
+  validation: z8.object({ valid: z8.boolean(), messages: z8.array(z8.string().max(2e3)).max(100) }).strict(),
+  createdAt: ReleaseTimestampSchema,
+  contentHash: ReleaseHashSchema
+}).strict();
+function defineReviewProfile(profile) {
+  return RefinerReviewProfileSchema.parse(profile);
+}
+function createRefinerRelease(input) {
+  const profile = RefinerReviewProfileSchema.parse(input.profile);
+  const createdAt = input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const coreHash = contentHash({ coreVersion: input.coreVersion, corePrompt: input.corePrompt });
+  const profileHash = contentHash(profile);
+  const composedPromptHash = contentHash({ coreHash, profile });
+  const releaseWithoutHash = {
+    schemaVersion: "openpond.refinerRelease.v1",
+    id: `refiner-${composedPromptHash.slice(0, 24)}`,
+    coreVersion: input.coreVersion,
+    coreHash,
+    profile,
+    profileHash,
+    composedPromptHash,
+    createdAt
+  };
+  return RefinerReleaseSchema.parse({
+    ...releaseWithoutHash,
+    contentHash: contentHash(releaseWithoutHash)
+  });
+}
+function refinerProfilePrompt(profile) {
+  const parsed = RefinerReviewProfileSchema.parse(profile);
+  return [
+    `Review profile: ${parsed.name} (${parsed.id}@${parsed.version})`,
+    `Objective: ${parsed.objective}`,
+    `Allowed Harness proposal routes: ${parsed.allowedProposalRoutes.join(", ")}.`,
+    `Allowed external routes: ${parsed.allowedExternalRoutes.join(", ")}.`,
+    ...parsed.instructions.map((instruction) => `[${instruction.id}] ${instruction.text}`)
+  ].join("\n");
+}
+function serializeReviewProfile(profile) {
+  return canonicalJson(RefinerReviewProfileSchema.parse(profile));
+}
+
+// ../harness/dist/refiner.js
+var RefinerNoActionDecisionSchema = z9.object({
+  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v1"),
+  decision: z9.literal("no_action"),
+  reason: z9.string().trim().min(1).max(1e4)
+}).strip();
+var RefinerExternalRouteDecisionSchema = z9.object({
+  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v1"),
+  decision: z9.literal("route"),
+  route: z9.enum(["runtime", "product", "taskset", "training"]),
+  summary: z9.string().trim().min(1).max(2e3),
+  expectedOutcome: z9.string().trim().min(1).max(1e4),
+  reason: z9.string().trim().min(1).max(1e4)
+}).strip();
+var RefinerProposalDecisionSchema = z9.object({
+  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v1"),
+  decision: z9.literal("propose"),
+  route: z9.enum(["memory", "prompt", "skill", "agent"]),
+  operation: z9.enum(["create", "update", "delete"]),
+  target: z9.string().trim().min(1).max(2e3),
+  summary: z9.string().trim().min(1).max(2e3),
+  createContent: z9.string().min(1).max(2e4).nullable(),
+  find: z9.string().min(1).max(8e3).nullable(),
+  replace: z9.string().max(8e3).nullable(),
+  expectedOutcome: z9.string().trim().min(1).max(1e4),
+  reason: z9.string().trim().min(1).max(1e4)
+}).strip().superRefine((decision, context) => {
+  if (decision.operation === "create" && (decision.createContent === null || decision.find !== null || decision.replace !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "create proposals require createContent and null find/replace",
+      path: ["createContent"]
+    });
+  }
+  if (decision.operation === "update" && (decision.createContent !== null || decision.find === null || decision.replace === null)) {
+    context.addIssue({
+      code: "custom",
+      message: "update proposals require one exact find/replace edit and null createContent",
+      path: ["find"]
+    });
+  }
+  if (decision.operation === "delete" && (decision.createContent !== null || decision.find !== null || decision.replace !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "delete proposals require null createContent/find/replace",
+      path: ["createContent"]
+    });
+  }
+});
+var LocalHarnessRefinerDecisionSchema = z9.discriminatedUnion("decision", [
+  RefinerNoActionDecisionSchema,
+  RefinerExternalRouteDecisionSchema,
+  RefinerProposalDecisionSchema
+]);
+var LocalHarnessRefinerDecisionV1Schema = LocalHarnessRefinerDecisionSchema;
+var HarnessRefinerEvidenceBasisSchema = z9.object({
+  kind: z9.enum(["single_deterministic", "recurrent_independent"]),
+  supportingEvidenceIds: z9.array(z9.string().trim().min(1).max(2e3)).min(1).max(100),
+  counterevidence: z9.array(z9.string().trim().min(1).max(2e3)).max(20)
+}).strict().superRefine((basis, context) => {
+  if (new Set(basis.supportingEvidenceIds).size !== basis.supportingEvidenceIds.length) {
+    context.addIssue({
+      code: "custom",
+      message: "supporting evidence IDs must be unique",
+      path: ["supportingEvidenceIds"]
+    });
+  }
+  if (basis.kind === "recurrent_independent" && basis.supportingEvidenceIds.length < 2) {
+    context.addIssue({
+      code: "custom",
+      message: "recurrent independent evidence requires at least two supplied incidents",
+      path: ["supportingEvidenceIds"]
+    });
+  }
+});
+var RefinerNoActionDecisionV2Schema = z9.object({
+  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v2"),
+  decision: z9.literal("no_action"),
+  reason: z9.string().trim().min(1).max(1e4)
+}).strict();
+var RefinerExternalRouteDecisionV2Schema = z9.object({
+  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v2"),
+  decision: z9.literal("route"),
+  route: z9.enum(["runtime", "product", "taskset", "training"]),
+  summary: z9.string().trim().min(1).max(2e3),
+  evidenceBasis: HarnessRefinerEvidenceBasisSchema,
+  expectedOutcome: z9.string().trim().min(1).max(1e4),
+  reason: z9.string().trim().min(1).max(1e4)
+}).strict();
+var RefinerProposalDecisionV2Schema = z9.object({
+  schemaVersion: z9.literal("openpond.localHarnessRefinerDecision.v2"),
+  decision: z9.literal("propose"),
+  route: z9.enum(["memory", "prompt", "skill", "agent"]),
+  operation: z9.enum(["create", "update", "delete"]),
+  target: z9.string().trim().min(1).max(2e3),
+  summary: z9.string().trim().min(1).max(2e3),
+  evidenceBasis: HarnessRefinerEvidenceBasisSchema,
+  createContent: z9.string().min(1).max(2e4).nullable(),
+  find: z9.string().min(1).max(8e3).nullable(),
+  replace: z9.string().max(8e3).nullable(),
+  expectedOutcome: z9.string().trim().min(1).max(1e4),
+  reason: z9.string().trim().min(1).max(1e4)
+}).strict().superRefine((decision, context) => {
+  if (decision.operation === "create" && (decision.createContent === null || decision.find !== null || decision.replace !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "create proposals require createContent and null find/replace",
+      path: ["createContent"]
+    });
+  }
+  if (decision.operation === "update" && (decision.createContent !== null || decision.find === null || decision.replace === null)) {
+    context.addIssue({
+      code: "custom",
+      message: "update proposals require one exact find/replace edit and null createContent",
+      path: ["find"]
+    });
+  }
+  if (decision.operation === "delete" && (decision.createContent !== null || decision.find !== null || decision.replace !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "delete proposals require null createContent/find/replace",
+      path: ["createContent"]
+    });
+  }
+});
+var LocalHarnessRefinerDecisionV2Schema = z9.discriminatedUnion("decision", [
+  RefinerNoActionDecisionV2Schema,
+  RefinerExternalRouteDecisionV2Schema,
+  RefinerProposalDecisionV2Schema
+]);
+var LocalHarnessRefinerDecisionAnySchema = z9.union([
+  LocalHarnessRefinerDecisionV1Schema,
+  LocalHarnessRefinerDecisionV2Schema
+]);
+var HarnessRefinerCapabilitiesSchema = z9.object({
+  memory: z9.boolean(),
+  prompt: z9.boolean(),
+  skill: z9.boolean(),
+  agent: z9.boolean()
+}).strict();
+var SourceKindSchema = z9.enum(["memory", "instruction", "skill", "agent"]);
+var RefinerSourceFileSchema = z9.object({
+  path: z9.string().trim().min(1).max(2e3),
+  kind: SourceKindSchema,
+  content: z9.string().max(6e4),
+  loaded: z9.boolean()
+}).strict();
+var RefinerSourceCatalogEntrySchema = z9.object({
+  path: z9.string().trim().min(1).max(2e3),
+  kind: SourceKindSchema,
+  loaded: z9.boolean()
+}).strict();
+var LocalHarnessRefinerEvidenceSchema = z9.object({
+  capabilities: HarnessRefinerCapabilitiesSchema,
+  trigger: z9.record(z9.string(), z9.unknown()),
+  observations: z9.array(z9.record(z9.string(), z9.unknown())).max(20),
+  admissibleEvidenceIds: z9.array(z9.string().trim().min(1).max(2e3)).max(1e4),
+  reviewPacket: z9.object({
+    currentTurn: z9.object({
+      id: z9.string().trim().min(1).max(2e3),
+      status: z9.string().trim().min(1).max(100).nullable(),
+      error: z9.string().max(2100).nullable(),
+      prompt: z9.string().max(8100).nullable(),
+      assistantOutput: z9.string().max(8100).nullable(),
+      assistantOutputLinkCount: z9.number().int().nonnegative()
+    }).strict(),
+    priorConversation: z9.array(z9.object({
+      turnId: z9.string().trim().min(1).max(2e3),
+      status: z9.string().trim().min(1).max(100).nullable(),
+      prompt: z9.string().max(3100).nullable(),
+      assistantOutput: z9.string().max(3100).nullable()
+    }).strict()).max(3),
+    timeline: z9.array(z9.record(z9.string(), z9.unknown())).max(60),
+    artifacts: z9.array(z9.record(z9.string(), z9.unknown())).max(30),
+    artifactDiagnostics: z9.array(z9.record(z9.string(), z9.unknown())).max(20),
+    executionProfile: z9.object({
+      modelRequestCount: z9.number().int().nonnegative(),
+      failedModelRequestCount: z9.number().int().nonnegative(),
+      promptTokens: z9.number().int().nonnegative(),
+      completionTokens: z9.number().int().nonnegative(),
+      totalTokens: z9.number().int().nonnegative(),
+      toolFailureCount: z9.number().int().nonnegative(),
+      retryCount: z9.number().int().nonnegative(),
+      recoveryCount: z9.number().int().nonnegative()
+    }).strict(),
+    priorIncidents: z9.array(z9.record(z9.string(), z9.unknown())).max(3),
+    truncation: z9.object({
+      timelineEventCount: z9.number().int().nonnegative(),
+      includedTimelineEventCount: z9.number().int().nonnegative(),
+      timelineTruncated: z9.boolean()
+    }).strict()
+  }).strict(),
+  runtimeActivation: z9.object({
+    admittedRelease: ImmutableReleaseRefSchema,
+    currentRelease: ImmutableReleaseRefSchema,
+    rebasedOntoCurrent: z9.boolean(),
+    admittedSourceFiles: z9.array(RefinerSourceFileSchema).max(100),
+    admittedSourceCatalog: z9.array(RefinerSourceCatalogEntrySchema).max(1e3)
+  }).strict(),
+  sourceFiles: z9.array(RefinerSourceFileSchema).max(100),
+  sourceCatalog: z9.array(RefinerSourceCatalogEntrySchema).max(1e3),
+  additionalEvidence: z9.unknown().nullable().optional()
+}).strict();
+var REFINER_CORE_VERSION = "openpond.refinerCore.v2";
+var OverlayRefSchema = z9.object({
+  id: z9.string().trim().min(1).max(240),
+  revision: z9.number().int().nonnegative(),
   contentHash: ReleaseHashSchema
 }).strict();
-var HostedHarnessRefinerRequestSchema = z4.object({
-  schemaVersion: z4.literal("openpond.hostedHarnessRefinerRequest.v2"),
-  requestId: z4.string().trim().min(1).max(240),
-  idempotencyKey: z4.string().trim().min(1).max(240),
+var HostedHarnessRefinerRequestSchema = z9.object({
+  schemaVersion: z9.literal("openpond.hostedHarnessRefinerRequest.v2"),
+  requestId: z9.string().trim().min(1).max(240),
+  idempotencyKey: z9.string().trim().min(1).max(240),
   evidenceHash: ReleaseHashSchema,
-  harness: z4.object({
+  harness: z9.object({
     admittedRelease: ImmutableReleaseRefSchema,
     currentRelease: ImmutableReleaseRefSchema,
     overlay: OverlayRefSchema,
-    workspace: z4.object({
-      id: z4.string().trim().min(1).max(240),
-      revision: z4.number().int().nonnegative(),
+    workspace: z9.object({
+      id: z9.string().trim().min(1).max(240),
+      revision: z9.number().int().nonnegative(),
       sourceRevision: ReleaseHashSchema,
-      channelRevision: z4.number().int().nonnegative()
+      channelRevision: z9.number().int().nonnegative()
     }).strict(),
     capabilities: HarnessRefinerCapabilitiesSchema
   }).strict(),
   evidence: LocalHarnessRefinerEvidenceSchema
 }).strict();
-var HostedHarnessRefinerUsageSchema = z4.object({
-  promptTokens: z4.number().int().nonnegative(),
-  completionTokens: z4.number().int().nonnegative(),
-  totalTokens: z4.number().int().nonnegative()
+var HostedHarnessRefinerUsageSchema = z9.object({
+  promptTokens: z9.number().int().nonnegative(),
+  completionTokens: z9.number().int().nonnegative(),
+  totalTokens: z9.number().int().nonnegative()
 }).strict();
-var HostedHarnessRefinerResponseSchema = z4.object({
-  schemaVersion: z4.literal("openpond.hostedHarnessRefinerResponse.v2"),
-  requestId: z4.string().trim().min(1).max(240),
+var HostedHarnessRefinerResponseSchema = z9.object({
+  schemaVersion: z9.literal("openpond.hostedHarnessRefinerResponse.v2"),
+  requestId: z9.string().trim().min(1).max(240),
   evidenceHash: ReleaseHashSchema,
   admittedRelease: ImmutableReleaseRefSchema,
   currentRelease: ImmutableReleaseRefSchema,
   decision: LocalHarnessRefinerDecisionV2Schema,
-  serviceRevision: z4.string().trim().min(1).max(240),
+  serviceRevision: z9.string().trim().min(1).max(240),
   usage: HostedHarnessRefinerUsageSchema
 }).strict();
 
+// ../harness/dist/refinement-lifecycle.js
+import { z as z10 } from "zod";
+var ShortTextSchema = z10.string().trim().min(1).max(2e3);
+var BoundedTextSchema4 = z10.string().trim().min(1).max(1e5);
+var HarnessRefinerOperationSchema = z10.enum(["create", "update", "delete"]);
+var HarnessRefinerInternalRouteSchema = z10.enum([
+  "memory",
+  "prompt",
+  "skill",
+  "agent"
+]);
+var HarnessRefinerExternalRouteSchema = z10.enum([
+  "runtime",
+  "product",
+  "taskset",
+  "training"
+]);
+var HarnessRefinerActivityResultSchema = z10.enum([
+  "no_action",
+  "routed",
+  "applied",
+  "retained",
+  "failed"
+]);
+var HarnessRefinerCritiqueStatusSchema = z10.enum([
+  "not_applicable",
+  "pending",
+  "passed",
+  "rejected",
+  "failed"
+]);
+var HarnessRefinerValidationStatusSchema = z10.enum([
+  "not_applicable",
+  "pending",
+  "passed",
+  "failed"
+]);
+var HarnessRefinerActivityReceiptContentSchema = z10.object({
+  schemaVersion: z10.literal("openpond.harnessRefinerActivityReceipt.v1"),
+  id: ReleaseIdSchema,
+  runRef: ReleaseIdSchema,
+  turnId: ReleaseIdSchema,
+  result: HarnessRefinerActivityResultSchema,
+  decision: z10.enum(["no_action", "route", "propose"]).nullable(),
+  route: HarnessImprovementRouteSchema.nullable(),
+  operation: HarnessRefinerOperationSchema.nullable(),
+  target: z10.string().trim().min(1).max(2e3).nullable(),
+  summary: ShortTextSchema,
+  evidenceBasis: HarnessRefinerEvidenceBasisSchema.nullable(),
+  critiqueStatus: HarnessRefinerCritiqueStatusSchema,
+  validationStatus: HarnessRefinerValidationStatusSchema,
+  trigger: ImmutableReleaseRefSchema,
+  outcome: ImmutableReleaseRefSchema.nullable(),
+  proposal: ImmutableReleaseRefSchema.nullable(),
+  applyReceipt: ImmutableReleaseRefSchema.nullable(),
+  inputHarness: ImmutableReleaseRefSchema,
+  outputHarness: ImmutableReleaseRefSchema.nullable(),
+  createdAt: ReleaseTimestampSchema
+}).strict().superRefine((receipt, context) => {
+  const proposalResult = receipt.result === "applied" || receipt.result === "retained";
+  if (receipt.result === "no_action") {
+    requireFields(context, receipt, {
+      decision: "no_action",
+      route: null,
+      operation: null,
+      target: null,
+      evidenceBasis: null,
+      proposal: null,
+      applyReceipt: null,
+      outputHarness: null,
+      critiqueStatus: "not_applicable",
+      validationStatus: "not_applicable"
+    });
+  } else if (receipt.result === "routed") {
+    if (receipt.decision !== "route" || !HarnessRefinerExternalRouteSchema.safeParse(receipt.route).success || receipt.operation !== null || receipt.target !== null || receipt.evidenceBasis === null || receipt.proposal !== null || receipt.applyReceipt !== null || receipt.outputHarness !== null) {
+      context.addIssue({
+        code: "custom",
+        message: "routed activity requires an external route and evidence basis without proposal state"
+      });
+    }
+    requireFields(context, receipt, {
+      critiqueStatus: "not_applicable",
+      validationStatus: "not_applicable"
+    });
+  } else if (proposalResult) {
+    if (receipt.decision !== "propose" || !HarnessRefinerInternalRouteSchema.safeParse(receipt.route).success || receipt.operation === null || receipt.target === null || receipt.evidenceBasis === null || receipt.proposal === null || receipt.applyReceipt === null) {
+      context.addIssue({
+        code: "custom",
+        message: "applied and retained activity requires complete proposal state"
+      });
+    }
+    if (receipt.result === "applied" && receipt.outputHarness === null) {
+      context.addIssue({
+        code: "custom",
+        message: "applied activity requires the advanced Harness release",
+        path: ["outputHarness"]
+      });
+    }
+    if (receipt.result === "applied" && (receipt.critiqueStatus !== "passed" || receipt.validationStatus !== "passed")) {
+      context.addIssue({
+        code: "custom",
+        message: "applied activity requires passed critique and validation"
+      });
+    }
+    if (receipt.result === "retained" && receipt.outputHarness !== null) {
+      context.addIssue({
+        code: "custom",
+        message: "retained activity cannot report a new Harness release",
+        path: ["outputHarness"]
+      });
+    }
+  } else if (receipt.decision !== null || receipt.route !== null || receipt.operation !== null || receipt.target !== null || receipt.evidenceBasis !== null || receipt.outcome !== null || receipt.proposal !== null || receipt.applyReceipt !== null || receipt.outputHarness !== null) {
+    context.addIssue({
+      code: "custom",
+      message: "failed activity cannot claim a decision, route, proposal, or release transition"
+    });
+  }
+  if (receipt.result !== "failed" && receipt.outcome === null) {
+    context.addIssue({
+      code: "custom",
+      message: "terminal Refiner decisions require an outcome reference",
+      path: ["outcome"]
+    });
+  }
+});
+var HarnessRefinerActivityReceiptSchema = HarnessRefinerActivityReceiptContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessRefinementCandidateStatusSchema = z10.enum([
+  "unresolved",
+  "confirmed",
+  "resolved",
+  "rejected",
+  "expired"
+]);
+var HarnessRefinementCandidateResolutionSchema = z10.object({
+  kind: z10.enum([
+    "applied_change",
+    "later_success",
+    "manual_rejection",
+    "source_revoked",
+    "expired"
+  ]),
+  reason: BoundedTextSchema4,
+  evidenceRefs: z10.array(ImmutableReleaseRefSchema).max(1e3),
+  resolvedAt: ReleaseTimestampSchema
+}).strict();
+var HarnessRefinementCandidateContentSchema = z10.object({
+  schemaVersion: z10.literal("openpond.harnessRefinementCandidate.v1"),
+  id: ReleaseIdSchema,
+  ownerScope: HarnessReviewOwnerScopeSchema,
+  workspaceRef: ReleaseIdSchema,
+  fingerprint: ReleaseHashSchema,
+  recurrenceFamily: z10.string().trim().min(1).max(1e3),
+  statement: BoundedTextSchema4,
+  status: HarnessRefinementCandidateStatusSchema,
+  occurrences: z10.array(HarnessReviewEvidenceRefSchema).max(1e3),
+  counterevidence: z10.array(HarnessReviewEvidenceRefSchema).max(1e3),
+  sourceReviews: z10.array(ImmutableReleaseRefSchema).min(1).max(100),
+  relatedHarnessReleases: z10.array(ImmutableReleaseRefSchema).max(100),
+  firstSeenAt: ReleaseTimestampSchema,
+  lastSeenAt: ReleaseTimestampSchema,
+  lastReviewedAt: ReleaseTimestampSchema,
+  expiresAt: ReleaseTimestampSchema,
+  resolution: HarnessRefinementCandidateResolutionSchema.nullable(),
+  createdAt: ReleaseTimestampSchema,
+  updatedAt: ReleaseTimestampSchema
+}).strict().superRefine((candidate, context) => {
+  requireUniqueRefs(context, candidate.occurrences, "occurrences");
+  requireUniqueRefs(context, candidate.counterevidence, "counterevidence");
+  requireUniqueRefs(context, candidate.sourceReviews, "sourceReviews");
+  requireUniqueRefs(context, candidate.relatedHarnessReleases, "relatedHarnessReleases");
+  const supportingKeys = new Set(candidate.occurrences.map((item) => item.occurrenceKey));
+  if (candidate.counterevidence.some((item) => supportingKeys.has(item.occurrenceKey))) {
+    context.addIssue({
+      code: "custom",
+      message: "supporting occurrences and counterevidence must be disjoint",
+      path: ["counterevidence"]
+    });
+  }
+  const actionable = candidate.status === "unresolved" || candidate.status === "confirmed";
+  if (actionable && candidate.occurrences.length === 0) {
+    context.addIssue({
+      code: "custom",
+      message: "actionable candidates require at least one supporting occurrence",
+      path: ["occurrences"]
+    });
+  }
+  if (actionable && [...candidate.occurrences, ...candidate.counterevidence].some((item) => item.sourcePolicy.state !== "authorized")) {
+    context.addIssue({
+      code: "custom",
+      message: "actionable candidates may contain only currently authorized evidence",
+      path: ["occurrences"]
+    });
+  }
+  if (actionable !== (candidate.resolution === null)) {
+    context.addIssue({
+      code: "custom",
+      message: "only resolved, rejected, or expired candidates require a resolution",
+      path: ["resolution"]
+    });
+  }
+  if (candidate.status === "expired" && candidate.resolution?.kind !== "expired") {
+    context.addIssue({
+      code: "custom",
+      message: "expired candidates require an expired resolution",
+      path: ["resolution", "kind"]
+    });
+  }
+  if (candidate.status === "rejected" && candidate.resolution && !["manual_rejection", "source_revoked"].includes(candidate.resolution.kind)) {
+    context.addIssue({
+      code: "custom",
+      message: "rejected candidates require a rejection or revocation resolution",
+      path: ["resolution", "kind"]
+    });
+  }
+  if (candidate.status === "resolved" && candidate.resolution && !["applied_change", "later_success"].includes(candidate.resolution.kind)) {
+    context.addIssue({
+      code: "custom",
+      message: "resolved candidates require applied-change or later-success evidence",
+      path: ["resolution", "kind"]
+    });
+  }
+  requireChronology(context, candidate);
+});
+var HarnessRefinementCandidateSchema = HarnessRefinementCandidateContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessRefinementCandidateLifecycleDecisionSchema = z10.enum([
+  "created",
+  "merged",
+  "rejected",
+  "expired",
+  "reopened",
+  "resolved"
+]);
+var HarnessRefinementCandidateLifecycleReceiptContentSchema = z10.object({
+  schemaVersion: z10.literal("openpond.harnessRefinementCandidateLifecycleReceipt.v1"),
+  id: ReleaseIdSchema,
+  candidateId: ReleaseIdSchema,
+  decision: HarnessRefinementCandidateLifecycleDecisionSchema,
+  beforeCandidate: ImmutableReleaseRefSchema.nullable(),
+  afterCandidate: ImmutableReleaseRefSchema,
+  review: ImmutableReleaseRefSchema,
+  addedEvidence: z10.array(HarnessReviewEvidenceRefSchema).max(1e3),
+  removedEvidence: z10.array(ImmutableReleaseRefSchema).max(1e3),
+  reason: BoundedTextSchema4,
+  createdAt: ReleaseTimestampSchema
+}).strict().superRefine((receipt, context) => {
+  if (receipt.decision === "created" !== (receipt.beforeCandidate === null)) {
+    context.addIssue({
+      code: "custom",
+      message: "only candidate creation omits the previous candidate reference",
+      path: ["beforeCandidate"]
+    });
+  }
+  if (receipt.beforeCandidate && receipt.beforeCandidate.contentHash === receipt.afterCandidate.contentHash) {
+    context.addIssue({
+      code: "custom",
+      message: "candidate lifecycle transitions must change candidate content",
+      path: ["afterCandidate"]
+    });
+  }
+  if (["created", "reopened"].includes(receipt.decision) && receipt.addedEvidence.length === 0) {
+    context.addIssue({
+      code: "custom",
+      message: `${receipt.decision} candidate transitions require added evidence`,
+      path: ["addedEvidence"]
+    });
+  }
+  if (receipt.addedEvidence.some((item) => item.sourcePolicy.state !== "authorized")) {
+    context.addIssue({
+      code: "custom",
+      message: "candidate transitions may add only authorized evidence",
+      path: ["addedEvidence"]
+    });
+  }
+  requireUniqueRefs(context, receipt.addedEvidence, "addedEvidence");
+  requireUniqueRefs(context, receipt.removedEvidence, "removedEvidence");
+  const removedKeys = new Set(receipt.removedEvidence.map((item) => refKey(item)));
+  if (receipt.addedEvidence.some((item) => removedKeys.has(refKey(item.evidence)))) {
+    context.addIssue({
+      code: "custom",
+      message: "candidate lifecycle evidence cannot be added and removed together",
+      path: ["removedEvidence"]
+    });
+  }
+});
+var HarnessRefinementCandidateLifecycleReceiptSchema = HarnessRefinementCandidateLifecycleReceiptContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+var HarnessCrossRunRefinementRequestContentSchema = z10.object({
+  schemaVersion: z10.literal("openpond.harnessCrossRunRefinementRequest.v1"),
+  id: ReleaseIdSchema,
+  ownerScope: HarnessReviewOwnerScopeSchema,
+  workspaceRef: ReleaseIdSchema,
+  candidate: ImmutableReleaseRefSchema,
+  candidateFingerprint: ReleaseHashSchema,
+  review: ImmutableReleaseRefSchema,
+  admittedHarness: ImmutableReleaseRefSchema,
+  evidence: z10.array(HarnessReviewEvidenceRefSchema).min(1).max(1e3),
+  capabilities: HarnessRefinerCapabilitiesSchema,
+  deduplicationKey: ReleaseHashSchema,
+  createdAt: ReleaseTimestampSchema
+}).strict().superRefine((request, context) => {
+  if (request.evidence.some((item) => item.sourcePolicy.state !== "authorized")) {
+    context.addIssue({
+      code: "custom",
+      message: "cross-run refinement requires currently authorized evidence",
+      path: ["evidence"]
+    });
+  }
+  requireUniqueRefs(context, request.evidence, "evidence");
+  if (!Object.values(request.capabilities).some(Boolean)) {
+    context.addIssue({
+      code: "custom",
+      message: "cross-run refinement requires at least one available Harness capability",
+      path: ["capabilities"]
+    });
+  }
+  const expected = harnessCrossRunRefinementDeduplicationKey(request);
+  if (request.deduplicationKey !== expected) {
+    context.addIssue({
+      code: "custom",
+      message: `cross-run refinement deduplicationKey is ${request.deduplicationKey}; expected ${expected}`,
+      path: ["deduplicationKey"]
+    });
+  }
+});
+var HarnessCrossRunRefinementRequestSchema = HarnessCrossRunRefinementRequestContentSchema.extend({
+  contentHash: ReleaseHashSchema
+}).strict();
+function harnessCrossRunRefinementDeduplicationKey(input) {
+  return contentHash({
+    schemaVersion: "openpond.harnessCrossRunRefinementIdentity.v1",
+    workspaceRef: input.workspaceRef,
+    candidateFingerprint: input.candidateFingerprint,
+    admittedHarness: input.admittedHarness
+  });
+}
+function requireFields(context, value, expected) {
+  for (const [key, expectedValue] of Object.entries(expected)) {
+    if (value[key] === expectedValue)
+      continue;
+    context.addIssue({
+      code: "custom",
+      message: `${key} must be ${String(expectedValue)}`,
+      path: [key]
+    });
+  }
+}
+function requireUniqueRefs(context, values, path) {
+  const keys = values.map((value) => refKey(value));
+  if (new Set(keys).size === keys.length)
+    return;
+  context.addIssue({
+    code: "custom",
+    message: `${path} references must be unique`,
+    path: [path]
+  });
+}
+function refKey(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return String(value);
+  const record = value;
+  if (typeof record.occurrenceKey === "string")
+    return record.occurrenceKey;
+  const nested = record.evidence;
+  if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+    const evidence = nested;
+    return `${String(evidence.id)}:${String(evidence.contentHash)}`;
+  }
+  return `${String(record.id)}:${String(record.contentHash)}`;
+}
+function requireChronology(context, candidate) {
+  const chronology = [
+    ["firstSeenAt", candidate.firstSeenAt],
+    ["lastSeenAt", candidate.lastSeenAt],
+    ["lastReviewedAt", candidate.lastReviewedAt],
+    ["updatedAt", candidate.updatedAt],
+    ["expiresAt", candidate.expiresAt]
+  ];
+  for (let index = 1; index < chronology.length; index += 1) {
+    const previous = chronology[index - 1];
+    const current = chronology[index];
+    if (Date.parse(previous[1]) <= Date.parse(current[1]))
+      continue;
+    context.addIssue({
+      code: "custom",
+      message: `${current[0]} must not precede ${previous[0]}`,
+      path: [current[0]]
+    });
+  }
+  if (Date.parse(candidate.createdAt) > Date.parse(candidate.updatedAt)) {
+    context.addIssue({
+      code: "custom",
+      message: "updatedAt must not precede createdAt",
+      path: ["updatedAt"]
+    });
+  }
+}
+
+// src/learning-credentials.ts
+import { LearningRevisionRefSchema } from "@openpond/evals/learning";
+import { TaskSplitSchema } from "@openpond/evals/tasksets";
+var LearningSourceCredentialSchema = z11.object({
+  id: ReleaseIdSchema,
+  scope: ReleaseIdSchema,
+  sourceId: ReleaseIdSchema,
+  name: z11.string().trim().min(1).max(100),
+  keyPrefix: z11.string().min(1).max(100),
+  createdAt: z11.iso.datetime(),
+  expiresAt: z11.iso.datetime(),
+  revokedAt: z11.iso.datetime().nullable()
+}).strict();
+var LearningSourceCredentialSecretSchema = z11.string().regex(/^opk_key_[A-Za-z0-9]{16}_[A-Za-z0-9]{48}$/);
+var LearningSourceCredentialRequestSchema = z11.discriminatedUnion("action", [
+  z11.object({ action: z11.literal("create"), scope: ReleaseIdSchema, sourceId: ReleaseIdSchema, name: z11.string().trim().min(1).max(100), expiresAt: z11.iso.datetime(), operationId: ReleaseIdSchema, apiKey: LearningSourceCredentialSecretSchema }).strict(),
+  z11.object({ action: z11.literal("list"), scope: ReleaseIdSchema, sourceId: ReleaseIdSchema, afterId: ReleaseIdSchema.optional(), limit: z11.number().int().min(1).max(100).default(30) }).strict(),
+  z11.object({ action: z11.literal("revoke"), scope: ReleaseIdSchema, sourceId: ReleaseIdSchema, id: ReleaseIdSchema }).strict()
+]);
+var LearningSourceCredentialCreatedSchema = z11.object({ credential: LearningSourceCredentialSchema, apiKey: LearningSourceCredentialSecretSchema }).strict();
+var LearningSourceCredentialPageSchema = z11.object({ items: z11.array(LearningSourceCredentialSchema).max(100), nextCursor: ReleaseIdSchema.nullable() }).strict();
+var LearningSourceConfigurationRequestSchema = z11.object({ scope: ReleaseIdSchema, sourceId: ReleaseIdSchema }).strict();
+var LearningSourceConfigurationSchema = z11.object({
+  scope: ReleaseIdSchema,
+  source: LearningRevisionRefSchema,
+  taskDefinition: LearningRevisionRefSchema,
+  enabled: z11.boolean(),
+  allowedSplits: z11.array(TaskSplitSchema).min(1).max(4)
+}).strict();
+function createSourceCredentialRequest(input) {
+  return { ...input, operationId: crypto.randomUUID(), apiKey: `opk_key_${randomToken(16)}_${randomToken(48)}` };
+}
+function randomToken(length) {
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let value = "";
+  while (value.length < length) {
+    for (const byte of crypto.getRandomValues(new Uint8Array(64))) {
+      if (byte < 248) value += alphabet[byte % 62];
+      if (value.length === length) return value;
+    }
+  }
+  return value;
+}
+function assertLearningCredentialExpiry(expiresAt, now) {
+  const expires = Date.parse(z11.iso.datetime().parse(expiresAt));
+  if (expires <= now.getTime() || expires > now.getTime() + 90 * 24 * 60 * 60 * 1e3) throw new Error("Source credentials must expire within 90 days.");
+}
+
+// src/learning.ts
+__reExport(learning_exports, learning_star);
+__reExport(learning_exports, rewards_star);
+import * as learning_star from "@openpond/evals/learning";
+import * as rewards_star from "@openpond/evals/rewards";
+var LearningBatchPublicationSchema = z12.object({
+  batchId: z12.string().trim().min(1).max(500),
+  modelProjectId: z12.string().trim().min(1).max(500)
+}).strict();
+var LearningBatchPublicationResultSchema = z12.object({
+  batchId: z12.string().min(1),
+  projectId: z12.string().min(1),
+  tasksetId: z12.string().min(1),
+  releaseId: z12.string().min(1),
+  revision: z12.number().int().positive(),
+  contentHash: z12.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var OpenPondLearningError = class extends Error {
+  constructor(status, code, message, details) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.name = "OpenPondLearningError";
+  }
+  status;
+  code;
+  details;
+};
+var OpenPondLearningClient = class {
+  #options;
+  constructor(options) {
+    if (!options.apiKey.trim() || !options.scope.trim()) throw new Error("Learning API key and scope are required.");
+    const url = new URL(options.baseUrl);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) throw new Error("Learning base URL must be an HTTP(S) endpoint without credentials, query, or fragment.");
+    this.#options = { ...options, baseUrl: url.toString().replace(/\/+$/, "") };
+  }
+  async command(command, options = {}) {
+    assertLearningRequestJson(command);
+    const request = LearningCommandRequestSchema.parse({ scope: this.#options.scope, command });
+    const result = LearningOperationResultSchema.parse(await this.#request("commands", request, options));
+    if (result.operationId !== command.operationId) throw new OpenPondLearningError(502, "operation_identity_mismatch", "Learning response did not match the submitted operation.", null);
+    return result;
+  }
+  submitExample(example, options = {}) {
+    return this.command({ action: "submit_example", operationId: example.idempotencyKey, example }, options);
+  }
+  submitFeedback(feedback, options = {}) {
+    return this.command({ action: "submit_feedback", operationId: feedback.idempotencyKey, feedback }, options);
+  }
+  async get(kind, id, revision, options = {}) {
+    const request = LearningReadRequestSchema.parse({ action: "get", scope: this.#options.scope, kind, id, ...revision === void 0 ? {} : { revision } });
+    return learningResourceSchemas[kind].parse(await this.#request("read", request, options));
+  }
+  async inspectEvidence(evidence, options = {}) {
+    const request = LearningReadRequestSchema.parse({ action: "inspect_evidence", scope: this.#options.scope, evidence });
+    const result = TaskEvidenceInspectionResultSchema.parse(await this.#request("read", request, options));
+    if (!sameLearningRef(result.evidence, evidence)) throw new OpenPondLearningError(502, "evidence_identity_mismatch", "Inspection did not match the requested evidence release.", null);
+    return result;
+  }
+  /** Prepare once with createSourceCredentialRequest and reuse it for retries. */
+  async createSourceCredential(input, options = {}) {
+    const request = LearningSourceCredentialRequestSchema.parse({ ...input, action: "create", scope: this.#options.scope });
+    const result = LearningSourceCredentialCreatedSchema.parse(await this.#request("credentials", request, options));
+    this.#assertCredentialScope(result.credential, input.sourceId);
+    if (result.apiKey !== input.apiKey || !input.apiKey.startsWith(`${result.credential.keyPrefix}_`)) throw new OpenPondLearningError(502, "credential_identity_mismatch", "Credential response did not match the prepared credential.", null);
+    return result;
+  }
+  async listSourceCredentials(sourceId, query = {}, options = {}) {
+    const request = LearningSourceCredentialRequestSchema.parse({ ...query, action: "list", scope: this.#options.scope, sourceId });
+    const result = LearningSourceCredentialPageSchema.parse(await this.#request("credentials", request, options));
+    if (result.items.length > (query.limit ?? 30)) throw new OpenPondLearningError(502, "credential_page_invalid", "Credential response exceeded the requested page size.", null);
+    for (const item of result.items) this.#assertCredentialScope(item, sourceId);
+    return result;
+  }
+  async revokeSourceCredential(sourceId, id, options = {}) {
+    const request = LearningSourceCredentialRequestSchema.parse({ action: "revoke", scope: this.#options.scope, sourceId, id });
+    const result = LearningSourceCredentialSchema.parse(await this.#request("credentials", request, options));
+    this.#assertCredentialScope(result, sourceId);
+    if (result.id !== id || result.revokedAt === null) throw new OpenPondLearningError(502, "credential_revocation_mismatch", "Credential revocation did not match the requested credential.", null);
+    return result;
+  }
+  async sourceConfiguration(sourceId, options = {}) {
+    const request = LearningSourceConfigurationRequestSchema.parse({ scope: this.#options.scope, sourceId });
+    const result = LearningSourceConfigurationSchema.parse(await this.#request("source-config", request, options));
+    if (result.scope !== this.#options.scope || result.source.id !== sourceId) throw new OpenPondLearningError(502, "source_identity_mismatch", "Source configuration did not match the requested source.", null);
+    return result;
+  }
+  #assertCredentialScope(value, sourceId) {
+    if (value.scope !== this.#options.scope || value.sourceId !== sourceId) throw new OpenPondLearningError(502, "credential_scope_mismatch", "Credential response did not match the requested source.", null);
+  }
+  async list(kind, query = {}, options = {}) {
+    const request = LearningReadRequestSchema.parse({ action: "list", scope: this.#options.scope, kind, ...query });
+    return z12.object({ items: z12.array(learningResourceSchemas[kind]).max(100), nextCursor: z12.string().nullable() }).strict().parse(await this.#request("read", request, options));
+  }
+  /** Hosted publication only: stores an immutable package and attaches it, without starting training. */
+  async publishBatch(input, options = {}) {
+    const request = LearningBatchPublicationSchema.parse(input);
+    const result = LearningBatchPublicationResultSchema.parse(await this.#request("publish-batch", { ...request, scope: this.#options.scope }, options));
+    if (result.batchId !== request.batchId) throw new OpenPondLearningError(502, "batch_identity_mismatch", "Published batch response did not match the requested batch.", null);
+    return result;
+  }
+  async #request(endpoint, body, options) {
+    assertBoundedTaskJson(body, 16777216);
+    const response = await (this.#options.fetch ?? globalThis.fetch)(`${this.#options.baseUrl}/v1/learning/${endpoint}`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.#options.apiKey}`, "Content-Type": "application/json", Accept: "application/json", "X-OpenPond-Team-Id": this.#options.scope },
+      body: JSON.stringify(body),
+      signal: options.signal,
+      redirect: "error"
+    });
+    const payload = await readBoundedLearningResponse(response);
+    if (!response.ok) {
+      const error = z12.object({ code: z12.string().optional(), error: z12.string().optional() }).passthrough().safeParse(payload);
+      throw new OpenPondLearningError(response.status, error.success ? error.data.code ?? "learning_request_failed" : "learning_request_failed", error.success ? error.data.error ?? `Learning request failed (${response.status}).` : `Learning request failed (${response.status}).`, payload);
+    }
+    return payload;
+  }
+};
+async function readBoundedLearningResponse(response) {
+  const maximumBytes = 16777216;
+  const reader = response.body?.getReader();
+  if (!reader) throw new OpenPondLearningError(response.status, "empty_response", "Learning response was empty.", null);
+  const decoder = new TextDecoder();
+  let bytes = 0;
+  let text = "";
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done) break;
+      bytes += next.value.byteLength;
+      if (bytes > maximumBytes) throw new OpenPondLearningError(response.status, "response_too_large", "Learning response exceeded 16 MiB; request a smaller page.", null);
+      text += decoder.decode(next.value, { stream: true });
+    }
+    text += decoder.decode();
+    const value = JSON.parse(text);
+    assertBoundedTaskJson(value, maximumBytes);
+    return value;
+  } finally {
+    await reader.cancel();
+    reader.releaseLock();
+  }
+}
+
 // ../cloud/dist/sandbox/types/runtime-profiles.js
 var SANDBOX_RUNTIME_PROFILE_IDS = [
   "openpond-generic-v1",