openpond 0.0.67 → 0.0.69

package/dist/chunks/{actions-command-DZ6D7JTO.js → actions-command-6N5XWMR6.js}

@@ -3,11 +3,12 @@ import {
   buildProjectActions,
   createLocalActionRunner,
   loadProjectActionConfiguration
-} from "./chunk-QETF6ILG.js";
+} from "./chunk-DLQQIWN2.js";
 import {
   createOpenPondClient
-} from "./chunk-K4JEWEJQ.js";
-import "./chunk-JGOP4GCK.js";
+} from "./chunk-4L3ZJS2T.js";
+import "./chunk-JTHL5XJ2.js";
+import "./chunk-FQS2QL5F.js";
 import {
   parseBooleanOption
 } from "./chunk-MUMPWI4O.js";

package/dist/chunks/{app-layer-MAATABDM.js → app-layer-EXXOWJ5H.js}

@@ -1,16 +1,17 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
   runProcessCommand
-} from "./chunk-J2REM7LE.js";
+} from "./chunk-HFPUR4CQ.js";
 import {
   CliUsageError
-} from "./chunk-MHUN6LXO.js";
+} from "./chunk-SFMNGWNO.js";
 import "./chunk-SMNFI2FU.js";
-import "./chunk-XIFRFL4T.js";
-import "./chunk-K4JEWEJQ.js";
-import "./chunk-JGOP4GCK.js";
-import "./chunk-DBHSOTYZ.js";
+import "./chunk-Y57RTLVV.js";
+import "./chunk-4L3ZJS2T.js";
+import "./chunk-JTHL5XJ2.js";
+import "./chunk-D7BO5Y5J.js";
 import "./chunk-KSRWKXRB.js";
+import "./chunk-FQS2QL5F.js";
 import "./chunk-MUMPWI4O.js";
 import "./chunk-UACZUFIA.js";
 

package/dist/chunks/app-server-runtime-7FBQBE3C.js

@@ -0,0 +1,20 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  APP_SERVER_COMPOSITION,
+  createOpenPondAppServer
+} from "./chunk-OOM2PHBE.js";
+import "./chunk-7C4OIFOC.js";
+import "./chunk-5TKZBMQM.js";
+import "./chunk-NPNIL6SQ.js";
+import "./chunk-FEOLMLYU.js";
+import "./chunk-MMRJNSWY.js";
+import "./chunk-DLQQIWN2.js";
+import "./chunk-BLFIIAWZ.js";
+import "./chunk-X7ZG4TSW.js";
+import "./chunk-JTHL5XJ2.js";
+import "./chunk-FQS2QL5F.js";
+import "./chunk-UACZUFIA.js";
+export {
+  APP_SERVER_COMPOSITION,
+  createOpenPondAppServer
+};

package/dist/chunks/{apps-L23POEUT.js → apps-RZSDOFAG.js}

@@ -10,15 +10,15 @@ import {
   normalizeRepoName,
   pollDeploymentLogs,
   resolveAppTarget
-} from "./chunk-J2REM7LE.js";
-import "./chunk-MHUN6LXO.js";
+} from "./chunk-HFPUR4CQ.js";
+import "./chunk-SFMNGWNO.js";
 import {
   resolveBaseUrl,
   resolvePublicApiBaseUrl
 } from "./chunk-SMNFI2FU.js";
-import "./chunk-XIFRFL4T.js";
-import "./chunk-K4JEWEJQ.js";
-import "./chunk-JGOP4GCK.js";
+import "./chunk-Y57RTLVV.js";
+import "./chunk-4L3ZJS2T.js";
+import "./chunk-JTHL5XJ2.js";
 import {
   createAgentFromPrompt,
   deployApp,
@@ -32,8 +32,9 @@ import {
   submitBacktestTx,
   updateAppCodeVisibility,
   updateAppEnvironment
-} from "./chunk-DBHSOTYZ.js";
+} from "./chunk-D7BO5Y5J.js";
 import "./chunk-KSRWKXRB.js";
