openpond 0.0.48 → 0.0.49

package/dist/chunks/{chunk-4GHFK3DG.js → chunk-CNIMJPM5.js}

@@ -20,7 +20,7 @@ import {
   getBundledRuntimeVersion,
   loadOpenPondAccountContext,
   streamOpenPondHostedChatTurn
-} from "./chunk-IM67TWCC.js";
+} from "./chunk-NRLI3S72.js";
 import {
   assertSafeBranchName,
   isGeneratedWorkspacePath,
@@ -33,14 +33,14 @@ import {
   truncatePatch,
   uniqueSortedPaths,
   workspaceImageContentType
-} from "./chunk-37IPWV2S.js";
+} from "./chunk-7M4HGT5X.js";
 import {
   HOSTED_CHAT_SYSTEM_PROMPT,
   VERSION,
   event,
   now,
   textFromUnknown
-} from "./chunk-RUEMWXU6.js";
+} from "./chunk-UJV3UYLP.js";
 import {
   AppPreferencesSchema,
   ApplyCreateImproveRunActionRequestSchema,
@@ -164,12 +164,13 @@ import {
   runAgentSdkProjectCommand,
   runProfileSkillCommand,
   sidebarFileBookmarkId
-} from "./chunk-CGVG46T5.js";
+} from "./chunk-3BR4ACFF.js";
 import {
   AgentSnapshotSchema,
   AttemptReceiptSchema,
   CONNECTED_APP_PROVIDER_TOOL_NAMES,
   CONNECTED_APP_TOOL_CALL_ENDPOINT,
+  DEFAULT_EVALUATION_REVIEW_MAX_OUTPUT_TOKENS,
   DEFAULT_REFINEMENT_TRIGGER_POLICY,
   DEFAULT_REFINER_MAX_OUTPUT_TOKENS,
   DEFAULT_REFINER_TIMEOUT_MS,
@@ -186,6 +187,8 @@ import {
   HarnessRunOverlaySchema,
   HarnessTargetedValidationReceiptSchema,
   HarnessWorkspaceSchema,
+  HostedHarnessRefinerRequestSchema,
+  HostedHarnessRefinerResponseSchema,
   ImmutableReleaseRefSchema,
   ImprovementApplyReceiptSchema,
   ImprovementObservationSchema,
@@ -201,6 +204,7 @@ import {
   WorkProcessTraceSchema,
   aggregateEvaluationReceipts,
   assertContentHash,
+  authorHarnessEvaluationReviewWithModel,
   authorLocalHarnessRefinementWithModel,
   boundedObservationEvidence,
   boundedTriggerEvidence,
@@ -234,7 +238,7 @@ import {
   stableId,
   uniqueEventRefs,
   validateConnectedAppProviderOperationRequest
-} from "./chunk-I4CQJSZK.js";
+} from "./chunk-7G472COA.js";
 import {
   external_exports
 } from "./chunk-WYDVQOBL.js";
@@ -656,7 +660,7 @@ var require_shell_quote = __commonJS({
 });
 
 // ../server/src/app-server-runtime.ts
-import path45 from "node:path";
+import path46 from "node:path";
 
 // ../../packages/logging/dist/index.js
 import { promises as fs } from "node:fs";
@@ -5269,9 +5273,9 @@ var SqliteHarnessMemoryStore = class extends SqliteSidebarFileBookmarkStore {
 
 // ../server/src/store/store-harness-evaluation-review-settings.ts
 var DEFAULT_SETTINGS = {
-  enabled: false,
-  cadence: "manual",
-  maxEstimatedCostUsd: 0,
+  enabled: true,
+  cadence: "daily",
+  maxEstimatedCostUsd: 0.1,
   nextRunAt: null,
   lastRunAt: null,
   lastResult: null,
@@ -5320,7 +5324,7 @@ var SqliteHarnessEvaluationReviewSettingsStore = class extends SqliteHarnessMemo
        FROM harness_evaluation_review_settings WHERE workspace_id = ?`,
       [workspaceId]
     );
-    if (!row) return { ...DEFAULT_SETTINGS };
+    if (!row) return { ...DEFAULT_SETTINGS, nextRunAt: (/* @__PURE__ */ new Date()).toISOString() };
     const lastResult = row.last_review_id && row.last_review_hash && row.last_classification ? {
       id: row.last_review_id,
       contentHash: row.last_review_hash,
@@ -5815,8 +5819,16 @@ var SqliteHarnessWorkspaceStore = class extends SqliteHarnessEvaluationReviewSet
         if (proposal.overlay.id !== overlay.id || proposal.overlay.revision !== overlay.revision || proposal.overlay.contentHash !== overlay.contentHash) {
           throw new Error("Refiner proposal is not bound to the atomically frozen overlay.");
         }
-        if (proposal.baseHarnessRelease.id !== overlay.baseHarnessRelease.id || proposal.baseHarnessRelease.contentHash !== overlay.baseHarnessRelease.contentHash) {
-          throw new Error("Refiner proposal base release differs from the run overlay.");
+        if (!sameReleaseRef(proposal.baseHarnessRelease, overlay.baseHarnessRelease)) {
+          const rebasedFrom = proposal.metadata.rebasedFromHarnessRelease;
+          const workspace = await this.readHarnessWorkspace(
+            current.workspace.workspaceId
+          );
+          if (!workspace || !isReleaseRef(rebasedFrom) || !sameReleaseRef(rebasedFrom, overlay.baseHarnessRelease) || !workspace.currentChannel.release || !sameReleaseRef(workspace.currentChannel.release, proposal.baseHarnessRelease) || proposal.expectedWorkspace.workspaceId !== workspace.id || proposal.expectedWorkspace.revision !== workspace.revision || proposal.expectedWorkspace.sourceRevision !== workspace.sourceRevision || proposal.expectedWorkspace.channelRevision !== workspace.currentChannel.revision) {
+            throw new Error(
+              "Refiner proposal base release differs from both the run overlay and the atomically verified current workspace."
+            );
+          }
         }
         if (JSON.stringify(proposal.edits) !== JSON.stringify(input.edits)) {
           throw new Error("Refiner proposal edits differ from the atomically applied edits.");
@@ -6180,6 +6192,14 @@ var SqliteHarnessWorkspaceStore = class extends SqliteHarnessEvaluationReviewSet
     );
   }
 };
+function isReleaseRef(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.id === "string" && typeof candidate.contentHash === "string";
+}
+function sameReleaseRef(left, right) {
+  return left.id === right.id && left.contentHash === right.contentHash;
+}
 
 // ../server/src/harness/local-harness-workspace-service.ts
 var HARNESS_SOURCE_MANIFEST = "harness.json";
@@ -7560,7 +7580,7 @@ async function ensureLocalHarnessRunOverlay(input) {
 }
 
 // ../server/src/harness/local-harness-history.ts
-import path6 from "node:path";
+import path8 from "node:path";
 
 // ../server/src/workspace-tools/workspace-tool-common.ts
 var MAX_READ_CHARS = 12e4;
@@ -7599,6 +7619,306 @@ function gitBasicAuthEnv(remoteUrl, token) {
   };
 }
 
+// ../server/src/harness/local-harness-refiner-context.ts
+import { execFile } from "node:child_process";
+import { promises as fs6 } from "node:fs";
+import path7 from "node:path";
+import { promisify } from "node:util";
+
+// ../server/src/runtime/executable-search-path-bun-compat.ts
+import path6 from "node:path";
+function executableSearchPath(environment = process.env, platform = process.platform) {
+  if (platform === "win32") return environment.PATH ?? "";
+  const userHome = environment.HOME?.trim();
+  const preferred = [
+    userHome ? path6.join(userHome, ".local", "bin") : null,
+    userHome ? path6.join(userHome, ".bun", "bin") : null,
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin"
+  ];
+  const inherited = (environment.PATH ?? "").split(path6.delimiter).filter(Boolean);
+  return Array.from(
+    /* @__PURE__ */ new Set([...preferred.filter((entry) => Boolean(entry)), ...inherited])
+  ).join(path6.delimiter);
+}
+
+// ../server/src/harness/local-harness-refiner-context.ts
+var MAX_REFINER_SOURCE_BYTES = 6e4;
+var MAX_PDF_ARTIFACTS = 10;
+var MAX_PDF_BYTES = 20 * 1024 * 1024;
+var execFileAsync = promisify(execFile);
+async function loadBoundedRefinerContext(store, trigger, observations) {
+  const [session, turn, events, turns] = await Promise.all([
+    store.getSession(trigger.runRef),
+    store.getTurn(trigger.turnId),
+    store.runtimeEventsForSession(trigger.runRef, { limit: 1e3 }),
+    store.turnsForSession(trigger.runRef, 1e3)
+  ]);
+  const orderedTurns = [...turns].sort(
+    (left, right) => left.startedAt.localeCompare(right.startedAt)
+  );
+  const turnIndex = orderedTurns.findIndex((candidate) => candidate.id === trigger.turnId);
+  const previousTurn = turnIndex > 0 ? orderedTurns[turnIndex - 1] : null;
+  const eventRefs = new Map(
+    observations.flatMap(
+      (observation) => observation.eventRefs.map((reference) => [reference.id, reference])
+    )
+  );
+  const exactEvents = events.filter((runtimeEvent) => eventRefs.has(runtimeEvent.id));
+  for (const [eventId, reference] of eventRefs) {
+    const runtimeEvent = exactEvents.find((candidate) => candidate.id === eventId);
+    if (!runtimeEvent || contentHash(runtimeEvent) !== reference.contentHash) {
+      throw new Error(`Refiner runtime event ${eventId} is unavailable or hash-mismatched.`);
+    }
+  }
+  const evidenceEvents = selectRefinerEvidenceWindow({
+    events,
+    exactEvents,
+    turnId: trigger.turnId,
+    boundarySequence: trigger.boundary.eventSequence,
+    limit: trigger.policy.maxEvidenceEvents
+  });
+  const assistantOutput = assistantOutputForTurn(events, trigger.turnId);
+  return {
+    task: {
+      prompt: turn?.prompt ? redactAndBoundRefinerText(turn.prompt, 8e3) : null,
+      assistantOutput,
+      assistantOutputLinkCount: countAbsoluteLinks(assistantOutput),
+      previousAssistantOutput: previousTurn ? assistantOutputForTurn(events, previousTurn.id) : null
+    },
+    artifactDiagnostics: await inspectBoundedPdfArtifactDiagnostics(session?.cwd),
+    eventExcerpts: evidenceEvents.map((runtimeEvent) => {
+      const data = asRecord(runtimeEvent.data);
+      const result = asRecord(data.result);
+      return {
+        id: runtimeEvent.id,
+        name: runtimeEvent.name,
+        action: runtimeEvent.action ?? (typeof data.tool === "string" ? data.tool : null),
+        status: runtimeEvent.status ?? null,
+        command: textField(result.command, 3e3),
+        error: textField(runtimeEvent.error, 2e3),
+        output: textField(result.output, 2e3) ?? textField(runtimeEvent.output, 2e3),
+        exitCode: typeof result.exitCode === "number" ? result.exitCode : null,
+        timedOut: result.timedOut === true,
+        stderr: textField(result.stderr, 3e3),
+        stdout: textField(result.stdout, 3e3)
+      };
+    })
+  };
+}
+async function inspectBoundedPdfArtifactDiagnostics(cwd) {
+  if (!cwd) return [];
+  let entries;
+  try {
+    entries = await fs6.readdir(cwd, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const pdfs = entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".pdf")).slice(0, MAX_PDF_ARTIFACTS);
+  return Promise.all(
+    pdfs.map(async (entry) => {
+      const filename = path7.join(cwd, entry.name);
+      try {
+        const metadata = await fs6.stat(filename);
+        if (metadata.size > MAX_PDF_BYTES) {
+          return {
+            path: entry.name,
+            mediaType: "application/pdf",
+            check: "pdf_text_bounds",
+            status: "unavailable",
+            reason: `artifact exceeds ${MAX_PDF_BYTES} byte inspection bound`
+          };
+        }
+        const { stdout } = await execFileAsync("pdftotext", ["-bbox", filename, "-"], {
+          env: { ...process.env, PATH: executableSearchPath() },
+          maxBuffer: 8 * 1024 * 1024,
+          timeout: 15e3
+        });
+        return pdfTextBoundsDiagnostic(entry.name, stdout);
+      } catch (error) {
+        return {
+          path: entry.name,
+          mediaType: "application/pdf",
+          check: "pdf_text_bounds",
+          status: "unavailable",
+          reason: error instanceof Error ? error.message.slice(0, 500) : String(error).slice(0, 500)
+        };
+      }
+    })
+  );
+}
+function pdfTextBoundsDiagnostic(artifactPath, bboxXml) {
+  const clipped = [];
+  let pages = 0;
+  for (const pageMatch of bboxXml.matchAll(
+    /<page\s+width="([^"]+)"\s+height="([^"]+)"[^>]*>([\s\S]*?)<\/page>/g
+  )) {
+    pages += 1;
+    const width = Number(pageMatch[1]);
+    const height = Number(pageMatch[2]);
+    for (const wordMatch of pageMatch[3].matchAll(
+      /<word\s+xMin="([^"]+)"\s+yMin="([^"]+)"\s+xMax="([^"]+)"\s+yMax="([^"]+)"[^>]*>([\s\S]*?)<\/word>/g
+    )) {
+      const [xMin, yMin, xMax, yMax] = wordMatch.slice(1, 5).map(Number);
+      if (xMin >= 0 && yMin >= 0 && xMax <= width && yMax <= height) continue;
+      clipped.push({
+        page: pages,
+        text: decodeXmlText(wordMatch[5]).slice(0, 120),
+        xMin,
+        yMin,
+        xMax,
+        yMax,
+        pageWidth: width,
+        pageHeight: height
+      });
+    }
+  }
+  return {
+    path: artifactPath,
+    mediaType: "application/pdf",
+    check: "pdf_text_bounds",
+    status: clipped.length > 0 ? "failed" : "passed",
+    pages,
+    clippedTextCount: clipped.length,
+    examples: clipped.slice(0, 10)
+  };
+}
+function decodeXmlText(value) {
+  return value.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;|&apos;/g, "'");
+}
+function countAbsoluteLinks(value) {
+  if (!value) return 0;
+  return value.match(/https?:\/\/[^\s<>)\]}"']+/gi)?.length ?? 0;
+}
+function assistantOutputForTurn(events, turnId) {
+  const output = events.filter(
+    (runtimeEvent) => runtimeEvent.turnId === turnId && runtimeEvent.name === "assistant.delta" && typeof runtimeEvent.output === "string"
+  ).sort(compareRuntimeEvents).map((runtimeEvent) => runtimeEvent.output).join("");
+  return output ? redactAndBoundRefinerText(output, 8e3) : null;
+}
+async function loadExactObservations(store, workspaceId, trigger) {
+  const available = await store.listHarnessImprovementArtifacts(
+    workspaceId,
+    "observation",
+    1e3
+  );
+  const byHash = new Map(
+    available.map((artifact) => {
+      const observation = ImprovementObservationSchema.parse(artifact);
+      return [observation.contentHash, observation];
+    })
+  );
+  return trigger.observations.map((reference) => {
+    const observation = byHash.get(reference.contentHash);
+    if (!observation || observation.id !== reference.id) {
+      throw new Error(`Refiner observation ${reference.id} is unavailable or hash-mismatched.`);
+    }
+    return observation;
+  });
+}
+async function readBoundedRefinerSource(bundlePath, trigger) {
+  const loadedSkillNames = loadedSkillNamesFromTrigger(trigger);
+  const sourceRoot = path7.resolve(bundlePath, "source");
+  const manifest = HarnessSourceManifestSchema.parse(
+    JSON.parse(await fs6.readFile(path7.join(sourceRoot, "harness.json"), "utf8"))
+  );
+  let remaining = MAX_REFINER_SOURCE_BYTES;
+  const result = [];
+  const catalog = manifest.files.filter(
+    (file) => ["instruction", "skill", "agent"].includes(file.kind) && file.visibility === "policy"
+  ).map((file) => ({
+    path: file.path,
+    kind: file.kind,
+    loaded: file.kind === "skill" && loadedSkillNames.has(skillNameFromPath(file.path))
+  }));
+  for (const file of manifest.files) {
+    if (!["instruction", "skill", "agent"].includes(file.kind) || file.visibility !== "policy" || !["text/markdown", "text/plain", "text/javascript"].includes(file.mediaType)) {
+      continue;
+    }
+    const target = containedSourcePath(sourceRoot, file.path);
+    const stats = await fs6.lstat(target);
+    if (!stats.isFile() || stats.isSymbolicLink()) continue;
+    const bytes = await fs6.readFile(target);
+    if (bytes.byteLength > remaining) continue;
+    result.push({
+      path: file.path,
+      kind: file.kind,
+      content: bytes.toString("utf8"),
+      loaded: file.kind === "skill" && loadedSkillNames.has(skillNameFromPath(file.path))
+    });
+    remaining -= bytes.byteLength;
+  }
+  return { manifest, files: result, catalog };
+}
+function selectRefinerEvidenceWindow(input) {
+  const orderedExact = [...input.exactEvents].sort(compareRuntimeEvents);
+  const firstEvidenceSequence = orderedExact.reduce(
+    (first, runtimeEvent) => {
+      if (runtimeEvent.sequence === void 0) return first;
+      return first === null ? runtimeEvent.sequence : Math.min(first, runtimeEvent.sequence);
+    },
+    null
+  );
+  const candidates = input.events.filter(
+    (runtimeEvent) => runtimeEvent.turnId === input.turnId && isRefinerEvidenceEvent(runtimeEvent) && (firstEvidenceSequence === null || runtimeEvent.sequence === void 0 || runtimeEvent.sequence >= firstEvidenceSequence) && (runtimeEvent.sequence === void 0 || runtimeEvent.sequence <= input.boundarySequence)
+  ).sort(compareRuntimeEvents);
+  if (candidates.length <= input.limit) return candidates;
+  const exactIds = new Set(orderedExact.map((runtimeEvent) => runtimeEvent.id));
+  const retainedExact = orderedExact.slice(0, input.limit);
+  const remaining = input.limit - retainedExact.length;
+  if (remaining <= 0) return retainedExact;
+  const tail = candidates.filter((runtimeEvent) => !exactIds.has(runtimeEvent.id)).slice(-remaining);
+  return [...retainedExact, ...tail].sort(compareRuntimeEvents);
+}
+function isRefinerEvidenceEvent(runtimeEvent) {
+  return [
+    "tool.completed",
+    "workspace_action_result",
+    "skill.loaded",
+    "validation.completed"
+  ].includes(runtimeEvent.name);
+}
+function compareRuntimeEvents(left, right) {
+  return (left.sequence ?? Number.MAX_SAFE_INTEGER) - (right.sequence ?? Number.MAX_SAFE_INTEGER);
+}
+function textField(value, maxLength) {
+  return typeof value === "string" ? redactAndBoundRefinerText(value, maxLength) : null;
+}
+function redactAndBoundRefinerText(value, maxLength) {
+  const redacted = value.replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [redacted]").replace(
+    /\b(api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret)(\s*[:=]\s*)([^\s,;]+)/gi,
+    "$1$2[redacted]"
+  );
+  return redacted.length <= maxLength ? redacted : `${redacted.slice(0, maxLength)}
+[truncated]`;
+}
+function loadedSkillNamesFromTrigger(trigger) {
+  const names = trigger.metadata.loadedSkillNames;
+  if (!Array.isArray(names)) return /* @__PURE__ */ new Set();
+  return new Set(
+    names.filter((name) => typeof name === "string" && name.trim().length > 0)
+  );
+}
+function skillNameFromPath(sourcePath) {
+  const match = /^skills\/([^/]+)\/SKILL\.md$/.exec(sourcePath.replaceAll("\\", "/"));
+  return match?.[1] ?? "";
+}
+function containedSourcePath(root, relativePath) {
+  const target = path7.resolve(root, ...relativePath.replaceAll("\\", "/").split("/"));
+  const relative = path7.relative(root, target);
+  if (!relative || relative.startsWith("..") || path7.isAbsolute(relative)) {
+    throw new Error(`Harness source path escapes its immutable bundle: ${relativePath}`);
+  }
+  return target;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
 // ../server/src/harness/local-harness-evaluation-review.ts
 var ReviewSourcePolicySchema = external_exports.object({
   sourceRef: external_exports.string().trim().min(1),
@@ -7615,16 +7935,26 @@ var LocalHarnessEvaluationReviewRequestSchema = external_exports.object({
   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)
+    maxDurationMs: external_exports.number().int().min(1).max(3e5).default(24e4),
+    maxEstimatedCostUsd: external_exports.number().finite().nonnegative().default(0.1)
   }).strict().default({
     maxEvidence: 200,
     maxTokens: 5e4,
-    maxDurationMs: 5e3,
-    maxEstimatedCostUsd: 0
+    maxDurationMs: 24e4,
+    maxEstimatedCostUsd: 0.1
   })
 }).strict();
-async function reviewSelectedLocalHarnessEvaluation(input) {
+var activeReviews = /* @__PURE__ */ new WeakMap();
+function reviewSelectedLocalHarnessEvaluation(input) {
+  const active = activeReviews.get(input.store);
+  if (active) return active;
+  const review = runSelectedLocalHarnessEvaluation(input).finally(() => {
+    if (activeReviews.get(input.store) === review) activeReviews.delete(input.store);
+  });
+  activeReviews.set(input.store, review);
+  return review;
+}
+async function runSelectedLocalHarnessEvaluation(input) {
   const request = LocalHarnessEvaluationReviewRequestSchema.parse(input.request ?? {});
   const startedAt = performance.now();
   const selectedRelease = await resolveSelectedLocalHarnessRelease(input.store);
@@ -7635,12 +7965,13 @@ async function reviewSelectedLocalHarnessEvaluation(input) {
   if (!workspace) {
     throw new Error(`Selected Harness workspace ${selectedRelease.workspaceId} does not exist.`);
   }
-  const [reviews, routes, triggers, observations, applyReceipts] = await Promise.all([
+  const [reviews, routes, triggers, observations, applyReceipts, outcomes] = 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)
+    input.store.listHarnessImprovementArtifacts(workspace.id, "apply_receipt", 1e3),
+    input.store.listHarnessImprovementArtifacts(workspace.id, "refiner_outcome", 1e3)
   ]);
   const latestReview = reviews[0] ?? null;
   const previousWatermark = request.previousWatermark ?? latestReview?.nextWatermark ?? null;
@@ -7648,7 +7979,13 @@ async function reviewSelectedLocalHarnessEvaluation(input) {
   const typedTriggers = triggers;
   const typedObservations = observations;
   const typedApplyReceipts = applyReceipts;
-  if (request.previousWatermark === void 0 && latestReview && !typedRoutes.some((route) => route.createdAt > latestReview.nextWatermark.throughCreatedAt)) {
+  const typedOutcomes = outcomes;
+  const allArtifacts = [
+    ...typedRoutes,
+    ...typedObservations,
+    ...typedOutcomes
+  ];
+  if (request.previousWatermark === void 0 && latestReview && !allArtifacts.some((artifact) => artifact.createdAt > latestReview.nextWatermark.throughCreatedAt)) {
     return latestReview;
   }
   const triggerByRef = new Map(
@@ -7659,97 +7996,267 @@ async function reviewSelectedLocalHarnessEvaluation(input) {
   );
   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) {
+  const rawCandidates = [];
+  const representedObservationKeys = /* @__PURE__ */ new Set();
+  const routedTriggerKeys = new Set(typedRoutes.map((route) => artifactKey(route.trigger)));
+  const eventsBySource = /* @__PURE__ */ new Map();
+  const artifactDiagnosticsBySource = /* @__PURE__ */ new Map();
+  const contextForObservation = async (observation) => {
+    let sourceEvents = eventsBySource.get(observation.runRef);
+    if (!sourceEvents) {
+      sourceEvents = await input.store.runtimeEventsForSession(observation.runRef);
+      eventsBySource.set(observation.runRef, sourceEvents);
+    }
+    const turnEvents = sourceEvents.filter((event2) => event2.turnId === observation.turnId);
+    const [turn, session] = await Promise.all([
+      input.store.getTurn(observation.turnId),
+      input.store.getSession(observation.runRef)
+    ]);
+    let artifactDiagnostics = artifactDiagnosticsBySource.get(observation.runRef);
+    if (!artifactDiagnostics) {
+      artifactDiagnostics = await inspectBoundedPdfArtifactDiagnostics(session?.cwd);
+      artifactDiagnosticsBySource.set(observation.runRef, artifactDiagnostics);
+    }
+    return {
+      turn: turn ? {
+        id: turn.id,
+        prompt: boundedReviewText(turn.prompt, 2e3),
+        startedAt: turn.startedAt,
+        completedAt: turn.completedAt,
+        status: turn.status,
+        error: boundedReviewText(turn.error ?? "", 1e3)
+      } : null,
+      assistantOutput: boundedReviewText(
+        turnEvents.filter((event2) => event2.name === "assistant.delta").map((event2) => event2.output ?? "").join(""),
+        6e3
+      ),
+      artifactDiagnostics,
+      events: turnEvents.filter((event2) => [
+        "tool.completed",
+        "validation.completed",
+        "workspace_action_result"
+      ].includes(event2.name)).filter(
+        (event2) => event2.status === "failed" || ["validation.completed", "workspace_action_result"].includes(event2.name)
+      ).slice(-8).map(boundedReviewEvent)
+    };
+  };
+  for (const routeDecision of typedRoutes) {
+    const trigger = triggerByRef.get(artifactKey(routeDecision.trigger));
+    if (!trigger) {
       excludedEvidence.push({
         evidence: artifactRef(routeDecision),
         sourcePolicy: null,
-        reason: "budget"
+        reason: "unverified"
       });
       continue;
     }
-    if (previousWatermark && routeDecision.createdAt <= previousWatermark.throughCreatedAt) {
+    const linkedObservations = trigger.observations.map((reference) => observationByRef.get(artifactKey(reference))).filter((value) => Boolean(value));
+    for (const observation of linkedObservations) {
+      representedObservationKeys.add(artifactKey(observation));
+    }
+    rawCandidates.push({
+      id: `route_decision:${routeDecision.id}`,
+      artifact: routeDecision,
+      kind: "route_decision",
+      sourceRef: linkedObservations[0]?.runRef ?? trigger.runRef,
+      payload: {
+        routeDecision,
+        trigger,
+        observations: linkedObservations,
+        turnContexts: await uniqueTurnContexts(linkedObservations, contextForObservation)
+      }
+    });
+  }
+  for (const outcome of typedOutcomes) {
+    if (routedTriggerKeys.has(artifactKey(outcome.trigger))) continue;
+    const trigger = triggerByRef.get(artifactKey(outcome.trigger));
+    if (!trigger) {
       excludedEvidence.push({
-        evidence: artifactRef(routeDecision),
+        evidence: artifactRef(outcome),
         sourcePolicy: null,
-        reason: "before_watermark"
+        reason: "unverified"
       });
       continue;
     }
-    if (examined >= request.limits.maxEvidence) {
+    const linkedObservations = trigger.observations.map((reference) => observationByRef.get(artifactKey(reference))).filter((value) => Boolean(value));
+    for (const observation of linkedObservations) {
+      representedObservationKeys.add(artifactKey(observation));
+    }
+    const linkedApplyReceipts = outcome.proposal ? typedApplyReceipts.filter(
+      (receipt2) => artifactKey(receipt2.proposal) === artifactKey(outcome.proposal)
+    ) : [];
+    rawCandidates.push({
+      id: `refiner_outcome:${outcome.id}`,
+      artifact: outcome,
+      kind: "refiner_outcome",
+      sourceRef: linkedObservations[0]?.runRef ?? trigger.runRef,
+      payload: {
+        outcome,
+        trigger,
+        observations: linkedObservations,
+        turnContexts: await uniqueTurnContexts(linkedObservations, contextForObservation),
+        applyReceipts: linkedApplyReceipts
+      }
+    });
+  }
+  for (const observation of typedObservations) {
+    if (representedObservationKeys.has(artifactKey(observation))) continue;
+    rawCandidates.push({
+      id: `observation:${observation.id}`,
+      artifact: observation,
+      kind: "observation",
+      sourceRef: observation.runRef,
+      payload: {
+        observation,
+        turnContext: await contextForObservation(observation)
+      }
+    });
+  }
+  const candidates = [];
+  const watermarkedArtifacts = [];
+  let examined = 0;
+  let estimatedTokens = 0;
+  for (const candidate of rawCandidates.slice().sort(
+    (left, right) => left.artifact.createdAt.localeCompare(right.artifact.createdAt) || left.id.localeCompare(right.id)
+  )) {
+    if (performance.now() - startedAt >= request.limits.maxDurationMs) {
       excludedEvidence.push({
-        evidence: artifactRef(routeDecision),
+        evidence: artifactRef(candidate.artifact),
         sourcePolicy: null,
         reason: "budget"
       });
       continue;
     }
-    examined += 1;
-    const trigger = triggerByRef.get(artifactKey(routeDecision.trigger));
-    if (!trigger) {
+    if (previousWatermark && candidate.artifact.createdAt <= previousWatermark.throughCreatedAt) {
       excludedEvidence.push({
-        evidence: artifactRef(routeDecision),
+        evidence: artifactRef(candidate.artifact),
         sourcePolicy: null,
-        reason: "unverified"
+        reason: "before_watermark"
       });
       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"
-    )) {
+    if (examined >= request.limits.maxEvidence) {
       excludedEvidence.push({
-        evidence: artifactRef(routeDecision),
+        evidence: artifactRef(candidate.artifact),
         sourcePolicy: null,
-        reason: "resolved"
+        reason: "budget"
       });
       continue;
     }
-    const candidateTokens = Math.ceil(JSON.stringify({ routeDecision, trigger, observation }).length / 4);
+    examined += 1;
+    const candidateTokens = Math.ceil(JSON.stringify(candidate.payload).length / 4);
     if (estimatedTokens + candidateTokens > request.limits.maxTokens) {
       excludedEvidence.push({
-        evidence: artifactRef(routeDecision),
+        evidence: artifactRef(candidate.artifact),
         sourcePolicy: null,
         reason: "budget"
       });
       continue;
     }
     estimatedTokens += candidateTokens;
-    const sourceRef = observation?.runRef ?? trigger.runRef;
-    const policy = policyBySource.get(sourceRef);
+    watermarkedArtifacts.push(candidate.artifact);
+    const policy = policyBySource.get(candidate.sourceRef);
     if (!policy || policy.state !== "authorized") {
       excludedEvidence.push({
-        evidence: artifactRef(routeDecision),
+        evidence: artifactRef(candidate.artifact),
         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
+    candidates.push(candidate);
+  }
+  let modelDecision = {
+    schemaVersion: "openpond.harnessEvaluationReviewModelDecision.v1",
+    decision: "no_action",
+    reason: "No authorized unresolved evidence qualified for model review.",
+    ignoredEvidence: []
+  };
+  let modelUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+  const navigation = { selectedIds: null };
+  if (candidates.length > 0 && request.limits.maxEstimatedCostUsd === 0) {
+    for (const candidate of candidates) {
+      excludedEvidence.push({
+        evidence: artifactRef(candidate.artifact),
+        sourcePolicy: sourcePolicyRef(policyBySource.get(candidate.sourceRef)),
+        reason: "budget"
+      });
+    }
+    modelDecision = {
+      schemaVersion: "openpond.harnessEvaluationReviewModelDecision.v1",
+      decision: "no_action",
+      reason: "Continuous review is disabled by a zero model-cost ceiling.",
+      ignoredEvidence: candidates.map((candidate) => ({
+        id: candidate.id,
+        reason: "The configured model-cost ceiling is zero."
+      }))
+    };
+  } else if (candidates.length > 0) {
+    if (!input.stream) {
+      throw new Error("Harness continuous review requires a model stream.");
+    }
+    modelDecision = await authorHarnessEvaluationReviewWithModel({
+      evidence: candidates.map((candidate) => ({
+        id: candidate.id,
+        evidence: artifactRef(candidate.artifact),
+        kind: candidate.kind,
+        sourceRef: candidate.sourceRef,
+        occurredAt: candidate.artifact.createdAt,
+        payload: candidate.payload
+      })),
+      harnessRelease: artifactRef(selectedRelease.harnessRelease),
+      previousReviews: reviews.slice(0, 20),
+      stream: async function* (streamInput) {
+        let invocationUsage = null;
+        for await (const delta of input.stream(streamInput)) {
+          if (delta.usage) invocationUsage = delta.usage;
+          yield delta;
+        }
+        if (invocationUsage) {
+          modelUsage = {
+            promptTokens: modelUsage.promptTokens + invocationUsage.promptTokens,
+            completionTokens: modelUsage.completionTokens + invocationUsage.completionTokens,
+            totalTokens: modelUsage.totalTokens + invocationUsage.totalTokens
+          };
+        }
+      },
+      signal: input.signal ?? new AbortController().signal,
+      timeoutMs: request.limits.maxDurationMs,
+      onNavigation: (decision) => {
+        navigation.selectedIds = new Set(decision.selectedEvidenceIds);
+      }
+    });
+  }
+  const deferredCandidates = navigation.selectedIds ? candidates.filter((candidate) => !navigation.selectedIds.has(candidate.id)) : [];
+  for (const candidate of deferredCandidates) {
+    excludedEvidence.push({
+      evidence: artifactRef(candidate.artifact),
+      sourcePolicy: sourcePolicyRef(policyBySource.get(candidate.sourceRef)),
+      reason: "budget"
     });
   }
-  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 selectedCandidates = modelDecision.decision === "review" ? modelDecision.selectedEvidenceIds.map((id) => {
+    const candidate = candidates.find((item) => item.id === id);
+    if (!candidate) throw new Error(`Review selected unavailable evidence ${id}.`);
+    return candidate;
+  }) : [];
+  const classification = modelDecision.decision === "review" ? modelDecision.classification : "no_action";
+  const selectedEvidence = selectedCandidates.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 deferredArtifactKeys = new Set(
+    deferredCandidates.map((candidate) => artifactKey(candidate.artifact))
+  );
+  const examinedArtifacts = watermarkedArtifacts.filter(
+    (artifact) => !deferredArtifactKeys.has(artifactKey(artifact))
+  );
+  const examinedCreatedAt = examinedArtifacts.map((artifact) => artifact.createdAt).sort().at(-1);
+  const throughCreatedAt = examinedCreatedAt ? maxTimestamp(previousWatermark?.throughCreatedAt, examinedCreatedAt) : maxTimestamp(previousWatermark?.throughCreatedAt, 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)
+    examined: examinedArtifacts.map(artifactRef)
   });
   const receiptId = `evaluation-review-${contentHash({
     workspaceId: workspace.id,
@@ -7767,33 +8274,43 @@ async function reviewSelectedLocalHarnessEvaluation(input) {
     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),
+    claim: modelDecision.decision === "review" ? {
+      fingerprint: contentHash({
+        family: modelDecision.recurrenceFamily,
+        evidence: selectedEvidence.map((item) => item.occurrenceKey)
+      }),
+      recurrenceFamily: modelDecision.recurrenceFamily,
+      statement: modelDecision.statement,
+      independentOccurrences: new Set(selectedCandidates.map((item) => item.sourceRef)).size,
+      unresolvedOccurrences: new Set(selectedCandidates.map((item) => item.sourceRef)).size
+    } : null,
+    classification,
+    triage: modelDecision.decision === "review" ? [{
+      layer: modelDecision.triageLayer,
       status: "unresolved",
-      reason: decision.reason,
+      reason: modelDecision.reason,
       evidenceRefs: selectedEvidence.map((item) => item.evidence)
-    }],
-    reason: decision.reason,
-    nextAuthority: nextAuthority(decision.classification),
+    }] : [],
+    reason: modelDecision.reason,
+    nextAuthority: nextAuthority(classification),
     maxEstimatedCostUsd: request.limits.maxEstimatedCostUsd,
     tasksetProposal: null,
     evaluation: null,
     trainingQualification: null,
-    policyVersion: "local-harness-evaluation-review-v1",
+    policyVersion: "public-model-driven-harness-review-v1",
     createdAt,
     metadata: {
       examinedEvidence: examined,
+      fullyReviewedEvidence: navigation.selectedIds?.size ?? candidates.length,
       estimatedTokens,
       elapsedMs: performance.now() - startedAt,
-      explicitInvocation: true
+      explicitInvocation: true,
+      modelDecision: modelDecision.decision,
+      modelConfidence: modelDecision.decision === "review" ? modelDecision.confidence : null,
+      counterevidence: modelDecision.decision === "review" ? modelDecision.counterevidence : null,
+      expectedOutcome: modelDecision.decision === "review" ? modelDecision.expectedOutcome : null,
+      ignoredEvidence: modelDecision.ignoredEvidence,
+      modelUsage
     }
   });
   await input.store.saveHarnessImprovementArtifact(workspace.id, "evaluation_review", receipt);
@@ -7808,66 +8325,19 @@ function artifactKey(artifact) {
 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",
+    evidence: artifactRef(candidate.artifact),
+    kind: candidate.kind,
     sourceRef: candidate.sourceRef,
     sourcePolicy: sourcePolicyRef(policy),
-    occurrenceKey: contentHash({ family: candidate.family, sourceRef: candidate.sourceRef }),
-    occurredAt: candidate.routeDecision.createdAt
+    occurrenceKey: contentHash({
+      evidence: artifactRef(candidate.artifact),
+      sourceRef: candidate.sourceRef
+    }),
+    occurredAt: candidate.artifact.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";
@@ -7876,16 +8346,53 @@ function nextAuthority(classification) {
   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);
 }
+function boundedReviewEvent(event2) {
+  const data = asRecord2(event2.data);
+  const result = asRecord2(data.result);
+  return {
+    id: event2.id,
+    name: event2.name,
+    action: event2.action ?? (typeof data.tool === "string" ? data.tool : null),
+    status: event2.status ?? null,
+    error: boundedReviewText(event2.error ?? "", 750),
+    output: boundedReviewText(
+      typeof result.output === "string" ? result.output : event2.output ?? "",
+      750
+    ),
+    stderr: boundedReviewText(
+      typeof result.stderr === "string" ? result.stderr : "",
+      750
+    ),
+    exitCode: typeof result.exitCode === "number" ? result.exitCode : null,
+    timedOut: result.timedOut === true
+  };
+}
+async function uniqueTurnContexts(observations, load) {
+  const byTurn = /* @__PURE__ */ new Map();
+  for (const observation of observations) {
+    byTurn.set(`${observation.runRef}:${observation.turnId}`, observation);
+  }
+  return Promise.all([...byTurn.values()].map(load));
+}
+function boundedReviewText(value, maxLength) {
+  if (!value) return null;
+  const redacted = value.replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [redacted]").replace(
+    /\b(api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret)(\s*[:=]\s*)([^\s,;]+)/gi,
+    "$1$2[redacted]"
+  );
+  if (redacted.length <= maxLength) return redacted;
+  const marker = "\n[... middle omitted ...]\n";
+  const available = Math.max(0, maxLength - marker.length);
+  const headLength = Math.ceil(available / 2);
+  const tailLength = Math.floor(available / 2);
+  return `${redacted.slice(0, headLength)}${marker}${redacted.slice(-tailLength)}`;
+}
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
 
 // ../server/src/harness/local-harness-evaluation-review-host.ts
 var SOURCE_POLICY_VERSION = "local-personal-work-v1";
@@ -7934,16 +8441,19 @@ async function reviewSelectedLocalHarnessEvaluationFromHost(input) {
       limits: {
         maxEvidence: 200,
         maxTokens: 5e4,
-        maxDurationMs: 5e3,
+        maxDurationMs: 24e4,
         maxEstimatedCostUsd: input.maxEstimatedCostUsd
       }
     },
+    stream: input.stream,
+    signal: input.signal,
     now: input.now
   });
 }
 
 // ../server/src/harness/local-harness-evaluation-review-scheduler.ts
 var DEFAULT_TICK_MS = 15e3;
