openpond 0.0.42 → 0.0.44

package/dist/chunks/{chunk-UNNPZEFB.js → chunk-6GLNUWY2.js}

@@ -15,12 +15,12 @@ import {
   runAgentCompactionProgram,
   runProviderRound,
   runProviderRoundLoop
-} from "./chunk-VCVQLECH.js";
+} from "./chunk-SLTKA5AW.js";
 import {
   getBundledRuntimeVersion,
   loadOpenPondAccountContext,
   streamOpenPondHostedChatTurn
-} from "./chunk-ZTE6A2VE.js";
+} from "./chunk-2NP3E4GP.js";
 import {
   assertSafeBranchName,
   isGeneratedWorkspacePath,
@@ -33,14 +33,14 @@ import {
   truncatePatch,
   uniqueSortedPaths,
   workspaceImageContentType
-} from "./chunk-KWZJAKIR.js";
+} from "./chunk-HLEQDBYN.js";
 import {
   HOSTED_CHAT_SYSTEM_PROMPT,
   VERSION,
   event,
   now,
   textFromUnknown
-} from "./chunk-SGWTAB4R.js";
+} from "./chunk-HKJG7VBI.js";
 import {
   AppPreferencesSchema,
   ApplyCreateImproveRunActionRequestSchema,
@@ -138,7 +138,7 @@ import {
   runAgentSdkProjectCommand,
   runProfileSkillCommand,
   sidebarFileBookmarkId
-} from "./chunk-2SF6HLT7.js";
+} from "./chunk-53YZBGDC.js";
 import {
   AgentSnapshotSchema,
   CONNECTED_APP_PROVIDER_TOOL_NAMES,
@@ -146,18 +146,22 @@ import {
   DEFAULT_REFINEMENT_TRIGGER_POLICY,
   DEFAULT_REFINER_MAX_OUTPUT_TOKENS,
   DEFAULT_REFINER_TIMEOUT_MS,
+  EvaluationResultSchema,
   EvidenceArtifactRefSchema,
   HarnessAdvanceReceiptSchema,
+  HarnessEvaluationReviewReceiptSchema,
   HarnessImprovementProposalSchema,
   HarnessOverlayMergeReceiptSchema,
   HarnessRefinerOutcomeSchema,
   HarnessReleaseSchema,
+  HarnessReviewWatermarkSchema,
   HarnessRunOverlaySchema,
   HarnessTargetedValidationReceiptSchema,
   HarnessWorkspaceSchema,
   ImprovementApplyReceiptSchema,
   ImprovementObservationSchema,
   ImprovementRouteDecisionSchema,
+  ModelImprovementQualificationReceiptSchema,
   OPENPOND_MANIFEST_FILE_NAME,
   RefinementTriggerDecisionSchema,
   SANDBOX_TEMPLATE_PREVIEW_PORT_MAX,
@@ -176,6 +180,7 @@ import {
   connectedAppProviderOperationById,
   contentHash,
   createAgentSnapshot,
+  createHarnessEvaluationReviewReceipt,
   createHarnessImprovementProposal,
   createHarnessRefinerOutcome,
   createHarnessRelease,
@@ -195,7 +200,7 @@ import {
   stableId,
   uniqueEventRefs,
   validateConnectedAppProviderOperationRequest
-} from "./chunk-M2NXTLH2.js";
+} from "./chunk-ZXWFYFFB.js";
 import {
   external_exports
 } from "./chunk-WYDVQOBL.js";
@@ -952,7 +957,7 @@ import { promises as fs2 } from "node:fs";
 import path2 from "node:path";
 
 // ../server/src/store/store-schema.ts
-var CURRENT_SQLITE_SCHEMA_VERSION = 39;
+var CURRENT_SQLITE_SCHEMA_VERSION = 40;
 var SQLITE_CREATE_SCHEMA_SQL = `
   CREATE TABLE IF NOT EXISTS sessions (
     id TEXT PRIMARY KEY,
@@ -1384,6 +1389,15 @@ var SQLITE_CREATE_SCHEMA_SQL = `
   );
   CREATE INDEX IF NOT EXISTS grade_results_attempt_idx ON grade_results(attempt_id, created_at DESC);
 
+  CREATE TABLE IF NOT EXISTS evaluation_results (
+    id TEXT PRIMARY KEY,
+    taskset_id TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    payload TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS evaluation_results_taskset_kind_idx ON evaluation_results(taskset_id, kind, created_at DESC);
+
   CREATE TABLE IF NOT EXISTS grader_audit_reports (
     id TEXT PRIMARY KEY,
     taskset_id TEXT NOT NULL,
@@ -1820,6 +1834,24 @@ async function createHarnessWorkspaceTables(exec) {
       FOREIGN KEY(workspace_id) REFERENCES harness_workspaces(id) ON DELETE RESTRICT
     );
 
+    CREATE TABLE IF NOT EXISTS harness_evaluation_review_settings (
+      workspace_id TEXT PRIMARY KEY,
+      enabled INTEGER NOT NULL DEFAULT 0,
+      cadence TEXT NOT NULL DEFAULT 'manual',
+      max_estimated_cost_usd REAL NOT NULL DEFAULT 0,
+      next_run_at TEXT,
+      last_run_at TEXT,
+      last_review_id TEXT,
+      last_review_hash TEXT,
+      last_classification TEXT,
+      last_error TEXT,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY(workspace_id) REFERENCES harness_workspaces(id) ON DELETE RESTRICT
+    );
+
+    CREATE INDEX IF NOT EXISTS harness_evaluation_review_settings_due_idx
+      ON harness_evaluation_review_settings(enabled, next_run_at);
+
     CREATE TABLE IF NOT EXISTS harness_release_records (
       content_hash TEXT PRIMARY KEY,
       id TEXT NOT NULL,
@@ -2232,6 +2264,10 @@ var SQLITE_MIGRATIONS = [
   {
     version: 39,
     run: (store) => store.createHarnessWorkspaceTables()
+  },
+  {
+    version: 40,
+    run: (store) => store.createHarnessWorkspaceTables()
   }
 ];
 
@@ -2524,6 +2560,8 @@ var TRAINING_TABLES_SQL = `
   CREATE INDEX IF NOT EXISTS task_attempts_taskset_split_idx ON task_attempts(taskset_id, split, created_at DESC);
   CREATE TABLE IF NOT EXISTS grade_results (id TEXT PRIMARY KEY, attempt_id TEXT NOT NULL, payload TEXT NOT NULL, created_at TEXT NOT NULL);
   CREATE INDEX IF NOT EXISTS grade_results_attempt_idx ON grade_results(attempt_id, created_at DESC);
+  CREATE TABLE IF NOT EXISTS evaluation_results (id TEXT PRIMARY KEY, taskset_id TEXT NOT NULL, kind TEXT NOT NULL, payload TEXT NOT NULL, created_at TEXT NOT NULL);
+  CREATE INDEX IF NOT EXISTS evaluation_results_taskset_kind_idx ON evaluation_results(taskset_id, kind, created_at DESC);
   CREATE TABLE IF NOT EXISTS readiness_reports (taskset_id TEXT PRIMARY KEY, payload TEXT NOT NULL, updated_at TEXT NOT NULL);
   CREATE TABLE IF NOT EXISTS task_miner_configs (profile_id TEXT PRIMARY KEY, payload TEXT NOT NULL, updated_at TEXT NOT NULL);
   CREATE TABLE IF NOT EXISTS task_miner_runs (id TEXT PRIMARY KEY, profile_id TEXT NOT NULL, status TEXT NOT NULL, payload TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);
@@ -3895,6 +3933,44 @@ var SqliteDatasetStore = class extends SqliteTrainingModelStore {
   }
 };
 
+// ../server/src/store/store-evaluation-results.ts
+var SqliteEvaluationResultStore = class extends SqliteDatasetStore {
+  async saveEvaluationResult(input) {
+    const result = EvaluationResultSchema.parse(input.result);
+    assertContentHash(result, "Evaluation result");
+    if (result.metadata.sourceTasksetId !== input.tasksetId) {
+      throw new Error("Evaluation result does not match the supplied Taskset identity.");
+    }
+    const existing = await this.getEvaluationResult(result.id);
+    if (existing) {
+      if (existing.contentHash !== result.contentHash) {
+        throw new Error(`Evaluation result ${result.id} is immutable and already has another content hash.`);
+      }
+      return existing;
+    }
+    await this.upsertPayload(
+      `INSERT INTO evaluation_results (id, taskset_id, kind, payload, created_at)
+       VALUES (?, ?, ?, ?, ?)`,
+      [result.id, input.tasksetId, input.kind, JSON.stringify(result), input.createdAt]
+    );
+    return result;
+  }
+  async getEvaluationResult(id) {
+    return this.getParsedPayload(
+      "SELECT payload FROM evaluation_results WHERE id = ?",
+      [id],
+      EvaluationResultSchema.parse
+    );
+  }
+  async listEvaluationResults(tasksetId, kind) {
+    return this.listParsedPayloads(
+      kind ? "SELECT payload FROM evaluation_results WHERE taskset_id = ? AND kind = ? ORDER BY created_at DESC, id ASC" : "SELECT payload FROM evaluation_results WHERE taskset_id = ? ORDER BY created_at DESC, id ASC",
+      kind ? [tasksetId, kind] : [tasksetId],
+      EvaluationResultSchema.parse
+    );
+  }
+};
+
 // ../server/src/store/store-training-search.ts
 function trainingChatSearchResult(query, offset, limit, total, rows, indexedChats, totalChats) {
   return {
@@ -3928,7 +4004,7 @@ function appendTrainingChatSearchText(target, sessionId, text) {
 
 // ../server/src/store/store-training.ts
 var ACTIVE_TRAINING_DESTINATIONS_SQL = "('local_cpu_fixture', 'openpond_managed')";
-var SqliteTrainingStore = class extends SqliteDatasetStore {
+var SqliteTrainingStore = class extends SqliteEvaluationResultStore {
   async trainingChatSearchSignatures(source) {
     await this.ready;
     await this.writeQueue;
@@ -4305,6 +4381,7 @@ var SqliteTrainingStore = class extends SqliteDatasetStore {
       await this.exec("BEGIN IMMEDIATE");
       try {
         await this.run("DELETE FROM grade_results WHERE attempt_id IN (SELECT id FROM task_attempts WHERE taskset_id = ?)", [id]);
+        await this.run("DELETE FROM evaluation_results WHERE taskset_id = ?", [id]);
         await this.run("DELETE FROM task_attempt_artifacts WHERE taskset_id = ?", [id]);
         await this.run("DELETE FROM task_attempts WHERE taskset_id = ?", [id]);
         await this.run("DELETE FROM grader_audit_reports WHERE taskset_id = ?", [id]);
@@ -5156,6 +5233,123 @@ var SqliteHarnessMemoryStore = class extends SqliteSidebarFileBookmarkStore {
   }
 };
 
+// ../server/src/store/store-harness-evaluation-review-settings.ts
+var DEFAULT_SETTINGS = {
+  enabled: false,
+  cadence: "manual",
+  maxEstimatedCostUsd: 0,
+  nextRunAt: null,
+  lastRunAt: null,
+  lastResult: null,
+  lastError: null,
+  updatedAt: null
+};
+var SqliteHarnessEvaluationReviewSettingsStore = class extends SqliteHarnessMemoryStore {
+  async getHarnessBackgroundReviewSettings(workspaceId) {
+    await this.ready;
+    await this.writeQueue;
+    const row = await this.get(
+      `SELECT background_review_enabled, updated_at
+       FROM harness_workspace_settings WHERE workspace_id = ?`,
+      [workspaceId]
+    );
+    return row ? { enabled: row.background_review_enabled === 1, updatedAt: row.updated_at } : { enabled: true, updatedAt: null };
+  }
+  async setHarnessBackgroundReviewSettings(input) {
+    await this.ready;
+    const write = this.writeQueue.then(async () => {
+      const workspace = await this.get(
+        "SELECT id FROM harness_workspaces WHERE id = ?",
+        [input.workspaceId]
+      );
+      if (!workspace) throw new Error(`Harness workspace ${input.workspaceId} does not exist.`);
+      await this.run(
+        `INSERT INTO harness_workspace_settings (
+           workspace_id, background_review_enabled, updated_at
+         ) VALUES (?, ?, ?)
+         ON CONFLICT(workspace_id) DO UPDATE SET
+           background_review_enabled = excluded.background_review_enabled,
+           updated_at = excluded.updated_at`,
+        [input.workspaceId, input.enabled ? 1 : 0, input.updatedAt]
+      );
+    });
+    this.writeQueue = write.catch(() => void 0);
+    await write;
+    return { enabled: input.enabled, updatedAt: input.updatedAt };
+  }
+  async getHarnessEvaluationReviewSettings(workspaceId) {
+    await this.ready;
+    await this.writeQueue;
+    const row = await this.get(
+      `SELECT enabled, cadence, max_estimated_cost_usd, next_run_at, last_run_at,
+              last_review_id, last_review_hash, last_classification, last_error, updated_at
+       FROM harness_evaluation_review_settings WHERE workspace_id = ?`,
+      [workspaceId]
+    );
+    if (!row) return { ...DEFAULT_SETTINGS };
+    const lastResult = row.last_review_id && row.last_review_hash && row.last_classification ? {
+      id: row.last_review_id,
+      contentHash: row.last_review_hash,
+      classification: row.last_classification
+    } : null;
+    return {
+      enabled: row.enabled === 1,
+      cadence: row.cadence,
+      maxEstimatedCostUsd: row.max_estimated_cost_usd,
+      nextRunAt: row.next_run_at,
+      lastRunAt: row.last_run_at,
+      lastResult,
+      lastError: row.last_error,
+      updatedAt: row.updated_at
+    };
+  }
+  async setHarnessEvaluationReviewSettings(input) {
+    await this.ready;
+    const write = this.writeQueue.then(async () => {
+      const workspace = await this.get(
+        "SELECT id FROM harness_workspaces WHERE id = ?",
+        [input.workspaceId]
+      );
+      if (!workspace) throw new Error(`Harness workspace ${input.workspaceId} does not exist.`);
+      const result = input.settings.lastResult;
+      await this.run(
+        `INSERT INTO harness_evaluation_review_settings (
+           workspace_id, enabled, cadence, max_estimated_cost_usd, next_run_at,
+           last_run_at, last_review_id, last_review_hash, last_classification,
+           last_error, updated_at
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(workspace_id) DO UPDATE SET
+           enabled = excluded.enabled,
+           cadence = excluded.cadence,
+           max_estimated_cost_usd = excluded.max_estimated_cost_usd,
+           next_run_at = excluded.next_run_at,
+           last_run_at = excluded.last_run_at,
+           last_review_id = excluded.last_review_id,
+           last_review_hash = excluded.last_review_hash,
+           last_classification = excluded.last_classification,
+           last_error = excluded.last_error,
+           updated_at = excluded.updated_at`,
+        [
+          input.workspaceId,
+          input.settings.enabled ? 1 : 0,
+          input.settings.cadence,
+          input.settings.maxEstimatedCostUsd,
+          input.settings.nextRunAt,
+          input.settings.lastRunAt,
+          result?.id ?? null,
+          result?.contentHash ?? null,
+          result?.classification ?? null,
+          input.settings.lastError,
+          input.settings.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+        ]
+      );
+    });
+    this.writeQueue = write.catch(() => void 0);
+    await write;
+    return input.settings;
+  }
+};
+
 // ../server/src/store/store-harness-release-record.ts
 var LocalHarnessReleaseRecordSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.localHarnessReleaseRecord.v1"),
@@ -5178,6 +5372,8 @@ var LocalHarnessReleaseRecordSchema = external_exports.object({
 // ../server/src/store/store-harness-workspace-artifacts.ts
 var HARNESS_IMPROVEMENT_ARTIFACT_SCHEMAS = {
   run_overlay: HarnessRunOverlaySchema,
+  evaluation_review: HarnessEvaluationReviewReceiptSchema,
+  training_qualification: ModelImprovementQualificationReceiptSchema,
   proposal: HarnessImprovementProposalSchema,
   targeted_validation: HarnessTargetedValidationReceiptSchema,
   merge_receipt: HarnessOverlayMergeReceiptSchema,
@@ -5208,35 +5404,7 @@ function immutableHarnessReleaseRecord(record5) {
 }
 
 // ../server/src/store/store-harness-workspaces.ts
-var SqliteHarnessWorkspaceStore = class extends SqliteHarnessMemoryStore {
-  async getHarnessBackgroundReviewSettings(workspaceId) {
-    await this.ready;
-    await this.writeQueue;
-    const row = await this.get(
-      `SELECT background_review_enabled, updated_at
-       FROM harness_workspace_settings WHERE workspace_id = ?`,
-      [workspaceId]
-    );
-    return row ? { enabled: row.background_review_enabled === 1, updatedAt: row.updated_at } : { enabled: true, updatedAt: null };
-  }
-  async setHarnessBackgroundReviewSettings(input) {
-    await this.ready;
-    const write = this.writeQueue.then(async () => {
-      await this.requireHarnessWorkspace(input.workspaceId);
-      await this.run(
-        `INSERT INTO harness_workspace_settings (
-           workspace_id, background_review_enabled, updated_at
-         ) VALUES (?, ?, ?)
-         ON CONFLICT(workspace_id) DO UPDATE SET
-           background_review_enabled = excluded.background_review_enabled,
-           updated_at = excluded.updated_at`,
-        [input.workspaceId, input.enabled ? 1 : 0, input.updatedAt]
-      );
-    });
-    this.writeQueue = write.catch(() => void 0);
-    await write;
-    return { enabled: input.enabled, updatedAt: input.updatedAt };
-  }
+var SqliteHarnessWorkspaceStore = class extends SqliteHarnessEvaluationReviewSettingsStore {
   async createHarnessWorkspace(input) {
     const workspace = HarnessWorkspaceSchema.parse(input);
     await this.ready;
@@ -7397,6 +7565,443 @@ function gitBasicAuthEnv(remoteUrl, token) {
   };
 }
 
+// ../server/src/harness/local-harness-evaluation-review.ts
+var ReviewSourcePolicySchema = external_exports.object({
+  sourceRef: external_exports.string().trim().min(1),
+  policy: external_exports.object({
+    id: external_exports.string().trim().min(1),
+    contentHash: external_exports.string().regex(/^[a-f0-9]{64}$/)
+  }).strict(),
+  state: external_exports.enum(["authorized", "revoked", "deleted", "expired"]),
+  checkedAt: external_exports.string().datetime()
+}).strict();
+var LocalHarnessEvaluationReviewRequestSchema = external_exports.object({
+  previousWatermark: HarnessReviewWatermarkSchema.nullable().optional(),
+  sourcePolicies: external_exports.array(ReviewSourcePolicySchema).max(1e4).default([]),
+  limits: external_exports.object({
+    maxEvidence: external_exports.number().int().min(1).max(1e3).default(200),
+    maxTokens: external_exports.number().int().min(1).max(1e6).default(5e4),
+    maxDurationMs: external_exports.number().int().min(1).max(6e4).default(5e3),
+    maxEstimatedCostUsd: external_exports.number().finite().nonnegative().default(0)
+  }).strict().default({
+    maxEvidence: 200,
+    maxTokens: 5e4,
+    maxDurationMs: 5e3,
+    maxEstimatedCostUsd: 0
+  })
+}).strict();
+async function reviewSelectedLocalHarnessEvaluation(input) {
+  const request = LocalHarnessEvaluationReviewRequestSchema.parse(input.request ?? {});
+  const startedAt = performance.now();
+  const selectedRelease = await resolveSelectedLocalHarnessRelease(input.store);
+  if (!selectedRelease) {
+    throw new Error("No Local Harness release is selected for evaluation review.");
+  }
+  const workspace = await input.store.getHarnessWorkspace(selectedRelease.workspaceId);
+  if (!workspace) {
+    throw new Error(`Selected Harness workspace ${selectedRelease.workspaceId} does not exist.`);
+  }
+  const [reviews, routes, triggers, observations, applyReceipts] = await Promise.all([
+    input.store.listHarnessImprovementArtifacts(workspace.id, "evaluation_review", 1e3),
+    input.store.listHarnessImprovementArtifacts(workspace.id, "route_decision", 1e3),
+    input.store.listHarnessImprovementArtifacts(workspace.id, "trigger_decision", 1e3),
+    input.store.listHarnessImprovementArtifacts(workspace.id, "observation", 1e3),
+    input.store.listHarnessImprovementArtifacts(workspace.id, "apply_receipt", 1e3)
+  ]);
+  const latestReview = reviews[0] ?? null;
+  const previousWatermark = request.previousWatermark ?? latestReview?.nextWatermark ?? null;
+  const typedRoutes = routes;
+  const typedTriggers = triggers;
+  const typedObservations = observations;
+  const typedApplyReceipts = applyReceipts;
+  if (request.previousWatermark === void 0 && latestReview && !typedRoutes.some((route) => route.createdAt > latestReview.nextWatermark.throughCreatedAt)) {
+    return latestReview;
+  }
+  const triggerByRef = new Map(
+    typedTriggers.map((trigger) => [artifactKey(trigger), trigger])
+  );
+  const observationByRef = new Map(
+    typedObservations.map((observation) => [artifactKey(observation), observation])
+  );
+  const policyBySource = new Map(request.sourcePolicies.map((policy) => [policy.sourceRef, policy]));
+  const excludedEvidence = [];
+  const candidates = [];
+  let examined = 0;
+  let estimatedTokens = 0;
+  for (const routeDecision of typedRoutes.slice().sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id))) {
+    if (performance.now() - startedAt >= request.limits.maxDurationMs) {
+      excludedEvidence.push({
+        evidence: artifactRef(routeDecision),
+        sourcePolicy: null,
+        reason: "budget"
+      });
+      continue;
+    }
+    if (previousWatermark && routeDecision.createdAt <= previousWatermark.throughCreatedAt) {
+      excludedEvidence.push({
+        evidence: artifactRef(routeDecision),
+        sourcePolicy: null,
+        reason: "before_watermark"
+      });
+      continue;
+    }
+    if (examined >= request.limits.maxEvidence) {
+      excludedEvidence.push({
+        evidence: artifactRef(routeDecision),
+        sourcePolicy: null,
+        reason: "budget"
+      });
+      continue;
+    }
+    examined += 1;
+    const trigger = triggerByRef.get(artifactKey(routeDecision.trigger));
+    if (!trigger) {
+      excludedEvidence.push({
+        evidence: artifactRef(routeDecision),
+        sourcePolicy: null,
+        reason: "unverified"
+      });
+      continue;
+    }
+    const observation = trigger.observations.map((reference) => observationByRef.get(artifactKey(reference)) ?? null).find((candidate) => candidate !== null) ?? null;
+    const proposalId = typeof routeDecision.metadata.proposalId === "string" ? routeDecision.metadata.proposalId : null;
+    if (proposalId && typedApplyReceipts.some(
+      (receipt2) => receipt2.proposal.id === proposalId && receipt2.decision === "applied"
+    )) {
+      excludedEvidence.push({
+        evidence: artifactRef(routeDecision),
+        sourcePolicy: null,
+        reason: "resolved"
+      });
+      continue;
+    }
+    const candidateTokens = Math.ceil(JSON.stringify({ routeDecision, trigger, observation }).length / 4);
+    if (estimatedTokens + candidateTokens > request.limits.maxTokens) {
+      excludedEvidence.push({
+        evidence: artifactRef(routeDecision),
+        sourcePolicy: null,
+        reason: "budget"
+      });
+      continue;
+    }
+    estimatedTokens += candidateTokens;
+    const sourceRef = observation?.runRef ?? trigger.runRef;
+    const policy = policyBySource.get(sourceRef);
+    if (!policy || policy.state !== "authorized") {
+      excludedEvidence.push({
+        evidence: artifactRef(routeDecision),
+        sourcePolicy: policy ? sourcePolicyRef(policy) : null,
+        reason: policy && policy.state !== "authorized" ? policy.state : "unverified"
+      });
+      continue;
+    }
+    candidates.push({
+      route: routeDecision.route,
+      family: recurrenceFamily(routeDecision.route, trigger, observation),
+      routeDecision,
+      trigger,
+      observation,
+      sourceRef
+    });
+  }
+  const deduplicated = deduplicateCandidates(candidates, excludedEvidence, policyBySource);
+  const grouped = groupCandidates(deduplicated);
+  const chosen = [...grouped.entries()].map(([family, items]) => ({ family, items })).sort((left, right) => right.items.length - left.items.length || left.family.localeCompare(right.family))[0] ?? null;
+  const decision = classify(chosen?.items ?? []);
+  const selectedEvidence = decision.classification === "no_action" ? [] : (chosen?.items ?? []).map((candidate) => evidenceRef(candidate, policyBySource.get(candidate.sourceRef)));
+  const createdAt = (input.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))();
+  const examinedCreatedAt = typedRoutes.filter((route) => !previousWatermark || route.createdAt > previousWatermark.throughCreatedAt).slice(0, request.limits.maxEvidence).map((route) => route.createdAt).sort().at(-1);
+  const throughCreatedAt = maxTimestamp(previousWatermark?.throughCreatedAt, examinedCreatedAt, createdAt);
+  const cursor = contentHash({
+    previousCursor: previousWatermark?.cursor ?? null,
+    throughCreatedAt,
+    examined: typedRoutes.filter((route) => !previousWatermark || route.createdAt > previousWatermark.throughCreatedAt).slice(0, request.limits.maxEvidence).map(artifactRef)
+  });
+  const receiptId = `evaluation-review-${contentHash({
+    workspaceId: workspace.id,
+    harnessRelease: selectedRelease.harnessRelease,
+    previousWatermark,
+    cursor
+  }).slice(0, 24)}`;
+  const receipt = createHarnessEvaluationReviewReceipt({
+    schemaVersion: "openpond.harnessEvaluationReviewReceipt.v1",
+    id: receiptId,
+    ownerScope: workspace.ownerScope,
+    workspaceRef: workspace.id,
+    harnessRelease: artifactRef(selectedRelease.harnessRelease),
+    previousWatermark,
+    nextWatermark: { cursor, throughCreatedAt },
+    selectedEvidence,
+    excludedEvidence,
+    claim: decision.classification === "no_action" || !chosen ? null : {
+      fingerprint: contentHash({ family: chosen.family, evidence: selectedEvidence.map((item) => item.occurrenceKey) }),
+      recurrenceFamily: chosen.family,
+      statement: decision.reason,
+      independentOccurrences: new Set(chosen.items.map((item) => item.sourceRef)).size,
+      unresolvedOccurrences: new Set(chosen.items.map((item) => item.sourceRef)).size
+    },
+    classification: decision.classification,
+    triage: decision.classification === "no_action" ? [] : [{
+      layer: triageLayer(decision.classification),
+      status: "unresolved",
+      reason: decision.reason,
+      evidenceRefs: selectedEvidence.map((item) => item.evidence)
+    }],
+    reason: decision.reason,
+    nextAuthority: nextAuthority(decision.classification),
+    maxEstimatedCostUsd: request.limits.maxEstimatedCostUsd,
+    tasksetProposal: null,
+    evaluation: null,
+    trainingQualification: null,
+    policyVersion: "local-harness-evaluation-review-v1",
+    createdAt,
+    metadata: {
+      examinedEvidence: examined,
+      estimatedTokens,
+      elapsedMs: performance.now() - startedAt,
+      explicitInvocation: true
+    }
+  });
+  await input.store.saveHarnessImprovementArtifact(workspace.id, "evaluation_review", receipt);
+  return receipt;
+}
+function artifactRef(artifact) {
+  return { id: artifact.id, contentHash: artifact.contentHash };
+}
+function artifactKey(artifact) {
+  return `${artifact.id}:${artifact.contentHash}`;
+}
+function sourcePolicyRef(policy) {
+  return { policy: policy.policy, state: policy.state, checkedAt: policy.checkedAt };
+}
+function recurrenceFamily(route, trigger, observation) {
+  return [
+    route,
+    observation?.deterministicClass ?? "unclassified",
+    observation?.tool?.name ?? trigger.deduplicationKey,
+    observation?.state ?? "unknown-state"
+  ].join(":");
+}
+function deduplicateCandidates(candidates, excluded, policies) {
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((candidate) => {
+    const key = `${candidate.family}:${candidate.sourceRef}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      return true;
+    }
+    excluded.push({
+      evidence: artifactRef(candidate.routeDecision),
+      sourcePolicy: sourcePolicyRef(policies.get(candidate.sourceRef)),
+      reason: "duplicate"
+    });
+    return false;
+  });
+}
+function groupCandidates(candidates) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    groups.set(candidate.family, [...groups.get(candidate.family) ?? [], candidate]);
+  }
+  return groups;
+}
+function evidenceRef(candidate, policy) {
+  return {
+    evidence: artifactRef(candidate.routeDecision),
+    kind: "route_decision",
+    sourceRef: candidate.sourceRef,
+    sourcePolicy: sourcePolicyRef(policy),
+    occurrenceKey: contentHash({ family: candidate.family, sourceRef: candidate.sourceRef }),
+    occurredAt: candidate.routeDecision.createdAt
+  };
+}
+function classify(items) {
+  if (items.length === 0) {
+    return { classification: "no_action", reason: "No authorized unresolved evidence qualified for action." };
+  }
+  const route = items[0].route;
+  if (route === "runtime") {
+    return { classification: "runtime", reason: "Authorized unresolved evidence belongs to the runtime-service layer." };
+  }
+  if (route === "product") {
+    return { classification: "product", reason: "Authorized unresolved evidence belongs to the product layer." };
+  }
+  if (route === "taskset" || route === "training") {
+    if (items.length >= 3) {
+      return { classification: "taskset", reason: "Three or more independent unresolved occurrences qualify for Taskset proposal review." };
+    }
+    return { classification: "no_action", reason: "Taskset evidence has not met the three-occurrence recurrence threshold." };
+  }
+  return { classification: "harness_maintenance", reason: "Authorized unresolved evidence belongs to Harness maintenance." };
+}
+function nextAuthority(classification) {
+  if (classification === "runtime") return "runtime_service";
+  if (classification === "product") return "product_team";
+  if (classification === "taskset") return "human_review";
+  if (classification === "harness_maintenance") return "human_review";
+  if (classification === "model_improvement") return "training_system";
+  return "none";
+}
+function triageLayer(classification) {
+  if (classification === "runtime") return "runtime";
+  if (classification === "product") return "product";
+  if (classification === "taskset") return "evaluation";
+  if (classification === "model_improvement") return "model";
+  return "harness";
+}
+function maxTimestamp(...values) {
+  return values.filter((value) => Boolean(value)).sort().at(-1);
+}
+
+// ../server/src/harness/local-harness-evaluation-review-host.ts
+var SOURCE_POLICY_VERSION = "local-personal-work-v1";
+async function reviewSelectedLocalHarnessEvaluationFromHost(input) {
+  const selected = await resolveSelectedLocalHarnessRelease(input.store);
+  if (!selected || selected.workspaceId !== input.workspaceId) {
+    throw new Error("Evaluation review requires the selected Personal Local Harness.");
+  }
+  const workspace = await input.store.getHarnessWorkspace(input.workspaceId);
+  if (!workspace || workspace.ownerScope.kind !== "personal" || workspace.location !== "local") {
+    throw new Error("Evaluation review requires the selected Personal Local Harness.");
+  }
+  const [observations, triggers] = await Promise.all([
+    input.store.listHarnessImprovementArtifacts(input.workspaceId, "observation", 1e4),
+    input.store.listHarnessImprovementArtifacts(input.workspaceId, "trigger_decision", 1e4)
+  ]);
+  const sourceRefs = /* @__PURE__ */ new Set([
+    ...observations.map((observation) => observation.runRef),
+    ...triggers.map((trigger) => trigger.runRef)
+  ]);
+  const checkedAt = (input.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))();
+  const sourcePolicies = await Promise.all([...sourceRefs].sort().map(async (sourceRef) => {
+    const session = await input.store.getSession(sourceRef);
+    return {
+      sourceRef,
+      policy: {
+        id: `source-policy-${contentHash({
+          workspaceId: input.workspaceId,
+          sourceRef,
+          policyVersion: SOURCE_POLICY_VERSION
+        }).slice(0, 24)}`,
+        contentHash: contentHash({
+          workspaceId: input.workspaceId,
+          sourceRef,
+          policyVersion: SOURCE_POLICY_VERSION
+        })
+      },
+      state: session ? "authorized" : "deleted",
+      checkedAt
+    };
+  }));
+  return reviewSelectedLocalHarnessEvaluation({
+    store: input.store,
+    request: {
+      sourcePolicies,
+      limits: {
+        maxEvidence: 200,
+        maxTokens: 5e4,
+        maxDurationMs: 5e3,
+        maxEstimatedCostUsd: input.maxEstimatedCostUsd
+      }
+    },
+    now: input.now
+  });
+}
+
+// ../server/src/harness/local-harness-evaluation-review-scheduler.ts
+var DEFAULT_TICK_MS = 15e3;
+function nextHarnessEvaluationReviewRunAt(cadence, from) {
+  if (cadence === "manual") return null;
+  const next = new Date(from);
+  next.setUTCDate(next.getUTCDate() + (cadence === "daily" ? 1 : 7));
+  return next.toISOString();
+}
+function createLocalHarnessEvaluationReviewScheduler(input) {
+  let interval = null;
+  let active = null;
+  const now2 = input.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  async function runDueNow() {
+    if (active) return active;
+    active = (async () => {
+      const workspace = await input.store.getSelectedHarnessWorkspace({
+        ownerKind: "personal",
+        ownerId: DESKTOP_PERSONAL_HARNESS_OWNER_ID
+      });
+      if (!workspace) return null;
+      const settings = await input.store.getHarnessEvaluationReviewSettings(workspace.id);
+      const startedAt = now2();
+      if (!settings.enabled || settings.cadence === "manual" || !settings.nextRunAt || settings.nextRunAt > startedAt) return null;
+      const claimed = {
+        ...settings,
+        nextRunAt: nextHarnessEvaluationReviewRunAt(settings.cadence, startedAt),
+        lastRunAt: startedAt,
+        lastError: null,
+        updatedAt: startedAt
+      };
+      await input.store.setHarnessEvaluationReviewSettings({
+        workspaceId: workspace.id,
+        settings: claimed
+      });
+      try {
+        const receipt = await reviewSelectedLocalHarnessEvaluationFromHost({
+          store: input.store,
+          workspaceId: workspace.id,
+          maxEstimatedCostUsd: settings.maxEstimatedCostUsd,
+          now: now2
+        });
+        await input.store.setHarnessEvaluationReviewSettings({
+          workspaceId: workspace.id,
+          settings: {
+            ...claimed,
+            lastResult: {
+              id: receipt.id,
+              contentHash: receipt.contentHash,
+              classification: receipt.classification
+            },
+            updatedAt: now2()
+          }
+        });
+        input.logger?.info("Harness evaluation review schedule completed", {
+          workspaceId: workspace.id,
+          reviewId: receipt.id,
+          classification: receipt.classification
+        });
+        return receipt;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await input.store.setHarnessEvaluationReviewSettings({
+          workspaceId: workspace.id,
+          settings: { ...claimed, lastError: message, updatedAt: now2() }
+        });
+        input.logger?.warn("Harness evaluation review schedule failed", {
+          workspaceId: workspace.id,
+          error: message
+        });
+        return null;
+      }
+    })().finally(() => {
+      active = null;
+    });
+    return active;
+  }
+  return {
+    start() {
+      if (interval) return;
+      interval = setInterval(() => {
+        if (!input.isClosing()) void runDueNow();
+      }, input.tickMs ?? DEFAULT_TICK_MS);
+      interval.unref?.();
+      void runDueNow();
+    },
+    async stop() {
+      if (interval) clearInterval(interval);
+      interval = null;
+      await active;
+    },
+    runDueNow
+  };
+}
+
 // ../server/src/harness/local-harness-history.ts
 function createLocalHarnessSettingsRoutePayloads(input) {
   return {
@@ -7405,6 +8010,14 @@ function createLocalHarnessSettingsRoutePayloads(input) {
       store: input.store,
       request: parseHarnessBackgroundReviewRequest(payload)
     }),
+    reviewHarnessEvaluationPayload: (payload) => reviewLocalHarnessEvaluationFromSettings({
+      store: input.store,
+      request: parseHarnessEvaluationReviewRequest(payload)
+    }),
+    updateHarnessEvaluationReviewSchedulePayload: (payload) => updateLocalHarnessEvaluationReviewScheduleFromSettings({
+      store: input.store,
+      request: parseHarnessEvaluationReviewScheduleRequest(payload)
+    }),
     harnessDiffPayload: (payload) => localHarnessReleaseDiffPayload({
       ...input,
       request: parseHarnessReleaseDiffRequest(payload)
@@ -7419,6 +8032,37 @@ function createLocalHarnessSettingsRoutePayloads(input) {
     })
   };
 }