+import "./chunk-FQS2QL5F.js";
 import {
   parseBooleanOption,
   parseJsonOption,

package/dist/chunks/{chunk-EJURKADM.js → chunk-47EIAYI7.js}

@@ -4,15 +4,15 @@ import {
   materializeSourceUploadFile,
   readSourceUploadCache,
   writeSourceUploadCache
-} from "./chunk-JIEUB6OS.js";
+} from "./chunk-J3YDKJFD.js";
 import {
   yaml
-} from "./chunk-WYDVQOBL.js";
+} from "./chunk-X7ZG4TSW.js";
 import {
   loadGlobalConfig,
   openPondConfigDirectory,
   saveGlobalConfig
-} from "./chunk-DBHSOTYZ.js";
+} from "./chunk-D7BO5Y5J.js";
 
 // ../../packages/cloud/src/profile/profile-setup-gate.ts
 var OpenPondProfileSetupRequiredError = class extends Error {

package/dist/chunks/{chunk-K4JEWEJQ.js → chunk-4L3ZJS2T.js}

@@ -6,7 +6,10 @@ import {
   readApiJson,
   resolveOpChatApiBaseUrl,
   sendHostedChatTurn
-} from "./chunk-JGOP4GCK.js";
+} from "./chunk-JTHL5XJ2.js";
+import {
+  external_exports
+} from "./chunk-FQS2QL5F.js";
 
 // ../../packages/sdk/src/work.ts
 var DEFAULT_MODEL = "openpond-chat";
@@ -746,6 +749,428 @@ function requiredId(value, label) {
   return normalized;
 }
 