+var EVENT_DRIVEN_REVIEW_BATCH_SIZE = 10;
 function nextHarnessEvaluationReviewRunAt(cadence, from) {
   if (cadence === "manual") return null;
   const next = new Date(from);
@@ -7964,10 +8474,16 @@ function createLocalHarnessEvaluationReviewScheduler(input) {
       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;
+      if (!settings.enabled) return null;
+      const scheduledDue = settings.cadence !== "manual" && Boolean(settings.nextRunAt) && settings.nextRunAt <= startedAt;
+      const eventDrivenDue = await hasEventDrivenReviewBatch({
+        store: input.store,
+        workspaceId: workspace.id
+      });
+      if (!scheduledDue && !eventDrivenDue) return null;
       const claimed = {
         ...settings,
-        nextRunAt: nextHarnessEvaluationReviewRunAt(settings.cadence, startedAt),
+        nextRunAt: scheduledDue ? nextHarnessEvaluationReviewRunAt(settings.cadence, startedAt) : settings.nextRunAt,
         lastRunAt: startedAt,
         lastError: null,
         updatedAt: startedAt
@@ -7981,6 +8497,7 @@ function createLocalHarnessEvaluationReviewScheduler(input) {
           store: input.store,
           workspaceId: workspace.id,
           maxEstimatedCostUsd: settings.maxEstimatedCostUsd,
+          stream: input.stream,
           now: now2
         });
         await input.store.setHarnessEvaluationReviewSettings({
@@ -8035,6 +8552,18 @@ function createLocalHarnessEvaluationReviewScheduler(input) {
     runDueNow
   };
 }
+async function hasEventDrivenReviewBatch(input) {
+  const [outcomes, reviews] = await Promise.all([
+    input.store.listHarnessImprovementArtifacts(
+      input.workspaceId,
+      "refiner_outcome",
+      EVENT_DRIVEN_REVIEW_BATCH_SIZE
+    ),
+    input.store.listHarnessImprovementArtifacts(input.workspaceId, "evaluation_review", 1)
+  ]);
+  const watermark = reviews[0]?.nextWatermark.throughCreatedAt ?? null;
+  return outcomes.filter((outcome) => !watermark || outcome.createdAt > watermark).length >= EVENT_DRIVEN_REVIEW_BATCH_SIZE;
+}
 
 // ../server/src/harness/local-harness-history.ts
 function createLocalHarnessSettingsRoutePayloads(input) {
@@ -8046,6 +8575,7 @@ function createLocalHarnessSettingsRoutePayloads(input) {
     }),
     reviewHarnessEvaluationPayload: (payload) => reviewLocalHarnessEvaluationFromSettings({
       store: input.store,
+      stream: input.evaluationReviewStream,
       request: parseHarnessEvaluationReviewRequest(payload)
     }),
     updateHarnessEvaluationReviewSchedulePayload: (payload) => updateLocalHarnessEvaluationReviewScheduleFromSettings({
@@ -8319,7 +8849,8 @@ async function reviewLocalHarnessEvaluationFromSettings(input) {
   const receipt = await reviewSelectedLocalHarnessEvaluationFromHost({
     store: input.store,
     workspaceId: input.request.workspaceId,
-    maxEstimatedCostUsd: input.request.maxEstimatedCostUsd ?? settings.maxEstimatedCostUsd
+    maxEstimatedCostUsd: input.request.maxEstimatedCostUsd ?? settings.maxEstimatedCostUsd,
+    stream: input.stream
   });
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   await input.store.setHarnessEvaluationReviewSettings({
@@ -8387,9 +8918,9 @@ async function requireHarnessReleaseRecord(input) {
   return record6;
 }
 function releaseSourcePath(record6, filePath) {
-  const sourceRoot = path6.resolve(record6.bundlePath, "source");
-  const target = path6.resolve(sourceRoot, ...filePath.split("/"));
-  if (target !== sourceRoot && !target.startsWith(`${sourceRoot}${path6.sep}`)) {
+  const sourceRoot = path8.resolve(record6.bundlePath, "source");
+  const target = path8.resolve(sourceRoot, ...filePath.split("/"));
+  if (target !== sourceRoot && !target.startsWith(`${sourceRoot}${path8.sep}`)) {
     throw new Error(`Harness release contains an unsafe file path: ${filePath}.`);
   }
   return target;
@@ -9430,10 +9961,10 @@ function mergeSystemMessages(messages) {
     ...nonSystemMessages
   ];
 }
-function providerEndpointUrl(baseUrl, path46) {
+function providerEndpointUrl(baseUrl, path47) {
   const normalized = normalizeOpenAiCompatibleBaseUrl(baseUrl);
   if (!normalized) throw new Error("Provider base URL is required.");
-  return `${normalized}/${path46}`;
+  return `${normalized}/${path47}`;
 }
 function normalizeOpenAiCompatibleBaseUrl(value) {
   const trimmed = (value ?? "").trim();
@@ -9449,13 +9980,13 @@ function normalizeOpenAiCompatibleBaseUrl(value) {
   }
   url.search = "";
   url.hash = "";
-  const path46 = url.pathname.replace(/\/+$/, "");
-  if (/\/chat\/completions$/i.test(path46)) {
-    url.pathname = path46.replace(/\/chat\/completions$/i, "") || "/";
-  } else if (/\/models$/i.test(path46)) {
-    url.pathname = path46.replace(/\/models$/i, "") || "/";
+  const path47 = url.pathname.replace(/\/+$/, "");
+  if (/\/chat\/completions$/i.test(path47)) {
+    url.pathname = path47.replace(/\/chat\/completions$/i, "") || "/";
+  } else if (/\/models$/i.test(path47)) {
+    url.pathname = path47.replace(/\/models$/i, "") || "/";
   } else {
-    url.pathname = path46 || "/";
+    url.pathname = path47 || "/";
   }
   return url.toString().replace(/\/+$/, "");
 }
@@ -10153,190 +10684,6 @@ async function recordLocalHarnessImprovementBoundary(input) {
   return detection;
 }
 
-// ../server/src/harness/local-harness-refiner-context.ts
-import { promises as fs6 } from "node:fs";
-import path7 from "node:path";
-var MAX_REFINER_SOURCE_BYTES = 6e4;
-async function loadBoundedRefinerContext(store, trigger, observations) {
-  const [turn, events, turns] = await Promise.all([
-    store.getTurn(trigger.turnId),
-    store.runtimeEventsForSession(trigger.runRef, { limit: 1e3 }),
-    store.turnsForSession(trigger.runRef, 1e3)
-  ]);
-  const orderedTurns = [...turns].sort(
-    (left, right) => left.startedAt.localeCompare(right.startedAt)
-  );
-  const turnIndex = orderedTurns.findIndex((candidate) => candidate.id === trigger.turnId);
-  const previousTurn = turnIndex > 0 ? orderedTurns[turnIndex - 1] : null;
-  const eventRefs = new Map(
-    observations.flatMap(
-      (observation) => observation.eventRefs.map((reference) => [reference.id, reference])
-    )
-  );
-  const exactEvents = events.filter((runtimeEvent) => eventRefs.has(runtimeEvent.id));
-  for (const [eventId, reference] of eventRefs) {
-    const runtimeEvent = exactEvents.find((candidate) => candidate.id === eventId);
-    if (!runtimeEvent || contentHash(runtimeEvent) !== reference.contentHash) {
-      throw new Error(`Refiner runtime event ${eventId} is unavailable or hash-mismatched.`);
-    }
-  }
-  const evidenceEvents = selectRefinerEvidenceWindow({
-    events,
-    exactEvents,
-    turnId: trigger.turnId,
-    boundarySequence: trigger.boundary.eventSequence,
-    limit: trigger.policy.maxEvidenceEvents
-  });
-  return {
-    task: {
-      prompt: turn?.prompt ? redactAndBoundRefinerText(turn.prompt, 8e3) : null,
-      assistantOutput: assistantOutputForTurn(events, trigger.turnId),
-      previousAssistantOutput: previousTurn ? assistantOutputForTurn(events, previousTurn.id) : null
-    },
-    eventExcerpts: evidenceEvents.map((runtimeEvent) => {
-      const data = asRecord(runtimeEvent.data);
-      const result = asRecord(data.result);
-      return {
-        id: runtimeEvent.id,
-        name: runtimeEvent.name,
-        action: runtimeEvent.action ?? (typeof data.tool === "string" ? data.tool : null),
-        status: runtimeEvent.status ?? null,
-        command: textField(result.command, 3e3),
-        error: textField(runtimeEvent.error, 2e3),
-        output: textField(result.output, 2e3) ?? textField(runtimeEvent.output, 2e3),
-        exitCode: typeof result.exitCode === "number" ? result.exitCode : null,
-        timedOut: result.timedOut === true,
-        stderr: textField(result.stderr, 3e3),
-        stdout: textField(result.stdout, 3e3)
-      };
-    })
-  };
-}
-function assistantOutputForTurn(events, turnId) {
-  const output = events.filter(
-    (runtimeEvent) => runtimeEvent.turnId === turnId && runtimeEvent.name === "assistant.delta" && typeof runtimeEvent.output === "string"
-  ).sort(compareRuntimeEvents).map((runtimeEvent) => runtimeEvent.output).join("");
-  return output ? redactAndBoundRefinerText(output, 8e3) : null;
-}
-async function loadExactObservations(store, workspaceId, trigger) {
-  const available = await store.listHarnessImprovementArtifacts(
-    workspaceId,
-    "observation",
-    1e3
-  );
-  const byHash = new Map(
-    available.map((artifact) => {
-      const observation = ImprovementObservationSchema.parse(artifact);
-      return [observation.contentHash, observation];
-    })
-  );
-  return trigger.observations.map((reference) => {
-    const observation = byHash.get(reference.contentHash);
-    if (!observation || observation.id !== reference.id) {
-      throw new Error(`Refiner observation ${reference.id} is unavailable or hash-mismatched.`);
-    }
-    return observation;
-  });
-}
-async function readBoundedRefinerSource(bundlePath, trigger) {
-  const loadedSkillNames = loadedSkillNamesFromTrigger(trigger);
-  const sourceRoot = path7.resolve(bundlePath, "source");
-  const manifest = HarnessSourceManifestSchema.parse(
-    JSON.parse(await fs6.readFile(path7.join(sourceRoot, "harness.json"), "utf8"))
-  );
-  let remaining = MAX_REFINER_SOURCE_BYTES;
-  const result = [];
-  const catalog = manifest.files.filter(
-    (file) => ["instruction", "skill", "agent"].includes(file.kind) && file.visibility === "policy"
-  ).map((file) => ({
-    path: file.path,
-    kind: file.kind,
-    loaded: file.kind === "skill" && loadedSkillNames.has(skillNameFromPath(file.path))
-  }));
-  for (const file of manifest.files) {
-    if (!["instruction", "skill", "agent"].includes(file.kind) || file.visibility !== "policy" || !["text/markdown", "text/plain", "text/javascript"].includes(file.mediaType)) {
-      continue;
-    }
-    const target = containedSourcePath(sourceRoot, file.path);
-    const stats = await fs6.lstat(target);
-    if (!stats.isFile() || stats.isSymbolicLink()) continue;
-    const bytes = await fs6.readFile(target);
-    if (bytes.byteLength > remaining) continue;
-    result.push({
-      path: file.path,
-      kind: file.kind,
-      content: bytes.toString("utf8"),
-      loaded: file.kind === "skill" && loadedSkillNames.has(skillNameFromPath(file.path))
-    });
-    remaining -= bytes.byteLength;
-  }
-  return { manifest, files: result, catalog };
-}
-function selectRefinerEvidenceWindow(input) {
-  const orderedExact = [...input.exactEvents].sort(compareRuntimeEvents);
-  const firstEvidenceSequence = orderedExact.reduce(
-    (first, runtimeEvent) => {
-      if (runtimeEvent.sequence === void 0) return first;
-      return first === null ? runtimeEvent.sequence : Math.min(first, runtimeEvent.sequence);
-    },
-    null
-  );
-  const candidates = input.events.filter(
-    (runtimeEvent) => runtimeEvent.turnId === input.turnId && isRefinerEvidenceEvent(runtimeEvent) && (firstEvidenceSequence === null || runtimeEvent.sequence === void 0 || runtimeEvent.sequence >= firstEvidenceSequence) && (runtimeEvent.sequence === void 0 || runtimeEvent.sequence <= input.boundarySequence)
-  ).sort(compareRuntimeEvents);
-  if (candidates.length <= input.limit) return candidates;
-  const exactIds = new Set(orderedExact.map((runtimeEvent) => runtimeEvent.id));
-  const retainedExact = orderedExact.slice(0, input.limit);
-  const remaining = input.limit - retainedExact.length;
-  if (remaining <= 0) return retainedExact;
-  const tail = candidates.filter((runtimeEvent) => !exactIds.has(runtimeEvent.id)).slice(-remaining);
-  return [...retainedExact, ...tail].sort(compareRuntimeEvents);
-}
-function isRefinerEvidenceEvent(runtimeEvent) {
-  return [
-    "tool.completed",
-    "workspace_action_result",
-    "skill.loaded",
-    "validation.completed"
-  ].includes(runtimeEvent.name);
-}
-function compareRuntimeEvents(left, right) {
-  return (left.sequence ?? Number.MAX_SAFE_INTEGER) - (right.sequence ?? Number.MAX_SAFE_INTEGER);
-}
-function textField(value, maxLength) {
-  return typeof value === "string" ? redactAndBoundRefinerText(value, maxLength) : null;
-}
-function redactAndBoundRefinerText(value, maxLength) {
-  const redacted = value.replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [redacted]").replace(
-    /\b(api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret)(\s*[:=]\s*)([^\s,;]+)/gi,
-    "$1$2[redacted]"
-  );
-  return redacted.length <= maxLength ? redacted : `${redacted.slice(0, maxLength)}
-[truncated]`;
-}
-function loadedSkillNamesFromTrigger(trigger) {
-  const names = trigger.metadata.loadedSkillNames;
-  if (!Array.isArray(names)) return /* @__PURE__ */ new Set();
-  return new Set(
-    names.filter((name) => typeof name === "string" && name.trim().length > 0)
-  );
-}
-function skillNameFromPath(sourcePath) {
-  const match = /^skills\/([^/]+)\/SKILL\.md$/.exec(sourcePath.replaceAll("\\", "/"));
-  return match?.[1] ?? "";
-}
-function containedSourcePath(root, relativePath) {
-  const target = path7.resolve(root, ...relativePath.replaceAll("\\", "/").split("/"));
-  const relative = path7.relative(root, target);
-  if (!relative || relative.startsWith("..") || path7.isAbsolute(relative)) {
-    throw new Error(`Harness source path escapes its immutable bundle: ${relativePath}`);
-  }
-  return target;
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-
 // ../server/src/harness/local-harness-refiner-worker-support.ts
 async function findRefinerOutcome(store, workspaceId, trigger) {
   const outcomes = await store.listHarnessImprovementArtifacts(
@@ -10453,36 +10800,62 @@ async function runLocalHarnessRefinerWorker(input) {
     content: entry.content,
     loaded: true
   }));
-  source.catalog.push(...memorySource.map(({ path: path46, kind, loaded }) => ({ path: path46, kind, loaded })));
+  source.catalog.push(...memorySource.map(({ path: path47, kind, loaded }) => ({ path: path47, kind, loaded })));
   source.files.push(...memorySource);
   const boundedContext = await loadBoundedRefinerContext(
     input.store,
     trigger,
     observations
   );
-  if (observations.every((observation) => observation.kind === "user_turn") && boundedContext.task.previousAssistantOutput === null) {
-    return persistNoAction({
-      store: input.store,
-      workspace,
-      overlay,
-      trigger,
-      observations,
-      reason: "The initial user turn has no prior result to improve and contains no execution evidence.",
-      now: input.now
+  const refinerEvidence = {
+    trigger: boundedTriggerEvidence(trigger),
+    observations: observations.map(boundedObservationEvidence),
+    task: boundedContext.task,
+    eventExcerpts: boundedContext.eventExcerpts,
+    artifactDiagnostics: boundedContext.artifactDiagnostics,
+    sourceFiles: source.files,
+    sourceCatalog: source.catalog
+  };
+  let decision;
+  if (input.stream) {
+    decision = await authorLocalHarnessRefinementWithModel({
+      evidence: refinerEvidence,
+      stream: input.stream,
+      signal: input.signal
+    });
+  } else if (input.refine) {
+    const request = HostedHarnessRefinerRequestSchema.parse({
+      schemaVersion: "openpond.hostedHarnessRefinerRequest.v1",
+      requestId: trigger.id,
+      idempotencyKey: trigger.contentHash,
+      evidenceHash: contentHash(refinerEvidence),
+      harness: {
+        admittedRelease: overlay.baseHarnessRelease,
+        currentRelease: effectiveReleaseRef,
+        overlay: overlayRef(overlay),
+        workspace: {
+          id: workspace.id,
+          revision: workspace.revision,
+          sourceRevision: workspace.sourceRevision,
+          channelRevision: workspace.currentChannel.revision
+        },
+        capabilities: {
+          memory: true,
+          prompt: true,
+          skill: true,
+          agent: false
+        }
+      },
+      evidence: refinerEvidence
     });
+    const response = HostedHarnessRefinerResponseSchema.parse(
+      await input.refine({ request, signal: input.signal })
+    );
+    assertHostedResponseBinding(request, response);
+    decision = response.decision;
+  } else {
+    throw new Error("Harness Refiner requires a public model stream or managed adapter.");
   }
-  const decision = await authorLocalHarnessRefinementWithModel({
-    evidence: {
-      trigger: boundedTriggerEvidence(trigger),
-      observations: observations.map(boundedObservationEvidence),
-      task: boundedContext.task,
-      eventExcerpts: boundedContext.eventExcerpts,
-      sourceFiles: source.files,
-      sourceCatalog: source.catalog
-    },
-    stream: input.stream,
-    signal: input.signal
-  });
   if (decision.decision === "no_action") {
     return persistNoAction({
       store: input.store,
@@ -10582,6 +10955,11 @@ async function runLocalHarnessRefinerWorker(input) {
     observations
   });
 }
+function assertHostedResponseBinding(request, response) {
+  if (response.requestId !== request.requestId || response.evidenceHash !== request.evidenceHash || response.admittedRelease.id !== request.harness.admittedRelease.id || response.admittedRelease.contentHash !== request.harness.admittedRelease.contentHash || response.currentRelease.id !== request.harness.currentRelease.id || response.currentRelease.contentHash !== request.harness.currentRelease.contentHash) {
+    throw new Error("Managed Harness Refiner response binding does not match the request.");
+  }
+}
 async function finishPersistedProposal(input) {
   const timestamp = (input.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))();
   let validations = await findProposalValidations(
@@ -11100,6 +11478,7 @@ function createLocalHarnessImprovementRuntime(input) {
             triggerId: trigger.id,
             timeoutMs: DEFAULT_REFINER_TIMEOUT_MS,
             maxOutputTokens: DEFAULT_REFINER_MAX_OUTPUT_TOKENS,
+            execution: "public_package",
             recoveredAfterRestart
           }
         })
@@ -11138,6 +11517,7 @@ function createLocalHarnessImprovementRuntime(input) {
                 queueWaitMs: Math.max(0, jobStartedAtMs - queuedAtMs),
                 timeoutMs: DEFAULT_REFINER_TIMEOUT_MS,
                 maxOutputTokens: DEFAULT_REFINER_MAX_OUTPUT_TOKENS,
+                execution: "public_package",
                 recoveredAfterRestart
               }
             })
@@ -11274,7 +11654,7 @@ function createLocalHarnessImprovementRuntime(input) {
 
 // ../server/src/harness/local-harness-model-tools.ts
 import { promises as fs7 } from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 var MAX_INSPECT_BYTES = 24e3;
 function createLocalHarnessModelToolDefinitions(input) {
   return [
@@ -11379,9 +11759,9 @@ function createLocalHarnessModelToolDefinitions(input) {
         const runtime = await loadLocalHarnessRuntimeForAgentRun(input.store, context.session.id);
         if (!runtime) throw new Error("No Local Harness release is selected for this run.");
         const overlay = await input.store.getHarnessRunOverlay(context.session.id);
-        const sourceRoot = path8.join(runtime.release.bundlePath, "source");
+        const sourceRoot = path9.join(runtime.release.bundlePath, "source");
         const manifest = HarnessSourceManifestSchema.parse(
-          JSON.parse(await fs7.readFile(path8.join(sourceRoot, "harness.json"), "utf8"))
+          JSON.parse(await fs7.readFile(path9.join(sourceRoot, "harness.json"), "utf8"))
         );
         const requestedPath = typeof context.args.path === "string" ? context.args.path.trim().replaceAll("\\", "/") : null;
         let source = null;
@@ -11477,7 +11857,7 @@ function createLocalHarnessModelToolDefinitions(input) {
           (artifact) => artifact.runRef === context.session.id
         );
         const triggerRefs = new Set(triggers.map((artifact) => artifactRefKey(artifact)));
-        const relatedToTrigger = (artifact) => triggerRefs.has(artifactRefKey(asRecord2(artifact.trigger)));
+        const relatedToTrigger = (artifact) => triggerRefs.has(artifactRefKey(asRecord3(artifact.trigger)));
         const routes = (await all("route_decision")).filter(
           (artifact) => artifact.schemaVersion === "openpond.improvementRouteDecision.v1"
         ).filter(relatedToTrigger);
@@ -11486,7 +11866,7 @@ function createLocalHarnessModelToolDefinitions(input) {
         ).filter(relatedToTrigger);
         const proposalRefs = new Set(
           outcomes.flatMap((artifact) => {
-            const proposal = asRecord2(artifact.proposal);
+            const proposal = asRecord3(artifact.proposal);
             return proposal.id && proposal.contentHash ? [artifactRefKey(proposal)] : [];
           })
         );
@@ -11495,7 +11875,7 @@ function createLocalHarnessModelToolDefinitions(input) {
         ).filter(
           (artifact) => proposalRefs.has(artifactRefKey(artifact))
         );
-        const relatedToProposal = (artifact) => proposalRefs.has(artifactRefKey(asRecord2(artifact.proposal)));
+        const relatedToProposal = (artifact) => proposalRefs.has(artifactRefKey(asRecord3(artifact.proposal)));
         const artifacts = [
           { kind: "trigger_decision", values: triggers },
           { kind: "route_decision", values: routes },
@@ -11515,7 +11895,7 @@ function createLocalHarnessModelToolDefinitions(input) {
 function artifactRefKey(artifact) {
   return `${String(artifact.id ?? "")}:${String(artifact.contentHash ?? "")}`;
 }
-function asRecord2(value) {
+function asRecord3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function modelResult(callId, name, data) {
@@ -11533,10 +11913,10 @@ function boundedJson(value, maxLength) {
   return { truncated: true, json: serialized.slice(0, maxLength) };
 }
 function containedSourcePath2(sourceRoot, relativePath) {
-  const root = path8.resolve(sourceRoot);
-  const absolute = path8.resolve(root, ...relativePath.split("/"));
-  const relative = path8.relative(root, absolute);
-  if (!relative || relative.startsWith("..") || path8.isAbsolute(relative)) {
+  const root = path9.resolve(sourceRoot);
+  const absolute = path9.resolve(root, ...relativePath.split("/"));
+  const relative = path9.relative(root, absolute);
+  if (!relative || relative.startsWith("..") || path9.isAbsolute(relative)) {
     throw new Error(`Harness source path escapes its release: ${relativePath}`);
   }
   return absolute;
@@ -11546,7 +11926,7 @@ function containedSourcePath2(sourceRoot, relativePath) {
 var import_shell_quote = __toESM(require_shell_quote(), 1);
 import { spawn } from "node:child_process";
 import { randomUUID as randomUUID4 } from "node:crypto";
-import path9 from "node:path";
+import path10 from "node:path";
 
 // ../server/src/workspace/workspace-execution-target.ts
 function resolveWorkspaceExecutionTarget(input) {
@@ -11655,7 +12035,7 @@ function createOpenPondCommandAccessService(deps) {
     const timeoutSeconds = normalizedTimeout(input.timeoutSeconds);
     const target = resolveWorkspaceExecutionTarget({ session: input.session });
     const cwd = resolveCommandCwd({ requestedCwd: input.cwd, session: input.session });
-    const explicitCwd = Boolean(input.cwd?.trim() && path9.isAbsolute(input.cwd.trim()));
+    const explicitCwd = Boolean(input.cwd?.trim() && path10.isAbsolute(input.cwd.trim()));
     if (target.target === "sandbox" || !cwd || target.target !== "local" && !explicitCwd) {
       return blockedCommandResult(command, cwd, SELECT_PROJECT_MESSAGE, timeoutSeconds);
     }
@@ -11880,8 +12260,8 @@ function commandRiskLabel(command) {
 function resolveCommandCwd(input) {
   const requested = input.requestedCwd?.trim();
   if (requested) {
-    if (path9.isAbsolute(requested)) return path9.resolve(requested);
-    return input.session.cwd ? path9.resolve(input.session.cwd, requested) : null;
+    if (path10.isAbsolute(requested)) return path10.resolve(requested);
+    return input.session.cwd ? path10.resolve(input.session.cwd, requested) : null;
   }
   return input.session.cwd?.trim() || null;
 }
@@ -11915,7 +12295,10 @@ function runShellCommand(input) {
     const child = spawn(shellCommand.command, {
       cwd: input.cwd,
       shell: shellCommand.shell,
-      env: process.env,
+      env: {
+        ...process.env,
+        PATH: executableSearchPath()
+      },
       stdio: ["ignore", "pipe", "pipe"],
       detached: process.platform !== "win32"
     });
@@ -12146,13 +12529,13 @@ function createCloudConnectedAppToolExecutor(options = {}) {
 }
 async function resolveCloudConnectedAppToolTarget(options = {}) {
   const env = options.env ?? process.env;
-  const path46 = normalizeToolPath(env.OPENPOND_CONNECTED_APP_TOOL_PATH);
+  const path47 = normalizeToolPath(env.OPENPOND_CONNECTED_APP_TOOL_PATH);
   const apiKey = env.OPENPOND_CONNECTED_APP_API_KEY?.trim() || env.OPENPOND_SANDBOX_API_KEY?.trim() || env.OPENPOND_API_KEY?.trim();
   if (apiKey) {
     return {
       apiBaseUrl: resolveCloudConnectedAppApiBaseUrl(env, null),
       apiKey,
-      path: path46
+      path: path47
     };
   }
   const loadAccountContext = options.loadAccountContext ?? loadOpenPondAccountContext;
@@ -12164,7 +12547,7 @@ async function resolveCloudConnectedAppToolTarget(options = {}) {
   return {
     apiBaseUrl: resolveCloudConnectedAppApiBaseUrl(env, context.apiBaseUrl),
     apiKey: token,
-    path: path46
+    path: path47
   };
 }
 function resolveCloudConnectedAppApiBaseUrl(env, accountApiBaseUrl) {
@@ -12203,9 +12586,9 @@ function normalizeApiBaseUrl(value) {
   }
 }
 function normalizeApiBasePath(pathname) {
-  let path46 = pathname.replace(/\/+$/, "");
-  path46 = path46.replace(/\/v1\/sandboxes$/i, "").replace(/\/api\/sandboxes$/i, "").replace(/\/sandboxes$/i, "").replace(/\/v1$/i, "");
-  return path46 || "/";
+  let path47 = pathname.replace(/\/+$/, "");
+  path47 = path47.replace(/\/v1\/sandboxes$/i, "").replace(/\/api\/sandboxes$/i, "").replace(/\/sandboxes$/i, "").replace(/\/v1$/i, "");
+  return path47 || "/";
 }
 function normalizeOptionalUrl(value) {
   const trimmed = value?.trim();
@@ -12234,7 +12617,7 @@ function errorMessage(error) {
 
 // ../server/src/openpond/hosted-turn-helpers.ts
 import { promises as fs11 } from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 
 // ../server/src/openpond/context-usage.ts
 var ESTIMATED_CHARS_PER_TOKEN = 4;
@@ -12763,37 +13146,37 @@ function isString(value) {
 
 // ../server/src/openpond/personalization.ts
 import { promises as fs9 } from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 
 // ../server/src/paths.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { promises as fs8 } from "node:fs";
 import os from "node:os";
-import path10 from "node:path";
+import path11 from "node:path";
 function appDataDir() {
-  return process.env.OPENPOND_APP_HOME || path10.join(os.homedir(), ".openpond", "openpond-app");
+  return process.env.OPENPOND_APP_HOME || path11.join(os.homedir(), ".openpond", "openpond-app");
 }
 function providersConfigPath(storeDir) {
-  return path10.join(storeDir, "providers.json");
+  return path11.join(storeDir, "providers.json");
 }
 function providerSecretsConfigPath(storeDir) {
-  return path10.join(storeDir, "provider-secrets.json");
+  return path11.join(storeDir, "provider-secrets.json");
 }
 function providerSecretsKeyPath(storeDir) {
-  return path10.join(storeDir, "provider-secrets.key");
+  return path11.join(storeDir, "provider-secrets.key");
 }
 function soulPath(storeDir) {
-  return path10.join(storeDir, "SOUL.md");
+  return path11.join(storeDir, "SOUL.md");
 }
 function soulsDir(storeDir) {
-  return path10.join(storeDir, "souls");
+  return path11.join(storeDir, "souls");
 }
 function personalizationStatePath(storeDir) {
-  return path10.join(storeDir, "personalization.json");
+  return path11.join(storeDir, "personalization.json");
 }
 async function ensureCapabilityToken(storeDir) {
   await fs8.mkdir(storeDir, { recursive: true });
-  const tokenFile = path10.join(storeDir, "token");
+  const tokenFile = path11.join(storeDir, "token");
   if (process.env.OPENPOND_APP_TOKEN) {
     await fs8.writeFile(tokenFile, process.env.OPENPOND_APP_TOKEN, { mode: 384 });
     return { token: process.env.OPENPOND_APP_TOKEN, tokenFile };
@@ -12835,7 +13218,7 @@ function fileTemplateId(filename) {
 function filenameFromTemplateId(templateId) {
   if (!templateId.startsWith(FILE_TEMPLATE_PREFIX)) return null;
   const filename = templateId.slice(FILE_TEMPLATE_PREFIX.length);
-  if (!filename || filename.includes("..") || path11.isAbsolute(filename)) return null;
+  if (!filename || filename.includes("..") || path12.isAbsolute(filename)) return null;
   return filename;
 }
 async function readJsonFile(filePath) {
@@ -12856,7 +13239,7 @@ async function readSoulFile(filePath) {
   }
 }
 async function writeSoulFile(filePath, content) {
-  await fs9.mkdir(path11.dirname(filePath), { recursive: true });
+  await fs9.mkdir(path12.dirname(filePath), { recursive: true });
   await fs9.writeFile(filePath, `${trimSoul(content)}
 `, { mode: 384 });
 }
@@ -12874,7 +13257,7 @@ async function writeActiveTemplateId(store, storeDir, activeTemplateId) {
   };
   await store.setCacheEntry(ACTIVE_TEMPLATE_CACHE_TYPE, ACTIVE_TEMPLATE_CACHE_KEY, activeTemplateId);
   const filePath = personalizationStatePath(storeDir);
-  await fs9.mkdir(path11.dirname(filePath), { recursive: true });
+  await fs9.mkdir(path12.dirname(filePath), { recursive: true });
   await fs9.writeFile(filePath, `${JSON.stringify(state, null, 2)}
 `, { mode: 384 });
   return state;
@@ -12884,7 +13267,7 @@ async function listFileTemplates(storeDir) {
   const templates = [];
   for (const entry of entries) {
     if (!entry.isFile() || !/^soul-.+\.md$/i.test(entry.name)) continue;
-    const content = await readSoulFile(path11.join(storeDir, entry.name));
+    const content = await readSoulFile(path12.join(storeDir, entry.name));
     if (!content) continue;
     templates.push({
       id: fileTemplateId(entry.name),
@@ -12898,7 +13281,7 @@ async function listFileTemplates(storeDir) {
   const legacyEntries = await fs9.readdir(legacyDirectory, { withFileTypes: true }).catch(() => []);
   for (const entry of legacyEntries) {
     if (!entry.isFile() || !entry.name.toLowerCase().endsWith(".md")) continue;
-    const content = await readSoulFile(path11.join(legacyDirectory, entry.name));
+    const content = await readSoulFile(path12.join(legacyDirectory, entry.name));
     if (!content) continue;
     templates.push({
       id: fileTemplateId(`souls/${entry.name}`),
@@ -12920,7 +13303,7 @@ async function uniqueSoulFilename(storeDir, name) {
   let candidate = `soul-${base}.md`;
   for (let index = 2; ; index += 1) {
     try {
-      await fs9.access(path11.join(directory, candidate));
+      await fs9.access(path12.join(directory, candidate));
       candidate = `soul-${base}-${index}.md`;
     } catch {
       return candidate;
@@ -12930,7 +13313,7 @@ async function uniqueSoulFilename(storeDir, name) {
 async function saveFileTemplate(storeDir, templateId, name, content) {
   const existingFilename = filenameFromTemplateId(templateId);
   const filename = existingFilename ?? await uniqueSoulFilename(storeDir, name);
-  await writeSoulFile(path11.join(storeDir, filename), content);
+  await writeSoulFile(path12.join(storeDir, filename), content);
   return fileTemplateId(filename);
 }
 async function importActiveSoulFile(storeDir, templates) {
@@ -12939,7 +13322,7 @@ async function importActiveSoulFile(storeDir, templates) {
   const existing = templates.find((template) => template.content === activeSoul);
   if (existing) return existing.id;
   const filename = await uniqueSoulFilename(storeDir, "Imported SOUL");
-  await writeSoulFile(path11.join(storeDir, filename), activeSoul);
+  await writeSoulFile(path12.join(storeDir, filename), activeSoul);
   return fileTemplateId(filename);
 }
 async function loadPersonalizationSettings(store, storeDir) {
@@ -12993,7 +13376,7 @@ var REPOSITORY_WORK_SYSTEM_CONTEXT = [
 
 // ../server/src/openpond/repository-instructions.ts
 import { promises as fs10 } from "node:fs";
-import path12 from "node:path";
+import path13 from "node:path";
 var MAX_REPOSITORY_INSTRUCTION_FILE_BYTES = 64 * 1024;
 var REPOSITORY_INSTRUCTION_FILE_NAME = "AGENTS.md";
 var REPOSITORY_INSTRUCTION_OVERRIDE_FILE_NAME = "AGENTS.override.md";
@@ -13056,7 +13439,7 @@ function buildRepositoryInstructionContext(resolution) {
 }
 async function canonicalDirectory(inputPath) {
   try {
-    const resolved = await fs10.realpath(path12.resolve(inputPath));
+    const resolved = await fs10.realpath(path13.resolve(inputPath));
     const stat = await fs10.stat(resolved);
     return stat.isDirectory() ? resolved : null;
   } catch {
@@ -13077,18 +13460,18 @@ function directoriesFromRoot(repositoryRoot, workingDirectory) {
   if (!isWithinDirectory(repositoryRoot, workingDirectory)) {
     return [workingDirectory];
   }
-  const relative = path12.relative(repositoryRoot, workingDirectory);
+  const relative = path13.relative(repositoryRoot, workingDirectory);
   const directories = [repositoryRoot];
   if (!relative) return directories;
   let current = repositoryRoot;
-  for (const segment2 of relative.split(path12.sep)) {
-    current = path12.join(current, segment2);
+  for (const segment2 of relative.split(path13.sep)) {
+    current = path13.join(current, segment2);
     directories.push(current);
   }
   return directories;
 }
 async function readInstructionCandidate(input) {
-  const candidatePath = path12.join(input.directory, input.fileName);
+  const candidatePath = path13.join(input.directory, input.fileName);
   let realPath;
   try {
     realPath = await fs10.realpath(candidatePath);
@@ -13125,7 +13508,7 @@ async function readInstructionCandidate(input) {
       status: "loaded",
       source: {
         absolutePath: realPath,
-        relativePath: path12.relative(input.repositoryRoot, candidatePath),
+        relativePath: path13.relative(input.repositoryRoot, candidatePath),
         content: await fs10.readFile(realPath, "utf8")
       }
     };
@@ -13142,8 +13525,8 @@ function addSource(source, sources, seenSourcePaths) {
   sources.push(source);
 }
 function isWithinDirectory(rootPath, candidatePath) {
-  const relative = path12.relative(rootPath, candidatePath);
-  return relative === "" || !path12.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path12.sep}`);
+  const relative = path13.relative(rootPath, candidatePath);
+  return relative === "" || !path13.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path13.sep}`);
 }
 
 // ../server/src/runtime/experience-policy.ts
@@ -13283,8 +13666,8 @@ function workWorkspaceRequestBlocker(action, args) {
 }
 function workPathBlocker(rawPath, allowedRoots) {
   if (typeof rawPath !== "string") return "A bounded Work path is required.";
-  const path46 = rawPath.trim().replaceAll("\\", "/");
-  if (!path46 || path46.startsWith("/") || path46.split("/").some((part) => part === "..") || !allowedRoots.some((root) => path46 === root || path46.startsWith(`${root}/`))) {
+  const path47 = rawPath.trim().replaceAll("\\", "/");
+  if (!path47 || path47.startsWith("/") || path47.split("/").some((part) => part === "..") || !allowedRoots.some((root) => path47 === root || path47.startsWith(`${root}/`))) {
     return `Work paths must stay under ${allowedRoots.map((root) => `/workspace/${root}`).join(", ")}.`;
   }
   return null;
@@ -13682,7 +14065,7 @@ function isHybridWorkspaceSession(session) {
 async function looksLikeSandboxTemplateRepo(repoPath) {
   if (!repoPath) return false;
   try {
-    await fs11.access(path13.join(repoPath, OPENPOND_MANIFEST_FILE_NAME));
+    await fs11.access(path14.join(repoPath, OPENPOND_MANIFEST_FILE_NAME));
     return true;
   } catch {
     return false;
@@ -13740,9 +14123,9 @@ function parseToolContent(content) {
     return null;
   }
 }
-function stringFromPath(record6, path46) {
+function stringFromPath(record6, path47) {
   let current = record6;
-  for (const segment2 of path46) {
+  for (const segment2 of path47) {
     if (Array.isArray(current)) {
       const index = Number(segment2);
       if (!Number.isInteger(index) || index < 0) return null;
@@ -14662,11 +15045,11 @@ function textFromUnknown2(value) {
 }
 
 // ../server/src/runtime/app-server-workspace.ts
-import path19 from "node:path";
+import path20 from "node:path";
 
 // ../server/src/workspace-tools/workspace-tool-file-system.ts
 import { promises as fs12 } from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 function normalizeWorkspacePath(input) {
   const normalized = input.replace(/\\/g, "/").replace(/^\.\/+/, "");
   if (!normalized.trim()) throw new Error("Path is required");
@@ -14679,15 +15062,15 @@ function normalizeWorkspacePath(input) {
   return parts.join("/");
 }
 function assertInside(root, target) {
-  const resolvedRoot = path14.resolve(root);
-  const resolvedTarget = path14.resolve(target);
-  if (resolvedTarget !== resolvedRoot && !resolvedTarget.startsWith(`${resolvedRoot}${path14.sep}`)) {
+  const resolvedRoot = path15.resolve(root);
+  const resolvedTarget = path15.resolve(target);
+  if (resolvedTarget !== resolvedRoot && !resolvedTarget.startsWith(`${resolvedRoot}${path15.sep}`)) {
     throw new Error("Path escapes the workspace root");
   }
 }
 async function resolveForRead(repoPath, input) {
   const relativePath = normalizeWorkspacePath(input);
-  const targetPath = path14.resolve(repoPath, relativePath);
+  const targetPath = path15.resolve(repoPath, relativePath);
   assertInside(repoPath, targetPath);
   const realRoot = await fs12.realpath(repoPath);
   const realTarget = await fs12.realpath(targetPath);
@@ -14696,7 +15079,7 @@ async function resolveForRead(repoPath, input) {
 }
 async function resolveForWrite(repoPath, input) {
   const relativePath = normalizeWorkspacePath(input);
-  const targetPath = path14.resolve(repoPath, relativePath);
+  const targetPath = path15.resolve(repoPath, relativePath);
   assertInside(repoPath, targetPath);
   try {
     const realRoot = await fs12.realpath(repoPath);
@@ -14704,7 +15087,7 @@ async function resolveForWrite(repoPath, input) {
     assertInside(realRoot, realTarget);
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
-    const parent = path14.dirname(targetPath);
+    const parent = path15.dirname(targetPath);
     await fs12.mkdir(parent, { recursive: true });
     const realRoot = await fs12.realpath(repoPath);
     const realParent = await fs12.realpath(parent);
@@ -14713,10 +15096,10 @@ async function resolveForWrite(repoPath, input) {
   return { relativePath, targetPath };
 }
 async function nearestExistingParent(targetPath, root) {
-  let current = path14.dirname(targetPath);
-  const resolvedRoot = path14.resolve(root);
-  while (current !== path14.dirname(current)) {
-    if (current === resolvedRoot || current.startsWith(`${resolvedRoot}${path14.sep}`)) {
+  let current = path15.dirname(targetPath);
+  const resolvedRoot = path15.resolve(root);
+  while (current !== path15.dirname(current)) {
+    if (current === resolvedRoot || current.startsWith(`${resolvedRoot}${path15.sep}`)) {
       try {
         const stat = await fs12.lstat(current);
         if (stat.isDirectory()) return current;
@@ -14725,13 +15108,13 @@ async function nearestExistingParent(targetPath, root) {
       }
     }
     if (current === resolvedRoot) break;
-    current = path14.dirname(current);
+    current = path15.dirname(current);
   }
   return resolvedRoot;
 }
 async function resolveForPreview(repoPath, input) {
   const relativePath = normalizeWorkspacePath(input);
-  const targetPath = path14.resolve(repoPath, relativePath);
+  const targetPath = path15.resolve(repoPath, relativePath);
   assertInside(repoPath, targetPath);
   const realRoot = await fs12.realpath(repoPath);
   try {
@@ -14828,7 +15211,7 @@ async function deleteWorkspaceFile(repoPath, filePath) {
 // ../server/src/workspace-tools/workspace-tool-preview.ts
 import { promises as fs13 } from "node:fs";
 import os2 from "node:os";
-import path15 from "node:path";
+import path16 from "node:path";
 async function readExistingFile(repoPath, filePath) {
   const { targetPath } = await resolveForPreview(repoPath, filePath);
   try {
@@ -14841,8 +15224,8 @@ async function readExistingFile(repoPath, filePath) {
   }
 }
 async function writeTempPreviewFile(root, relativePath, content) {
-  const target = path15.join(root, relativePath);
-  await fs13.mkdir(path15.dirname(target), { recursive: true });
+  const target = path16.join(root, relativePath);
+  await fs13.mkdir(path16.dirname(target), { recursive: true });
   await fs13.writeFile(target, content, "utf8");
   return target;
 }
@@ -14866,10 +15249,10 @@ async function previewFileChange(repoPath, filePath, nextContent) {
   if (status === "unchanged") {
     return { path: relativePath, status, additions: 0, deletions: 0, patch: "" };
   }
-  const tempRoot = await fs13.mkdtemp(path15.join(os2.tmpdir(), "openpond-preview-"));
+  const tempRoot = await fs13.mkdtemp(path16.join(os2.tmpdir(), "openpond-preview-"));
   try {
-    const oldRoot = path15.join(tempRoot, "old");
-    const newRoot = path15.join(tempRoot, "new");
+    const oldRoot = path16.join(tempRoot, "old");
+    const newRoot = path16.join(tempRoot, "new");
     const oldArg = previousContent === null ? "/dev/null" : await writeTempPreviewFile(oldRoot, relativePath, previousContent);
     const newArg = nextContent === null ? "/dev/null" : await writeTempPreviewFile(newRoot, relativePath, nextContent);
     const diff = await runCommand("git", ["diff", "--no-index", "--unified=80", "--", oldArg, newArg], repoPath);
@@ -14934,7 +15317,7 @@ async function previewWorkspaceDeleteFile(repoPath, filePath) {
 
 // ../server/src/workspace-tools/workspace-tool-git.ts
 import { promises as fs14 } from "node:fs";
-import path16 from "node:path";
+import path17 from "node:path";
 function parseBranchStatus(line) {
   const value = line.replace(/^##\s*/, "").trim();
   const [branchPart, trackingPartRaw] = value.split("...");
@@ -15016,7 +15399,7 @@ async function setWorkspaceOrigin(repoPath, remoteUrl, options = {}) {
 }
 async function lastFetchAt(repoPath) {
   const fetchHead = await runCommand("git", ["rev-parse", "--git-path", "FETCH_HEAD"], repoPath);
-  const fetchHeadPath = fetchHead.code === 0 && fetchHead.stdout.trim() ? path16.resolve(repoPath, fetchHead.stdout.trim()) : path16.join(repoPath, ".git", "FETCH_HEAD");
+  const fetchHeadPath = fetchHead.code === 0 && fetchHead.stdout.trim() ? path17.resolve(repoPath, fetchHead.stdout.trim()) : path17.join(repoPath, ".git", "FETCH_HEAD");
   try {
     const stat = await fs14.stat(fetchHeadPath);
     return stat.mtime.toISOString();
@@ -15125,11 +15508,11 @@ async function getWorkspaceDeploymentSource(repoPath) {
 
 // ../server/src/openpond/resources.ts
 import { promises as fs16 } from "node:fs";
-import path18 from "node:path";
+import path19 from "node:path";
 
 // ../server/src/openpond/workspace-resource-search.ts
 import { promises as fs15 } from "node:fs";
-import path17 from "node:path";
+import path18 from "node:path";
 var DEFAULT_RESOURCE_SEARCH_LIMIT = 20;
 var MAX_RESOURCE_SEARCH_LIMIT = 100;
 var WORKSPACE_SEARCH_MAX_BYTES = 12e4;
@@ -15451,12 +15834,12 @@ function orderedCharacterScore(value, query) {
   return Math.min(1, compactness * 0.7 + boundaryBonus * 0.3);
 }
 function workspaceRelativePathQuery(repoPath, query) {
-  if (!path17.isAbsolute(query)) return query;
-  const relative = path17.relative(path17.resolve(repoPath), path17.resolve(query));
-  if (!relative || relative === ".." || relative.startsWith(`..${path17.sep}`) || path17.isAbsolute(relative)) {
+  if (!path18.isAbsolute(query)) return query;
+  const relative = path18.relative(path18.resolve(repoPath), path18.resolve(query));
+  if (!relative || relative === ".." || relative.startsWith(`..${path18.sep}`) || path18.isAbsolute(relative)) {
     return query;
   }
-  return relative.split(path17.sep).join("/");
+  return relative.split(path18.sep).join("/");
 }
 function workspaceSearchMode(filters) {
   const raw = filters?.matchMode ?? filters?.mode;
@@ -15476,7 +15859,7 @@ async function visibleWorkspaceFiles(repoPath) {
   }
 }
 async function readWorkspaceSearchText(repoPath, filePath) {
-  if (BINARY_EXTENSIONS.has(path17.extname(filePath).toLowerCase())) return null;
+  if (BINARY_EXTENSIONS.has(path18.extname(filePath).toLowerCase())) return null;
   try {
     const { targetPath } = await resolveForRead(repoPath, filePath);
     const stat = await fs15.lstat(targetPath);
@@ -16020,7 +16403,7 @@ async function readWorkspaceFileResource(repoPath, identifier, request) {
       ...metadata,
       lineCount: countLines(content.text)
     },
-    relatedRefs: [workspaceDirRef(path18.dirname(filePath) === "." ? "" : path18.dirname(filePath))],
+    relatedRefs: [workspaceDirRef(path19.dirname(filePath) === "." ? "" : path19.dirname(filePath))],
     truncation: content.truncation
   };
 }
@@ -16061,16 +16444,16 @@ async function readWorkspaceDirectoryResource(repoPath, identifier, request) {
 }
 async function resolveWorkspacePath(repoPath, relativePath) {
   const root = await fs16.realpath(repoPath);
-  const target = path18.resolve(root, relativePath || ".");
+  const target = path19.resolve(root, relativePath || ".");
   assertInside2(root, target);
   const realTarget = await fs16.realpath(target);
   assertInside2(root, realTarget);
   return realTarget;
 }
 function assertInside2(root, target) {
-  const resolvedRoot = path18.resolve(root);
-  const resolvedTarget = path18.resolve(target);
-  if (resolvedTarget !== resolvedRoot && !resolvedTarget.startsWith(`${resolvedRoot}${path18.sep}`)) {
+  const resolvedRoot = path19.resolve(root);
+  const resolvedTarget = path19.resolve(target);
+  if (resolvedTarget !== resolvedRoot && !resolvedTarget.startsWith(`${resolvedRoot}${path19.sep}`)) {
     throw new Error("Resource path escapes the workspace root");
   }
 }
@@ -16257,9 +16640,9 @@ function goalContextDocumentForRef(events, sessionId, identifier) {
 function goalContextDocumentsFromEvent(event2) {
   const output = [];
   const add = (candidate) => {
-    const record6 = asRecord3(candidate);
+    const record6 = asRecord4(candidate);
     if (!record6 || !looksLikeGoalContextDocument(record6)) return;
-    const source = asRecord3(record6.source);
+    const source = asRecord4(record6.source);
     const id = stringValue4(record6.id) ?? stringValue4(record6.documentId) ?? stringValue4(source?.path) ?? stringValue4(record6.title);
     if (!id) return;
     const title = stringValue4(record6.title) ?? stringValue4(record6.name) ?? stringValue4(source?.path) ?? id;
@@ -16298,7 +16681,7 @@ function goalContextDocumentsFromEvent(event2) {
   return output;
 }
 function collectGoalContextDocumentCandidates(value, add) {
-  const record6 = asRecord3(value);
+  const record6 = asRecord4(value);
   if (!record6) {
     if (Array.isArray(value)) {
       for (const item of value) collectGoalContextDocumentCandidates(item, add);
@@ -16311,16 +16694,16 @@ function collectGoalContextDocumentCandidates(value, add) {
       for (const item of child) add(item);
     }
   }
-  const context = asRecord3(record6.context);
+  const context = asRecord4(record6.context);
   if (Array.isArray(context?.items)) {
     for (const item of context.items) add(item);
   }
-  const goal = asRecord3(record6.goal);
+  const goal = asRecord4(record6.goal);
   if (goal && goal !== record6) collectGoalContextDocumentCandidates(goal, add);
 }
 function looksLikeGoalContextDocument(record6) {
   const kind = stringValue4(record6.kind);
-  const sourceKind = stringValue4(asRecord3(record6.source)?.kind);
+  const sourceKind = stringValue4(asRecord4(record6.source)?.kind);
   const role = stringValue4(record6.role);
   return kind === "document" || sourceKind === "profile_goal_doc" || role === "primary_context" || role === "supporting_context" || role === "handoff" || role === "test_plan";
 }
@@ -16383,7 +16766,7 @@ function stringValues(value) {
 function stringValue4(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function asRecord3(value) {
+function asRecord4(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function safeDecodeURIComponent(value) {
@@ -16394,7 +16777,7 @@ function safeDecodeURIComponent(value) {
   }
 }
 function isLikelyBinaryArtifactRef(value) {
-  return BINARY_EXTENSIONS2.has(path18.extname(value).toLowerCase());
+  return BINARY_EXTENSIONS2.has(path19.extname(value).toLowerCase());
 }
 function snippetFromText(value, lowerQuery) {
   const lower = value.toLowerCase();
@@ -16407,7 +16790,7 @@ function snippetFromText(value, lowerQuery) {
 function contentTypeForPath(filePath) {
   const imageType = workspaceImageContentType(filePath);
   if (imageType) return imageType;
-  const extension = path18.extname(filePath).toLowerCase();
+  const extension = path19.extname(filePath).toLowerCase();
   if (extension === ".json") return "application/json";
   if (extension === ".md" || extension === ".mdx") return "text/markdown";
   if ([".css", ".csv", ".html", ".js", ".jsx", ".ts", ".tsx", ".txt", ".yaml", ".yml"].includes(extension)) {
@@ -16416,7 +16799,7 @@ function contentTypeForPath(filePath) {
   return null;
 }
 async function isBinaryFile(targetPath, filePath) {
-  if (BINARY_EXTENSIONS2.has(path18.extname(filePath).toLowerCase())) return true;
+  if (BINARY_EXTENSIONS2.has(path19.extname(filePath).toLowerCase())) return true;
   const file = await fs16.open(targetPath, "r");
   try {
     const sample = Buffer.alloc(TEXT_SAMPLE_BYTES);
@@ -17065,13 +17448,13 @@ function createSandboxRuntimeHandle(client, runtimeId, initial = null) {
     keepAlive,
     checkpoint: (input) => client.checkpointSandboxRuntime(runtimeId, input),
     files: {
-      write: async (path46, contents) => client.uploadFile((await resume()).id, path46, contents),
-      read: async (path46) => client.downloadFile((await resume()).id, path46),
+      write: async (path47, contents) => client.uploadFile((await resume()).id, path47, contents),
+      read: async (path47) => client.downloadFile((await resume()).id, path47),
       readResponse: async (input) => client.downloadFileResponse((await resume()).id, input),
       list: async (input = {}) => client.listFiles((await resume()).id, input),
-      delete: async (path46, input = {}) => client.deleteFile((await resume()).id, path46, input),
+      delete: async (path47, input = {}) => client.deleteFile((await resume()).id, path47, input),
       search: async (input) => client.searchFiles((await resume()).id, input),
-      stat: async (path46) => client.statFile((await resume()).id, path46),
+      stat: async (path47) => client.statFile((await resume()).id, path47),
       mkdir: async (input) => client.mkdir((await resume()).id, input),
       move: async (input) => client.moveFile((await resume()).id, input)
     },
@@ -17727,20 +18110,20 @@ var OpenPondSandboxInstanceClient = class {
       path: `/${encodeURIComponent(sandboxId)}/pty/${encodeURIComponent(ptyId)}/stream${query.size > 0 ? `?${query.toString()}` : ""}`
     });
   }
-  uploadFile(sandboxId, path46, contents) {
-    return this.uploadFileBase64(sandboxId, path46, Buffer.from(contents, "utf-8").toString("base64"));
+  uploadFile(sandboxId, path47, contents) {
+    return this.uploadFileBase64(sandboxId, path47, Buffer.from(contents, "utf-8").toString("base64"));
   }
-  uploadFileBase64(sandboxId, path46, contentsBase64) {
+  uploadFileBase64(sandboxId, path47, contentsBase64) {
     return this.request(`/${encodeURIComponent(sandboxId)}/files`, {
       method: "POST",
       body: JSON.stringify({
-        path: path46,
+        path: path47,
         contentsBase64
       })
     });
   }
-  async downloadFile(sandboxId, path46) {
-    const payload = await this.downloadFileResponse(sandboxId, path46);
+  async downloadFile(sandboxId, path47) {
+    const payload = await this.downloadFileResponse(sandboxId, path47);
     return Buffer.from(payload.file.contentsBase64, "base64").toString("utf-8");
   }
   downloadFileResponse(sandboxId, input) {
@@ -17764,16 +18147,16 @@ var OpenPondSandboxInstanceClient = class {
       query.set("maxEntries", String(input.maxEntries));
     return this.request(`/${encodeURIComponent(sandboxId)}/files?${query.toString()}`);
   }
-  deleteFile(sandboxId, path46, input = {}) {
-    const query = new URLSearchParams({ path: path46 });
+  deleteFile(sandboxId, path47, input = {}) {
+    const query = new URLSearchParams({ path: path47 });
     if (input.recursive !== void 0)
       query.set("recursive", String(input.recursive));
     return this.request(`/${encodeURIComponent(sandboxId)}/files?${query.toString()}`, {
       method: "DELETE"
     });
   }
-  statFile(sandboxId, path46) {
-    const query = new URLSearchParams({ stat: "1", path: path46 });
+  statFile(sandboxId, path47) {
+    const query = new URLSearchParams({ stat: "1", path: path47 });
     return this.request(`/${encodeURIComponent(sandboxId)}/files?${query.toString()}`);
   }
   mkdir(sandboxId, input) {
@@ -17949,12 +18332,12 @@ var OpenPondSandboxInstanceClient = class {
       body: JSON.stringify({ leaseId })
     });
   }
-  async request(path46, init = {}) {
-    const response = await apiFetch2(this.sandboxApiUrl, this.apiKey, path46, init);
+  async request(path47, init = {}) {
+    const response = await apiFetch2(this.sandboxApiUrl, this.apiKey, path47, init);
     return readApiJson(response, "Sandbox request");
   }
-  async requestApiRoot(path46, init = {}) {
-    const response = await apiFetch2(this.apiRootUrl, this.apiKey, path46, init);
+  async requestApiRoot(path47, init = {}) {
+    const response = await apiFetch2(this.apiRootUrl, this.apiKey, path47, init);
     return readApiJson(response, "OpenPond API request");
   }
 };
@@ -18632,7 +19015,7 @@ function normalizeOptionalUrl3(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed.replace(/\/$/, "") : null;
 }
-function asRecord4(value) {
+function asRecord5(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 var UI_PURPOSE_METADATA_KEYS = ["workspacePurpose", "purpose"];
@@ -18659,7 +19042,7 @@ function sanitizeSandboxRuntimeInput(value) {
   return runtime;
 }
 function normalizeCreateInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   if (input.sandboxRuntime) {
     throw new Error(
       "Sandbox runtime settings must use /v1/runtimes before materializing a sandbox."
@@ -18716,7 +19099,7 @@ function normalizeCreateInput(payload) {
   return out;
 }
 function normalizeSandboxRuntimeCreateInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const runtime = sanitizeSandboxRuntimeInput(input) ?? {};
   const out = {};
   if (typeof runtime.teamId === "string" && runtime.teamId.trim()) {
@@ -18763,10 +19146,10 @@ function normalizeSandboxRuntimeSandboxCreateInput(payload) {
   return normalizeCreateInput(payload);
 }
 function normalizeSnapshotCreateInput(payload) {
-  return asRecord4(payload);
+  return asRecord5(payload);
 }
 function normalizeSandboxListInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const teamId = typeof input.teamId === "string" ? input.teamId.trim() : "";
   const projectId = typeof input.projectId === "string" ? input.projectId.trim() : "";
   const agentId = typeof input.agentId === "string" ? input.agentId.trim() : "";
@@ -18777,7 +19160,7 @@ function normalizeSandboxListInput(payload) {
   };
 }
 function normalizeReplayStartInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const teamId = typeof input.teamId === "string" ? input.teamId.trim() : "";
   const projectId = typeof input.projectId === "string" ? input.projectId.trim() : "";
   const {
@@ -18798,7 +19181,7 @@ function normalizeIntegrationStatusFilter(value) {
   return void 0;
 }
 function normalizeIntegrationAttachInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const connectionId = typeof input.connectionId === "string" ? input.connectionId.trim() : "";
   if (!connectionId) {
     throw new Error("Sandbox integration connection is required.");
@@ -18830,7 +19213,7 @@ function normalizeIntegrationLeaseRefsForRuntime(value) {
   return value.map((item) => normalizeIntegrationLeaseRefForRuntime(item));
 }
 function normalizeIntegrationLeaseRefForRuntime(value) {
-  const input = asRecord4(value);
+  const input = asRecord5(value);
   const leaseId = typeof input.leaseId === "string" ? input.leaseId.trim() : "";
   if (!leaseId) {
     throw new Error("Sandbox integration leaseId is required.");
@@ -18905,7 +19288,7 @@ function validateIntegrationCapabilitiesForProvider(providerValue, capabilities)
   }
 }
 function normalizeIntegrationLeaseId(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const leaseId = typeof input.leaseId === "string" ? input.leaseId.trim() : "";
   if (!leaseId) {
     throw new Error("Sandbox integration lease is required.");
@@ -18967,20 +19350,20 @@ function normalizeIntegrationResourcePolicy(value) {
   }
   return value;
 }
-function assertNoSensitiveResourcePolicyKeys(value, path46) {
+function assertNoSensitiveResourcePolicyKeys(value, path47) {
   if (!value || typeof value !== "object") return;
-  if (path46.length > 8) {
+  if (path47.length > 8) {
     throw new Error("Sandbox integration resourcePolicy is too deeply nested.");
   }
   if (Array.isArray(value)) {
-    for (const item of value) assertNoSensitiveResourcePolicyKeys(item, path46);
+    for (const item of value) assertNoSensitiveResourcePolicyKeys(item, path47);
     return;
   }
   for (const [key, child] of Object.entries(value)) {
     if (isSensitivePolicyKey(key)) {
       throw new Error("Sandbox integration resourcePolicy must not include secrets or credentials.");
     }
-    assertNoSensitiveResourcePolicyKeys(child, [...path46, key]);
+    assertNoSensitiveResourcePolicyKeys(child, [...path47, key]);
   }
 }
 function isSensitivePolicyKey(key) {
@@ -18988,7 +19371,7 @@ function isSensitivePolicyKey(key) {
   return normalized.includes("accesstoken") || normalized.includes("refreshtoken") || normalized.includes("idtoken") || normalized.includes("oauth") || normalized.includes("bearer") || normalized.includes("authorization") || normalized.includes("cookie") || normalized.includes("secret") || normalized.includes("password") || normalized.includes("credential");
 }
 function normalizeExecInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const command = typeof input.command === "string" ? input.command.trim() : "";
   if (!command) throw new Error("Sandbox command is required.");
   const timeoutSeconds = typeof input.timeoutSeconds === "number" && Number.isFinite(input.timeoutSeconds) ? Math.max(1, Math.floor(input.timeoutSeconds)) : void 0;
@@ -18996,19 +19379,19 @@ function normalizeExecInput(payload) {
   return timeoutSeconds ? { command: pipefailCommand, timeoutSeconds } : { command: pipefailCommand };
 }
 function normalizeProcessStartInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const command = typeof input.command === "string" ? input.command.trim() : "";
   if (!command) throw new Error("Sandbox process command is required.");
   const timeoutSeconds = typeof input.timeoutSeconds === "number" && Number.isFinite(input.timeoutSeconds) ? Math.max(1, Math.floor(input.timeoutSeconds)) : void 0;
   return timeoutSeconds ? { command, timeoutSeconds } : { command };
 }
 function normalizeProcessCursorInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const since = Number(input.since);
   return Number.isFinite(since) ? { since: Math.max(0, Math.floor(since)) } : {};
 }
 function normalizeOpenPortInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const port = typeof input.port === "number" ? input.port : Number(input.port);
   if (!Number.isInteger(port) || port < SANDBOX_TEMPLATE_PREVIEW_PORT_MIN || port > SANDBOX_TEMPLATE_PREVIEW_PORT_MAX) {
     throw new Error(
@@ -19038,10 +19421,10 @@ function normalizeOpenPortInput(payload) {
   return out;
 }
 function normalizeSnapshotUpdateInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const out = {};
   if (input.template && typeof input.template === "object" && !Array.isArray(input.template)) {
-    const template = asRecord4(input.template);
+    const template = asRecord5(input.template);
     const nextTemplate = {};
     if (typeof template.description === "string") {
       nextTemplate.description = template.description.trim();
@@ -19064,7 +19447,7 @@ function normalizeSnapshotUpdateInput(payload) {
     }
   }
   if (input.retention && typeof input.retention === "object" && !Array.isArray(input.retention)) {
-    const retention = asRecord4(input.retention);
+    const retention = asRecord5(input.retention);
     const nextRetention = {};
     if (retention.class === "ephemeral" || retention.class === "cached" || retention.class === "pinned") {
       nextRetention.class = retention.class;
@@ -19084,7 +19467,7 @@ function normalizeSnapshotUpdateInput(payload) {
   return out;
 }
 function normalizeSnapshotValidateInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const cleanup = typeof input.cleanup === "string" ? input.cleanup.trim() : "";
   if (cleanup === "delete" || cleanup === "stop" || cleanup === "archive") {
     return { cleanup };
@@ -19092,7 +19475,7 @@ function normalizeSnapshotValidateInput(payload) {
   return {};
 }
 function normalizeForkInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const out = {};
   if (typeof input.snapshotId === "string" && input.snapshotId.trim()) {
     out.snapshotId = input.snapshotId.trim();
@@ -19148,7 +19531,7 @@ function normalizeSandboxEnvRefsForApp(value) {
   });
 }
 function normalizeTemplateLaunchInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const teamId = typeof input.teamId === "string" ? input.teamId.trim() : "";
   const projectId = typeof input.projectId === "string" ? input.projectId.trim() : "";
   const snapshotId = typeof input.snapshotId === "string" ? input.snapshotId.trim() : "";
@@ -19169,43 +19552,43 @@ function normalizeTemplateLaunchInput(payload) {
   };
 }
 function normalizeListFilesInput(payload) {
-  const input = asRecord4(payload);
-  const path46 = typeof input.path === "string" ? input.path.trim() : "";
+  const input = asRecord5(payload);
+  const path47 = typeof input.path === "string" ? input.path.trim() : "";
   const maxEntries = Number(input.maxEntries);
   return {
-    ...path46 ? { path: path46 } : {},
+    ...path47 ? { path: path47 } : {},
     ...typeof input.recursive === "boolean" ? { recursive: input.recursive } : {},
     ...Number.isFinite(maxEntries) ? { maxEntries } : {}
   };
 }
 function normalizeSearchFilesInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const query = typeof input.query === "string" ? input.query.trim() : "";
   if (!query) {
     throw new Error("Sandbox file search query is required.");
   }
-  const path46 = typeof input.path === "string" ? input.path.trim() : "";
+  const path47 = typeof input.path === "string" ? input.path.trim() : "";
   const maxResults = Number(input.maxResults);
   return {
     query,
-    ...path46 ? { path: path46 } : {},
+    ...path47 ? { path: path47 } : {},
     ...Number.isFinite(maxResults) ? { maxResults } : {}
   };
 }
 function normalizeDeleteFileInput(payload) {
-  const input = asRecord4(payload);
-  const path46 = typeof input.path === "string" ? input.path.trim() : "";
-  if (!path46) {
+  const input = asRecord5(payload);
+  const path47 = typeof input.path === "string" ? input.path.trim() : "";
+  if (!path47) {
     throw new Error("Sandbox file path is required.");
   }
   return {
-    path: path46,
+    path: path47,
     recursive: typeof input.recursive === "boolean" ? input.recursive : void 0
   };
 }
 function normalizeDownloadFileInput(payload) {
   const input = normalizeDeleteFileInput(payload);
-  const raw = asRecord4(payload);
+  const raw = asRecord5(payload);
   const offsetBytes = Number(raw.offsetBytes);
   const maxBytes = Number(raw.maxBytes);
   return {
@@ -19215,24 +19598,24 @@ function normalizeDownloadFileInput(payload) {
   };
 }
 function normalizeUploadFileInput(payload) {
-  const input = asRecord4(payload);
-  const path46 = typeof input.path === "string" ? input.path.trim() : "";
+  const input = asRecord5(payload);
+  const path47 = typeof input.path === "string" ? input.path.trim() : "";
   const contents = typeof input.contents === "string" ? input.contents : "";
   const contentsBase64 = typeof input.contentsBase64 === "string" ? input.contentsBase64.trim() : "";
-  if (!path46) {
+  if (!path47) {
     throw new Error("Sandbox file path is required.");
   }
   if (!contents && !contentsBase64) {
     throw new Error("Sandbox file contents are required.");
   }
   return {
-    path: path46,
+    path: path47,
     contents,
     contentsBase64
   };
 }
 function normalizeMoveFileInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const fromPath = typeof input.fromPath === "string" ? input.fromPath.trim() : "";
   const toPath = typeof input.toPath === "string" ? input.toPath.trim() : "";
   if (!fromPath || !toPath) {
@@ -19245,7 +19628,7 @@ function normalizeMoveFileInput(payload) {
   };
 }
 function normalizeGitBranchInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const branch = typeof input.branch === "string" ? input.branch.trim() : "";
   const startPoint = typeof input.startPoint === "string" ? input.startPoint.trim() : "";
   if (!branch) {
@@ -19258,10 +19641,10 @@ function normalizeGitBranchInput(payload) {
   };
 }
 function normalizeGitCommitInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const message = typeof input.message === "string" ? input.message.trim() : "";
   const all = input.all === true;
-  const paths = Array.isArray(input.paths) ? input.paths.filter((path46) => typeof path46 === "string" && path46.trim() !== "") : [];
+  const paths = Array.isArray(input.paths) ? input.paths.filter((path47) => typeof path47 === "string" && path47.trim() !== "") : [];
   if (!message) {
     throw new Error("Sandbox git commit message is required.");
   }
@@ -19270,11 +19653,11 @@ function normalizeGitCommitInput(payload) {
   }
   return {
     message,
-    ...all ? { all: true } : { paths: paths.map((path46) => path46.trim()) }
+    ...all ? { all: true } : { paths: paths.map((path47) => path47.trim()) }
   };
 }
 function normalizeGitPullInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const remote = typeof input.remote === "string" ? input.remote.trim() : "";
   const branch = typeof input.branch === "string" ? input.branch.trim() : "";
   const rebase = input.rebase === true;
@@ -19290,7 +19673,7 @@ function normalizeGitPullInput(payload) {
   };
 }
 function normalizeGitPushInput(payload) {
-  const input = asRecord4(payload);
+  const input = asRecord5(payload);
   const remote = typeof input.remote === "string" ? input.remote.trim() : "";
   const branch = typeof input.branch === "string" ? input.branch.trim() : "";
   return {
@@ -19316,7 +19699,7 @@ async function sandboxRequestPayload(action) {
     };
   }
   if (action.type === "snapshot_catalog") {
-    const input = asRecord4(action.payload);
+    const input = asRecord5(action.payload);
     const teamId = typeof input.teamId === "string" ? input.teamId.trim() : "";
     const projectId = typeof input.projectId === "string" ? input.projectId.trim() : "";
     const agentId = typeof input.agentId === "string" ? input.agentId.trim() : "";
@@ -19347,7 +19730,7 @@ async function sandboxRequestPayload(action) {
     };
   }
   if (action.type === "template_catalog") {
-    const input = asRecord4(action.payload);
+    const input = asRecord5(action.payload);
     const teamId = typeof input.teamId === "string" ? input.teamId.trim() : "";
     const projectId = typeof input.projectId === "string" ? input.projectId.trim() : "";
     const query = typeof input.q === "string" ? input.q.trim() : "";
@@ -19369,7 +19752,7 @@ async function sandboxRequestPayload(action) {
     };
   }
   if (action.type === "integration_connections") {
-    const input = asRecord4(action.payload);
+    const input = asRecord5(action.payload);
     const teamId = typeof input.teamId === "string" ? input.teamId.trim() : "";
     const projectId = typeof input.projectId === "string" ? input.projectId.trim() : "";
     const agentId = typeof input.agentId === "string" ? input.agentId.trim() : "";
@@ -19389,7 +19772,7 @@ async function sandboxRequestPayload(action) {
     };
   }
   if (action.type === "connected_app_status") {
-    const input = asRecord4(action.payload);
+    const input = asRecord5(action.payload);
     const explicitTeamId = typeof input.teamId === "string" ? input.teamId.trim() : "";
     const projectId = typeof input.projectId === "string" ? input.projectId.trim() : "";
     const agentId = typeof input.agentId === "string" ? input.agentId.trim() : "";
@@ -19453,7 +19836,7 @@ async function sandboxRequestPayload(action) {
     };
   }
   if (action.type === "sandbox_runtime_preserve_source") {
-    const input = asRecord4(action.payload);
+    const input = asRecord5(action.payload);
     return {
       ...await client.preserveSandboxRuntimeSource(
         action.runtimeId,
@@ -19468,7 +19851,7 @@ async function sandboxRequestPayload(action) {
     };
   }
   if (action.type === "sandbox_runtime_promote") {
-    const input = asRecord4(action.payload);
+    const input = asRecord5(action.payload);
     return {
       ...await client.promoteSandboxRuntime(
         action.runtimeId,
@@ -19523,7 +19906,7 @@ async function sandboxRequestPayload(action) {
     };
   }
   if (action.type === "profile_push") {
-    const payload = asRecord4(action.payload);
+    const payload = asRecord5(action.payload);
     const { teamId: _teamId, ...body } = payload;
     return {
       ...await requestSandboxPublicApiRoot({
@@ -19546,7 +19929,7 @@ async function sandboxRequestPayload(action) {
         sandboxApiUrl,
         path: "/projects",
         method: "POST",
-        body: asRecord4(action.payload)
+        body: asRecord5(action.payload)
       }),
       account: account2
     };
@@ -19593,7 +19976,7 @@ async function sandboxRequestPayload(action) {
     };
   }
   if (action.type === "project_source_upload") {
-    const payload = asRecord4(action.payload);
+    const payload = asRecord5(action.payload);
     const { teamId: _teamId, ...body } = payload;
     return {
       ...await requestSandboxPublicApiRoot({
@@ -19643,7 +20026,7 @@ async function sandboxRequestPayload(action) {
         sandboxApiUrl,
         path: "/agents",
         method: "POST",
-        body: asRecord4(action.payload)
+        body: asRecord5(action.payload)
       }),
       account: account2
     };
@@ -19655,7 +20038,7 @@ async function sandboxRequestPayload(action) {
         sandboxApiUrl,
         path: `/agents/${encodeURIComponent(action.agentId)}/run`,
         method: "POST",
-        body: asRecord4(action.payload)
+        body: asRecord5(action.payload)
       }),
       account: account2
     };
@@ -19674,7 +20057,7 @@ async function sandboxRequestPayload(action) {
     };
   }
   if (action.type === "agent_source_checks") {
-    const payload = asRecord4(action.payload);
+    const payload = asRecord5(action.payload);
     const { teamId: _teamId, ...body } = payload;
     return {
       ...await requestSandboxPublicApiRoot({
@@ -19691,7 +20074,7 @@ async function sandboxRequestPayload(action) {
     };
   }
   if (action.type === "agent_source_publish") {
-    const payload = asRecord4(action.payload);
+    const payload = asRecord5(action.payload);
     const { teamId: _teamId, ...body } = payload;
     return {
       ...await requestSandboxPublicApiRoot({
@@ -19762,7 +20145,7 @@ async function sandboxRequestPayload(action) {
           action.sandboxId
         )}/actions/${encodeURIComponent(action.actionName)}/run`,
         method: "POST",
-        body: asRecord4(action.payload)
+        body: asRecord5(action.payload)
       }),
       account: account2
     };
@@ -19853,7 +20236,7 @@ async function sandboxRequestPayload(action) {
   if (action.type === "schedule_create") {
     return {
       ...await client.createSchedule(
-        asRecord4(action.payload)
+        asRecord5(action.payload)
       ),
       account: account2
     };
@@ -20020,7 +20403,7 @@ async function sandboxRequestPayload(action) {
     return { ...await client.gitStatus(action.sandboxId), account: account2 };
   }
   if (action.type === "git_diff") {
-    const input = asRecord4(action.payload);
+    const input = asRecord5(action.payload);
     const baseRef = typeof input.baseRef === "string" ? input.baseRef.trim() : "";
     return {
       ...await client.gitDiff(action.sandboxId, {
@@ -20030,7 +20413,7 @@ async function sandboxRequestPayload(action) {
     };
   }
   if (action.type === "git_export_patch") {
-    const input = asRecord4(action.payload);
+    const input = asRecord5(action.payload);
     const baseRef = typeof input.baseRef === "string" ? input.baseRef.trim() : "";
     return {
       ...await client.gitExportPatch(action.sandboxId, {
@@ -20276,12 +20659,12 @@ function sandboxPublicApiRootUrl(sandboxApiUrl) {
   }
   return normalized.replace(/\/sandboxes\/?$/, "");
 }
-function sandboxScopedCollectionPath(path46, queryInput) {
+function sandboxScopedCollectionPath(path47, queryInput) {
   const query = new URLSearchParams();
   if (queryInput.teamId) query.set("teamId", queryInput.teamId);
   if (queryInput.projectId) query.set("projectId", queryInput.projectId);
   if (queryInput.agentId) query.set("agentId", queryInput.agentId);
-  return `${path46}${query.size > 0 ? `?${query.toString()}` : ""}`;
+  return `${path47}${query.size > 0 ? `?${query.toString()}` : ""}`;
 }
 async function requestSandboxApiRoot(params) {
   const response = await apiFetch(
@@ -20501,34 +20884,34 @@ async function executeAppServerSandboxTool(input) {
   });
 }
 async function editRemoteSandboxFile(input) {
-  const path46 = requiredString(input.args.path, "path");
+  const path47 = requiredString(input.args.path, "path");
   const oldText = requiredString(input.args.oldText, "oldText");
   const newText = stringValue5(input.args.newText);
-  const downloaded = asRecord5(
+  const downloaded = asRecord6(
     await input.sandboxRequest({
       type: "download_file",
       sandboxId: input.sandboxId,
-      payload: { path: path46, maxBytes: 1024 * 1024 }
+      payload: { path: path47, maxBytes: 1024 * 1024 }
     })
   );
-  const file = asRecord5(downloaded.file);
+  const file = asRecord6(downloaded.file);
   const content = optionalString(downloaded.contents) || optionalString(downloaded.content) || optionalString(file.contents) || optionalString(file.content) || decodeBase64(optionalString(file.contentsBase64));
   if (!content.includes(oldText)) {
-    throw new Error(`Text to replace was not found in ${path46}.`);
+    throw new Error(`Text to replace was not found in ${path47}.`);
   }
   if (input.args.replaceAll !== true && content.indexOf(oldText) !== content.lastIndexOf(oldText)) {
-    throw new Error(`Text to replace is not unique in ${path46}.`);
+    throw new Error(`Text to replace is not unique in ${path47}.`);
   }
   const nextContent = input.args.replaceAll === true ? content.split(oldText).join(newText) : content.replace(oldText, newText);
   return input.sandboxRequest({
     type: "upload_file",
     sandboxId: input.sandboxId,
-    payload: { path: path46, contents: nextContent }
+    payload: { path: path47, contents: nextContent }
   });
 }
 function withDecodedFileContent(value) {
-  const result = asRecord5(value);
-  const file = asRecord5(result.file);
+  const result = asRecord6(value);
+  const file = asRecord6(result.file);
   const contentsBase64 = optionalString(file.contentsBase64);
   if (!contentsBase64) return value;
   return {
@@ -20543,7 +20926,7 @@ function decodeBase64(value) {
   if (!value) return "";
   return Buffer2.from(value, "base64").toString("utf8");
 }
-function asRecord5(value) {
+function asRecord6(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function stringValue5(value) {
@@ -20568,10 +20951,10 @@ function requiredNumber(value, name) {
 
 // ../server/src/runtime/app-server-workspace.ts
 function createAppServerWorkspace(input) {
-  const workspaceDir = path19.resolve(input.workspaceDir);
+  const workspaceDir = path20.resolve(input.workspaceDir);
   const locks = /* @__PURE__ */ new Map();
   async function workspaceForSession(session) {
-    const repoPath = path19.resolve(session.cwd?.trim() || workspaceDir);
+    const repoPath = path20.resolve(session.cwd?.trim() || workspaceDir);
     const app = workspaceApp(repoPath, session.updatedAt);
     const state = await loadWorkspaceStateAtPath(
       { workspacePath: repoPath, repoPath },
@@ -20729,7 +21112,7 @@ function createAppServerWorkspace(input) {
 function workspaceApp(repoPath, updatedAt) {
   return {
     id: localPathWorkspaceId(repoPath),
-    name: path19.basename(repoPath) || "Sandbox workspace",
+    name: path20.basename(repoPath) || "Sandbox workspace",
     description: null,
     visibility: "private",
     gitOwner: null,
@@ -20748,7 +21131,7 @@ function sameDiff(current, baseline) {
 // ../server/src/runtime/bundled-authoring-skills.ts
 import { createHash as createHash3 } from "node:crypto";
 import { access, readFile } from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 import { fileURLToPath } from "node:url";
 var BUNDLED_AUTHORING_SKILL_NAMES = [
   "openpond-skill-authoring",
@@ -20767,7 +21150,7 @@ var REFERENCE_FILES = {
     "references/validation-and-repair.md"
   ]
 };
-var moduleDirectory = path20.dirname(fileURLToPath(import.meta.url));
+var moduleDirectory = path21.dirname(fileURLToPath(import.meta.url));
 function isBundledAuthoringSkillName(value) {
   return BUNDLED_AUTHORING_SKILL_NAMES.includes(value);
 }
@@ -20781,7 +21164,7 @@ async function loadBundledAuthoringProfileSkill(name, repoRoot = process.cwd())
   if (!builtIn) throw new Error(`Built-in OpenPond authoring skill metadata not found: ${name}`);
   return {
     ...builtIn,
-    path: path20.join(root, "SKILL.md"),
+    path: path21.join(root, "SKILL.md"),
     sourcePath: root,
     charCount: body.length,
     sourceHash: createHash3("sha256").update(body).digest("hex"),
@@ -20806,8 +21189,8 @@ async function readBundledAuthoringProfileSkill(name, repoRoot = process.cwd())
 async function loadBundledAuthoringSkillBundle(name, repoRoot = process.cwd()) {
   const root = await resolveBundledAuthoringSkillRoot(name, repoRoot);
   const [skill, ...references] = await Promise.all([
-    readFile(path20.join(root, "SKILL.md"), "utf8"),
-    ...REFERENCE_FILES[name].map((relativePath) => readFile(path20.join(root, relativePath), "utf8"))
+    readFile(path21.join(root, "SKILL.md"), "utf8"),
+    ...REFERENCE_FILES[name].map((relativePath) => readFile(path21.join(root, relativePath), "utf8"))
   ]);
   return [
     skill.trim(),
@@ -20819,14 +21202,14 @@ ${reference.trim()}`)
 }
 async function resolveBundledAuthoringSkillRoot(name, repoRoot = process.cwd(), executablePath = process.execPath) {
   const candidates = [
-    path20.resolve(repoRoot, "apps", "cli", "skills", name),
-    path20.resolve(repoRoot, "dist", "skills", name),
-    path20.resolve(path20.dirname(executablePath), "skills", name),
-    path20.resolve(moduleDirectory, "skills", name),
-    path20.resolve(moduleDirectory, "..", "skills", name)
+    path21.resolve(repoRoot, "apps", "cli", "skills", name),
+    path21.resolve(repoRoot, "dist", "skills", name),
+    path21.resolve(path21.dirname(executablePath), "skills", name),
+    path21.resolve(moduleDirectory, "skills", name),
+    path21.resolve(moduleDirectory, "..", "skills", name)
   ];
   for (const candidate of candidates) {
-    if (await access(path20.join(candidate, "SKILL.md")).then(() => true, () => false)) return candidate;
+    if (await access(path21.join(candidate, "SKILL.md")).then(() => true, () => false)) return candidate;
   }
   throw new Error(`Bundled OpenPond authoring skill ${name} was not found. Checked: ${candidates.join(", ")}`);
 }
@@ -20971,8 +21354,35 @@ function notificationMethod(name) {
   return "turn/event";
 }
 
+// ../server/src/harness/local-harness-evaluation-review-model.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+function createLocalHarnessEvaluationReviewModelStream(streamOpenPondHostedChatTurn2) {
+  return async function* ({ messages, signal }) {
+    for await (const delta of streamOpenPondHostedChatTurn2({
+      model: DEFAULT_OPENPOND_CHAT_MODEL,
+      messages,
+      requestId: `harness-continuous-review:${randomUUID6()}`,
+      reasoningEffort: "medium",
+      maxTokens: DEFAULT_EVALUATION_REVIEW_MAX_OUTPUT_TOKENS,
+      signal
+    })) {
+      if (delta.type === "text_delta" && delta.text) {
+        yield { text: delta.text };
+      } else if (delta.type === "usage") {
+        yield {
+          usage: {
+            promptTokens: delta.usage.prompt_tokens ?? 0,
+            completionTokens: delta.usage.completion_tokens ?? 0,
+            totalTokens: delta.usage.total_tokens ?? 0
+          }
+        };
+      }
+    }
+  };
+}
+
 // ../server/src/harness/local-harness-taskset-review.ts
-import path32 from "node:path";
+import path33 from "node:path";
 
 // ../../packages/taskset-sdk/dist/graders.js
 async function gradeAttempt(input) {
@@ -21123,7 +21533,7 @@ function normalizedFinalAnswer(value) {
 
 // ../../packages/taskset-sdk/dist/materialize.js
 import { access as access2, mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
-import path21 from "node:path";
+import path22 from "node:path";
 
 // ../../packages/taskset-sdk/dist/validation.js
 function validateTaskset(input) {
@@ -21318,13 +21728,13 @@ function validateWorkExecution(taskset, issues) {
     const assetIds = /* @__PURE__ */ new Set();
     const fileNames = /* @__PURE__ */ new Set();
     for (const [assetIndex, asset2] of (task.assets ?? []).entries()) {
-      const path46 = `tasks.${taskIndex}.assets.${assetIndex}`;
+      const path47 = `tasks.${taskIndex}.assets.${assetIndex}`;
       if (assetIds.has(asset2.id)) {
         issues.push({
           code: "work_asset_duplicate_id",
           severity: "error",
           message: `Task ${task.id} repeats asset id ${asset2.id}.`,
-          path: `${path46}.id`
+          path: `${path47}.id`
         });
       }
       if (fileNames.has(asset2.fileName)) {
@@ -21332,7 +21742,7 @@ function validateWorkExecution(taskset, issues) {
           code: "work_asset_duplicate_name",
           severity: "error",
           message: `Task ${task.id} repeats staged file name ${asset2.fileName}.`,
-          path: `${path46}.fileName`
+          path: `${path47}.fileName`
         });
       }
       assetIds.add(asset2.id);
@@ -21342,7 +21752,7 @@ function validateWorkExecution(taskset, issues) {
           code: "work_asset_task_source_missing",
           severity: "error",
           message: `Asset ${asset2.id} references source ${asset2.sourceRefId} outside task ${task.id}.`,
-          path: `${path46}.sourceRefId`
+          path: `${path47}.sourceRefId`
         });
       }
       const source = sourceById.get(asset2.sourceRefId);
@@ -21351,14 +21761,14 @@ function validateWorkExecution(taskset, issues) {
           code: "work_asset_source_missing",
           severity: "error",
           message: `Asset ${asset2.id} references missing source ${asset2.sourceRefId}.`,
-          path: `${path46}.sourceRefId`
+          path: `${path47}.sourceRefId`
         });
       } else if ("sourceFileHashes" in source && !source.sourceFileHashes.includes(asset2.sha256)) {
         issues.push({
           code: "work_asset_hash_unregistered",
           severity: "error",
           message: `Asset ${asset2.id} hash is not registered by source ${asset2.sourceRefId}.`,
-          path: `${path46}.sha256`
+          path: `${path47}.sha256`
         });
       }
       if (source && "kind" in source && source.kind === "uploaded_file" && !source.originalFileNames.includes(asset2.fileName)) {
@@ -21366,7 +21776,7 @@ function validateWorkExecution(taskset, issues) {
           code: "work_asset_name_unregistered",
           severity: "error",
           message: `Asset ${asset2.id} file name is not registered by source ${asset2.sourceRefId}.`,
-          path: `${path46}.fileName`
+          path: `${path47}.fileName`
         });
       }
       if (source && "kind" in source && source.kind === "uploaded_file" && !source.mediaTypes.includes(asset2.mediaType)) {
@@ -21374,7 +21784,7 @@ function validateWorkExecution(taskset, issues) {
           code: "work_asset_media_type_unregistered",
           severity: "error",
           message: `Asset ${asset2.id} media type is not registered by source ${asset2.sourceRefId}.`,
-          path: `${path46}.mediaType`
+          path: `${path47}.mediaType`
         });
       }
       if (asset2.split !== task.split) {
@@ -21382,20 +21792,20 @@ function validateWorkExecution(taskset, issues) {
           code: "work_asset_split_mismatch",
           severity: "error",
           message: `Asset ${asset2.id} is assigned to ${asset2.split}, not task split ${task.split}.`,
-          path: `${path46}.split`
+          path: `${path47}.split`
         });
       }
     }
     const outputPaths = /* @__PURE__ */ new Set();
     for (const [outputIndex, output] of (task.requiredOutputs ?? []).entries()) {
       const normalized = output.path.replaceAll("\\", "/");
-      const path46 = `tasks.${taskIndex}.requiredOutputs.${outputIndex}.path`;
+      const path47 = `tasks.${taskIndex}.requiredOutputs.${outputIndex}.path`;
       if (outputPaths.has(normalized)) {
         issues.push({
           code: "work_output_duplicate_path",
           severity: "error",
           message: `Task ${task.id} repeats required output path ${normalized}.`,
-          path: path46
+          path: path47
         });
       }
       outputPaths.add(normalized);
@@ -21492,17 +21902,17 @@ async function buildTaskset(input, directory, options = {}) {
   const report = validateTaskset(taskset);
   if (!report.valid)
     throw new Error(report.issues.map((issue) => `${issue.code}: ${issue.message}`).join("\n"));
-  await mkdir(path21.join(directory, "data"), { recursive: true });
-  await mkdir(path21.join(directory, "graders"), { recursive: true });
-  await mkdir(path21.join(directory, "environment"), { recursive: true });
-  await mkdir(path21.join(directory, "fixtures"), { recursive: true });
+  await mkdir(path22.join(directory, "data"), { recursive: true });
+  await mkdir(path22.join(directory, "graders"), { recursive: true });
+  await mkdir(path22.join(directory, "environment"), { recursive: true });
+  await mkdir(path22.join(directory, "fixtures"), { recursive: true });
   const files = [
-    path21.join(directory, "taskset.json"),
-    path21.join(directory, "capabilities.json"),
-    path21.join(directory, "data", "tasks.jsonl"),
-    path21.join(directory, "graders", "graders.json"),
-    path21.join(directory, "fixtures", "grader-fixtures.json"),
-    path21.join(directory, "environment", "taskset.ts")
+    path22.join(directory, "taskset.json"),
+    path22.join(directory, "capabilities.json"),
+    path22.join(directory, "data", "tasks.jsonl"),
+    path22.join(directory, "graders", "graders.json"),
+    path22.join(directory, "fixtures", "grader-fixtures.json"),
+    path22.join(directory, "environment", "taskset.ts")
   ];
   await writeFile(files[0], canonicalJson(taskset), "utf8");
   await writeFile(files[1], canonicalJson(taskset.capabilities), "utf8");
@@ -21512,8 +21922,8 @@ async function buildTaskset(input, directory, options = {}) {
   await writeFile(files[5], generatedEnvironmentSource(taskset), "utf8");
   for (const generated of options.generatedFiles ?? []) {
     const relative = safeGeneratedPath(generated.path, generated.role);
-    const destination = path21.join(directory, relative);
-    await mkdir(path21.dirname(destination), { recursive: true });
+    const destination = path22.join(directory, relative);
+    await mkdir(path22.dirname(destination), { recursive: true });
     await writeFile(destination, generated.content, "utf8");
     files.push(destination);
   }
@@ -21522,7 +21932,7 @@ async function buildTaskset(input, directory, options = {}) {
       continue;
     const relative = safeGeneratedPath(grader.module, "verifier");
     try {
-      await access2(path21.join(directory, relative));
+      await access2(path22.join(directory, relative));
     } catch {
       throw new Error(`Custom verifier ${grader.id} is missing generated source ${relative}.`);
     }
@@ -21531,7 +21941,7 @@ async function buildTaskset(input, directory, options = {}) {
 }
 function safeGeneratedPath(value, role) {
   const normalized = value.replaceAll("\\", "/");
-  if (path21.posix.isAbsolute(normalized) || normalized.split("/").includes(".."))
+  if (path22.posix.isAbsolute(normalized) || normalized.split("/").includes(".."))
     throw new Error(`Generated ${role} path must stay inside the Taskset: ${value}.`);
   const prefix = role === "verifier" ? "graders/" : role === "environment" ? "environment/" : "fixtures/";
   if (!normalized.startsWith(prefix))
@@ -21773,18 +22183,18 @@ function uniqueObjects(values) {
 // ../server/src/training/task-authoring-skill.ts
 import { access as access3, readFile as readFile3 } from "node:fs/promises";
 import { createHash as createHash4 } from "node:crypto";
-import path22 from "node:path";
+import path23 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var SKILL_DIRECTORY = "openpond-taskset-authoring";
 var SKILL_ARTIFACT_FILE = "artifact.json";
-var moduleDirectory2 = path22.dirname(fileURLToPath2(import.meta.url));
+var moduleDirectory2 = path23.dirname(fileURLToPath2(import.meta.url));
 async function loadTasksetAuthoringSkillBundle(repoRoot = process.cwd()) {
   return (await loadTasksetAuthoringSkillArtifact(repoRoot)).bundle;
 }
 async function loadTasksetAuthoringSkillArtifact(repoRoot = process.cwd()) {
   const skillRoot = await resolveTasksetAuthoringSkillRoot(repoRoot);
   const parsed = JSON.parse(
-    await readFile3(path22.join(skillRoot, SKILL_ARTIFACT_FILE), "utf8")
+    await readFile3(path23.join(skillRoot, SKILL_ARTIFACT_FILE), "utf8")
   );
   if (parsed.schemaVersion !== 1 || parsed.skillName !== SKILL_DIRECTORY || !parsed.artifactVersion || !parsed.bundle || !/^[a-f0-9]{64}$/.test(parsed.contentHash)) {
     throw new Error("Bundled Taskset Authoring artifact is invalid.");
@@ -21810,7 +22220,7 @@ async function loadTasksetAuthoringProfileSkill(repoRoot = process.cwd()) {
   const builtIn = BUILT_IN_OPENPOND_PROFILE_SKILLS[0];
   return {
     ...builtIn,
-    path: path22.join(root, "SKILL.md"),
+    path: path23.join(root, "SKILL.md"),
     sourcePath: root,
     charCount: body.length,
     sourceHash: artifact.contentHash,
@@ -21835,14 +22245,14 @@ async function readTasksetAuthoringProfileSkill(repoRoot = process.cwd()) {
 async function resolveTasksetAuthoringSkillRoot(repoRoot = process.cwd(), executablePath = process.execPath) {
   const candidates = [
     process.env.OPENPOND_TASKSET_AUTHORING_SKILL_ROOT,
-    path22.resolve(repoRoot, "apps", "cli", "skills", SKILL_DIRECTORY),
-    path22.resolve(repoRoot, "dist", "skills", SKILL_DIRECTORY),
-    path22.resolve(path22.dirname(executablePath), "skills", SKILL_DIRECTORY),
-    path22.resolve(moduleDirectory2, "skills", SKILL_DIRECTORY),
-    path22.resolve(moduleDirectory2, "..", "skills", SKILL_DIRECTORY)
+    path23.resolve(repoRoot, "apps", "cli", "skills", SKILL_DIRECTORY),
+    path23.resolve(repoRoot, "dist", "skills", SKILL_DIRECTORY),
+    path23.resolve(path23.dirname(executablePath), "skills", SKILL_DIRECTORY),
+    path23.resolve(moduleDirectory2, "skills", SKILL_DIRECTORY),
+    path23.resolve(moduleDirectory2, "..", "skills", SKILL_DIRECTORY)
   ].filter((candidate) => Boolean(candidate));
   for (const candidate of candidates) {
-    if (await access3(path22.join(candidate, SKILL_ARTIFACT_FILE)).then(
+    if (await access3(path23.join(candidate, SKILL_ARTIFACT_FILE)).then(
       () => true,
       () => false
     )) {
@@ -21853,8 +22263,8 @@ async function resolveTasksetAuthoringSkillRoot(repoRoot = process.cwd(), execut
 }
 
 // ../server/src/training/task-creator.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
-import path24 from "node:path";
+import { randomUUID as randomUUID9 } from "node:crypto";
+import path25 from "node:path";
 
 // ../server/src/training/privacy.ts
 var SECRET_PATTERNS = [
@@ -21934,18 +22344,18 @@ function trajectoryMessages(task, trajectory) {
 }
 
 // ../server/src/training/cross-system-operations/expert-bootstrap-service.ts
-import path23 from "node:path";
+import path24 from "node:path";
 
 // ../server/src/training/cross-system-operations/environment.ts
 import { Buffer as Buffer3 } from "node:buffer";
 
 // ../server/src/training/cross-system-operations/python-sandbox.ts
-import { execFile, spawn as spawn2 } from "node:child_process";
+import { execFile as execFile2, spawn as spawn2 } from "node:child_process";
 import { tmpdir } from "node:os";
 import readline from "node:readline";
-import { randomUUID as randomUUID6 } from "node:crypto";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
 var DEFAULT_MAX_MEMORY_BYTES = 256 * 1024 * 1024;
 var DEFAULT_MEMORY_POLL_INTERVAL_MS = 100;
 var MAX_STDERR_BYTES = 4096;
@@ -22049,7 +22459,7 @@ var PersistentPythonSandbox = class {
     if (this.closed) throw new Error("Python sandbox is closed.");
     if (Buffer.byteLength(code, "utf8") > 1e4) throw new Error("Python code exceeds the 10,000-byte limit.");
     if (signal?.aborted) throw abortError(signal);
-    const id = `python_${randomUUID6()}`;
+    const id = `python_${randomUUID7()}`;
     const result = new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
@@ -22153,7 +22563,7 @@ async function readResidentMemoryBytes(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return null;
   try {
     if (process.platform === "win32") {
-      const { stdout: stdout2 } = await execFileAsync(
+      const { stdout: stdout2 } = await execFileAsync2(
         "powershell.exe",
         [
           "-NoProfile",
@@ -22166,7 +22576,7 @@ async function readResidentMemoryBytes(pid) {
       const bytes = Number(String(stdout2).trim());
       return Number.isFinite(bytes) && bytes >= 0 ? bytes : null;
     }
-    const { stdout } = await execFileAsync(
+    const { stdout } = await execFileAsync2(
       "ps",
       ["-o", "rss=", "-p", String(pid)],
       { encoding: "utf8", timeout: 1e3, windowsHide: true }
@@ -23309,7 +23719,7 @@ function createCrossSystemExpertBootstrapService(deps) {
     const generatedFiles = await generatedTaskFiles(taskset, records, approval);
     await buildTaskset(
       updated,
-      path23.join(deps.storeDir, "training", "tasksets", updated.id),
+      path24.join(deps.storeDir, "training", "tasksets", updated.id),
       { generatedFiles }
     );
     await deps.store.upsertTaskset(updated);
@@ -23849,7 +24259,7 @@ function isCrossSystemToolName(value) {
 }
 
 // ../server/src/training/cross-system-operations/rollout.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 
 // ../server/src/openpond/native-tool-calls.ts
 var NativeToolCallAccumulator = class {
@@ -24106,47 +24516,47 @@ function localAdapterToolInstruction(tools, toolChoice) {
   }
   return crossSystemLocalToolSystemPrompt(toolChoice ?? "auto");
 }
-function validateJsonSchema(value, schema, path46) {
+function validateJsonSchema(value, schema, path47) {
   if (Array.isArray(schema.anyOf)) {
-    return schema.anyOf.some((candidate) => isRecord4(candidate) && !validateJsonSchema(value, candidate, path46)) ? null : `${path46} does not match an allowed schema.`;
+    return schema.anyOf.some((candidate) => isRecord4(candidate) && !validateJsonSchema(value, candidate, path47)) ? null : `${path47} does not match an allowed schema.`;
   }
   const type = schema.type;
   if (type === "object") {
-    if (!isRecord4(value)) return `${path46} must be an object.`;
+    if (!isRecord4(value)) return `${path47} must be an object.`;
     const properties = isRecord4(schema.properties) ? schema.properties : {};
     const required = Array.isArray(schema.required) ? schema.required.filter((item) => typeof item === "string") : [];
-    for (const key of required) if (!Object.hasOwn(value, key)) return `${path46}.${key} is required.`;
+    for (const key of required) if (!Object.hasOwn(value, key)) return `${path47}.${key} is required.`;
     if (schema.additionalProperties === false) {
       const extra = Object.keys(value).find((key) => !Object.hasOwn(properties, key));
-      if (extra) return `${path46}.${extra} is not allowed.`;
+      if (extra) return `${path47}.${extra} is not allowed.`;
     }
     for (const [key, item] of Object.entries(value)) {
       const propertySchema = properties[key];
       if (isRecord4(propertySchema)) {
-        const issue = validateJsonSchema(item, propertySchema, `${path46}.${key}`);
+        const issue = validateJsonSchema(item, propertySchema, `${path47}.${key}`);
         if (issue) return issue;
       }
     }
   } else if (type === "array") {
-    if (!Array.isArray(value)) return `${path46} must be an array.`;
-    if (typeof schema.minItems === "number" && value.length < schema.minItems) return `${path46} has too few items.`;
-    if (typeof schema.maxItems === "number" && value.length > schema.maxItems) return `${path46} has too many items.`;
-    if (schema.uniqueItems === true && new Set(value.map((item) => JSON.stringify(item))).size !== value.length) return `${path46} items must be unique.`;
+    if (!Array.isArray(value)) return `${path47} must be an array.`;
+    if (typeof schema.minItems === "number" && value.length < schema.minItems) return `${path47} has too few items.`;
+    if (typeof schema.maxItems === "number" && value.length > schema.maxItems) return `${path47} has too many items.`;
+    if (schema.uniqueItems === true && new Set(value.map((item) => JSON.stringify(item))).size !== value.length) return `${path47} items must be unique.`;
     if (isRecord4(schema.items)) for (let index = 0; index < value.length; index += 1) {
-      const issue = validateJsonSchema(value[index], schema.items, `${path46}[${index}]`);
+      const issue = validateJsonSchema(value[index], schema.items, `${path47}[${index}]`);
       if (issue) return issue;
     }
   } else if (type === "string") {
-    if (typeof value !== "string") return `${path46} must be a string.`;
-    if (typeof schema.minLength === "number" && value.length < schema.minLength) return `${path46} is too short.`;
-    if (typeof schema.maxLength === "number" && value.length > schema.maxLength) return `${path46} is too long.`;
-    if (schema.format === "date" && !/^\d{4}-\d{2}-\d{2}$/.test(value)) return `${path46} must be an ISO date.`;
+    if (typeof value !== "string") return `${path47} must be a string.`;
+    if (typeof schema.minLength === "number" && value.length < schema.minLength) return `${path47} is too short.`;
+    if (typeof schema.maxLength === "number" && value.length > schema.maxLength) return `${path47} is too long.`;
+    if (schema.format === "date" && !/^\d{4}-\d{2}-\d{2}$/.test(value)) return `${path47} must be an ISO date.`;
   } else if (type === "integer") {
-    if (!Number.isInteger(value)) return `${path46} must be an integer.`;
-    if (typeof schema.minimum === "number" && Number(value) < schema.minimum) return `${path46} is below its minimum.`;
-    if (typeof schema.maximum === "number" && Number(value) > schema.maximum) return `${path46} exceeds its maximum.`;
-  } else if (type === "null" && value !== null) return `${path46} must be null.`;
-  if (Array.isArray(schema.enum) && !schema.enum.some((candidate) => Object.is(candidate, value))) return `${path46} is outside the allowed enum.`;
+    if (!Number.isInteger(value)) return `${path47} must be an integer.`;
+    if (typeof schema.minimum === "number" && Number(value) < schema.minimum) return `${path47} is below its minimum.`;
+    if (typeof schema.maximum === "number" && Number(value) > schema.maximum) return `${path47} exceeds its maximum.`;
+  } else if (type === "null" && value !== null) return `${path47} must be null.`;
+  if (Array.isArray(schema.enum) && !schema.enum.some((candidate) => Object.is(candidate, value))) return `${path47} is outside the allowed enum.`;
   return null;
 }
 function parseArgumentsForHistory(value) {
@@ -24224,7 +24634,7 @@ function stableSuffix(name, args) {
 
 // ../server/src/training/cross-system-operations/rollout.ts
 async function runCrossSystemRollout(input) {
-  const id = input.trajectoryId ?? `cso_rollout_${randomUUID7()}`;
+  const id = input.trajectoryId ?? `cso_rollout_${randomUUID8()}`;
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const environment = new CrossSystemEnvironment({
     attemptId: id,
@@ -25242,7 +25652,7 @@ function createTaskCreatorService(deps) {
         state: "failed",
         blockedReason: "OpenPond restarted during Taskset authoring. The reviewed evidence and proposal were preserved; start authoring again to continue.",
         transcript: [...snapshot.transcript, {
-          id: `task_message_${randomUUID8()}`,
+          id: `task_message_${randomUUID9()}`,
           role: "assistant",
           text: "Taskset authoring stopped when OpenPond restarted. The reviewed evidence and any completed proposal were preserved.",
           createdAt: timestamp
@@ -25261,7 +25671,7 @@ function createTaskCreatorService(deps) {
     const timestamp = now();
     const source = TrainingSourceRefSchema.parse({
       schemaVersion: "openpond.trainingSource.v1",
-      id: `training_source_${randomUUID8()}`,
+      id: `training_source_${randomUUID9()}`,
       profileId: input.profileId,
       sessionId: input.sessionId,
       turnIds,
@@ -25316,10 +25726,10 @@ function createTaskCreatorService(deps) {
     const sources = await requireSources(input.profileId, input.sourceIds);
     assertSourcesEligible(sources);
     const timestamp = now();
-    const disclosureApprovalId = input.analysisModel && sources.length ? `task_disclosure_${randomUUID8()}` : null;
+    const disclosureApprovalId = input.analysisModel && sources.length ? `task_disclosure_${randomUUID9()}` : null;
     const request = TaskCreationRequestSchema.parse({
       schemaVersion: "openpond.taskCreationRequest.v1",
-      id: `task_creation_request_${randomUUID8()}`,
+      id: `task_creation_request_${randomUUID9()}`,
       profileId: input.profileId,
       surface: input.surface,
       mode: input.mode,
@@ -25354,13 +25764,13 @@ function createTaskCreatorService(deps) {
     });
     const needsDisclosure = request.disclosure.status === "pending";
     const blockingQuestions = [
-      ...!request.objective && request.mode === "customize" ? [{ id: `task_question_${randomUUID8()}`, kind: "objective", prompt: "What repeatable capability should this Taskset teach or evaluate?", answer: null }] : [],
-      ...!sources.length && !input.buildSpecification ? [{ id: `task_question_${randomUUID8()}`, kind: "success_signal", prompt: "Add at least one successful example, correction, reviewer choice, or outcome-bearing run so the authoring model can ground this capability without fabricating demonstrations.", answer: null }] : []
+      ...!request.objective && request.mode === "customize" ? [{ id: `task_question_${randomUUID9()}`, kind: "objective", prompt: "What repeatable capability should this Taskset teach or evaluate?", answer: null }] : [],
+      ...!sources.length && !input.buildSpecification ? [{ id: `task_question_${randomUUID9()}`, kind: "success_signal", prompt: "Add at least one successful example, correction, reviewer choice, or outcome-bearing run so the authoring model can ground this capability without fabricating demonstrations.", answer: null }] : []
     ];
     const initialState = blockingQuestions.length ? "awaiting_questions" : needsDisclosure ? "awaiting_disclosure_approval" : "planning";
     let snapshot = TaskCreationSnapshotSchema.parse({
       schemaVersion: "openpond.taskCreationSnapshot.v1",
-      id: `task_creation_${randomUUID8()}`,
+      id: `task_creation_${randomUUID9()}`,
       request,
       state: initialState,
       proposal: null,
@@ -25368,7 +25778,7 @@ function createTaskCreatorService(deps) {
       disclosureApprovalId,
       materializationApprovalId: null,
       blockingQuestions,
-      transcript: [{ id: `task_message_${randomUUID8()}`, role: "user", text: request.objective ?? "Create a Taskset from the selected conversations.", createdAt: timestamp }],
+      transcript: [{ id: `task_message_${randomUUID9()}`, role: "user", text: request.objective ?? "Create a Taskset from the selected conversations.", createdAt: timestamp }],
       blockedReason: null,
       createdAt: timestamp,
       updatedAt: timestamp
@@ -25411,7 +25821,7 @@ function createTaskCreatorService(deps) {
       state: "planning",
       blockedReason: null,
       transcript: [...snapshot.transcript, {
-        id: `task_message_${randomUUID8()}`,
+        id: `task_message_${randomUUID9()}`,
         role: "user",
         text: "Retry Taskset authoring with the same approved evidence and authoring configuration.",
         createdAt: timestamp
@@ -25464,7 +25874,7 @@ function createTaskCreatorService(deps) {
       );
       applying = await persist({ ...applying, proposal, updatedAt: now() });
       const taskset = await materializeTaskset(applying, proposal, sources);
-      return persist({ ...applying, state: "ready", materializedTasksetId: taskset.id, blockedReason: null, updatedAt: now(), transcript: [...applying.transcript, { id: `task_message_${randomUUID8()}`, role: "assistant", text: `Materialized ${taskset.name} with ${taskset.tasks.length} tasks and ${taskset.graders.length} graders.`, createdAt: now() }] });
+      return persist({ ...applying, state: "ready", materializedTasksetId: taskset.id, blockedReason: null, updatedAt: now(), transcript: [...applying.transcript, { id: `task_message_${randomUUID9()}`, role: "assistant", text: `Materialized ${taskset.name} with ${taskset.tasks.length} tasks and ${taskset.graders.length} graders.`, createdAt: now() }] });
     } catch (error) {
       return persist({ ...applying, state: "failed", blockedReason: error instanceof Error ? error.message : String(error), updatedAt: now() });
     }
@@ -25476,7 +25886,7 @@ function createTaskCreatorService(deps) {
     if (!snapshot.request.analysisModel || !deps.authorProposal) throw new Error("Task Creator chat requires a configured authoring model.");
     if (["materializing", "validating", "ready", "cancelled"].includes(snapshot.state)) throw new Error(`Task Creator cannot revise a ${snapshot.state} creation.`);
     const timestamp = now();
-    const chatting = TaskCreationSnapshotSchema.parse({ ...snapshot, state: "planning", blockedReason: null, transcript: [...snapshot.transcript, { id: `task_message_${randomUUID8()}`, role: "user", text: instruction, createdAt: timestamp }], updatedAt: timestamp });
+    const chatting = TaskCreationSnapshotSchema.parse({ ...snapshot, state: "planning", blockedReason: null, transcript: [...snapshot.transcript, { id: `task_message_${randomUUID9()}`, role: "user", text: instruction, createdAt: timestamp }], updatedAt: timestamp });
     await persist(chatting);
     const sources = await requireSources(snapshot.request.profileId, snapshot.request.sourceIds);
     try {
@@ -25514,7 +25924,7 @@ function createTaskCreatorService(deps) {
       ...manual ? [manual.evidence] : []
     ];
     if (snapshot.request.analysisModel) assertHostedAuthoringEvidenceBudget(evidence);
-    const proposalId = `task_proposal_${randomUUID8()}`;
+    const proposalId = `task_proposal_${randomUUID9()}`;
     const authored = snapshot.request.analysisModel && deps.authorProposal ? await deps.authorProposal({ id: proposalId, model: snapshot.request.analysisModel, reasoningEffort: snapshot.request.analysisReasoningEffort, evidence, buildIntent: snapshot.request.buildIntent, buildSpecification: snapshot.request.buildSpecification, methodHint: snapshot.request.methodHint, signal, instruction: instruction ?? snapshot.request.objective, currentProposal }) : heuristicProposal(proposalId, snapshot, effectiveSources, evidence);
     const proposal = "proposal" in authored ? authored.proposal : authored;
     const repairHistory = "proposal" in authored ? authored.repairHistory : [];
@@ -25536,8 +25946,8 @@ function createTaskCreatorService(deps) {
       proposal: reviewed,
       blockedReason: null,
       repairHistory: [...snapshot.repairHistory, ...repairHistory],
-      materializationApprovalId: `task_materialization_${randomUUID8()}`,
-      transcript: [...snapshot.transcript, { id: `task_message_${randomUUID8()}`, role: "assistant", text: `Proposed \u201C${reviewed.name}\u201D. Review what should be learned, what should remain context, and the evidence before creating a Taskset.`, createdAt: now() }],
+      materializationApprovalId: `task_materialization_${randomUUID9()}`,
+      transcript: [...snapshot.transcript, { id: `task_message_${randomUUID9()}`, role: "assistant", text: `Proposed \u201C${reviewed.name}\u201D. Review what should be learned, what should remain context, and the evidence before creating a Taskset.`, createdAt: now() }],
       updatedAt: now()
     });
   }
@@ -25666,7 +26076,7 @@ function createTaskCreatorService(deps) {
     };
     const unhashed = TasksetSchema.parse({ ...draft, contentHash: "00000000" });
     const taskset = TasksetSchema.parse({ ...unhashed, contentHash: computeTasksetHash(unhashed) });
-    await buildTaskset(taskset, path24.join(deps.tasksetRootDir, taskset.id), {
+    await buildTaskset(taskset, path25.join(deps.tasksetRootDir, taskset.id), {
       generatedFiles: [
         ...proposal.generatedFiles
       ]
@@ -25953,7 +26363,7 @@ function validateProposedExamples(proposal, evidence) {
 }
 
 // ../server/src/training/evaluation-service.ts
-import path31 from "node:path";
+import path32 from "node:path";
 
 // ../server/src/training/evaluation-helpers.ts
 function fixtureAttempt(tasksetId, fixture, index) {
@@ -26122,12 +26532,12 @@ function metadataStrings(value) {
 
 // ../server/src/training/sandboxed-verifier.ts
 import { readFile as readFile4, realpath } from "node:fs/promises";
-import path25 from "node:path";
+import path26 from "node:path";
 import vm from "node:vm";
 async function runSandboxedVerifier(input) {
   const root = await realpath(input.allowedRoot);
-  const modulePath = await realpath(path25.resolve(root, input.grader.module));
-  if (modulePath !== root && !modulePath.startsWith(`${root}${path25.sep}`)) throw new Error("Verifier module is outside the approved Taskset root.");
+  const modulePath = await realpath(path26.resolve(root, input.grader.module));
+  if (modulePath !== root && !modulePath.startsWith(`${root}${path26.sep}`)) throw new Error("Verifier module is outside the approved Taskset root.");
   const source = await readFile4(modulePath, "utf8");
   assertSandboxableSource(source);
   const functionSource = verifierFunctionSource(source, input.grader.exportName);
@@ -26136,7 +26546,7 @@ async function runSandboxedVerifier(input) {
     JSON: Object.freeze(JSON),
     Math: Object.freeze(Math)
   }), { name: `openpond-verifier:${input.grader.id}`, codeGeneration: { strings: false, wasm: false } });
-  const script = new vm.Script(`(${functionSource})`, { filename: path25.basename(modulePath) });
+  const script = new vm.Script(`(${functionSource})`, { filename: path26.basename(modulePath) });
   const verifier = script.runInContext(context, { timeout: Math.min(input.grader.timeoutMs, 5e3) });
   if (typeof verifier !== "function") throw new Error("Verifier export did not evaluate to a function.");
   const result = await withTimeout(
@@ -26366,16 +26776,16 @@ function failureClassFor(outcome) {
 }
 
 // ../server/src/training/task-attempt-artifact-service.ts
-import path26 from "node:path";
+import path27 from "node:path";
 import { mkdir as mkdir2, readFile as readFile5, writeFile as writeFile2 } from "node:fs/promises";
 async function persistJsonTaskAttemptArtifact(input) {
-  const directory = path26.join(
+  const directory = path27.join(
     input.storeDir,
     "training",
     "evaluation-artifacts",
     input.tasksetId
   );
-  const file = path26.join(
+  const file = path27.join(
     directory,
     `${input.attemptId}-${input.kind}.json`
   );
@@ -26399,7 +26809,7 @@ async function persistTaskAttemptOutputArtifact(input) {
   const checksum = sha256(bytes);
   if (bytes.byteLength !== input.expectedSizeBytes || checksum !== input.expectedSha256) {
     throw new Error(
-      `Saved Work output ${path26.basename(input.path)} no longer matches its OutputRef.`
+      `Saved Work output ${path27.basename(input.path)} no longer matches its OutputRef.`
     );
   }
   return saveArtifact({
@@ -26444,7 +26854,7 @@ async function saveArtifact(input) {
 }
 
 // ../server/src/training/taskset-work-attempt-runner.ts
-import path30 from "node:path";
+import path31 from "node:path";
 import { readFile as readFile7 } from "node:fs/promises";
 
 // ../server/src/openpond/model-tool-registry.ts
@@ -26452,7 +26862,7 @@ import { createHash as createHash6 } from "node:crypto";
 
 // ../server/src/openpond/command-artifacts.ts
 import { promises as fs17 } from "node:fs";
-import path27 from "node:path";
+import path28 from "node:path";
 var ARTIFACT_CONTENT_TYPES = /* @__PURE__ */ new Map([
   [".avif", "image/avif"],
   [".csv", "text/csv"],
@@ -26501,10 +26911,10 @@ async function discoverCommandArtifacts(result, limit = 12) {
   const artifacts = [];
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of candidates) {
-    const resolved = path27.isAbsolute(candidate) ? path27.resolve(candidate) : result.cwd ? path27.resolve(result.cwd, candidate) : null;
+    const resolved = path28.isAbsolute(candidate) ? path28.resolve(candidate) : result.cwd ? path28.resolve(result.cwd, candidate) : null;
     if (!resolved || seen.has(resolved)) continue;
     const contentType = ARTIFACT_CONTENT_TYPES.get(
-      path27.extname(resolved).toLowerCase()
+      path28.extname(resolved).toLowerCase()
     );
     if (!contentType) continue;
     try {
@@ -26514,7 +26924,7 @@ async function discoverCommandArtifacts(result, limit = 12) {
       artifacts.push({
         artifactRef: resolved,
         path: resolved,
-        title: path27.basename(resolved),
+        title: path28.basename(resolved),
         contentType,
         sizeBytes: stat.size,
         binary: true
@@ -26554,7 +26964,7 @@ function collectJsonPaths(value, output) {
 function collectJsonStrings(value, output, depth = 0) {
   if (depth > 8 || value == null) return;
   if (typeof value === "string") {
-    const extension = path27.extname(value).toLowerCase();
+    const extension = path28.extname(value).toLowerCase();
     if (ARTIFACT_CONTENT_TYPES.has(extension)) output.add(value);
     return;
   }
@@ -26648,7 +27058,7 @@ function createResourceModelToolDefinitions(deps) {
               scope,
               query: stringArg2(context.args, "query"),
               ...typeof context.args.limit === "number" ? { limit: context.args.limit } : {},
-              ...asRecord6(context.args.filters) ? { filters: asRecord6(context.args.filters) } : {}
+              ...asRecord7(context.args.filters) ? { filters: asRecord7(context.args.filters) } : {}
             }
           });
           return resourceSearchResultToModelToolResult(context.callId, result2);
@@ -26662,7 +27072,7 @@ function createResourceModelToolDefinitions(deps) {
               args: {
                 query: stringArg2(context.args, "query"),
                 ...typeof context.args.limit === "number" ? { maxResults: context.args.limit } : {},
-                ...typeof asRecord6(context.args.filters)?.path === "string" ? { path: asRecord6(context.args.filters)?.path } : {}
+                ...typeof asRecord7(context.args.filters)?.path === "string" ? { path: asRecord7(context.args.filters)?.path } : {}
               },
               source: "chat_action"
             },
@@ -27131,7 +27541,7 @@ function createWebFetchModelToolDefinition(input = {}) {
 function createWebSearchModelToolDefinition(deps) {
   return {
     name: "web_search",
-    description: "Search the web for current or external information. Cite by source title or source name in prose; the app renders clickable source pills, so do not paste raw URLs unless the user explicitly asks for URLs.",
+    description: "Search the web for current or external information. The app renders clickable source pills automatically. Cite by source title or source name in prose by default; when the user explicitly requests URLs or linked evidence, use the result URLs in clickable Markdown links.",
     parameters: {
       type: "object",
       additionalProperties: false,
@@ -27179,7 +27589,7 @@ function createWebSearchModelToolDefinition(deps) {
           {
             ok: true,
             action: "web_search",
-            output: `Found ${result.results.length} web result${result.results.length === 1 ? "" : "s"}. Use the source titles or names for citations; do not paste raw URLs unless the user asks.`,
+            output: `Found ${result.results.length} web result${result.results.length === 1 ? "" : "s"}. Source pills are automatic. Cite source titles or names by default; when the user requests URLs or linked evidence, use the result URLs in clickable Markdown links.`,
             data: { result: webSearchResultForModel(result) }
           },
           null,
@@ -27238,6 +27648,7 @@ function webSearchResultForModel(result) {
       id: item.id,
       citation: `[${index + 1}]`,
       title: item.title,
+      url: item.url,
       snippet: item.snippet,
       sourceName: item.sourceName,
       domain: hostnameFromUrl2(item.url),
@@ -27418,7 +27829,7 @@ function createOpenPondActionModelToolDefinitions(deps) {
     })
   })) : [];
   const directAgentActions = deps.actionCatalog.filter((action) => {
-    const implementation = asRecord6(action.implementation);
+    const implementation = asRecord7(action.implementation);
     const actionName = action.sourceActionId ?? action.name ?? action.id;
     return !CROSS_SYSTEM_TOOL_NAMES.includes(actionName) && (Boolean(action.agentId) || implementation?.type === "openpond-profile-action");
   });
@@ -27521,7 +27932,7 @@ function createOpenPondActionModelToolDefinitions(deps) {
           deps,
           resultToolName: "openpond_action_run",
           compactProfileResultForModel: true,
-          input: asRecord6(context.args.input) ?? {},
+          input: asRecord7(context.args.input) ?? {},
           requestedProjectId: stringValue7(context.args.projectId) ?? void 0,
           requestedAgentId: stringValue7(context.args.agentId) ?? void 0
         });
@@ -27536,11 +27947,11 @@ function directOpenPondActionToolName(action) {
   return `agent_${slug}_${suffix}`;
 }
 function directOpenPondActionAliasName(action) {
-  const name = stringValue7(asRecord6(action.implementation)?.actionId) ?? action.sourceActionId ?? action.name ?? action.id;
+  const name = stringValue7(asRecord7(action.implementation)?.actionId) ?? action.sourceActionId ?? action.name ?? action.id;
   return /^[A-Za-z0-9_-]{1,64}$/.test(name) ? name : null;
 }
 function actionInputSchema(action) {
-  const schema = asRecord6(action.inputSchema);
+  const schema = asRecord7(action.inputSchema);
   if (schema?.type === "object") return structuredClone(schema);
   return {
     type: "object",
@@ -27550,7 +27961,7 @@ function actionInputSchema(action) {
 }
 async function executeScopedOpenPondAction(input) {
   const { action, context, deps, resultToolName } = input;
-  const implementation = asRecord6(action.implementation);
+  const implementation = asRecord7(action.implementation);
   if (implementation?.type === "openpond-profile-action") {
     const executionTarget = resolveWorkspaceExecutionTarget({ session: context.session });
     if (isSandboxExecutionTarget(executionTarget)) {
@@ -27649,7 +28060,7 @@ async function executeScopedOpenPondAction(input) {
   return workspaceToolResultToModelToolResult(context.callId, resultToolName, result);
 }
 function compactProfileActionResult(value) {
-  const execution = asRecord6(value);
+  const execution = asRecord7(value);
   const stdout = stringValue7(execution?.stdout);
   if (!stdout) return value;
   let payload;
@@ -27658,9 +28069,9 @@ function compactProfileActionResult(value) {
   } catch {
     return value;
   }
-  const actionResult = asRecord6(payload)?.result ?? payload;
-  const actionResultRecord = asRecord6(actionResult);
-  const metadata = asRecord6(actionResultRecord?.metadata);
+  const actionResult = asRecord7(payload)?.result ?? payload;
+  const actionResultRecord = asRecord7(actionResult);
+  const metadata = asRecord7(actionResultRecord?.metadata);
   for (const key of ["snapshot", "decision", "submission", "receipt"]) {
     if (metadata && Object.hasOwn(metadata, key)) return metadata[key];
   }
@@ -27923,23 +28334,23 @@ function sandboxResourceRefForExecutionTarget(ref, target) {
   return null;
 }
 function gitChangedFileRefs(value, sandboxMode = false) {
-  const record6 = asRecord6(value);
-  const status = asRecord6(record6?.status);
+  const record6 = asRecord7(value);
+  const status = asRecord7(record6?.status);
   const files = Array.isArray(record6?.files) ? record6.files : Array.isArray(status?.files) ? status.files : [];
   return files.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)).map((item) => stringValue7(item.path)).filter((item) => Boolean(item)).map((filePath) => `${sandboxMode ? "sandbox" : "workspace"}:file:${filePath}`);
 }
 function gitDiffText(value) {
-  const record6 = asRecord6(value);
-  return stringValue7(record6?.diff) ?? stringValue7(asRecord6(record6?.result)?.diff);
+  const record6 = asRecord7(value);
+  return stringValue7(record6?.diff) ?? stringValue7(asRecord7(record6?.result)?.diff);
 }
 function sandboxPathItems(value) {
   const records = nestedArraysForKeys(value, ["matches", "files", "entries"]);
   const items = [];
   for (const record6 of records) {
-    const path46 = stringValue7(record6.path) ?? stringValue7(record6.name);
-    if (!path46) continue;
+    const path47 = stringValue7(record6.path) ?? stringValue7(record6.name);
+    if (!path47) continue;
     items.push({
-      path: path46,
+      path: path47,
       snippet: stringValue7(record6.text) ?? stringValue7(record6.snippet) ?? stringValue7(record6.content) ?? void 0,
       line: typeof record6.line === "number" ? record6.line : null,
       kind: stringValue7(record6.kind) ?? stringValue7(record6.type)
@@ -27965,7 +28376,7 @@ function nestedArraysForKeys(value, keys) {
   return output;
 }
 function sandboxFileContent(value) {
-  const record6 = asRecord6(value);
+  const record6 = asRecord7(value);
   const file = sandboxFileRecord(value);
   const encoded = stringValue7(file?.contentsBase64) ?? stringValue7(record6?.contentsBase64);
   if (encoded && !sandboxFileMetadata(value, stringValue7(file?.path) ?? "").binary) {
@@ -27985,8 +28396,8 @@ function contentTypeForResourcePath(value) {
   return null;
 }
 function sandboxFileRecord(value) {
-  const record6 = asRecord6(value);
-  return asRecord6(record6?.file) ?? asRecord6(asRecord6(record6?.result)?.file);
+  const record6 = asRecord7(value);
+  return asRecord7(record6?.file) ?? asRecord7(asRecord7(record6?.result)?.file);
 }
 function sandboxFileMetadata(value, resourcePath) {
   const file = sandboxFileRecord(value);
@@ -28066,7 +28477,7 @@ function actionCatalogText(action) {
   ].filter((value) => typeof value === "string" && value.trim().length > 0).join(" ").toLowerCase();
 }
 function actionCatalogItemForModel(action) {
-  const implementation = asRecord6(action.implementation);
+  const implementation = asRecord7(action.implementation);
   const directRunAllowed = implementation?.type !== "openpond-profile-action";
   return {
     actionId: action.id,
@@ -28097,7 +28508,7 @@ function failedActionToolResult(callId, name, message) {
     )
   };
 }
-function asRecord6(value) {
+function asRecord7(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function stringValue7(value) {
@@ -28108,12 +28519,12 @@ function numberValue3(value) {
 }
 
 // ../server/src/openpond/work-tool-registry.ts
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 
 // ../server/src/openpond/work-runtime-service.ts
 import { createHash as createHash7 } from "node:crypto";
 import { promises as fs18 } from "node:fs";
-import path28 from "node:path";
+import path29 from "node:path";
 var WORK_RUNTIME_PROFILE_ID = "openpond-work-v1";
 var WORK_LAYOUT_COMMAND = "mkdir -p inputs work outputs";
 var WORK_RESET_COMMAND = "find /workspace/inputs /workspace/work /workspace/outputs -mindepth 1 -maxdepth 1 -exec rm -rf -- {} +";
@@ -28280,7 +28691,7 @@ function workPath(rawArea, rawPath, allowedAreas = ["inputs", "work", "outputs"]
   if (value.startsWith("/")) {
     throw new Error("Work paths must be relative to their selected area.");
   }
-  const normalized = path28.posix.normalize(value);
+  const normalized = path29.posix.normalize(value);
   if (normalized === ".." || normalized.startsWith("../") || normalized.includes("/../")) {
     throw new Error("Work path escaped its selected area.");
   }
@@ -28879,7 +29290,7 @@ function createWorkModelToolDefinitions(deps) {
         const url = validHttpUrl(context.args.url);
         const validation = Array.isArray(context.args.validation) ? context.args.validation : [];
         const identity = {
-          id: randomUUID9(),
+          id: randomUUID10(),
           title,
           sourceTaskId: context.session.id,
           sourceTurnId: context.turnId,
@@ -29041,10 +29452,10 @@ function validHttpUrl(value) {
 
 // ../server/src/training/taskset-work-cost-evidence.ts
 function workRuntimeCostEvidence(value) {
-  const record6 = asRecord7(value);
-  const sandbox = asRecord7(record6.sandbox);
+  const record6 = asRecord8(value);
+  const sandbox = asRecord8(record6.sandbox);
   const receiptValues = Array.isArray(record6.receipts) ? record6.receipts : Array.isArray(sandbox.receipts) ? sandbox.receipts : [];
-  const receipts = receiptValues.map(asRecord7);
+  const receipts = receiptValues.map(asRecord8);
   const captured = receipts.flatMap((receipt) => {
     const id = typeof receipt.id === "string" ? receipt.id : null;
     const totalUsd = numericUsd(receipt.totalUsd);
@@ -29052,7 +29463,7 @@ function workRuntimeCostEvidence(value) {
     if (receipt.status !== "captured" || !id || totalUsd === null || durationSeconds === null) {
       return [];
     }
-    const settlement = asRecord7(receipt.mpp).mode;
+    const settlement = asRecord8(receipt.mpp).mode;
     return [{
       id,
       totalUsd,
@@ -29097,14 +29508,14 @@ function numericUsd(value) {
   const parsed = Number(value);
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
 }
-function asRecord7(value) {
+function asRecord8(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
 // ../server/src/training/taskset-work-assets.ts
 import { createHash as createHash8 } from "node:crypto";
 import { lstat, readFile as readFile6 } from "node:fs/promises";
-import path29 from "node:path";
+import path30 from "node:path";
 var DEFAULT_MAX_WORK_INPUT_BYTES = 25e7;
 var MAX_WORK_INPUT_BYTES2 = 1e9;
 async function resolveTasksetWorkAssets(input) {
@@ -29114,13 +29525,13 @@ async function resolveTasksetWorkAssets(input) {
   const sourceById = new Map(
     input.taskset.sourceRefs.map((source) => [source.id, source])
   );
-  const tasksetRoot = path29.resolve(
+  const tasksetRoot = path30.resolve(
     input.storeDir,
     "training",
     "tasksets",
     input.taskset.id
   );
-  const assetRoot = path29.resolve(tasksetRoot, "assets");
+  const assetRoot = path30.resolve(tasksetRoot, "assets");
   const resolved = [];
   for (const asset2 of input.task.assets ?? []) {
     if (asset2.split !== input.task.split) {
@@ -29140,8 +29551,8 @@ async function resolveTasksetWorkAssets(input) {
       );
     }
     assertEligibleSource(source, asset2);
-    const target = path29.resolve(tasksetRoot, asset2.artifactRef);
-    if (target === assetRoot || !target.startsWith(`${assetRoot}${path29.sep}`)) {
+    const target = path30.resolve(tasksetRoot, asset2.artifactRef);
+    if (target === assetRoot || !target.startsWith(`${assetRoot}${path30.sep}`)) {
       throw new Error(
         `Work asset ${asset2.id} must resolve inside the Taskset assets directory.`
       );
@@ -29492,7 +29903,7 @@ async function runTasksetWorkAttempt(input) {
           ]).slice(0, 20)}`,
           args: {
             path: requiredOutput.path,
-            suggestedName: path30.posix.basename(requiredOutput.path),
+            suggestedName: path31.posix.basename(requiredOutput.path),
             validation: []
           },
           signal: controller.signal,
@@ -29767,9 +30178,9 @@ async function executeDefinition(input) {
 }
 function savedWorkOutput(args, result) {
   if (!result.ok || result.name !== "work_save_output") return null;
-  const data = asRecord8(result.data);
+  const data = asRecord9(result.data);
   const parsed = FileOutputRefSchema.safeParse(data.outputRef);
-  const artifact = asRecord8(data.artifact);
+  const artifact = asRecord9(data.artifact);
   const artifactPath = typeof artifact.path === "string" ? artifact.path : null;
   const relativePath = typeof args.path === "string" ? normalizedOutputPath(args.path) : null;
   if (!parsed.success || !artifactPath || !relativePath) return null;
@@ -29867,7 +30278,7 @@ function userPrompt(task) {
     return task.input.prompt.trim();
   }
   const messages = Array.isArray(task.input.messages) ? task.input.messages.flatMap((value) => {
-    const record6 = asRecord8(value);
+    const record6 = asRecord9(value);
     return (record6.role === "system" || record6.role === "user") && typeof record6.content === "string" && record6.content.trim() ? [record6.content.trim()] : [];
   }) : [];
   if (messages.length) return messages.join("\n\n");
@@ -29880,7 +30291,7 @@ function workToolTurnLimit(taskset) {
 function normalizedOutputPath(value) {
   const normalized = value.trim().replaceAll("\\", "/");
   if (!normalized || normalized.startsWith("/")) return null;
-  const clean = path30.posix.normalize(normalized);
+  const clean = path31.posix.normalize(normalized);
   if (clean === "." || clean === ".." || clean.startsWith("../") || clean.split("/").includes("..")) {
     return null;
   }
@@ -29893,7 +30304,7 @@ function throwIfAborted2(signal) {
 function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function asRecord8(value) {
+function asRecord9(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function elapsedMilliseconds(startedAt, completedAt) {
@@ -30862,7 +31273,7 @@ function createTaskEvaluationService(deps) {
     }
     await buildTaskset(
       updated,
-      path31.join(deps.storeDir, "training", "tasksets", updated.id)
+      path32.join(deps.storeDir, "training", "tasksets", updated.id)
     );
     await deps.store.upsertTaskset(updated);
     return {
@@ -31007,7 +31418,7 @@ function createTaskEvaluationService(deps) {
       return void 0;
     }
     const profile = deps.storeDir ? null : await (deps.loadProfileState ?? loadOpenPondProfileState)();
-    const tasksetRoot = deps.storeDir ? path31.join(deps.storeDir, "training", "tasksets", tasksetId) : profile?.sourcePath ? path31.join(profile.sourcePath, "tasksets", tasksetId) : null;
+    const tasksetRoot = deps.storeDir ? path32.join(deps.storeDir, "training", "tasksets", tasksetId) : profile?.sourcePath ? path32.join(profile.sourcePath, "tasksets", tasksetId) : null;
     const creationSnapshotId = typeof taskset.metadata.creationSnapshotId === "string" ? taskset.metadata.creationSnapshotId : null;
     const proposal = creationSnapshotId ? await deps.store.getTaskDesignProposal(creationSnapshotId) : null;
     if (tasksetRoot) {
@@ -31558,7 +31969,7 @@ async function createLocalHarnessTasksetReviewControl(input) {
   const tasksetAuthoringSkill = await loadTasksetAuthoringSkillArtifact();
   const taskCreator = createTaskCreatorService({
     store: input.store,
-    tasksetRootDir: path32.join(input.storeDir, "training", "tasksets"),
+    tasksetRootDir: path33.join(input.storeDir, "training", "tasksets"),
     authoringSkillHash: contentHash(tasksetAuthoringSkill.bundle),
     loadProfileState: loadOpenPondProfileState
   });
@@ -31876,11 +32287,11 @@ function assistantDeltaKey(runtimeEvent) {
 }
 
 // ../server/src/runtime/turn-runner.ts
-import { createHash as createHash9, randomUUID as randomUUID14 } from "node:crypto";
+import { createHash as createHash9, randomUUID as randomUUID15 } from "node:crypto";
 
 // ../server/src/chat-attachments.ts
 import { promises as fs19 } from "node:fs";
-import path33 from "node:path";
+import path34 from "node:path";
 var ATTACHMENT_CONTEXT_TEXT_LIMIT = 12e4;
 var MAX_CHAT_ATTACHMENT_IMAGE_BYTES = 15 * 1024 * 1024;
 var CHAT_ATTACHMENT_TEXT_PREVIEW_MAX_BYTES = 2 * 1024 * 1024;
@@ -31941,7 +32352,7 @@ var CHAT_ATTACHMENT_TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
 async function materializeChatAttachments(input) {
   const attachments = input.attachments ?? [];
   if (attachments.length === 0) return [];
-  const turnDir = path33.join(
+  const turnDir = path34.join(
     input.attachmentRootDir,
     safeChatAttachmentPathSegment(input.sessionId),
     safeChatAttachmentPathSegment(input.turnId)
@@ -31961,8 +32372,8 @@ async function materializeChatAttachments(input) {
         usedNames,
         index + 1
       );
-      const localPath = path33.join(turnDir, safeName);
-      await fs19.mkdir(path33.dirname(localPath), { recursive: true });
+      const localPath = path34.join(turnDir, safeName);
+      await fs19.mkdir(path34.dirname(localPath), { recursive: true });
       await fs19.writeFile(
         localPath,
         Buffer.from(attachment.contentsBase64, "base64"),
@@ -32072,13 +32483,13 @@ async function readChatAttachmentImageFile(input) {
     storageName ?? ""
   );
   if (!storageName || !contentType) return null;
-  const turnDir = path33.resolve(
+  const turnDir = path34.resolve(
     input.attachmentRootDir,
     sessionSegment,
     turnSegment
   );
-  const target = path33.resolve(turnDir, storageName);
-  if (target !== turnDir && !target.startsWith(`${turnDir}${path33.sep}`))
+  const target = path34.resolve(turnDir, storageName);
+  if (target !== turnDir && !target.startsWith(`${turnDir}${path34.sep}`))
     return null;
   try {
     const stat = await fs19.lstat(target);
@@ -32117,7 +32528,7 @@ function chatAttachmentImageContentType(mediaType, fileName) {
   if (CHAT_ATTACHMENT_IMAGE_MEDIA_TYPES.has(normalizedMediaType))
     return normalizedMediaType;
   return CHAT_ATTACHMENT_IMAGE_CONTENT_TYPES.get(
-    path33.extname(fileName).toLowerCase()
+    path34.extname(fileName).toLowerCase()
   ) ?? null;
 }
 function safeChatAttachmentPathSegment(value) {
@@ -32127,18 +32538,18 @@ function cleanStorageName(value) {
   const trimmed = value.trim();
   if (!trimmed || trimmed === "." || trimmed === ".." || /[\\/]/.test(trimmed))
     return null;
-  return path33.basename(trimmed);
+  return path34.basename(trimmed);
 }
 function chatAttachmentStoredFilePath(input) {
   const storageName = cleanStoragePath(input.storageName);
   if (!storageName) return null;
-  const turnDir = path33.resolve(
+  const turnDir = path34.resolve(
     input.attachmentRootDir,
     safeChatAttachmentPathSegment(input.sessionId),
     safeChatAttachmentPathSegment(input.turnId)
   );
-  const absolutePath = path33.resolve(turnDir, storageName);
-  if (!absolutePath.startsWith(`${turnDir}${path33.sep}`)) return null;
+  const absolutePath = path34.resolve(turnDir, storageName);
+  if (!absolutePath.startsWith(`${turnDir}${path34.sep}`)) return null;
   return { absolutePath, storageName };
 }
 function cleanStoragePath(value) {
@@ -32154,7 +32565,7 @@ function chatAttachmentTextPreviewSupported(contentType, fileName) {
   if (normalizedType.startsWith("text/")) return true;
   if (CHAT_ATTACHMENT_TEXT_CONTENT_TYPES.has(normalizedType)) return true;
   return CHAT_ATTACHMENT_TEXT_EXTENSIONS.has(
-    path33.extname(fileName).toLowerCase()
+    path34.extname(fileName).toLowerCase()
   );
 }
 function uniqueSafeFileName(name, usedNames, fallbackIndex) {
@@ -32163,7 +32574,7 @@ function uniqueSafeFileName(name, usedNames, fallbackIndex) {
   let candidate = safeName;
   let index = 2;
   while (usedNames.has(candidate)) {
-    const extension = path33.extname(safeName);
+    const extension = path34.extname(safeName);
     const base = extension ? safeName.slice(0, -extension.length) : safeName;
     candidate = `${base}-${index}${extension}`;
     index += 1;
@@ -32933,7 +33344,7 @@ function resolveContextCompactionAdapter(provider) {
 }
 
 // ../server/src/openpond/context-compaction/index.ts
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 
 // ../server/src/openpond/context-compaction/file-ledger.ts
 function buildFileOperationLedger(records) {
@@ -32941,9 +33352,9 @@ function buildFileOperationLedger(records) {
   for (const record6 of records) {
     const paths = /* @__PURE__ */ new Set([...record6.filePaths, ...extractFilePaths(record6.body)]);
     if (paths.size === 0) continue;
-    for (const path46 of paths) {
-      const entry = entries.get(path46) ?? {
-        path: path46,
+    for (const path47 of paths) {
+      const entry = entries.get(path47) ?? {
+        path: path47,
         operations: [],
         relevance: "referenced",
         latestStatus: "unknown",
@@ -32960,7 +33371,7 @@ function buildFileOperationLedger(records) {
         entry.latestStatus = "failed";
       }
       entry.relevance = relevanceForEntry(entry);
-      entries.set(path46, entry);
+      entries.set(path47, entry);
     }
   }
   return [...entries.values()].sort((a, b) => relevanceRank(b.relevance) - relevanceRank(a.relevance) || a.path.localeCompare(b.path)).slice(0, 100);
@@ -33229,7 +33640,7 @@ function goalContextPreview(event2) {
 function subagentEventPreview(event2) {
   const run = subagentRunFromEvent(event2);
   if (!run) return eventPreview(event2);
-  const usage = asRecord9(run.metadata.usage);
+  const usage = asRecord10(run.metadata.usage);
   const report = run.report;
   return [
     `run: subagent-run:${run.id}`,
@@ -33282,8 +33693,8 @@ function isDurableResourceRef(value) {
   return /^(workspace:(?:file|dir):|sandbox:(?:file|dir):|git:|event:|message:|artifact:|goal-context:|session:|subagent-run:)/.test(value);
 }
 function subagentRunFromEvent(event2) {
-  const data = asRecord9(event2.data);
-  const parsed = SubagentRunSchema.safeParse(asRecord9(data?.run));
+  const data = asRecord10(event2.data);
+  const parsed = SubagentRunSchema.safeParse(asRecord10(data?.run));
   return parsed.success ? parsed.data : null;
 }
 function subagentRefsPreview(refs, label) {
@@ -33322,7 +33733,7 @@ function extractFilePaths2(value) {
   }
   return [...paths].slice(0, 20);
 }
-function asRecord9(value) {
+function asRecord10(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function numberValue5(value) {
@@ -33585,7 +33996,7 @@ function hostedCompactionContextLimit(provider, model, maxContextTokens) {
 }
 async function streamCompactionSummary(input) {
   let text = "";
-  const requestId = `compact-${randomUUID10()}`;
+  const requestId = `compact-${randomUUID11()}`;
   const streamCompactionChatTurn = input.streamCompactionChatTurn ?? defaultOpenPondCompactionStream;
   for await (const delta of streamCompactionChatTurn({
     provider: input.provider,
@@ -34653,17 +35064,17 @@ function createNativeToolRuntime(deps) {
     const name = stringFromRecord(record6, "name");
     const description = stringFromRecord(record6, "description");
     const body = stringFromRecord(record6, "body");
-    const path46 = stringFromRecord(record6, "path");
+    const path47 = stringFromRecord(record6, "path");
     const sourceHash = stringFromRecord(record6, "sourceHash");
     const charCount = typeof record6.charCount === "number" ? record6.charCount : null;
-    if (!name || !description || !body || !path46 || !sourceHash || charCount === null) return null;
+    if (!name || !description || !body || !path47 || !sourceHash || charCount === null) return null;
     const packagePath = stringFromRecord(record6, "packagePath");
     const resourceFiles = Array.isArray(record6.resourceFiles) ? record6.resourceFiles.filter((file) => typeof file === "string") : [];
     return {
       name,
       description,
       body,
-      path: path46,
+      path: path47,
       sourceHash,
       charCount,
       ...packagePath ? { packagePath } : {},
@@ -34679,16 +35090,16 @@ function createNativeToolRuntime(deps) {
     const name = stringFromRecord(record6, "name");
     const description = stringFromRecord(record6, "description");
     const body = stringFromRecord(record6, "body");
-    const path46 = stringFromRecord(record6, "path");
+    const path47 = stringFromRecord(record6, "path");
     const sourceHash = stringFromRecord(record6, "sourceHash");
     const provider = stringFromRecord(record6, "provider");
     const charCount = typeof record6.charCount === "number" ? record6.charCount : null;
-    if (!name || !description || !body || !path46 || !sourceHash || !provider || charCount === null) return null;
+    if (!name || !description || !body || !path47 || !sourceHash || !provider || charCount === null) return null;
     return {
       name,
       description,
       body,
-      path: path46,
+      path: path47,
       sourceHash,
       provider,
       charCount
@@ -35392,8 +35803,6 @@ function createHostedToolLoopRuntime(deps) {
   const maxHostedWorkspaceToolRounds = deps.maxHostedWorkspaceToolRounds;
   const maxRepeatedInvalidToolRequests = deps.maxRepeatedInvalidToolRequests;
   const appendRuntimeEvent = deps.appendRuntimeEvent;
-  const processHarnessImprovementBoundary = deps.processHarnessImprovementBoundary;
-  const recordCompletedToolBatch = (session, turn) => processHarnessImprovementBoundary?.({ session, turn, boundaryKind: "completed_tool_batch" });
   const safeUpsertModelUsageRecord = deps.upsertModelUsageRecord;
   const executeNativeToolCalls = deps.executeNativeToolCalls;
   const readProfileSkillForModel = deps.readProfileSkillForModel;
@@ -35662,7 +36071,6 @@ function createHostedToolLoopRuntime(deps) {
           for (const result of nativeResults) {
             messages.push(toolResultMessage(result));
           }
-          await recordCompletedToolBatch(session, params.turn);
           const blockingQuestion = nativeResults.find(
             (result) => result.turnControl === "await_user_input"
           );
@@ -35900,7 +36308,6 @@ function createHostedToolLoopRuntime(deps) {
           session = withDefaultExperience(await getSession(session.id));
           toolResults2.push(formatWorkspaceToolResultForModel(result));
         }
-        await recordCompletedToolBatch(session, params.turn);
         messages.push({
           role: "user",
           content: [
@@ -36555,9 +36962,9 @@ function manageSidebarFileToolInput(args) {
   if (action !== "pin" && action !== "save_for_later" && action !== "remove" && action !== "list") {
     throw new Error("action must be pin, save_for_later, remove, or list");
   }
-  const path46 = optionalStringArg(args, "path");
-  if (action !== "list" && !path46) throw new Error("path is required for this action");
-  return { action, ...path46 ? { path: path46 } : {} };
+  const path47 = optionalStringArg(args, "path");
+  if (action !== "list" && !path47) throw new Error("path is required for this action");
+  return { action, ...path47 ? { path: path47 } : {} };
 }
 function manageSidebarFileToolResult(callId, result) {
   return {
@@ -36715,7 +37122,7 @@ function optionalBooleanArg(args, key) {
 
 // ../server/src/openpond/authoring-tool-registry.ts
 import { realpath as realpath2 } from "node:fs/promises";
-import path34 from "node:path";
+import path35 from "node:path";
 function createAuthoringModelToolDefinitions(deps) {
   const definitions = [askUserDefinition()];
   if (!deps.loadProfileState) return definitions;
@@ -36921,7 +37328,7 @@ async function resolveAgentTarget(loadProfileState, context) {
   }
   const agent = profile.agents.find((candidate2) => candidate2.id === agentId);
   if (!agent?.enabled) throw new Error(`Enabled Profile Agent not found: ${agentId}`);
-  const candidate = agentId === "default" ? profile.sourcePath : path34.resolve(profile.sourcePath, "agents", agentId);
+  const candidate = agentId === "default" ? profile.sourcePath : path35.resolve(profile.sourcePath, "agents", agentId);
   const canonicalRoot = await realpath2(profile.sourcePath);
   const canonicalTarget = await realpath2(candidate).catch(() => null);
   if (!canonicalTarget) throw new Error(`Profile Agent source does not exist: ${agentId}`);
@@ -36958,7 +37365,7 @@ function profileProjection(profile, turnMetadata, ref) {
     repoPath: profile.repoPath,
     sourcePath: profile.sourcePath,
     manifestPath: profile.manifestPath,
-    profileConfigPath: profile.sourcePath ? path34.join(profile.sourcePath, "settings", "profile.yaml") : null,
+    profileConfigPath: profile.sourcePath ? path35.join(profile.sourcePath, "settings", "profile.yaml") : null,
     authoring: recordArg(turnMetadata, "authoringIntent"),
     skills: profile.skills.slice(0, 200).map((skill) => ({
       name: skill.name,
@@ -36974,7 +37381,7 @@ function profileProjection(profile, turnMetadata, ref) {
         id: agent.id,
         name: agent.name,
         path: agent.path,
-        sourcePath: profile.sourcePath ? agent.id === "default" ? profile.sourcePath : path34.resolve(profile.sourcePath, "agents", agent.id) : agent.path,
+        sourcePath: profile.sourcePath ? agent.id === "default" ? profile.sourcePath : path35.resolve(profile.sourcePath, "agents", agent.id) : agent.path,
         enabled: agent.enabled,
         defaultAction: actions.find(
           (action) => action.sourceActionId === "chat" || action.id === `${agent.id}.chat`
@@ -37066,13 +37473,13 @@ function recordArg(value, key) {
   return candidate && typeof candidate === "object" && !Array.isArray(candidate) ? candidate : null;
 }
 function isWithin(root, candidate) {
-  const relative = path34.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path34.isAbsolute(relative);
+  const relative = path35.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path35.isAbsolute(relative);
 }
 
 // ../server/src/openpond/local-image-tool-registry.ts
-import { execFile as execFile2 } from "node:child_process";
-import path35 from "node:path";
+import { execFile as execFile3 } from "node:child_process";
+import path36 from "node:path";
 var SAMPLE_WIDTH = 12;
 var SAMPLE_HEIGHT = 8;
 var LUMINANCE_RAMP = " .:-=+*#%@";
@@ -37099,7 +37506,7 @@ function createLocalImageModelToolDefinition() {
     },
     execute: async (context) => {
       const requestedPath = stringArg6(context.args.path, "path");
-      const imagePath = path35.isAbsolute(requestedPath) ? path35.resolve(requestedPath) : context.session.cwd ? path35.resolve(context.session.cwd, requestedPath) : "";
+      const imagePath = path36.isAbsolute(requestedPath) ? path36.resolve(requestedPath) : context.session.cwd ? path36.resolve(context.session.cwd, requestedPath) : "";
       if (!imagePath) throw new Error("A relative image path requires a selected local project.");
       const image = await readLocalImageFile(imagePath);
       if (!image) throw new Error(`Local image was not found or is not a supported image: ${imagePath}`);
@@ -37185,7 +37592,7 @@ function hexByte(value) {
 }
 function runImageCommand(command, args, signal) {
   return new Promise((resolve, reject) => {
-    execFile2(command, args, { encoding: "utf8", maxBuffer: 256 * 1024, signal }, (error, stdout) => {
+    execFile3(command, args, { encoding: "utf8", maxBuffer: 256 * 1024, signal }, (error, stdout) => {
       if (error) {
         reject(new Error(`${command} could not inspect the image: ${error.message}`));
         return;
@@ -37354,7 +37761,7 @@ function assertCreateImproveMutationApproved(input) {
 }
 
 // ../server/src/runtime/create-pipeline-planner.ts
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 var PlannerQuestionOptionSchema = external_exports.object({
   id: external_exports.string().trim().min(1).optional(),
   label: external_exports.string().trim().min(1),
@@ -37524,8 +37931,8 @@ function createQuestionRun(run, decision, modelRef) {
 }
 function createPlanRun(run, decision, modelRef) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const planId = `create_improve_plan_${randomUUID11()}`;
-  const approvalId = `approval_${randomUUID11()}`;
+  const planId = `create_improve_plan_${randomUUID12()}`;
+  const approvalId = `approval_${randomUUID12()}`;
   const target = plannedTarget(run.target, decision, run.objective);
   const sourceRoot = sourceRootForTarget(target);
   const actionShape = decision.actionShape;
@@ -37608,7 +38015,7 @@ function workflowCaptureForRun(run) {
   );
   return CreateImproveWorkflowCaptureSchema.parse({
     schemaVersion: "openpond.createImprove.workflowCapture.v1",
-    id: `workflow_capture_${randomUUID11()}`,
+    id: `workflow_capture_${randomUUID12()}`,
     runId: run.id,
     command: run.command,
     objective: run.objective,
@@ -38057,12 +38464,12 @@ var KeyedRegistry = class {
 // ../server/src/runtime/local-create-pipeline.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { cp, mkdir as mkdir3, readFile as readFile9 } from "node:fs/promises";
-import path37 from "node:path";
+import path38 from "node:path";
 
 // ../server/src/runtime/local-create-pipeline-checks.ts
 import { existsSync } from "node:fs";
 import { readFile as readFile8 } from "node:fs/promises";
-import path36 from "node:path";
+import path37 from "node:path";
 async function runLocalCreatePipelineChecks(input) {
   await assertLocalCreateSourceLayout(input.target);
   const checkMetadata = {};
@@ -38106,7 +38513,7 @@ async function runLocalCreatePipelineChecks(input) {
     const traceArtifactRef = traceRefFromCommandResult(parsedStdout);
     if (traceArtifactRef) {
       checkRefs.add(
-        path36.join(input.target.sourceRootRelativePath, traceArtifactRef)
+        path37.join(input.target.sourceRootRelativePath, traceArtifactRef)
       );
     }
     checkMetadata[command.name] = {
@@ -38131,19 +38538,19 @@ async function assertLocalCreateSourceLayout(target) {
       `Codex did not create the expected agent source root: ${target.sourceRoot}`
     );
   }
-  const agentSourcePath = path36.join(target.sourceRoot, "agent", "agent.ts");
+  const agentSourcePath = path37.join(target.sourceRoot, "agent", "agent.ts");
   if (!existsSync(agentSourcePath)) {
     throw new Error(
       `Codex did not create the expected SDK agent source: ${agentSourcePath}`
     );
   }
-  const rootManifestPath = path36.join(target.repoPath, "openpond-profile.json");
+  const rootManifestPath = path37.join(target.repoPath, "openpond-profile.json");
   if (!existsSync(rootManifestPath)) {
     throw new Error(
       `Codex did not update the profile repo manifest: ${rootManifestPath}`
     );
   }
-  const profileManifestPath = path36.join(
+  const profileManifestPath = path37.join(
     target.sourcePath,
     "settings",
     "profile.yaml"
@@ -38179,12 +38586,12 @@ async function assertLocalCreateSourceLayout(target) {
   }
 }
 async function assertGeneratedSdkArtifacts(target, requireEvalPass = true) {
-  const registryPath = path36.join(
+  const registryPath = path37.join(
     target.sourceRoot,
     ".openpond",
     "action-registry.json"
   );
-  const evalResultsPath = path36.join(
+  const evalResultsPath = path37.join(
     target.sourceRoot,
     ".openpond",
     "eval-results.json"
@@ -38251,44 +38658,44 @@ function parseJsonOutput(stdout) {
     return null;
   }
 }
-function asRecord10(value) {
+function asRecord11(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function recordArray(value) {
   if (!Array.isArray(value)) return null;
   return value.filter(
-    (item) => Boolean(asRecord10(item))
+    (item) => Boolean(asRecord11(item))
   );
 }
 function traceRefFromCommandResult(value) {
-  const record6 = asRecord10(value);
+  const record6 = asRecord11(value);
   const ref = stringValue9(record6?.traceArtifactRef);
   return ref?.startsWith(".openpond/") ? ref : null;
 }
 function summaryFromCommandResult(commandName, value) {
-  const record6 = asRecord10(value);
+  const record6 = asRecord11(value);
   if (!record6) return null;
   if (commandName === "inspect") {
     return {
       actionCount: Array.isArray(record6.actionCatalog) ? record6.actionCatalog.length : null,
-      defaultAction: asRecord10(record6.agent)?.defaultAction ?? null,
-      projectName: asRecord10(record6.project)?.name ?? null
+      defaultAction: asRecord11(record6.agent)?.defaultAction ?? null,
+      projectName: asRecord11(record6.project)?.name ?? null
     };
   }
   if (commandName === "validate") {
     return {
       status: record6.status ?? null,
-      errors: asRecord10(record6.summary)?.errors ?? null,
-      warnings: asRecord10(record6.summary)?.warnings ?? null
+      errors: asRecord11(record6.summary)?.errors ?? null,
+      warnings: asRecord11(record6.summary)?.warnings ?? null
     };
   }
   if (commandName === "eval") {
-    return asRecord10(record6.summary);
+    return asRecord11(record6.summary);
   }
   if (commandName === "direct-run") {
     return {
-      hasResult: Boolean(asRecord10(record6.result)),
-      resultKeys: Object.keys(asRecord10(record6.result) ?? {})
+      hasResult: Boolean(asRecord11(record6.result)),
+      resultKeys: Object.keys(asRecord11(record6.result) ?? {})
     };
   }
   return null;
@@ -38363,7 +38770,7 @@ async function applyApprovedLocalCreateImproveRun(snapshot, options = {}) {
     blockedReason: null,
     sourceRefs: [
       target.sourceRootRelativePath,
-      path37.join(target.profileRelativePath, "settings", "profile.yaml"),
+      path38.join(target.profileRelativePath, "settings", "profile.yaml"),
       "openpond-profile.json"
     ],
     metadata: {
@@ -38389,7 +38796,7 @@ async function applyApprovedLocalCreateImproveRun(snapshot, options = {}) {
         allowedPaths: snapshot.plan?.sourcePlan.map((item) => item.path) ?? [],
         sourceRefs: [
           target.sourceRootRelativePath,
-          path37.join(target.profileRelativePath, "settings", "profile.yaml"),
+          path38.join(target.profileRelativePath, "settings", "profile.yaml"),
           "openpond-profile.json"
         ],
         artifactRefs: [],
@@ -38518,7 +38925,7 @@ function agentCandidateId(runId) {
   return `agent_candidate_${runId}`;
 }
 function checkSummary(metadata) {
-  const evaluation = asRecord11(metadata?.eval);
+  const evaluation = asRecord12(metadata?.eval);
   const total = typeof evaluation?.total === "number" ? evaluation.total : null;
   return total === null ? "Agent SDK checks and deterministic Evals passed." : `${total} Agent SDK Eval${total === 1 ? "" : "s"} passed.`;
 }
@@ -38535,14 +38942,14 @@ function resolveLocalCreatePipelineTarget(snapshot) {
   if (!repoPath)
     throw new Error("Local Create approval is missing a profile repo path.");
   const activeProfile = adapter.activeProfile?.trim() || "default";
-  const resolvedSourcePath = path37.resolve(sourcePath);
-  const resolvedRepoPath = path37.resolve(repoPath);
+  const resolvedSourcePath = path38.resolve(sourcePath);
+  const resolvedRepoPath = path38.resolve(repoPath);
   const agentId = normalizeAgentId(snapshot.target.id) ?? agentIdFromSourcePlan(snapshot) ?? slugFromObjective(snapshot.objective);
   const defaultAction = sourceActionIdForAgent(
     normalizeActionId(snapshot.plan?.defaultChatAction.key) ?? "chat",
     agentId
   );
-  const sourceRoot = snapshot.operation === "improve" && agentId === "default" ? resolvedSourcePath : path37.join(resolvedSourcePath, "agents", agentId);
+  const sourceRoot = snapshot.operation === "improve" && agentId === "default" ? resolvedSourcePath : path38.join(resolvedSourcePath, "agents", agentId);
   return {
     activeProfile,
     agentId,
@@ -38551,11 +38958,11 @@ function resolveLocalCreatePipelineTarget(snapshot) {
     sourcePath: resolvedSourcePath,
     workspaceRoot: resolvedRepoPath,
     profileRelativePath: normalizeRelativePath(
-      path37.relative(resolvedRepoPath, resolvedSourcePath)
+      path38.relative(resolvedRepoPath, resolvedSourcePath)
     ),
     sourceRoot,
     sourceRootRelativePath: normalizeRelativePath(
-      path37.relative(resolvedRepoPath, sourceRoot)
+      path38.relative(resolvedRepoPath, sourceRoot)
     )
   };
 }
@@ -38699,20 +39106,20 @@ async function runModelBackedLocalCreateSourceApplication(input) {
 }
 async function applyPreparedHarnessSourceApplication(snapshot, target, env = process.env) {
   if (!scriptedOpenPondModelsEnabled(env)) return false;
-  const manifestPath = path37.join(
+  const manifestPath = path38.join(
     target.workspaceRoot,
     HARNESS_PREPARED_SOURCE_MANIFEST
   );
   if (!existsSync2(manifestPath)) return false;
   const manifest = JSON.parse(await readFile9(manifestPath, "utf8"));
-  const root = asRecord11(manifest);
+  const root = asRecord12(manifest);
   if (root?.schema !== "openpond.harnessPreparedSource.v1") {
     throw new Error(
       `${HARNESS_PREPARED_SOURCE_MANIFEST} must use schema openpond.harnessPreparedSource.v1.`
     );
   }
-  const agents = asRecord11(root.agents);
-  const agent = asRecord11(agents?.[target.agentId]);
+  const agents = asRecord12(root.agents);
+  const agent = asRecord12(agents?.[target.agentId]);
   const operation = asHarnessPreparedSourceOperation(
     agent?.[snapshot.operation]
   );
@@ -38745,20 +39152,20 @@ async function applyPreparedHarnessSourceApplication(snapshot, target, env = pro
         `Prepared harness registration source does not exist: ${registration.source}`
       );
     }
-    await mkdir3(path37.dirname(registrationTarget), { recursive: true });
+    await mkdir3(path38.dirname(registrationTarget), { recursive: true });
     await cp(registrationSource, registrationTarget, { force: true });
   }
   return true;
 }
 function asHarnessPreparedSourceOperation(value) {
-  const operation = asRecord11(value);
+  const operation = asRecord12(value);
   if (!operation || typeof operation.source !== "string" || !operation.source.trim())
     return null;
   if (operation.registrations !== void 0 && !Array.isArray(operation.registrations)) {
     throw new Error("Prepared harness source registrations must be an array.");
   }
   const registrations = (operation.registrations ?? []).map((value2) => {
-    const registration = asRecord11(value2);
+    const registration = asRecord12(value2);
     if (!registration || typeof registration.source !== "string" || !registration.source.trim() || typeof registration.target !== "string" || !registration.target.trim()) {
       throw new Error(
         "Prepared harness source registrations require source and target paths."
@@ -38769,14 +39176,14 @@ function asHarnessPreparedSourceOperation(value) {
   return { source: operation.source, registrations };
 }
 function resolveHarnessManifestPath(workspaceRoot, relativePath, label) {
-  if (path37.isAbsolute(relativePath)) {
+  if (path38.isAbsolute(relativePath)) {
     throw new Error(
       `Prepared harness ${label} must be relative to the profile repo.`
     );
   }
-  const root = path37.resolve(workspaceRoot);
-  const resolved = path37.resolve(root, relativePath);
-  if (resolved !== root && !resolved.startsWith(`${root}${path37.sep}`)) {
+  const root = path38.resolve(workspaceRoot);
+  const resolved = path38.resolve(root, relativePath);
+  if (resolved !== root && !resolved.startsWith(`${root}${path38.sep}`)) {
     throw new Error(
       `Prepared harness ${label} must stay inside the profile repo.`
     );
@@ -38813,10 +39220,10 @@ async function localCreateSourceLayoutIsStable(target) {
 }
 async function sourceLayoutFingerprint(target) {
   const paths = [
-    path37.join(target.sourceRoot, "agent", "agent.ts"),
-    path37.join(target.sourceRoot, "package.json"),
-    path37.join(target.repoPath, "openpond-profile.json"),
-    path37.join(target.sourcePath, "settings", "profile.yaml")
+    path38.join(target.sourceRoot, "agent", "agent.ts"),
+    path38.join(target.sourceRoot, "package.json"),
+    path38.join(target.repoPath, "openpond-profile.json"),
+    path38.join(target.sourcePath, "settings", "profile.yaml")
   ];
   const parts = await Promise.all(
     paths.map(async (filePath) => {
@@ -38889,7 +39296,7 @@ function normalizeActionId(value) {
   const trimmed = value?.trim();
   return trimmed || null;
 }
-function asRecord11(value) {
+function asRecord12(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function sourceActionIdForAgent(actionId, agentId) {
@@ -38904,7 +39311,7 @@ function normalizeRelativePath(value) {
 }
 
 // ../server/src/runtime/create-pipeline/agent-evaluation.ts
-import path38 from "node:path";
+import path39 from "node:path";
 
 // ../server/src/training/create-improve-taskset-lineage.ts
 function createEvidenceSnapshot(input) {
@@ -39175,15 +39582,15 @@ async function runNormalizedAgentEvaluation(input) {
   const results = Array.isArray(payload.results) ? payload.results : [];
   const sdkEvalRefs = results.map((evaluation) => stringValue11(evaluation.name)).filter((value) => Boolean(value));
   const artifactRefs = /* @__PURE__ */ new Set([
-    path38.posix.join(input.sourceRef, ".openpond/eval-results.json")
+    path39.posix.join(input.sourceRef, ".openpond/eval-results.json")
   ]);
   for (const evaluation of results) {
     const trace = stringValue11(evaluation.traceArtifactRef);
     if (trace)
-      artifactRefs.add(path38.posix.join(input.sourceRef, normalizeRef(trace)));
+      artifactRefs.add(path39.posix.join(input.sourceRef, normalizeRef(trace)));
     for (const artifact of stringArray4(evaluation.artifacts)) {
       artifactRefs.add(
-        path38.posix.join(input.sourceRef, normalizeRef(artifact))
+        path39.posix.join(input.sourceRef, normalizeRef(artifact))
       );
     }
   }
@@ -39314,29 +39721,29 @@ function stringArray4(value) {
 import { existsSync as existsSync4 } from "node:fs";
 import { mkdir as mkdir5, realpath as realpath3, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
 import os3 from "node:os";
-import path40 from "node:path";
+import path41 from "node:path";
 
 // ../server/src/runtime/create-pipeline/agent-improvement-git-helpers.ts
 import { existsSync as existsSync3 } from "node:fs";
 import { cp as cp2, lstat as lstat2, mkdir as mkdir4, rm, symlink, writeFile as writeFile3 } from "node:fs/promises";
-import path39 from "node:path";
+import path40 from "node:path";
 function allowedAgentImprovementPaths(run, target) {
   const profilePath = normalizeRepoPath(target.profileRelativePath);
   const defaults = [
     normalizeRepoPath(target.sourceRootRelativePath),
-    path39.posix.join(profilePath, "evals"),
-    path39.posix.join(profilePath, "settings"),
-    path39.posix.join(profilePath, "package.json"),
-    path39.posix.join(profilePath, "tsconfig.json"),
-    path39.posix.join(profilePath, "openpond.lock"),
-    path39.posix.join(profilePath, ".gitignore"),
+    path40.posix.join(profilePath, "evals"),
+    path40.posix.join(profilePath, "settings"),
+    path40.posix.join(profilePath, "package.json"),
+    path40.posix.join(profilePath, "tsconfig.json"),
+    path40.posix.join(profilePath, "openpond.lock"),
+    path40.posix.join(profilePath, ".gitignore"),
     "openpond-profile.json"
   ];
   const planned = (run.plan?.sourcePlan ?? []).flatMap((item) => {
     const value = normalizeRepoPath(item.path);
     if (!value) return [];
     if (value === "." || value.startsWith(`${profilePath}/`)) return [value];
-    return [path39.posix.join(profilePath, value), value];
+    return [path40.posix.join(profilePath, value), value];
   });
   return [.../* @__PURE__ */ new Set([...defaults, ...planned])];
 }
@@ -39378,7 +39785,7 @@ async function workingTreeMatchesCommit(input) {
       "rev-parse",
       `${input.commit}:${relativePath}`
     ]);
-    const absolutePath = path39.join(input.repoPath, ...relativePath.split("/"));
+    const absolutePath = path40.join(input.repoPath, ...relativePath.split("/"));
     if (!blob) {
       if (existsSync3(absolutePath)) return false;
       continue;
@@ -39396,21 +39803,21 @@ async function workingTreeMatchesCommit(input) {
 async function linkCandidateDependencies(target, worktreePath) {
   const relativePaths = /* @__PURE__ */ new Set([
     "node_modules",
-    path39.posix.join(
+    path40.posix.join(
       normalizeRepoPath(target.profileRelativePath),
       "node_modules"
     ),
-    path39.posix.join(
+    path40.posix.join(
       normalizeRepoPath(target.sourceRootRelativePath),
       "node_modules"
     )
   ]);
   for (const relativePath of relativePaths) {
-    const sourcePath = path39.join(target.repoPath, ...relativePath.split("/"));
-    const destinationPath = path39.join(worktreePath, ...relativePath.split("/"));
+    const sourcePath = path40.join(target.repoPath, ...relativePath.split("/"));
+    const destinationPath = path40.join(worktreePath, ...relativePath.split("/"));
     if (!await directoryExists(sourcePath) || existsSync3(destinationPath))
       continue;
-    await mkdir4(path39.dirname(destinationPath), { recursive: true });
+    await mkdir4(path40.dirname(destinationPath), { recursive: true });
     await symlink(
       sourcePath,
       destinationPath,
@@ -39426,7 +39833,7 @@ async function snapshotActiveProfileChanges(input) {
   );
   assertCommand(trackedDiff, "Unable to capture active Profile changes.");
   if (trackedDiff.stdout) {
-    const patchPath = path39.join(input.workspaceRoot, "active-profile.patch");
+    const patchPath = path40.join(input.workspaceRoot, "active-profile.patch");
     await writeFile3(patchPath, trackedDiff.stdout, "utf8");
     const applied = await input.command(
       "git",
@@ -39446,12 +39853,12 @@ async function snapshotActiveProfileChanges(input) {
   );
   assertCommand(untracked, "Unable to inspect untracked Profile source.");
   for (const relativePath of untracked.stdout.split("\0").filter(snapshotEligiblePath)) {
-    const source = path39.join(input.repoPath, ...relativePath.split("/"));
-    const destination = path39.join(
+    const source = path40.join(input.repoPath, ...relativePath.split("/"));
+    const destination = path40.join(
       input.worktreePath,
       ...relativePath.split("/")
     );
-    await mkdir4(path39.dirname(destination), { recursive: true });
+    await mkdir4(path40.dirname(destination), { recursive: true });
     await cp2(source, destination, {
       recursive: true,
       preserveTimestamps: true
@@ -39612,8 +40019,8 @@ function restoreAgentImprovementWorkspace(target, git) {
       ...target,
       repoPath: worktreePath,
       workspaceRoot: worktreePath,
-      sourcePath: path40.join(worktreePath, ...profileRelativePath.split("/")),
-      sourceRoot: path40.join(worktreePath, ...sourceRootRelativePath.split("/"))
+      sourcePath: path41.join(worktreePath, ...profileRelativePath.split("/")),
+      sourceRoot: path41.join(worktreePath, ...sourceRootRelativePath.split("/"))
     },
     git
   };
@@ -39668,13 +40075,13 @@ async function prepareAgentImprovementWorkspace(input) {
     );
   }
   const branch = candidateBranch(input.run, input.target.agentId);
-  const workspaceRoot = path40.join(
+  const workspaceRoot = path41.join(
     os3.tmpdir(),
     "openpond-agent-improvements",
-    safePathSegment(path40.basename(repoPath) || "profile"),
+    safePathSegment(path41.basename(repoPath) || "profile"),
     safePathSegment(input.run.id)
   );
-  const worktreePath = path40.join(workspaceRoot, "repo");
+  const worktreePath = path41.join(workspaceRoot, "repo");
   await mkdir5(workspaceRoot, { recursive: true });
   const existingBranch = await command(
     "git",
@@ -39735,8 +40142,8 @@ async function prepareAgentImprovementWorkspace(input) {
       ...input.target,
       repoPath: worktreePath,
       workspaceRoot: worktreePath,
-      sourcePath: path40.join(worktreePath, ...profileRelativePath.split("/")),
-      sourceRoot: path40.join(worktreePath, ...sourceRootRelativePath.split("/"))
+      sourcePath: path41.join(worktreePath, ...profileRelativePath.split("/")),
+      sourceRoot: path41.join(worktreePath, ...sourceRootRelativePath.split("/"))
     },
     git: {
       baseBranch,
@@ -40033,7 +40440,7 @@ async function applyAgentImprovementCandidateLocally(input) {
   assertCommand(patch, "Unable to build the local Agent change.");
   if (!patch.stdout.trim())
     throw new Error("Agent candidate produced an empty local change.");
-  const patchPath = path40.join(
+  const patchPath = path41.join(
     os3.tmpdir(),
     `openpond-agent-change-${safePathSegment(input.run.id)}-${Date.now()}.patch`
   );
@@ -40144,7 +40551,7 @@ async function cleanupAgentImprovementWorkspace(input) {
     await command("git", ["branch", "-D", input.git.branch], input.repoPath);
   }
   if (input.git.worktreePath) {
-    await rm2(path40.dirname(input.git.worktreePath), {
+    await rm2(path41.dirname(input.git.worktreePath), {
       recursive: true,
       force: true
     }).catch(() => void 0);
@@ -40153,14 +40560,14 @@ async function cleanupAgentImprovementWorkspace(input) {
 
 // ../server/src/agents/agent-package-origin.ts
 import { promises as fs20 } from "node:fs";
-import path41 from "node:path";
+import path42 from "node:path";
 async function readAgentPackageOrigin(agentRootPath, manifestHash) {
-  const originPath = path41.join(
+  const originPath = path42.join(
     agentRootPath,
     ".openpond",
     "agent-package-origin.json"
   );
-  const origin = await fs20.readFile(originPath, "utf8").then((raw) => asRecord12(JSON.parse(raw))).catch(() => ({}));
+  const origin = await fs20.readFile(originPath, "utf8").then((raw) => asRecord13(JSON.parse(raw))).catch(() => ({}));
   const versionId = stringValue13(origin.versionId);
   const digest = stringValue13(origin.digest);
   if (versionId && digest && /^[a-f0-9]{64}$/.test(digest) && versionId === `agent-${digest.slice(0, 20)}`) {
@@ -40178,7 +40585,7 @@ async function readAgentPackageOrigin(agentRootPath, manifestHash) {
     evalReceiptIds: []
   };
 }
-function asRecord12(value) {
+function asRecord13(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function stringValue13(value) {
@@ -41255,7 +41662,7 @@ function uniqueEvidence(run, evidence) {
 }
 async function verifyAppliedProfileCommit(input) {
   const command = input.command ?? (async (name, args, cwd, env) => {
-    const { runWorkspaceCommand } = await import("./workspaces-5LKGF3AG.js");
+    const { runWorkspaceCommand } = await import("./workspaces-26IF6TQV.js");
     return runWorkspaceCommand(name, args, cwd, env);
   });
   const result = await command("git", ["rev-parse", "HEAD"], input.repoPath);
@@ -42046,7 +42453,7 @@ function subagentSystemContextForSession(session, delegation) {
 }
 
 // ../server/src/runtime/subagents/workspace-state.ts
-import path42 from "node:path";
+import path43 from "node:path";
 var RETAINED_WORKSPACE_DAYS = 7;
 var RETAINED_WORKSPACE_MS = RETAINED_WORKSPACE_DAYS * 24 * 60 * 60 * 1e3;
 function subagentCleanupRetainReason(run, policy) {
@@ -42097,10 +42504,10 @@ function truthyRecordBoolean(record6, key) {
   return record6[key] === true;
 }
 function assertPathInside(input) {
-  const rootPath = path42.resolve(input.rootPath);
-  const targetPath = path42.resolve(input.targetPath);
-  const relative = path42.relative(rootPath, targetPath);
-  if (relative && !relative.startsWith("..") && !path42.isAbsolute(relative)) return;
+  const rootPath = path43.resolve(input.rootPath);
+  const targetPath = path43.resolve(input.targetPath);
+  const relative = path43.relative(rootPath, targetPath);
+  if (relative && !relative.startsWith("..") && !path43.isAbsolute(relative)) return;
   throw new Error(`${input.label} path must stay inside the isolated subagent workspace.`);
 }
 function addMillisecondsToIso(iso, ms) {
@@ -42264,7 +42671,7 @@ async function applySubagentPatch(run, options = {}) {
 // ../server/src/runtime/subagents/workspace-runtime.ts
 import { promises as fs21 } from "node:fs";
 import os4 from "node:os";
-import path43 from "node:path";
+import path44 from "node:path";
 function createSubagentWorkspaceRuntime(deps) {
   const {
     attachmentRootDir,
@@ -42544,13 +42951,13 @@ function createSubagentWorkspaceRuntime(deps) {
     }
     const safeRunId = safeSubagentPathSegment(input.runId);
     const safeRoleId = safeSubagentPathSegment(input.role.id);
-    const workspaceRoot = path43.join(
+    const workspaceRoot = path44.join(
       os4.tmpdir(),
       "openpond-subagents",
-      safeSubagentPathSegment(path43.basename(parentRepoPath) || "repo"),
+      safeSubagentPathSegment(path44.basename(parentRepoPath) || "repo"),
       `${safeRoleId}-${safeRunId}`
     );
-    const worktreePath = path43.join(workspaceRoot, "repo");
+    const worktreePath = path44.join(workspaceRoot, "repo");
     const branch = `openpond/subagent/${safeRoleId}/${safeRunId.slice(0, 24)}`;
     await fs21.rm(workspaceRoot, { recursive: true, force: true });
     await fs21.mkdir(workspaceRoot, { recursive: true });
@@ -42587,8 +42994,8 @@ function createSubagentWorkspaceRuntime(deps) {
     const links = [];
     const candidates = await localSubagentDependencyArtifactCandidates(input.parentRepoPath);
     for (const relativePath of candidates) {
-      const sourcePath = path43.join(input.parentRepoPath, ...relativePath.split("/"));
-      const targetPath = path43.join(input.worktreePath, ...relativePath.split("/"));
+      const sourcePath = path44.join(input.parentRepoPath, ...relativePath.split("/"));
+      const targetPath = path44.join(input.worktreePath, ...relativePath.split("/"));
       const sourceStat = await safeLstat(sourcePath);
       if (!sourceStat) {
         links.push({ path: relativePath, sourcePath, targetPath, status: "missing" });
@@ -42607,7 +43014,7 @@ function createSubagentWorkspaceRuntime(deps) {
         continue;
       }
       try {
-        await fs21.mkdir(path43.dirname(targetPath), { recursive: true });
+        await fs21.mkdir(path44.dirname(targetPath), { recursive: true });
         await fs21.symlink(sourcePath, targetPath, process.platform === "win32" ? "junction" : "dir");
         links.push({ path: relativePath, sourcePath, targetPath, status: "linked" });
       } catch (error) {
@@ -42625,14 +43032,14 @@ function createSubagentWorkspaceRuntime(deps) {
   async function localSubagentDependencyArtifactCandidates(parentRepoPath) {
     const candidates = /* @__PURE__ */ new Set(["node_modules"]);
     for (const workspaceDir of await localWorkspacePackageDirs(parentRepoPath)) {
-      const relativePath = path43.posix.join(workspaceDir, "node_modules");
-      const sourcePath = path43.join(parentRepoPath, ...relativePath.split("/"));
+      const relativePath = path44.posix.join(workspaceDir, "node_modules");
+      const sourcePath = path44.join(parentRepoPath, ...relativePath.split("/"));
       if (await safeLstat(sourcePath)) candidates.add(relativePath);
     }
     return [...candidates];
   }
   async function localWorkspacePackageDirs(parentRepoPath) {
-    const packageJson = await readJsonFile2(path43.join(parentRepoPath, "package.json"));
+    const packageJson = await readJsonFile2(path44.join(parentRepoPath, "package.json"));
     const workspaces = workspacePatternsFromPackageJson(packageJson);
     const dirs = [];
     for (const pattern of workspaces) {
@@ -42661,22 +43068,22 @@ function createSubagentWorkspaceRuntime(deps) {
       if (segment2 === "*") {
         const expanded = [];
         for (const relDir of relDirs) {
-          const absoluteDir = path43.join(parentRepoPath, ...relDir.split("/").filter(Boolean));
+          const absoluteDir = path44.join(parentRepoPath, ...relDir.split("/").filter(Boolean));
           const entries = await safeReaddir(absoluteDir);
           for (const entry of entries) {
             if (!entry.isDirectory() || entry.name === "node_modules" || entry.name === ".git") continue;
-            expanded.push(path43.posix.join(relDir, entry.name));
+            expanded.push(path44.posix.join(relDir, entry.name));
           }
         }
         relDirs = expanded;
         continue;
       }
       if (segment2.includes("*")) return [];
-      relDirs = relDirs.map((relDir) => path43.posix.join(relDir, segment2));
+      relDirs = relDirs.map((relDir) => path44.posix.join(relDir, segment2));
     }
     const existing = [];
     for (const relDir of relDirs) {
-      const stat = await safeLstat(path43.join(parentRepoPath, ...relDir.split("/").filter(Boolean)));
+      const stat = await safeLstat(path44.join(parentRepoPath, ...relDir.split("/").filter(Boolean)));
       if (stat?.isDirectory()) existing.push(relDir);
     }
     return existing;
@@ -42755,7 +43162,7 @@ function createSubagentWorkspaceRuntime(deps) {
     const patch = diffResult.stdout;
     const changed = Boolean(patch.trim());
     const patchArtifact = changed ? await durableSubagentPatchArtifact(run) : null;
-    const patchPath = patchArtifact?.patchPath ?? path43.join(workspaceRoot, "handoff.patch");
+    const patchPath = patchArtifact?.patchPath ?? path44.join(workspaceRoot, "handoff.patch");
     if (changed) await fs21.writeFile(patchPath, patch, "utf8");
     const patchPreview = truncatePatch(patch);
     const patchRef = changed ? { kind: "file", id: patchPath, label: "Isolated child patch" } : null;
@@ -42790,7 +43197,7 @@ function createSubagentWorkspaceRuntime(deps) {
     };
   }
   async function durableSubagentPatchArtifact(run) {
-    const rootPath = path43.join(
+    const rootPath = path44.join(
       attachmentRootDir,
       "subagents",
       safeSubagentPathSegment(run.parentSessionId),
@@ -42799,7 +43206,7 @@ function createSubagentWorkspaceRuntime(deps) {
     await fs21.mkdir(rootPath, { recursive: true });
     return {
       rootPath,
-      patchPath: path43.join(rootPath, "handoff.patch")
+      patchPath: path44.join(rootPath, "handoff.patch")
     };
   }
   function captureSubagentSandboxForkHandoff(run, workspace) {
@@ -43742,7 +44149,7 @@ function sandboxRank(sandbox) {
 }
 
 // ../server/src/runtime/subagents/messaging-runtime.ts
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 function subagentActiveTurnIsDurablyTerminal(active, durableTurn) {
   return Boolean(
     active && durableTurn?.id === active.turn.id && durableTurn.status !== "in_progress"
@@ -43786,7 +44193,7 @@ function createSubagentMessagingRuntime(deps) {
       reason: delivered ? null : input.toRunId || input.toRole ? "No matching active child run was available for delivery." : "No target run or role was supplied."
     };
     let message = SubagentMessageSchema.parse({
-      id: randomUUID12(),
+      id: randomUUID13(),
       fromRunId,
       toRunId: input.toRunId ?? null,
       toRole: input.toRole ?? null,
@@ -43861,7 +44268,7 @@ function createSubagentMessagingRuntime(deps) {
       reason: input.run.childSessionId ? null : "The child run has no child conversation."
     });
     const message = SubagentMessageSchema.parse({
-      id: randomUUID12(),
+      id: randomUUID13(),
       fromRunId: input.context.session.subagentRunId ?? `parent:${input.context.session.id}`,
       toRunId: input.run.id,
       toRole: input.run.roleId,
@@ -44690,7 +45097,7 @@ function completionNotifications(run) {
 }
 
 // ../server/src/runtime/subagents/tool-runtime.ts
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 function createSubagentToolRuntime(deps) {
   const SUBAGENT_JOIN_WAIT_MS = 6e4;
   const SUBAGENT_JOIN_POLL_MS = 250;
@@ -44784,7 +45191,7 @@ function createSubagentToolRuntime(deps) {
           );
         }
       }
-      const runId = randomUUID13();
+      const runId = randomUUID14();
       const createdAt = now();
       const childTurnPermissions = subagentChildTurnPermissions(
         context.turnPermissions,
@@ -45829,7 +46236,6 @@ function createTurnRunner(deps) {
     maxHostedWorkspaceToolRounds,
     maxRepeatedInvalidToolRequests,
     appendRuntimeEvent,
-    processHarnessImprovementBoundary: processHarnessImprovementBoundarySafely,
     upsertModelUsageRecord: safeUpsertModelUsageRecord,
     executeNativeToolCalls,
     readProfileSkillForModel,
@@ -46126,7 +46532,7 @@ function createTurnRunner(deps) {
       } : {}
     };
     const turn = {
-      id: randomUUID14(),
+      id: randomUUID15(),
       sessionId,
       providerTurnId: null,
       modelRef: turnModelRef,
@@ -46842,7 +47248,7 @@ function createImproveLimit(value) {
 }
 
 // ../server/src/store/session-store.ts
-import { randomUUID as randomUUID15 } from "node:crypto";
+import { randomUUID as randomUUID16 } from "node:crypto";
 function createSessionStore(deps) {
   const {
     store,
@@ -46855,7 +47261,7 @@ function createSessionStore(deps) {
   async function createSession(payload) {
     const input = CreateSessionRequestSchema.parse(payload);
     const createdAt = now();
-    const sessionId = randomUUID15();
+    const sessionId = randomUUID16();
     const sessionCount = await store.sessionCount();
     const workspaceKind = input.workspaceKind ?? (input.appId ? "sandbox_app" : void 0);
     const openPondCommandAccessMode = input.openPondCommandAccessMode ?? (loadAppPreferences ? (await loadAppPreferences()).openPondCommandAccessMode : DEFAULT_OPENPOND_COMMAND_ACCESS_MODE);
@@ -47059,23 +47465,23 @@ function normalizeSession(session, sidebarPatch) {
 
 // ../server/src/workspace/project-directories.ts
 import os5 from "node:os";
-import path44 from "node:path";
+import path45 from "node:path";
 var DEFAULT_NEW_PROJECTS_FOLDER = "OpenPond Projects";
 function expandHomeDirectory(inputPath) {
   if (inputPath === "~") return os5.homedir();
   if (inputPath.startsWith("~/") || inputPath.startsWith("~\\")) {
-    return path44.join(os5.homedir(), inputPath.slice(2));
+    return path45.join(os5.homedir(), inputPath.slice(2));
   }
   return inputPath;
 }
 function defaultNewProjectDirectory() {
-  const documentsDir = process.env.OPENPOND_APP_DOCUMENTS_DIR?.trim() || path44.join(os5.homedir(), "Documents");
-  return path44.join(documentsDir, DEFAULT_NEW_PROJECTS_FOLDER);
+  const documentsDir = process.env.OPENPOND_APP_DOCUMENTS_DIR?.trim() || path45.join(os5.homedir(), "Documents");
+  return path45.join(documentsDir, DEFAULT_NEW_PROJECTS_FOLDER);
 }
 function normalizeProjectDirectory(inputPath) {
   const trimmed = inputPath?.trim();
   if (!trimmed) return defaultNewProjectDirectory();
-  return path44.resolve(expandHomeDirectory(trimmed));
+  return path45.resolve(expandHomeDirectory(trimmed));
 }
 
 // ../server/src/preferences.ts
@@ -48644,13 +49050,13 @@ var APP_SERVER_COMPOSITION = [
   "jsonl_transport"
 ];
 async function createOpenPondAppServer(options = {}) {
-  const storeDir = path45.resolve(options.storeDir ?? appDataDir());
-  const workspaceDir = path45.resolve(options.workspaceDir ?? process.cwd());
+  const storeDir = path46.resolve(options.storeDir ?? appDataDir());
+  const workspaceDir = path46.resolve(options.workspaceDir ?? process.cwd());
   const version = options.version ?? VERSION;
   const runtimeVersion = getBundledRuntimeVersion();
   const logger = createLogger({
     channel: "app-server",
-    logDir: path45.join(storeDir, "logs"),
+    logDir: path46.join(storeDir, "logs"),
     metadata: { version, runtimeVersion, placement: "hosted_work" }
   });
   const store = new SqliteStore(storeDir, { logger });
@@ -48658,6 +49064,7 @@ async function createOpenPondAppServer(options = {}) {
     options.streamOpenPondHostedChatTurn ?? streamOpenPondHostedChatTurn,
     { enabled: scriptedOpenPondModelsEnabled() }
   );
+  const harnessEvaluationReviewStream = createLocalHarnessEvaluationReviewModelStream(streamOpenPondHostedChatTurn2);
   const {
     appendRuntimeEvent,
     closeEventSubscribers,
@@ -48755,7 +49162,7 @@ async function createOpenPondAppServer(options = {}) {
   });
   await harnessImprovement.reconcilePending();
   const turnRunner = createTurnRunner({
-    attachmentRootDir: path45.join(storeDir, "attachments"),
+    attachmentRootDir: path46.join(storeDir, "attachments"),
     store,
     createSession,
     upsertApproval,
@@ -48831,7 +49238,8 @@ async function createOpenPondAppServer(options = {}) {
   let closing = false;
   const harnessSettings = createLocalHarnessSettingsRoutePayloads({
     store,
-    storeDir
+    storeDir,
+    evaluationReviewStream: harnessEvaluationReviewStream
   });
   const instance = createAppServer({
     ports: createAgentRuntimePorts({
@@ -48846,8 +49254,12 @@ async function createOpenPondAppServer(options = {}) {
       interruptSessionTurn: turnRunner.interruptSessionTurn,
       resolveApproval,
       inspectHarness: () => localHarnessHistoryPayload(store),
-      reviewHarnessProposal: createLocalHarnessSettingsRoutePayloads({ store, storeDir }).reviewHarnessProposalPayload,
-      reviewHarness: (request) => reviewSelectedLocalHarnessEvaluation({ store, request }),
+      reviewHarnessProposal: harnessSettings.reviewHarnessProposalPayload,
+      reviewHarness: (request) => reviewSelectedLocalHarnessEvaluation({
+        store,
+        request,
+        stream: harnessEvaluationReviewStream
+      }),
       acceptHarnessEvaluationReview: harnessTasksetReview.acceptEvaluationReview,
       materializeHarnessEvaluationTaskset: harnessTasksetReview.materializeEvaluationTaskset,
       runHarnessEvaluationBaseline: harnessTasksetReview.runEvaluationBaseline,
@@ -48899,7 +49311,7 @@ async function createOpenPondAppServer(options = {}) {
 function workspaceApp2(appId, workspaceDir) {
   return {
     id: appId || localPathWorkspaceId(workspaceDir),
-    name: path45.basename(workspaceDir) || "Sandbox workspace",
+    name: path46.basename(workspaceDir) || "Sandbox workspace",
     description: null,
     visibility: "private",
     gitOwner: null,
@@ -48935,6 +49347,7 @@ export {
   loadLocalHarnessRuntimeForAgentRun,
   ensureLocalHarnessRunOverlay,
   trimOutput,
+  executableSearchPath,
   reviewSelectedLocalHarnessEvaluation,
   createLocalHarnessEvaluationReviewScheduler,
   createLocalHarnessSettingsRoutePayloads,
@@ -48985,6 +49398,7 @@ export {
   loadBundledAuthoringSkills,
   readBundledAuthoringProfileSkill,
   createAgentRuntimePorts,
+  createLocalHarnessEvaluationReviewModelStream,
   gradeAttempt,
   computeTasksetHash,
   startHarnessReviewTasksetAuthoring,