+function parseHarnessEvaluationReviewRequest(payload) {
+  if (!payload || typeof payload !== "object") {
+    throw new Error("Harness evaluation review requires a workspace.");
+  }
+  const record5 = payload;
+  if (typeof record5.workspaceId !== "string") {
+    throw new Error("Harness evaluation review requires a workspace.");
+  }
+  if (record5.maxEstimatedCostUsd !== void 0 && (typeof record5.maxEstimatedCostUsd !== "number" || !Number.isFinite(record5.maxEstimatedCostUsd) || record5.maxEstimatedCostUsd < 0)) {
+    throw new Error("Harness evaluation review cost must be a non-negative number.");
+  }
+  return {
+    workspaceId: record5.workspaceId,
+    maxEstimatedCostUsd: record5.maxEstimatedCostUsd
+  };
+}
+function parseHarnessEvaluationReviewScheduleRequest(payload) {
+  if (!payload || typeof payload !== "object") {
+    throw new Error("Harness evaluation review schedule requires a workspace and cadence.");
+  }
+  const record5 = payload;
+  if (typeof record5.workspaceId !== "string" || typeof record5.enabled !== "boolean" || record5.cadence !== "manual" && record5.cadence !== "daily" && record5.cadence !== "weekly" || typeof record5.maxEstimatedCostUsd !== "number" || !Number.isFinite(record5.maxEstimatedCostUsd) || record5.maxEstimatedCostUsd < 0) {
+    throw new Error("Harness evaluation review schedule requires a valid workspace, cadence, and cost limit.");
+  }
+  return {
+    workspaceId: record5.workspaceId,
+    enabled: record5.enabled,
+    cadence: record5.cadence,
+    maxEstimatedCostUsd: record5.maxEstimatedCostUsd
+  };
+}
 function parseHarnessBackgroundReviewRequest(payload) {
   if (!payload || typeof payload !== "object") {
     throw new Error("Harness background review requires a workspace and enabled state.");
@@ -7499,30 +8143,48 @@ async function localHarnessHistoryPayload(store) {
     return {
       workspace: null,
       backgroundReview: { enabled: true, updatedAt: null },
+      evaluationReviewSchedule: {
+        enabled: false,
+        cadence: "manual",
+        maxEstimatedCostUsd: 0,
+        nextRunAt: null,
+        lastRunAt: null,
+        lastResult: null,
+        lastError: null,
+        updatedAt: null
+      },
       releases: [],
       changes: [],
       routes: [],
+      evaluationReviews: [],
+      modelImprovementQualifications: [],
       pendingReviews: [],
       memories: []
     };
   }
   const [
     backgroundReview,
+    evaluationReviewSchedule,
     releaseRecords,
     receipts,
     proposals,
     validations,
     routeDecisions,
+    evaluationReviews,
+    modelImprovementQualifications,
     applyReceipts,
     outcomes,
     triggers
   ] = await Promise.all([
     store.getHarnessBackgroundReviewSettings(workspace.id),
+    store.getHarnessEvaluationReviewSettings(workspace.id),
     store.listHarnessReleaseRecords(workspace.id),
     store.listHarnessAdvanceReceipts(workspace.id),
     store.listHarnessImprovementArtifacts(workspace.id, "proposal", 1e3),
     store.listHarnessImprovementArtifacts(workspace.id, "targeted_validation", 1e3),
     store.listHarnessImprovementArtifacts(workspace.id, "route_decision", 1e3),
+    store.listHarnessImprovementArtifacts(workspace.id, "evaluation_review", 1e3),
+    store.listHarnessImprovementArtifacts(workspace.id, "training_qualification", 1e3),
     store.listHarnessImprovementArtifacts(workspace.id, "apply_receipt", 1e3),
     store.listHarnessImprovementArtifacts(workspace.id, "refiner_outcome", 1e3),
     store.listHarnessImprovementArtifacts(workspace.id, "trigger_decision", 1e3)
@@ -7595,6 +8257,7 @@ async function localHarnessHistoryPayload(store) {
   return {
     workspace,
     backgroundReview,
+    evaluationReviewSchedule,
     releases: releaseRecords.map((record5) => ({
       id: record5.harnessRelease.id,
       contentHash: record5.harnessRelease.contentHash,
@@ -7611,10 +8274,65 @@ async function localHarnessHistoryPayload(store) {
     })),
     changes,
     routes,
+    evaluationReviews,
+    modelImprovementQualifications,
     pendingReviews,
     memories: await store.listHarnessMemories(workspace.id)
   };
 }
+async function reviewLocalHarnessEvaluationFromSettings(input) {
+  const settings = await input.store.getHarnessEvaluationReviewSettings(input.request.workspaceId);
+  const receipt = await reviewSelectedLocalHarnessEvaluationFromHost({
+    store: input.store,
+    workspaceId: input.request.workspaceId,
+    maxEstimatedCostUsd: input.request.maxEstimatedCostUsd ?? settings.maxEstimatedCostUsd
+  });
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  await input.store.setHarnessEvaluationReviewSettings({
+    workspaceId: input.request.workspaceId,
+    settings: {
+      ...settings,
+      lastRunAt: timestamp,
+      lastResult: {
+        id: receipt.id,
+        contentHash: receipt.contentHash,
+        classification: receipt.classification
+      },
+      lastError: null,
+      updatedAt: timestamp
+    }
+  });
+  return { receipt, history: await localHarnessHistoryPayload(input.store) };
+}
+async function updateLocalHarnessEvaluationReviewScheduleFromSettings(input) {
+  const workspace = await input.store.getHarnessWorkspace(input.request.workspaceId);
+  if (!workspace || workspace.ownerScope.kind !== "personal" || workspace.location !== "local") {
+    throw new Error("Evaluation review schedule requires the selected Personal Local Harness.");
+  }
+  const selected = await input.store.getSelectedHarnessWorkspace({
+    ownerKind: "personal",
+    ownerId: DESKTOP_PERSONAL_HARNESS_OWNER_ID
+  });
+  if (selected?.id !== workspace.id) {
+    throw new Error("Evaluation review schedule requires the selected Personal Local Harness.");
+  }
+  const previous = await input.store.getHarnessEvaluationReviewSettings(workspace.id);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const enabled = input.request.enabled && input.request.cadence !== "manual";
+  await input.store.setHarnessEvaluationReviewSettings({
+    workspaceId: workspace.id,
+    settings: {
+      ...previous,
+      enabled,
+      cadence: input.request.cadence,
+      maxEstimatedCostUsd: input.request.maxEstimatedCostUsd,
+      nextRunAt: enabled ? nextHarnessEvaluationReviewRunAt(input.request.cadence, timestamp) : null,
+      lastError: null,
+      updatedAt: timestamp
+    }
+  });
+  return { history: await localHarnessHistoryPayload(input.store) };
+}
 async function updateLocalHarnessBackgroundReviewFromSettings(input) {
   const workspace = await input.store.getHarnessWorkspace(input.request.workspaceId);
   if (!workspace || workspace.ownerScope.kind !== "personal" || workspace.location !== "local") {
@@ -13653,8 +14371,8 @@ function normalizeSearchApiUrl(value) {
   if (url.protocol !== "http:" && url.protocol !== "https:") {
     throw new Error("Hosted web search endpoint must use http or https.");
   }
-  if (url.hostname === "api.staging-api.openpond.ai" || url.hostname === "staging-api.openpond.ai") {
-    url.hostname = "api-new.staging-api.openpond.ai";
+  if (url.hostname === "api.staging-api.openpond.ai" || url.hostname === "api-new.staging-api.openpond.ai") {
+    url.hostname = "staging-api.openpond.ai";
   }
   const segments = url.pathname.split("/").filter(Boolean);
   const opchatIndex = segments.findIndex((segment) => segment.toLowerCase() === "opchat");
@@ -15355,8 +16073,8 @@ function checkResultRef(eventId, index) {
 function messageRef(eventId) {
   return `message:${eventId}`;
 }
-function artifactResourceRef(eventId, artifactRef) {
-  return `artifact:${eventId}:${encodeURIComponent(artifactRef)}`;
+function artifactResourceRef(eventId, artifactRef2) {
+  return `artifact:${eventId}:${encodeURIComponent(artifactRef2)}`;
 }
 function goalContextRef(identifier) {
   return `goal-context:${encodeURIComponent(identifier)}`;
@@ -20100,8 +20818,14 @@ function createAgentRuntimePorts(deps) {
         userInput: true,
         compaction: true,
         harnessInspection: true,
+        harnessProposalReview: true,
+        harnessEvaluationReview: true,
         harnessValidation: true,
-        immutableHarnessAdmission: true
+        immutableHarnessAdmission: true,
+        harnessBackgroundReview: true,
+        harnessDiff: true,
+        harnessRollback: true,
+        harnessReview: true
       },
       tools: recordedTools,
       toolCatalogHash: recordedHash
@@ -20119,7 +20843,12 @@ function createAgentRuntimePorts(deps) {
     interruptTurn: deps.interruptSessionTurn,
     resolveApproval: deps.resolveApproval,
     inspectHarness: deps.inspectHarness,
+    reviewHarnessProposal: deps.reviewHarnessProposal,
+    reviewHarness: deps.reviewHarness,
     validateHarness: deps.validateHarness,
+    updateHarnessBackgroundReview: deps.updateHarnessBackgroundReview,
+    diffHarness: deps.diffHarness,
+    rollbackHarness: deps.rollbackHarness,
     subscribeEvents: deps.subscribeRuntimeEvents,
     eventNotification: runtimeEventNotification,
     telemetry: deps.observeRuntimeOperation
@@ -33118,7 +33847,7 @@ function uniqueEvidence(run, evidence) {
 }
 async function verifyAppliedProfileCommit(input) {
   const command = input.command ?? (async (name, args, cwd, env) => {
-    const { runWorkspaceCommand } = await import("./workspaces-Y3GSQO3Y.js");
+    const { runWorkspaceCommand } = await import("./workspaces-RKZVNT2A.js");
     return runWorkspaceCommand(name, args, cwd, env);
   });
   const result = await command("git", ["rev-parse", "HEAD"], input.repoPath);
@@ -40672,6 +41401,10 @@ async function createOpenPondAppServer(options = {}) {
     throw new Error(`Approval not found: ${approvalId}`);
   }
   let closing = false;
+  const harnessSettings = createLocalHarnessSettingsRoutePayloads({
+    store,
+    storeDir
+  });
   const instance = createAppServer({
     ports: createAgentRuntimePorts({
       placement: "hosted_work",
@@ -40685,6 +41418,8 @@ async function createOpenPondAppServer(options = {}) {
       interruptSessionTurn: turnRunner.interruptSessionTurn,
       resolveApproval,
       inspectHarness: () => localHarnessHistoryPayload(store),
+      reviewHarnessProposal: createLocalHarnessSettingsRoutePayloads({ store, storeDir }).reviewHarnessProposalPayload,
+      reviewHarness: (request) => reviewSelectedLocalHarnessEvaluation({ store, request }),
       validateHarness: async () => {
         const release = await resolveSelectedLocalHarnessRelease(store);
         return release ? {
@@ -40697,6 +41432,9 @@ async function createOpenPondAppServer(options = {}) {
           reason: "No app-server Harness release is selected."
         };
       },
+      updateHarnessBackgroundReview: harnessSettings.updateHarnessBackgroundReviewPayload,
+      diffHarness: harnessSettings.harnessDiffPayload,
+      rollbackHarness: harnessSettings.rollbackHarnessPayload,
       subscribeRuntimeEvents,
       observeRuntimeOperation: (runtimeEvent) => {
         logger.info("agent runtime operation", runtimeEvent);
@@ -40766,6 +41504,8 @@ export {
   loadLocalHarnessRuntimeForAgentRun,
   ensureLocalHarnessRunOverlay,
   trimOutput,
+  reviewSelectedLocalHarnessEvaluation,
+  createLocalHarnessEvaluationReviewScheduler,
   createLocalHarnessSettingsRoutePayloads,
   createOpenAiSubscriptionAuthService,
   isOpenAiCompatibleProviderId,