+// ../../node_modules/.pnpm/@openpond+harness@0.2.5/node_modules/@openpond/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
+]);
+
+// ../../node_modules/.pnpm/@openpond+harness@0.2.5/node_modules/@openpond/harness/dist/common.js
+var MAX_PORTABLE_PATH_BYTES = 2e3;
+var MAX_PORTABLE_ASSET_BYTES = 25e7;
+var ReleaseIdSchema = external_exports.string().trim().min(1).max(240);
+var ReleaseHashSchema = external_exports.string().regex(/^[a-f0-9]{64}$/);
+var ReleaseTimestampSchema = external_exports.string().datetime({ offset: true });
+var MetadataSchema = external_exports.record(external_exports.string(), external_exports.unknown()).default({});
+var ImmutableReleaseRefSchema = external_exports.object({
+  id: ReleaseIdSchema,
+  contentHash: ReleaseHashSchema
+}).strict();
+var ImmutableAssetRefSchema = external_exports.object({
+  id: ReleaseIdSchema,
+  path: external_exports.string().trim().min(1).max(MAX_PORTABLE_PATH_BYTES).refine(safeRelativePath),
+  contentHash: ReleaseHashSchema,
+  sizeBytes: external_exports.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES),
+  mediaType: external_exports.string().trim().min(1).max(200),
+  visibility: external_exports.enum(["policy", "verifier", "host_private"])
+}).strict();
+var ImmutableArtifactRefSchema = external_exports.object({
+  id: ReleaseIdSchema,
+  contentHash: ReleaseHashSchema,
+  mediaType: external_exports.string().trim().min(1).max(200).nullable().default(null),
+  sizeBytes: external_exports.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES).nullable().default(null)
+}).strict();
+var FailureClassSchema = external_exports.enum([
+  "policy_failure",
+  "grader_failure",
+  "environment_failure",
+  "infrastructure_failure",
+  "timeout",
+  "cancelled"
+]);
+function safeRelativePath(value) {
+  const normalized = value.replaceAll("\\", "/");
+  if (!normalized || normalized.startsWith("/") || normalized.includes("\0"))
+    return false;
+  return !normalized.split("/").some((part) => !part || part === "." || part === "..");
+}
+
+// ../../node_modules/.pnpm/@openpond+harness@0.2.5/node_modules/@openpond/harness/dist/refiner-profiles.js
+var RefinerProposalRouteSchema = external_exports.enum(["memory", "prompt", "skill", "agent"]);
+var RefinerExternalRouteSchema = external_exports.enum(["runtime", "product", "taskset", "training"]);
+var RefinerReviewInstructionSchema = external_exports.object({
+  id: external_exports.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
+  text: external_exports.string().trim().min(1).max(1e4)
+}).strict();
+var RefinerReviewProfileSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.refinerReviewProfile.v1"),
+  id: external_exports.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
+  version: external_exports.string().trim().min(1).max(120),
+  name: external_exports.string().trim().min(1).max(200),
+  objective: external_exports.string().trim().min(1).max(1e4),
+  instructions: external_exports.array(RefinerReviewInstructionSchema).max(100),
+  allowedProposalRoutes: external_exports.array(RefinerProposalRouteSchema).max(4),
+  allowedExternalRoutes: external_exports.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 RefinerReleaseSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.refinerRelease.v1"),
+  id: external_exports.string().trim().min(1).max(240),
+  coreVersion: external_exports.string().trim().min(1).max(120),
+  coreHash: ReleaseHashSchema,
+  profile: RefinerReviewProfileSchema,
+  profileHash: ReleaseHashSchema,
+  composedPromptHash: ReleaseHashSchema,
+  createdAt: ReleaseTimestampSchema,
+  contentHash: ReleaseHashSchema
+}).strict();
+var RefinerBindingSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.refinerBinding.v1"),
+  channel: external_exports.literal("active"),
+  revision: external_exports.number().int().nonnegative(),
+  release: ImmutableReleaseRefSchema,
+  updatedAt: ReleaseTimestampSchema
+}).strict();
+var RefinerTransitionReceiptSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.refinerTransitionReceipt.v1"),
+  id: external_exports.string().trim().min(1).max(240),
+  operation: external_exports.enum(["initialize", "update", "activate", "rollback"]),
+  bindingChanged: external_exports.boolean(),
+  previousRelease: ImmutableReleaseRefSchema.nullable(),
+  nextRelease: ImmutableReleaseRefSchema,
+  actor: external_exports.string().trim().min(1).max(240),
+  reason: external_exports.string().trim().min(1).max(1e4),
+  authoringSkillHash: ReleaseHashSchema.nullable(),
+  validation: external_exports.object({ valid: external_exports.boolean(), messages: external_exports.array(external_exports.string().max(2e3)).max(100) }).strict(),
+  createdAt: ReleaseTimestampSchema,
+  contentHash: ReleaseHashSchema
+}).strict();
+
+// ../../node_modules/.pnpm/@openpond+harness@0.2.5/node_modules/@openpond/harness/dist/refiner.js
+var RefinerNoActionDecisionSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.localHarnessRefinerDecision.v1"),
+  decision: external_exports.literal("no_action"),
+  reason: external_exports.string().trim().min(1).max(1e4)
+}).strip();
+var RefinerExternalRouteDecisionSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.localHarnessRefinerDecision.v1"),
+  decision: external_exports.literal("route"),
+  route: external_exports.enum(["runtime", "product", "taskset", "training"]),
+  summary: external_exports.string().trim().min(1).max(2e3),
+  expectedOutcome: external_exports.string().trim().min(1).max(1e4),
+  reason: external_exports.string().trim().min(1).max(1e4)
+}).strip();
+var RefinerProposalDecisionSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.localHarnessRefinerDecision.v1"),
+  decision: external_exports.literal("propose"),
+  route: external_exports.enum(["memory", "prompt", "skill", "agent"]),
+  operation: external_exports.enum(["create", "update", "delete"]),
+  target: external_exports.string().trim().min(1).max(2e3),
+  summary: external_exports.string().trim().min(1).max(2e3),
+  createContent: external_exports.string().min(1).max(2e4).nullable(),
+  find: external_exports.string().min(1).max(8e3).nullable(),
+  replace: external_exports.string().max(8e3).nullable(),
+  expectedOutcome: external_exports.string().trim().min(1).max(1e4),
+  reason: external_exports.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 = external_exports.discriminatedUnion("decision", [
+  RefinerNoActionDecisionSchema,
+  RefinerExternalRouteDecisionSchema,
+  RefinerProposalDecisionSchema
+]);
+var LocalHarnessRefinerDecisionV1Schema = LocalHarnessRefinerDecisionSchema;
+var HarnessRefinerEvidenceBasisSchema = external_exports.object({
+  kind: external_exports.enum(["single_deterministic", "recurrent_independent"]),
+  supportingEvidenceIds: external_exports.array(external_exports.string().trim().min(1).max(2e3)).min(1).max(100),
+  counterevidence: external_exports.array(external_exports.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 = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.localHarnessRefinerDecision.v2"),
+  decision: external_exports.literal("no_action"),
+  reason: external_exports.string().trim().min(1).max(1e4)
+}).strict();
+var RefinerExternalRouteDecisionV2Schema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.localHarnessRefinerDecision.v2"),
+  decision: external_exports.literal("route"),
+  route: external_exports.enum(["runtime", "product", "taskset", "training"]),
+  summary: external_exports.string().trim().min(1).max(2e3),
+  evidenceBasis: HarnessRefinerEvidenceBasisSchema,
+  expectedOutcome: external_exports.string().trim().min(1).max(1e4),
+  reason: external_exports.string().trim().min(1).max(1e4)
+}).strict();
+var RefinerProposalDecisionV2Schema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.localHarnessRefinerDecision.v2"),
+  decision: external_exports.literal("propose"),
+  route: external_exports.enum(["memory", "prompt", "skill", "agent"]),
+  operation: external_exports.enum(["create", "update", "delete"]),
+  target: external_exports.string().trim().min(1).max(2e3),
+  summary: external_exports.string().trim().min(1).max(2e3),
+  evidenceBasis: HarnessRefinerEvidenceBasisSchema,
+  createContent: external_exports.string().min(1).max(2e4).nullable(),
+  find: external_exports.string().min(1).max(8e3).nullable(),
+  replace: external_exports.string().max(8e3).nullable(),
+  expectedOutcome: external_exports.string().trim().min(1).max(1e4),
+  reason: external_exports.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 = external_exports.discriminatedUnion("decision", [
+  RefinerNoActionDecisionV2Schema,
+  RefinerExternalRouteDecisionV2Schema,
+  RefinerProposalDecisionV2Schema
+]);
+var LocalHarnessRefinerDecisionAnySchema = external_exports.union([
+  LocalHarnessRefinerDecisionV1Schema,
+  LocalHarnessRefinerDecisionV2Schema
+]);
+var HarnessRefinerCapabilitiesSchema = external_exports.object({
+  memory: external_exports.boolean(),
+  prompt: external_exports.boolean(),
+  skill: external_exports.boolean(),
+  agent: external_exports.boolean()
+}).strict();
+var SourceKindSchema = external_exports.enum(["memory", "instruction", "skill", "agent"]);
+var RefinerSourceFileSchema = external_exports.object({
+  path: external_exports.string().trim().min(1).max(2e3),
+  kind: SourceKindSchema,
+  content: external_exports.string().max(6e4),
+  loaded: external_exports.boolean()
+}).strict();
+var RefinerSourceCatalogEntrySchema = external_exports.object({
+  path: external_exports.string().trim().min(1).max(2e3),
+  kind: SourceKindSchema,
+  loaded: external_exports.boolean()
+}).strict();
+var LocalHarnessRefinerEvidenceSchema = external_exports.object({
+  capabilities: HarnessRefinerCapabilitiesSchema,
+  trigger: external_exports.record(external_exports.string(), external_exports.unknown()),
+  observations: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())).max(20),
+  admissibleEvidenceIds: external_exports.array(external_exports.string().trim().min(1).max(2e3)).max(1e4),
+  reviewPacket: external_exports.object({
+    currentTurn: external_exports.object({
+      id: external_exports.string().trim().min(1).max(2e3),
+      status: external_exports.string().trim().min(1).max(100).nullable(),
+      error: external_exports.string().max(2100).nullable(),
+      prompt: external_exports.string().max(8100).nullable(),
+      assistantOutput: external_exports.string().max(8100).nullable(),
+      assistantOutputLinkCount: external_exports.number().int().nonnegative()
+    }).strict(),
+    priorConversation: external_exports.array(external_exports.object({
+      turnId: external_exports.string().trim().min(1).max(2e3),
+      status: external_exports.string().trim().min(1).max(100).nullable(),
+      prompt: external_exports.string().max(3100).nullable(),
+      assistantOutput: external_exports.string().max(3100).nullable()
+    }).strict()).max(3),
+    timeline: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())).max(60),
+    artifacts: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())).max(30),
+    artifactDiagnostics: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())).max(20),
+    executionProfile: external_exports.object({
+      modelRequestCount: external_exports.number().int().nonnegative(),
+      failedModelRequestCount: external_exports.number().int().nonnegative(),
+      promptTokens: external_exports.number().int().nonnegative(),
+      completionTokens: external_exports.number().int().nonnegative(),
+      totalTokens: external_exports.number().int().nonnegative(),
+      toolFailureCount: external_exports.number().int().nonnegative(),
+      retryCount: external_exports.number().int().nonnegative(),
+      recoveryCount: external_exports.number().int().nonnegative()
+    }).strict(),
+    priorIncidents: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())).max(3),
+    truncation: external_exports.object({
+      timelineEventCount: external_exports.number().int().nonnegative(),
+      includedTimelineEventCount: external_exports.number().int().nonnegative(),
+      timelineTruncated: external_exports.boolean()
+    }).strict()
+  }).strict(),
+  runtimeActivation: external_exports.object({
+    admittedRelease: ImmutableReleaseRefSchema,
+    currentRelease: ImmutableReleaseRefSchema,
+    rebasedOntoCurrent: external_exports.boolean(),
+    admittedSourceFiles: external_exports.array(RefinerSourceFileSchema).max(100),
+    admittedSourceCatalog: external_exports.array(RefinerSourceCatalogEntrySchema).max(1e3)
+  }).strict(),
+  sourceFiles: external_exports.array(RefinerSourceFileSchema).max(100),
+  sourceCatalog: external_exports.array(RefinerSourceCatalogEntrySchema).max(1e3),
+  additionalEvidence: external_exports.unknown().nullable().optional()
+}).strict();
+var OverlayRefSchema = external_exports.object({
+  id: external_exports.string().trim().min(1).max(240),
+  revision: external_exports.number().int().nonnegative(),
+  contentHash: ReleaseHashSchema
+}).strict();
+var HostedHarnessRefinerRequestSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.hostedHarnessRefinerRequest.v2"),
+  requestId: external_exports.string().trim().min(1).max(240),
+  idempotencyKey: external_exports.string().trim().min(1).max(240),
+  evidenceHash: ReleaseHashSchema,
+  harness: external_exports.object({
+    admittedRelease: ImmutableReleaseRefSchema,
+    currentRelease: ImmutableReleaseRefSchema,
+    overlay: OverlayRefSchema,
+    workspace: external_exports.object({
+      id: external_exports.string().trim().min(1).max(240),
+      revision: external_exports.number().int().nonnegative(),
+      sourceRevision: ReleaseHashSchema,
+      channelRevision: external_exports.number().int().nonnegative()
+    }).strict(),
+    capabilities: HarnessRefinerCapabilitiesSchema
+  }).strict(),
+  evidence: LocalHarnessRefinerEvidenceSchema
+}).strict();
+var HostedHarnessRefinerUsageSchema = external_exports.object({
+  promptTokens: external_exports.number().int().nonnegative(),
+  completionTokens: external_exports.number().int().nonnegative(),
+  totalTokens: external_exports.number().int().nonnegative()
+}).strict();
+var HostedHarnessRefinerResponseSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.hostedHarnessRefinerResponse.v2"),
+  requestId: external_exports.string().trim().min(1).max(240),
+  evidenceHash: ReleaseHashSchema,
+  admittedRelease: ImmutableReleaseRefSchema,
+  currentRelease: ImmutableReleaseRefSchema,
+  decision: LocalHarnessRefinerDecisionV2Schema,
+  serviceRevision: external_exports.string().trim().min(1).max(240),
+  usage: HostedHarnessRefinerUsageSchema
+}).strict();
+
 // ../../packages/sdk/src/index.ts
 var OpenPondClient = class {
   sandboxes;

package/dist/chunks/{chunk-CWCMYSX2.js → chunk-5TKZBMQM.js}

@@ -1,7 +1,7 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
   external_exports
-} from "./chunk-WYDVQOBL.js";
+} from "./chunk-FQS2QL5F.js";
 
 // ../../packages/agent-runtime/dist/compaction.js
 function agentCompactionDecision(input) {
@@ -179,7 +179,7 @@ function canonicalEventHash(event) {
 }
 
 // ../../packages/agent-runtime/dist/protocol.js
-var AGENT_PROTOCOL_VERSION = "2026-08-06";
+var AGENT_PROTOCOL_VERSION = "2026-08-26";
 var AGENT_RPC_METHODS = [
   "initialize",
   "initialized",
@@ -201,7 +201,11 @@ var AGENT_RPC_METHODS = [
   "harness/validate",
   "harness/backgroundReview",
   "harness/diff",
-  "harness/rollback"
+  "harness/rollback",
+  "refiner/inspect",
+  "refiner/update",
+  "refiner/activate",
+  "refiner/rollback"
 ];
 var JsonRpcRequestSchema = external_exports.object({
   jsonrpc: external_exports.literal("2.0"),
@@ -331,6 +335,14 @@ var AgentJsonRpcDispatcher = class {
         return this.#host.harnessDiff(params);
       case "harness/rollback":
         return this.#host.harnessRollback(params);
+      case "refiner/inspect":
+        return this.#host.refinerInspect(params);
+      case "refiner/update":
+        return this.#host.refinerUpdate(params);
+      case "refiner/activate":
+        return this.#host.refinerActivate(params);
+      case "refiner/rollback":
+        return this.#host.refinerRollback(params);
       default:
         throw new JsonRpcDispatchError(-32601, `Method not found: ${method}`);
     }
@@ -579,6 +591,10 @@ function createAgentRuntimeService(ports) {
     harnessBackgroundReview: (params) => run("harness/backgroundReview", null, () => ports.updateHarnessBackgroundReview(params)),
     harnessDiff: (params) => run("harness/diff", null, () => ports.diffHarness(params)),
     harnessRollback: (params) => run("harness/rollback", null, () => ports.rollbackHarness(params)),
+    refinerInspect: () => run("refiner/inspect", null, () => ports.inspectRefiner()),
+    refinerUpdate: (params) => run("refiner/update", null, () => ports.updateRefiner(params)),
+    refinerActivate: (params) => run("refiner/activate", null, () => ports.activateRefiner(params)),
+    refinerRollback: (params) => run("refiner/rollback", null, () => ports.rollbackRefiner(params)),
     subscribe: ports.subscribeEvents && ports.eventNotification ? (listener) => ports.subscribeEvents((event) => listener(ports.eventNotification(event))) : void 0
   };
 }

package/dist/chunks/{chunk-Z3SXHGOC.js → chunk-7C4OIFOC.js}

@@ -1,7 +1,7 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
   now
-} from "./chunk-DEEQG5MY.js";
+} from "./chunk-NPNIL6SQ.js";
 
 // ../server/src/workspace/workspace-command.ts
 import { spawn, spawnSync } from "node:child_process";