openpond-sdk 0.0.11 → 0.0.13

package/dist/index.js

@@ -57,6 +57,7 @@ function createSandboxAgentNamespace(client) {
     sourceDeployPlan: (agentId, input) => client.getAgentSourceDeployPlan(agentId, input),
     manifestSnapshots: (agentId, input) => client.listAgentManifestSnapshots(agentId, input),
     requestSourceChecks: (agentId, input) => client.requestAgentSourceChecks(agentId, input),
+    configureSourceSetup: (agentId, input) => client.configureAgentSourceSetup(agentId, input),
     publishSource: (agentId, input) => client.publishAgentSource(agentId, input)
   };
 }
@@ -498,25 +499,6 @@ function asyncRequestHeaders(options = {}) {
   return options.async || options.respondAsync ? { Prefer: "respond-async" } : void 0;
 }
 
-// ../cloud/dist/api/vercel-protection.js
-var VERCEL_PROTECTION_BYPASS_HEADER = "x-vercel-protection-bypass";
-function withVercelProtectionBypass(requestUrl, inputHeaders, env = typeof process === "undefined" ? {} : process.env) {
-  const headers = new Headers(inputHeaders);
-  const secret = env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();
-  if (!secret || !isOpenPondStagingUrl(requestUrl))
-    return headers;
-  headers.set(VERCEL_PROTECTION_BYPASS_HEADER, secret);
-  return headers;
-}
-function isOpenPondStagingUrl(requestUrl) {
-  try {
-    const hostname = new URL(requestUrl).hostname.toLowerCase();
-    return hostname === "staging.openpond.ai" || hostname === "staging-api.openpond.ai" || hostname.endsWith(".staging-api.openpond.ai");
-  } catch {
-    return false;
-  }
-}
-
 // ../cloud/dist/api/core.js
 var DEFAULT_API_TIMEOUT_MS = 3e4;
 var DEFAULT_API_RESPONSE_BYTES = 8 * 1024 * 1024;
@@ -559,7 +541,7 @@ var OpenPondApiError = class extends Error {
 async function apiFetch(baseUrl, token, requestPath, options = {}) {
   const { timeoutMs = DEFAULT_API_TIMEOUT_MS, maxResponseBytes = DEFAULT_API_RESPONSE_BYTES, ...init } = options;
   const requestUrl = `${baseUrl}${requestPath}`;
-  const headers = withVercelProtectionBypass(requestUrl, init.headers);
+  const headers = new Headers(init.headers);
   headers.set("Content-Type", "application/json");
   const apiKey = process.env.OPENPOND_API_KEY;
   const trimmedToken = token?.trim() || "";
@@ -755,7 +737,7 @@ function apiRootUrlFromSandboxApiUrl(sandboxApiUrl) {
   return sandboxApiUrl.slice(0, -suffix.length);
 }
 function isOpenPondHostedApiHost(hostname) {
-  return hostname === "api.openpond.ai" || hostname === "staging-api.openpond.ai" || hostname.startsWith("api") && hostname.endsWith(".openpond.ai");
+  return hostname === "api.openpond.ai" || hostname.startsWith("api") && hostname.endsWith(".openpond.ai");
 }
 
 // ../cloud/dist/sandbox/sandbox-instance-client.js
@@ -1308,6 +1290,11 @@ var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
       timeoutMs: 15 * 60 * 1e3
     });
   }
+  configureAgentSourceSetup(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
+    return this.requestApiRoot(`/agents/${encodeURIComponent(agentId)}/source/setup?${query.toString()}`, { method: "POST", body: JSON.stringify(body) });
+  }
   publishAgentSource(agentId, input) {
     const query = new URLSearchParams({ teamId: input.teamId });
     const { teamId: _teamId, ...body } = input;
@@ -1773,14 +1760,14 @@ function requireToken(value) {
     throw new Error("OpenPond API key is required");
   return trimmed;
 }
-function hostedHeaders(requestUrl, token, accept, requestId) {
+function hostedHeaders(token, accept, requestId) {
   const headers = new Headers();
   headers.set("Authorization", `Bearer ${requireToken(token)}`);
   headers.set("Content-Type", "application/json");
   headers.set("Accept", accept);
   headers.set("x-openpond-client", "openpond-code");
   headers.set("x-openpond-request-id", requestId || randomUUID());
-  return withVercelProtectionBypass(requestUrl, headers);
+  return headers;
 }
 async function readError(response) {
   const text = await response.text().catch(() => "");
@@ -1826,7 +1813,7 @@ async function listOpChatModels(options) {
   const requestUrl = `${apiBaseUrl}/models`;
   const response = await fetch(requestUrl, {
     method: "GET",
-    headers: hostedHeaders(requestUrl, options.token, "application/json"),
+    headers: hostedHeaders(options.token, "application/json"),
     signal: options.signal
   });
   if (!response.ok) {
@@ -1839,7 +1826,7 @@ async function getOpChatModel(options) {
   const requestUrl = `${apiBaseUrl}/models/${encodeURIComponent(options.model)}`;
   const response = await fetch(requestUrl, {
     method: "GET",
-    headers: hostedHeaders(requestUrl, options.token, "application/json"),
+    headers: hostedHeaders(options.token, "application/json"),
     signal: options.signal
   });
   if (!response.ok) {
@@ -1852,7 +1839,7 @@ async function listOpChatProviders(options) {
   const requestUrl = `${apiBaseUrl}/providers`;
   const response = await fetch(requestUrl, {
     method: "GET",
-    headers: hostedHeaders(requestUrl, options.token, "application/json"),
+    headers: hostedHeaders(options.token, "application/json"),
     signal: options.signal
   });
   if (!response.ok) {
@@ -1865,7 +1852,7 @@ async function getOpChatProvider(options) {
   const requestUrl = `${apiBaseUrl}/providers/${encodeURIComponent(options.provider)}`;
   const response = await fetch(requestUrl, {
     method: "GET",
-    headers: hostedHeaders(requestUrl, options.token, "application/json"),
+    headers: hostedHeaders(options.token, "application/json"),
     signal: options.signal
   });
   if (!response.ok) {
@@ -1878,7 +1865,7 @@ async function sendHostedChatTurn(options) {
   const requestUrl = `${apiBaseUrl}/chat/completions`;
   const response = await fetch(requestUrl, {
     method: "POST",
-    headers: hostedHeaders(requestUrl, options.token, "application/json", options.requestId),
+    headers: hostedHeaders(options.token, "application/json", options.requestId),
     body: JSON.stringify(buildHostedChatBody(options, false)),
     signal: options.signal
   });
@@ -1926,7 +1913,7 @@ async function* streamHostedChatTurn(options) {
   const requestUrl = `${apiBaseUrl}/chat/completions`;
   const response = await fetch(requestUrl, {
     method: "POST",
-    headers: hostedHeaders(requestUrl, options.token, "text/event-stream", options.requestId),
+    headers: hostedHeaders(options.token, "text/event-stream", options.requestId),
     body: JSON.stringify(buildHostedChatBody(options, true)),
     signal: options.signal
   });
@@ -2700,6 +2687,561 @@ function requiredId(value, label) {
   return normalized;
 }
 
+// ../harness/dist/refiner.js
+import { z as z3 } from "zod";
+
+// ../harness/dist/common.js
+import { z } from "zod";
+
+// ../harness/dist/sha256.js
+var INITIAL_STATE = new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+var ROUND_CONSTANTS = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function sha256Hex(value) {
+  const bytes = typeof value === "string" ? new TextEncoder().encode(value) : value;
+  const paddedLength = Math.ceil((bytes.byteLength + 9) / 64) * 64;
+  const padded = new Uint8Array(paddedLength);
+  padded.set(bytes);
+  padded[bytes.byteLength] = 128;
+  const bitLength = bytes.byteLength * 8;
+  const view = new DataView(padded.buffer);
+  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296), false);
+  view.setUint32(paddedLength - 4, bitLength >>> 0, false);
+  const state = new Uint32Array(INITIAL_STATE);
+  const words = new Uint32Array(64);
+  for (let offset = 0; offset < paddedLength; offset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      words[index] = view.getUint32(offset + index * 4, false);
+    }
+    for (let index = 16; index < 64; index += 1) {
+      const previous = words[index - 15];
+      const recent = words[index - 2];
+      const sigma0 = rotateRight(previous, 7) ^ rotateRight(previous, 18) ^ previous >>> 3;
+      const sigma1 = rotateRight(recent, 17) ^ rotateRight(recent, 19) ^ recent >>> 10;
+      words[index] = words[index - 16] + sigma0 + words[index - 7] + sigma1 >>> 0;
+    }
+    let a = state[0];
+    let b = state[1];
+    let c = state[2];
+    let d = state[3];
+    let e = state[4];
+    let f = state[5];
+    let g = state[6];
+    let h = state[7];
+    for (let index = 0; index < 64; index += 1) {
+      const choice = e & f ^ ~e & g;
+      const majority = a & b ^ a & c ^ b & c;
+      const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+      const first = h + sum1 + choice + ROUND_CONSTANTS[index] + words[index] >>> 0;
+      const second = sum0 + majority >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + first >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = first + second >>> 0;
+    }
+    state[0] = state[0] + a >>> 0;
+    state[1] = state[1] + b >>> 0;
+    state[2] = state[2] + c >>> 0;
+    state[3] = state[3] + d >>> 0;
+    state[4] = state[4] + e >>> 0;
+    state[5] = state[5] + f >>> 0;
+    state[6] = state[6] + g >>> 0;
+    state[7] = state[7] + h >>> 0;
+  }
+  return Array.from(state, (word) => word.toString(16).padStart(8, "0")).join("");
+}
+function rotateRight(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+
+// ../harness/dist/common.js
+var MAX_PORTABLE_PATH_BYTES = 2e3;
+var MAX_PORTABLE_ASSET_BYTES = 25e7;
+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 = z.object({
+  id: ReleaseIdSchema,
+  path: z.string().trim().min(1).max(MAX_PORTABLE_PATH_BYTES).refine(safeRelativePath),
+  contentHash: ReleaseHashSchema,
+  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 = z.object({
+  id: ReleaseIdSchema,
+  contentHash: ReleaseHashSchema,
+  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 = z.enum([
+  "policy_failure",
+  "grader_failure",
+  "environment_failure",
+  "infrastructure_failure",
+  "timeout",
+  "cancelled"
+]);
+function canonicalJson(value) {
+  return `${JSON.stringify(sortValue(value), null, 2)}
+`;
+}
+function sha256(value) {
+  return sha256Hex(value);
+}
+function contentHash(value) {
+  return sha256(canonicalJson(value));
+}
+function safeRelativePath(value) {
+  const normalized = value.replaceAll("\\", "/");
+  if (!normalized || normalized.startsWith("/") || normalized.includes("\0"))
+    return false;
+  return !normalized.split("/").some((part) => !part || part === "." || part === "..");
+}
+function sortValue(value) {
+  if (Array.isArray(value))
+    return value.map(sortValue);
+  if (!value || typeof value !== "object")
+    return 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 z2 } from "zod";
+var RefinerProposalRouteSchema = z2.enum(["memory", "prompt", "skill", "agent"]);
+var RefinerExternalRouteSchema = z2.enum(["runtime", "product", "taskset", "training"]);
+var RefinerReviewInstructionSchema = z2.object({
+  id: z2.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
+  text: z2.string().trim().min(1).max(1e4)
+}).strict();
+var RefinerReviewProfileSchema = z2.object({
+  schemaVersion: z2.literal("openpond.refinerReviewProfile.v1"),
+  id: z2.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
+  version: z2.string().trim().min(1).max(120),
+  name: z2.string().trim().min(1).max(200),
+  objective: z2.string().trim().min(1).max(1e4),
+  instructions: z2.array(RefinerReviewInstructionSchema).max(100),
+  allowedProposalRoutes: z2.array(RefinerProposalRouteSchema).max(4),
+  allowedExternalRoutes: z2.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 = z2.object({
+  schemaVersion: z2.literal("openpond.refinerRelease.v1"),
+  id: z2.string().trim().min(1).max(240),
+  coreVersion: z2.string().trim().min(1).max(120),
+  coreHash: ReleaseHashSchema,
+  profile: RefinerReviewProfileSchema,
+  profileHash: ReleaseHashSchema,
+  composedPromptHash: ReleaseHashSchema,
+  createdAt: ReleaseTimestampSchema,
+  contentHash: ReleaseHashSchema
+}).strict();
+var RefinerBindingSchema = z2.object({
+  schemaVersion: z2.literal("openpond.refinerBinding.v1"),
+  channel: z2.literal("active"),
+  revision: z2.number().int().nonnegative(),
+  release: ImmutableReleaseRefSchema,
+  updatedAt: ReleaseTimestampSchema
+}).strict();
+var RefinerTransitionReceiptSchema = z2.object({
+  schemaVersion: z2.literal("openpond.refinerTransitionReceipt.v1"),
+  id: z2.string().trim().min(1).max(240),
+  operation: z2.enum(["initialize", "update", "activate", "rollback"]),
+  bindingChanged: z2.boolean(),
+  previousRelease: ImmutableReleaseRefSchema.nullable(),
+  nextRelease: ImmutableReleaseRefSchema,
+  actor: z2.string().trim().min(1).max(240),
+  reason: z2.string().trim().min(1).max(1e4),
+  authoringSkillHash: ReleaseHashSchema.nullable(),
+  validation: z2.object({ valid: z2.boolean(), messages: z2.array(z2.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 = z3.object({
+  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v1"),
+  decision: z3.literal("no_action"),
+  reason: z3.string().trim().min(1).max(1e4)
+}).strip();
+var RefinerExternalRouteDecisionSchema = z3.object({
+  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v1"),
+  decision: z3.literal("route"),
+  route: z3.enum(["runtime", "product", "taskset", "training"]),
+  summary: z3.string().trim().min(1).max(2e3),
+  expectedOutcome: z3.string().trim().min(1).max(1e4),
+  reason: z3.string().trim().min(1).max(1e4)
+}).strip();
+var RefinerProposalDecisionSchema = z3.object({
+  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v1"),
+  decision: z3.literal("propose"),
+  route: z3.enum(["memory", "prompt", "skill", "agent"]),
+  operation: z3.enum(["create", "update", "delete"]),
+  target: z3.string().trim().min(1).max(2e3),
+  summary: z3.string().trim().min(1).max(2e3),
+  createContent: z3.string().min(1).max(2e4).nullable(),
+  find: z3.string().min(1).max(8e3).nullable(),
+  replace: z3.string().max(8e3).nullable(),
+  expectedOutcome: z3.string().trim().min(1).max(1e4),
+  reason: z3.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 = z3.discriminatedUnion("decision", [
+  RefinerNoActionDecisionSchema,
+  RefinerExternalRouteDecisionSchema,
+  RefinerProposalDecisionSchema
+]);
+var LocalHarnessRefinerDecisionV1Schema = LocalHarnessRefinerDecisionSchema;
+var HarnessRefinerEvidenceBasisSchema = z3.object({
+  kind: z3.enum(["single_deterministic", "recurrent_independent"]),
+  supportingEvidenceIds: z3.array(z3.string().trim().min(1).max(2e3)).min(1).max(100),
+  counterevidence: z3.array(z3.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 = z3.object({
+  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v2"),
+  decision: z3.literal("no_action"),
+  reason: z3.string().trim().min(1).max(1e4)
+}).strict();
+var RefinerExternalRouteDecisionV2Schema = z3.object({
+  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v2"),
+  decision: z3.literal("route"),
+  route: z3.enum(["runtime", "product", "taskset", "training"]),
+  summary: z3.string().trim().min(1).max(2e3),
+  evidenceBasis: HarnessRefinerEvidenceBasisSchema,
+  expectedOutcome: z3.string().trim().min(1).max(1e4),
+  reason: z3.string().trim().min(1).max(1e4)
+}).strict();
+var RefinerProposalDecisionV2Schema = z3.object({
+  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v2"),
+  decision: z3.literal("propose"),
+  route: z3.enum(["memory", "prompt", "skill", "agent"]),
+  operation: z3.enum(["create", "update", "delete"]),
+  target: z3.string().trim().min(1).max(2e3),
+  summary: z3.string().trim().min(1).max(2e3),
+  evidenceBasis: HarnessRefinerEvidenceBasisSchema,
+  createContent: z3.string().min(1).max(2e4).nullable(),
+  find: z3.string().min(1).max(8e3).nullable(),
+  replace: z3.string().max(8e3).nullable(),
+  expectedOutcome: z3.string().trim().min(1).max(1e4),
+  reason: z3.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 = z3.discriminatedUnion("decision", [
+  RefinerNoActionDecisionV2Schema,
+  RefinerExternalRouteDecisionV2Schema,
+  RefinerProposalDecisionV2Schema
+]);
+var LocalHarnessRefinerDecisionAnySchema = z3.union([
+  LocalHarnessRefinerDecisionV1Schema,
+  LocalHarnessRefinerDecisionV2Schema
+]);
+var HarnessRefinerCapabilitiesSchema = z3.object({
+  memory: z3.boolean(),
+  prompt: z3.boolean(),
+  skill: z3.boolean(),
+  agent: z3.boolean()
+}).strict();
+var SourceKindSchema = z3.enum(["memory", "instruction", "skill", "agent"]);
+var RefinerSourceFileSchema = z3.object({
+  path: z3.string().trim().min(1).max(2e3),
+  kind: SourceKindSchema,
+  content: z3.string().max(6e4),
+  loaded: z3.boolean()
+}).strict();
+var RefinerSourceCatalogEntrySchema = z3.object({
+  path: z3.string().trim().min(1).max(2e3),
+  kind: SourceKindSchema,
+  loaded: z3.boolean()
+}).strict();
+var LocalHarnessRefinerEvidenceSchema = z3.object({
+  capabilities: HarnessRefinerCapabilitiesSchema,
+  trigger: z3.record(z3.string(), z3.unknown()),
+  observations: z3.array(z3.record(z3.string(), z3.unknown())).max(20),
+  admissibleEvidenceIds: z3.array(z3.string().trim().min(1).max(2e3)).max(1e4),
+  reviewPacket: z3.object({
+    currentTurn: z3.object({
+      id: z3.string().trim().min(1).max(2e3),
+      status: z3.string().trim().min(1).max(100).nullable(),
+      error: z3.string().max(2100).nullable(),
+      prompt: z3.string().max(8100).nullable(),
+      assistantOutput: z3.string().max(8100).nullable(),
+      assistantOutputLinkCount: z3.number().int().nonnegative()
+    }).strict(),
+    priorConversation: z3.array(z3.object({
+      turnId: z3.string().trim().min(1).max(2e3),
+      status: z3.string().trim().min(1).max(100).nullable(),
+      prompt: z3.string().max(3100).nullable(),
+      assistantOutput: z3.string().max(3100).nullable()
+    }).strict()).max(3),
+    timeline: z3.array(z3.record(z3.string(), z3.unknown())).max(60),
+    artifacts: z3.array(z3.record(z3.string(), z3.unknown())).max(30),
+    artifactDiagnostics: z3.array(z3.record(z3.string(), z3.unknown())).max(20),
+    executionProfile: z3.object({
+      modelRequestCount: z3.number().int().nonnegative(),
+      failedModelRequestCount: z3.number().int().nonnegative(),
+      promptTokens: z3.number().int().nonnegative(),
+      completionTokens: z3.number().int().nonnegative(),
+      totalTokens: z3.number().int().nonnegative(),
+      toolFailureCount: z3.number().int().nonnegative(),
+      retryCount: z3.number().int().nonnegative(),
+      recoveryCount: z3.number().int().nonnegative()
+    }).strict(),
+    priorIncidents: z3.array(z3.record(z3.string(), z3.unknown())).max(3),
+    truncation: z3.object({
+      timelineEventCount: z3.number().int().nonnegative(),
+      includedTimelineEventCount: z3.number().int().nonnegative(),
+      timelineTruncated: z3.boolean()
+    }).strict()
+  }).strict(),
+  runtimeActivation: z3.object({
+    admittedRelease: ImmutableReleaseRefSchema,
+    currentRelease: ImmutableReleaseRefSchema,
+    rebasedOntoCurrent: z3.boolean(),
+    admittedSourceFiles: z3.array(RefinerSourceFileSchema).max(100),
+    admittedSourceCatalog: z3.array(RefinerSourceCatalogEntrySchema).max(1e3)
+  }).strict(),
+  sourceFiles: z3.array(RefinerSourceFileSchema).max(100),
+  sourceCatalog: z3.array(RefinerSourceCatalogEntrySchema).max(1e3),
+  additionalEvidence: z3.unknown().nullable().optional()
+}).strict();
+var REFINER_CORE_VERSION = "openpond.refinerCore.v2";
+var OverlayRefSchema = z3.object({
+  id: z3.string().trim().min(1).max(240),
+  revision: z3.number().int().nonnegative(),
+  contentHash: ReleaseHashSchema
+}).strict();
+var HostedHarnessRefinerRequestSchema = z3.object({
+  schemaVersion: z3.literal("openpond.hostedHarnessRefinerRequest.v2"),
+  requestId: z3.string().trim().min(1).max(240),
+  idempotencyKey: z3.string().trim().min(1).max(240),
+  evidenceHash: ReleaseHashSchema,
+  harness: z3.object({
+    admittedRelease: ImmutableReleaseRefSchema,
+    currentRelease: ImmutableReleaseRefSchema,
+    overlay: OverlayRefSchema,
+    workspace: z3.object({
+      id: z3.string().trim().min(1).max(240),
+      revision: z3.number().int().nonnegative(),
+      sourceRevision: ReleaseHashSchema,
+      channelRevision: z3.number().int().nonnegative()
+    }).strict(),
+    capabilities: HarnessRefinerCapabilitiesSchema
+  }).strict(),
+  evidence: LocalHarnessRefinerEvidenceSchema
+}).strict();
+var HostedHarnessRefinerUsageSchema = z3.object({
+  promptTokens: z3.number().int().nonnegative(),
+  completionTokens: z3.number().int().nonnegative(),
+  totalTokens: z3.number().int().nonnegative()
+}).strict();
+var HostedHarnessRefinerResponseSchema = z3.object({
+  schemaVersion: z3.literal("openpond.hostedHarnessRefinerResponse.v2"),
+  requestId: z3.string().trim().min(1).max(240),
+  evidenceHash: ReleaseHashSchema,
+  admittedRelease: ImmutableReleaseRefSchema,
+  currentRelease: ImmutableReleaseRefSchema,
+  decision: LocalHarnessRefinerDecisionV2Schema,
+  serviceRevision: z3.string().trim().min(1).max(240),
+  usage: HostedHarnessRefinerUsageSchema
+}).strict();
+
 // ../cloud/dist/sandbox/types/runtime-profiles.js
 var SANDBOX_RUNTIME_PROFILE_IDS = [
   "openpond-generic-v1",
@@ -2739,6 +3281,7 @@ function createOpenPondClient(options) {
   return new OpenPondClient(options);
 }
 export {
+  DEFAULT_REFINER_REVIEW_PROFILE,
   OpenPondApiError,
   OpenPondClient,
   OpenPondProfileActionsClient,
@@ -2746,16 +3289,26 @@ export {
   OpenPondSandboxClient,
   OpenPondWorkClient,
   OpenPondWorkflowsClient,
+  REFINER_CORE_VERSION,
+  RefinerBindingSchema,
+  RefinerReleaseSchema,
+  RefinerReviewInstructionSchema,
+  RefinerReviewProfileSchema,
+  RefinerTransitionReceiptSchema,
   SANDBOX_RUNTIME_PROFILE_IDS,
   createOpenPondClient,
   createOpenPondSandboxClient,
+  createRefinerRelease,
+  defineReviewProfile,
   getOpChatModel,
   getOpChatProvider,
   listOpChatModels,
   listOpChatProviders,
   normalizeSandboxApiUrl,
+  refinerProfilePrompt,
   resolveOpChatApiBaseUrl,
   sendHostedChatTurn,
+  serializeReviewProfile,
   streamHostedChatTurn
 };
 //# sourceMappingURL=index.js.map