openpond 0.0.56 → 0.0.58

package/dist/chunks/{src-6UCIW76H.js → src-NJYDLJ2M.js}

@@ -117,28 +117,7 @@ import {
   workspaceHasHead,
   workspaceToolExperienceBlocker,
   writeWorkspaceFile
-} from "./chunk-Q4YKGVNG.js";
-import {
-  runOpenPondServerCli
-} from "./chunk-CW6FAJEF.js";
-import {
-  createAppServer,
-  runAgentCompaction
-} from "./chunk-NFNEENNR.js";
-import {
-  createOpenPondRepoApp,
-  getBundledRuntimeVersion,
-  getOpenPondAppEnvironment,
-  loadOpenPondAccountContext,
-  loadOpenPondAccountState,
-  loadOpenPondApps,
-  loadOpenPondProviderCatalog,
-  removeOpenPondAccount,
-  saveOpenPondAccount,
-  streamOpenPondHostedChatTurn,
-  switchOpenPondAccount,
-  updateOpenPondAccountConfig
-} from "./chunk-EIRW6Z6S.js";
+} from "./chunk-AD6KZWHL.js";
 import {
   appWorkspacePaths,
   checkWorkspaceGitAvailability,
@@ -166,7 +145,14 @@ import {
   runCommand,
   startMacOSCommandLineToolsInstall,
   workspaceImageContentType
-} from "./chunk-H44J7BB4.js";
+} from "./chunk-BFR6VZ2A.js";
+import {
+  runOpenPondServerCli
+} from "./chunk-QIB27QOT.js";
+import {
+  createAppServer,
+  runAgentCompaction
+} from "./chunk-NFNEENNR.js";
 import {
   APP_PREFERENCES_CACHE_KEY,
   APP_PREFERENCES_CACHE_TYPE,
@@ -178,7 +164,21 @@ import {
   isCliEntrypoint,
   now,
   textFromUnknown
-} from "./chunk-OSLQMUIB.js";
+} from "./chunk-OI65U2B5.js";
+import {
+  createOpenPondRepoApp,
+  getBundledRuntimeVersion,
+  getOpenPondAppEnvironment,
+  loadOpenPondAccountContext,
+  loadOpenPondAccountState,
+  loadOpenPondApps,
+  loadOpenPondProviderCatalog,
+  removeOpenPondAccount,
+  saveOpenPondAccount,
+  streamOpenPondHostedChatTurn,
+  switchOpenPondAccount,
+  updateOpenPondAccountConfig
+} from "./chunk-LMQ4MPQI.js";
 import {
   AccountStateSchema,
   AdapterValidationReceiptSchema,
@@ -249,6 +249,7 @@ import {
   ModelRunSchema,
   ModelUsageRecordSchema,
   ModelVersionSchema,
+  OpenPondActionCatalogEntrySchema,
   OpenPondAppSchema,
   OpenPondExtensionSourceRequestSchema,
   OpenPondProfilePublicationPreviewRequestSchema,
@@ -411,7 +412,12 @@ import {
   workFormatCapabilityForContentType,
   workspacePathFromLocalPathWorkspaceId,
   writeSourceUploadCache
-} from "./chunk-55KT7K5P.js";
+} from "./chunk-PVGJXCAK.js";
+import {
+  PROJECT_ACTION_CONFIG_PATH,
+  createLocalActionRunner,
+  loadProjectActionConfiguration
+} from "./chunk-QETF6ILG.js";
 import {
   AttemptReceiptContentSchema,
   AttemptReceiptSchema,
@@ -451,15 +457,16 @@ import {
   workEvidenceReceiptRef,
   workSourceOpaqueRef,
   workWorkspaceOpaqueRef
-} from "./chunk-US7DOPAH.js";
+} from "./chunk-VG4H4TQG.js";
 import {
   external_exports,
   yaml
 } from "./chunk-WYDVQOBL.js";
 import {
   apiFetch,
+  readApiJson,
   withVercelProtectionBypass
-} from "./chunk-KHNHUA2H.js";
+} from "./chunk-DXSHQ6TO.js";
 import {
   __commonJS,
   __require,
@@ -13312,9 +13319,9 @@ var require_dist = __commonJS({
 });
 
 // ../server/src/index.ts
-import path62 from "node:path";
+import path63 from "node:path";
 import { randomUUID as randomUUID25 } from "node:crypto";
-import { promises as fs26 } from "node:fs";
+import { promises as fs27 } from "node:fs";
 
 // ../../packages/codex-provider/dist/client.js
 import { spawn } from "node:child_process";
@@ -14877,7 +14884,7 @@ function createCodexRuntimeManager({
 
 // ../server/src/api/server-payloads.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import path21 from "node:path";
+import path22 from "node:path";
 
 // ../server/src/codex-personal-skills.ts
 import { createHash } from "node:crypto";
@@ -20699,8 +20706,8 @@ async function organizationRequestPayload(action) {
   }
   throw new Error(`Unsupported organization action: ${action.type}`);
 }
-async function openPondApiRequest(apiBaseUrl, token, path63, init = {}) {
-  const response = await apiFetch(apiBaseUrl, token, path63, init);
+async function openPondApiRequest(apiBaseUrl, token, path64, init = {}) {
+  const response = await apiFetch(apiBaseUrl, token, path64, init);
   const payload = await response.json().catch(() => ({}));
   if (!response.ok) {
     const message2 = typeof payload.message === "string" ? payload.message : typeof payload.error === "string" ? payload.error : response.statusText;
@@ -23605,6 +23612,53 @@ function createProfilePayloads(deps) {
   };
 }
 
+// ../server/src/project-actions/local-project-actions.ts
+import path21 from "node:path";
+import { promises as fs13 } from "node:fs";
+async function localProjectActionCatalog(project) {
+  const sourceDirectory = await projectActionSourceDirectory(project.workspacePath);
+  const sourceStats = await fs13.stat(sourceDirectory).catch(() => null);
+  if (!sourceStats?.isDirectory()) return [];
+  const runner = createLocalActionRunner({
+    projectRoot: project.workspacePath,
+    build: "always"
+  });
+  const registry = await runner.catalog();
+  return registry.actions.map(
+    (action) => OpenPondActionCatalogEntrySchema.parse({
+      ...action,
+      sourcePath: project.workspacePath,
+      implementation: {
+        ...action.implementation,
+        projectId: project.id,
+        projectRoot: path21.resolve(project.workspacePath)
+      }
+    })
+  );
+}
+async function runLocalProjectAction(input) {
+  return createLocalActionRunner({
+    projectRoot: input.projectRoot,
+    build: "always"
+  }).run({
+    actionId: input.actionId,
+    input: input.value,
+    runId: input.runId,
+    idempotencyKey: input.idempotencyKey,
+    signal: input.signal
+  });
+}
+async function projectActionSourceDirectory(projectRoot) {
+  try {
+    const configuration = await loadProjectActionConfiguration(projectRoot);
+    return path21.resolve(projectRoot, configuration.sourceDirectory ?? "openpond/actions");
+  } catch (error) {
+    throw new Error(
+      `Cannot load ${PROJECT_ACTION_CONFIG_PATH}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
 // ../server/src/training/managed-adapter-models.ts
 async function listManagedAdapterProviderModels(store) {
   const [lineages, bindings, modelProjects] = await Promise.all([
@@ -23687,7 +23741,7 @@ function createServerPayloads(deps) {
     appendRuntimeEvent,
     isClosing
   } = deps;
-  const attachmentRootDir = deps.attachmentRootDir ?? path21.join(storeDir, "attachments");
+  const attachmentRootDir = deps.attachmentRootDir ?? path22.join(storeDir, "attachments");
   const {
     appendAppPage,
     loadOpenPondData,
@@ -24166,11 +24220,11 @@ function createServerPayloads(deps) {
       (candidate2) => candidate2.name === skillName
     );
     if (!skill) throw new Error(`Profile skill not found: ${skillName}`);
-    const absoluteSkillPath = path21.resolve(skill.sourcePath, skill.path);
+    const absoluteSkillPath = path22.resolve(skill.sourcePath, skill.path);
     return readSkillSourceFile({
       skillName,
       scope,
-      packageRoot: path21.dirname(absoluteSkillPath),
+      packageRoot: path22.dirname(absoluteSkillPath),
       relativeFilePath: filePath
     });
   }
@@ -24466,6 +24520,14 @@ Uploaded from OpenPond Desktop.
       }
     };
   }
+  async function localProjectActionCatalogPayload(projectId) {
+    const localProject = await findLocalProject(store, projectId);
+    if (!localProject) throw new Error("Project workspace not found");
+    return {
+      projectId: localProject.id,
+      actions: await localProjectActionCatalog(localProject)
+    };
+  }
   async function uploadLocalProjectCloudSourcePayload(projectId, payload) {
     const input = UploadLocalProjectCloudSourceRequestSchema.parse(payload);
     const localProject = await findLocalProject(store, projectId);
@@ -25002,6 +25064,7 @@ Uploaded from OpenPond Desktop.
     ...workspacePayloads,
     previewLocalProjectCloudSourcePayload,
     uploadLocalProjectCloudSourcePayload,
+    localProjectActionCatalogPayload,
     patchSidebarAppPreference,
     listSidebarFileBookmarksPayload,
     patchSidebarFileBookmarkPayload,
@@ -25017,6 +25080,180 @@ Uploaded from OpenPond Desktop.
   };
 }
 
+// ../server/src/openpond/hosted-api-access.ts
+var DEFAULT_OPENPOND_API_BASE_URL2 = "https://api.openpond.ai";
+async function resolveHostedApiAccess(dependencies = {}) {
+  const context = await (dependencies.loadAccountContext ?? loadOpenPondAccountContext)();
+  const token = context.token?.trim();
+  if (!token) throw new Error("OpenPond account API key is required.");
+  return { apiBaseUrl: resolveApiBaseUrl2(context), token };
+}
+async function resolveManagedAdapterUserAccess(dependencies = {}) {
+  const access5 = await resolveHostedApiAccess(dependencies);
+  return { ...access5, teamId: managedAdapterTeamId(dependencies.teamId) };
+}
+function hostedApiAuthHeaders(token) {
+  const headers = new Headers();
+  if (token.startsWith("opk_")) {
+    headers.set("Authorization", `ApiKey ${token}`);
+    headers.set("openpond-api-key", token);
+  } else {
+    headers.set("Authorization", `Bearer ${token}`);
+  }
+  return headers;
+}
+function resolveApiBaseUrl2(context) {
+  return normalizeOptionalUrl2(context.apiBaseUrl) ?? normalizeOptionalUrl2(context.account?.apiBaseUrl) ?? normalizeOptionalUrl2(context.config.apiBaseUrl) ?? normalizeOpenPondWebBaseAsApi2(context.account?.baseUrl) ?? normalizeOpenPondWebBaseAsApi2(context.config.baseUrl) ?? DEFAULT_OPENPOND_API_BASE_URL2;
+}
+function managedAdapterTeamId(explicitTeamId) {
+  const teamId = explicitTeamId?.trim();
+  if (!teamId || !/^[A-Za-z0-9_-]{3,191}$/.test(teamId)) {
+    throw new Error("Select an OpenPond workspace before using OpenPond Managed RL.");
+  }
+  return teamId;
+}
+function normalizeOpenPondWebBaseAsApi2(value) {
+  const normalized = normalizeOptionalUrl2(value);
+  if (!normalized) return null;
+  try {
+    const url = new URL(normalized);
+    if (url.hostname === "openpond.ai") return "https://api.openpond.ai";
+    if (!url.hostname.startsWith("api.") && url.hostname.endsWith(".openpond.ai")) {
+      url.hostname = `api.${url.hostname}`;
+      return url.origin;
+    }
+  } catch {
+    return normalized;
+  }
+  return normalized;
+}
+function normalizeOptionalUrl2(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed.replace(/\/$/, "") : null;
+}
+
+// ../server/src/project-actions/hosted-project-actions.ts
+async function runHostedProjectAction(input, dependencies = {}) {
+  const access5 = await (dependencies.resolveAccess ?? resolveHostedApiAccess)();
+  const response = await (dependencies.fetch ?? apiFetch)(
+    access5.apiBaseUrl,
+    access5.token,
+    `/v1/project-actions/${encodeURIComponent(input.projectId)}/actions/${encodeURIComponent(input.actionId)}?teamId=${encodeURIComponent(input.teamId)}`,
+    {
+      method: "POST",
+      body: JSON.stringify({
+        input: input.value,
+        releaseId: input.releaseId,
+        idempotencyKey: input.idempotencyKey,
+        callerType: "work",
+        callerId: input.callerId
+      }),
+      signal: input.signal,
+      timeoutMs: 15 * 60 * 1e3
+    }
+  );
+  const payload = await readApiJson(
+    response,
+    "Run hosted Project Action"
+  );
+  if (payload.invocation.status === "failed") {
+    throw new Error(
+      payload.invocation.failureMessage || payload.invocation.failureCode || "Hosted Project Action failed."
+    );
+  }
+  return payload.invocation;
+}
+
+// ../server/src/project-actions/project-action-payload.ts
+function createProjectActionRunPayload(deps) {
+  return async function projectActionRunPayload(payload) {
+    const input = asRecord5(payload);
+    const action = stringValue5(input.action) ?? stringValue5(input.actionName);
+    if (!action) throw new Error("Project Action name is required.");
+    const metadata = asRecord5(input.metadata);
+    if (stringValue5(metadata.execution) === "hosted") {
+      const result2 = await runHostedProjectAction({
+        projectId: requiredMetadata(metadata, "projectId"),
+        teamId: requiredMetadata(metadata, "teamId"),
+        releaseId: requiredMetadata(metadata, "releaseId"),
+        actionId: action,
+        value: input.input ?? {},
+        idempotencyKey: stringValue5(metadata.toolCallId) ? `${requiredMetadata(metadata, "turnId")}:${requiredMetadata(metadata, "toolCallId")}` : void 0,
+        callerId: stringValue5(metadata.turnId) ?? void 0
+      });
+      const sessionId2 = stringValue5(metadata.sessionId);
+      if (sessionId2) {
+        await deps.appendRuntimeEvent(event({
+          name: "workspace_action_result",
+          sessionId: sessionId2,
+          turnId: requiredMetadata(metadata, "turnId"),
+          source: "chat_action",
+          action: "project_action_run",
+          appId: null,
+          status: "completed",
+          output: JSON.stringify(result2.resultJson),
+          data: {
+            openPondHostedProjectActionRun: true,
+            action: {
+              name: action,
+              label: stringValue5(metadata.selectedActionLabel) ?? action
+            },
+            releaseId: result2.releaseId,
+            invocationId: result2.id,
+            traces: result2.traceJson,
+            outputs: result2.outputJson
+          }
+        }));
+      }
+      return result2;
+    }
+    const projectId = stringValue5(metadata.projectId);
+    if (!projectId) throw new Error("Project Action Project id is required.");
+    const projectRoot = await deps.resolveProjectRoot(projectId);
+    if (!projectRoot) throw new Error("Project Action Project is not registered locally.");
+    const sessionId = stringValue5(metadata.sessionId);
+    const turnId = stringValue5(metadata.turnId) ?? `openpond_project_action_${Date.now()}`;
+    const toolCallId = stringValue5(metadata.toolCallId);
+    const result = await runLocalProjectAction({
+      projectRoot,
+      actionId: action,
+      value: input.input ?? {},
+      runId: toolCallId ?? void 0,
+      idempotencyKey: toolCallId ? `${turnId}:${toolCallId}` : null
+    });
+    if (sessionId) {
+      await deps.appendRuntimeEvent(event({
+        name: "workspace_action_result",
+        sessionId,
+        turnId,
+        source: "chat_action",
+        action: "project_action_run",
+        appId: null,
+        status: "completed",
+        output: JSON.stringify(result.output),
+        data: {
+          openPondProjectActionRun: true,
+          action: {
+            name: action,
+            label: stringValue5(metadata.selectedActionLabel) ?? action
+          },
+          runId: result.runId,
+          traces: result.traces,
+          outputs: result.outputs,
+          outputDirectory: result.outputDirectory,
+          durationMs: result.durationMs
+        }
+      }));
+    }
+    return result;
+  };
+}
+function requiredMetadata(metadata, name) {
+  const value = stringValue5(metadata[name]);
+  if (!value) throw new Error(`Hosted Project Action ${name} is required.`);
+  return value;
+}
+
 // ../server/src/api/event-page.ts
 var DEFAULT_EVENT_PAGE_LIMIT = 100;
 var MAX_EVENT_PAGE_LIMIT = 500;
@@ -26113,58 +26350,6 @@ async function handleCreateImproveRoutes({
   return false;
 }
 
-// ../server/src/openpond/hosted-api-access.ts
-var DEFAULT_OPENPOND_API_BASE_URL2 = "https://api.openpond.ai";
-async function resolveHostedApiAccess(dependencies = {}) {
-  const context = await (dependencies.loadAccountContext ?? loadOpenPondAccountContext)();
-  const token = context.token?.trim();
-  if (!token) throw new Error("OpenPond account API key is required.");
-  return { apiBaseUrl: resolveApiBaseUrl2(context), token };
-}
-async function resolveManagedAdapterUserAccess(dependencies = {}) {
-  const access5 = await resolveHostedApiAccess(dependencies);
-  return { ...access5, teamId: managedAdapterTeamId(dependencies.teamId) };
-}
-function hostedApiAuthHeaders(token) {
-  const headers = new Headers();
-  if (token.startsWith("opk_")) {
-    headers.set("Authorization", `ApiKey ${token}`);
-    headers.set("openpond-api-key", token);
-  } else {
-    headers.set("Authorization", `Bearer ${token}`);
-  }
-  return headers;
-}
-function resolveApiBaseUrl2(context) {
-  return normalizeOptionalUrl2(context.apiBaseUrl) ?? normalizeOptionalUrl2(context.account?.apiBaseUrl) ?? normalizeOptionalUrl2(context.config.apiBaseUrl) ?? normalizeOpenPondWebBaseAsApi2(context.account?.baseUrl) ?? normalizeOpenPondWebBaseAsApi2(context.config.baseUrl) ?? DEFAULT_OPENPOND_API_BASE_URL2;
-}
-function managedAdapterTeamId(explicitTeamId) {
-  const teamId = explicitTeamId?.trim();
-  if (!teamId || !/^[A-Za-z0-9_-]{3,191}$/.test(teamId)) {
-    throw new Error("Select an OpenPond workspace before using OpenPond Managed RL.");
-  }
-  return teamId;
-}
-function normalizeOpenPondWebBaseAsApi2(value) {
-  const normalized = normalizeOptionalUrl2(value);
-  if (!normalized) return null;
-  try {
-    const url = new URL(normalized);
-    if (url.hostname === "openpond.ai") return "https://api.openpond.ai";
-    if (!url.hostname.startsWith("api.") && url.hostname.endsWith(".openpond.ai")) {
-      url.hostname = `api.${url.hostname}`;
-      return url.origin;
-    }
-  } catch {
-    return normalized;
-  }
-  return normalized;
-}
-function normalizeOptionalUrl2(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed.replace(/\/$/, "") : null;
-}
-
 // ../server/src/openpond/community-client.ts
 var CommunityApiError = class extends Error {
   constructor(code, status, details = null) {
@@ -26187,11 +26372,11 @@ async function communityRequestPayload(action, dependencies = {}) {
   const payload = await requestCommunityApi(request.path, request.init, dependencies);
   return schemaForAction(action).parse(payload);
 }
-async function requestCommunityApi(path63, init = {}, dependencies = {}) {
+async function requestCommunityApi(path64, init = {}, dependencies = {}) {
   const access5 = await resolveHostedApiAccess(dependencies);
   const headers = hostedApiAuthHeaders(access5.token);
   headers.set("Content-Type", "application/json");
-  const response = await (dependencies.fetchImpl ?? fetch)(`${access5.apiBaseUrl}${path63}`, {
+  const response = await (dependencies.fetchImpl ?? fetch)(`${access5.apiBaseUrl}${path64}`, {
     ...init,
     headers
   });
@@ -26360,11 +26545,11 @@ async function uploadCommunityAttachment(action, dependencies) {
     )
   );
 }
-function post(path63, body) {
-  return jsonRequest(path63, "POST", body);
+function post(path64, body) {
+  return jsonRequest(path64, "POST", body);
 }
-function jsonRequest(path63, method, body) {
-  return { path: path63, init: { method, body: JSON.stringify(body) } };
+function jsonRequest(path64, method, body) {
+  return { path: path64, init: { method, body: JSON.stringify(body) } };
 }
 
 // ../server/src/api/routes/community-routes.ts
@@ -26664,7 +26849,7 @@ async function handleDesktopBrowserRoutes({
 // ../server/src/api/signed-workspace-image.ts
 import { createHmac, timingSafeEqual } from "node:crypto";
 import { Buffer as Buffer6 } from "node:buffer";
-import path22 from "node:path";
+import path23 from "node:path";
 var SIGNED_WORKSPACE_IMAGE_TTL_MS = 5 * 60 * 1e3;
 var CHAT_ATTACHMENT_IMAGE_CONTENT_TYPES = /* @__PURE__ */ new Set(["image/gif", "image/jpeg", "image/png", "image/webp"]);
 function signedWorkspaceImageUrlPayload(input, requestUrl, token) {
@@ -26736,13 +26921,13 @@ function verifySignedWorkspaceImageRequest(requestUrl, token) {
   if (!appId || !rawPath || !expiresRaw || !signature) {
     return { ok: false, status: 401, error: "Signed asset URL is missing required claims." };
   }
-  const path63 = normalizeSignedWorkspaceImagePath(rawPath);
+  const path64 = normalizeSignedWorkspaceImagePath(rawPath);
   const expiresAt = Number(expiresRaw);
-  if (!path63 || !Number.isInteger(expiresAt)) {
+  if (!path64 || !Number.isInteger(expiresAt)) {
     return { ok: false, status: 401, error: "Signed asset URL is invalid." };
   }
   if (expiresAt < Date.now()) return { ok: false, status: 401, error: "Signed asset URL expired." };
-  const claims = { appId: appId.trim(), path: path63, expiresAt };
+  const claims = { appId: appId.trim(), path: path64, expiresAt };
   if (!safeSignatureEqual(signature, signWorkspaceImageClaims(claims, token))) {
     return { ok: false, status: 401, error: "Signed asset URL signature is invalid." };
   }
@@ -26836,9 +27021,9 @@ function requiredSearchParam(requestUrl, name) {
 }
 function normalizeSignedWorkspaceImagePath(value) {
   if (/^file:\/\//i.test(value) || /^\//.test(value) || /^[A-Za-z]:[\\/]/.test(value)) return null;
-  const path63 = normalizeWorkspaceFilePath(value);
-  if (!path63 || !workspaceImageContentType(path63)) return null;
-  return path63;
+  const path64 = normalizeWorkspaceFilePath(value);
+  if (!path64 || !workspaceImageContentType(path64)) return null;
+  return path64;
 }
 function normalizeSignedLocalImagePath(value) {
   const cleaned = normalizeSignedLocalAssetPath(value);
@@ -26860,8 +27045,8 @@ function normalizeSignedLocalAssetPath(value) {
       cleaned = cleaned.replace(/^file:\/\//, "");
     }
   }
-  if (!path22.isAbsolute(cleaned)) return null;
-  return path22.resolve(cleaned);
+  if (!path23.isAbsolute(cleaned)) return null;
+  return path23.resolve(cleaned);
 }
 function normalizeSignedChatAttachmentStorageName(value) {
   const trimmed = value.trim();
@@ -27260,9 +27445,23 @@ async function handleProjectCloudRoutes({ deps, request, requestUrl, response })
     createLocalProjectPayload,
     previewLocalProjectCloudSourcePayload,
     uploadLocalProjectCloudSourcePayload,
+    localProjectActionCatalogPayload,
     updateLocalProjectAgentSetupPayload,
     deleteLocalProjectPayload
   } = deps;
+  const localProjectActionsMatch = /^\/v1\/projects\/([^/]+)\/actions$/.exec(
+    requestUrl.pathname
+  );
+  if (request.method === "GET" && localProjectActionsMatch) {
+    sendJson(
+      response,
+      200,
+      await localProjectActionCatalogPayload(
+        decodeURIComponent(localProjectActionsMatch[1])
+      )
+    );
+    return true;
+  }
   if (request.method === "POST" && requestUrl.pathname === "/v1/projects") {
     sendJson(response, 201, await createLocalProjectPayload(await readJson(request)));
     return true;
@@ -28424,13 +28623,13 @@ function decode2(value) {
 // ../server/src/api/routes/training-routes.ts
 import { createReadStream as createReadStream3 } from "node:fs";
 import { stat as stat3 } from "node:fs/promises";
-import path24 from "node:path";
+import path25 from "node:path";
 
 // ../server/src/training/training-artifact-package.ts
 import { createReadStream as createReadStream2 } from "node:fs";
 import { once } from "node:events";
 import { stat as stat2 } from "node:fs/promises";
-import path23 from "node:path";
+import path24 from "node:path";
 var TAR_BLOCK_BYTES = 512;
 var PORTABLE_MODEL_FILENAMES = /* @__PURE__ */ new Set([
   "adapter_model.safetensors",
@@ -28448,7 +28647,7 @@ function selectPortableModelArtifacts(artifacts) {
       continue;
     }
     const normalized = providerFilename.replaceAll("\\", "/");
-    const name = path23.posix.basename(normalized);
+    const name = path24.posix.basename(normalized);
     if (!PORTABLE_MODEL_FILENAMES.has(name) && !SHARDED_ADAPTER_WEIGHTS_PATTERN.test(name)) continue;
     const candidate2 = { artifact, name, providerFilename };
     const current = selected.get(name);
@@ -28581,7 +28780,7 @@ async function handleTrainingRoutes({ deps, request, requestUrl, response }) {
     const result = await deps.trainingPayload("artifact_download", { artifactId: decodeURIComponent(downloadMatch[1]) }, requestUrl);
     const info = await stat3(result.path);
     if (!info.isFile() || info.size !== result.artifact.sizeBytes) throw new Error("Training artifact changed before download.");
-    response.writeHead(200, { "Content-Type": "application/octet-stream", "Content-Length": String(info.size), "Content-Disposition": `attachment; filename="${path24.basename(result.path).replaceAll('"', "")}"`, "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
+    response.writeHead(200, { "Content-Type": "application/octet-stream", "Content-Length": String(info.size), "Content-Disposition": `attachment; filename="${path25.basename(result.path).replaceAll('"', "")}"`, "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
     createReadStream3(result.path).pipe(response);
     return true;
   }
@@ -29211,8 +29410,8 @@ function normalizeRoutePath(pathValue) {
 
 // ../server/src/api/static-web.ts
 import { createReadStream as createReadStream5 } from "node:fs";
-import { promises as fs13 } from "node:fs";
-import path25 from "node:path";
+import { promises as fs14 } from "node:fs";
+import path26 from "node:path";
 var API_PATH_PREFIXES = ["/v1/"];
 var API_PATHS = /* @__PURE__ */ new Set(["/health"]);
 var ONE_YEAR_SECONDS = 31536e3;
@@ -29239,7 +29438,7 @@ function shouldPassToApi(request, pathname) {
   return request.method !== "GET" && request.method !== "HEAD";
 }
 function contentType(filePath) {
-  return MIME_TYPES[path25.extname(filePath).toLowerCase()] ?? "application/octet-stream";
+  return MIME_TYPES[path26.extname(filePath).toLowerCase()] ?? "application/octet-stream";
 }
 function safeResolve(root, pathname) {
   let decoded;
@@ -29249,23 +29448,23 @@ function safeResolve(root, pathname) {
     return null;
   }
   const relative2 = decoded.replace(/^\/+/, "") || "index.html";
-  const resolved = path25.resolve(root, relative2);
-  const relativeToRoot = path25.relative(root, resolved);
-  if (relativeToRoot === "" || !relativeToRoot.startsWith("..") && !path25.isAbsolute(relativeToRoot)) {
+  const resolved = path26.resolve(root, relative2);
+  const relativeToRoot = path26.relative(root, resolved);
+  if (relativeToRoot === "" || !relativeToRoot.startsWith("..") && !path26.isAbsolute(relativeToRoot)) {
     return resolved;
   }
   return null;
 }
 async function fileStat(filePath) {
   try {
-    const stat7 = await fs13.stat(filePath);
+    const stat7 = await fs14.stat(filePath);
     return stat7.isFile() ? stat7 : null;
   } catch {
     return null;
   }
 }
 function cacheControl(filePath) {
-  const normalized = filePath.split(path25.sep).join("/");
+  const normalized = filePath.split(path26.sep).join("/");
   return normalized.includes("/assets/") ? `public, max-age=${ONE_YEAR_SECONDS}, immutable` : "no-cache";
 }
 function sendFile(request, response, filePath, stat7) {
@@ -29293,7 +29492,7 @@ async function sendIndex({
   indexPath,
   token
 }) {
-  let html = await fs13.readFile(indexPath, "utf8");
+  let html = await fs14.readFile(indexPath, "utf8");
   if (isLoopbackHost(requestUrl.hostname)) {
     const connectionScript = `<script>window.__OPENPOND_WEB_CONNECTION__=${escapeScriptJson(
       JSON.stringify({
@@ -29329,8 +29528,8 @@ function createStaticWebHandler({
   token,
   webRoot
 }) {
-  const root = path25.resolve(webRoot);
-  const indexPath = path25.join(root, "index.html");
+  const root = path26.resolve(webRoot);
+  const indexPath = path26.join(root, "index.html");
   return (request, response, next) => {
     void (async () => {
       const requestUrl = new URL(request.url ?? "/", `http://${request.headers.host ?? "127.0.0.1"}`);
@@ -29352,7 +29551,7 @@ function createStaticWebHandler({
         sendFile(request, response, resolved, directStat);
         return;
       }
-      if (path25.extname(requestUrl.pathname)) {
+      if (path26.extname(requestUrl.pathname)) {
         sendNotFound(response);
         return;
       }
@@ -29375,7 +29574,7 @@ function createStaticWebHandler({
 import { Buffer as Buffer8 } from "node:buffer";
 import { existsSync as existsSync10, mkdtempSync, rmSync, statSync as statSync4, writeFileSync as writeFileSync3 } from "node:fs";
 import os7 from "node:os";
-import path26 from "node:path";
+import path27 from "node:path";
 import { spawn as spawnPty } from "node-pty";
 
 // ../../node_modules/.pnpm/ws@8.21.1/node_modules/ws/wrapper.mjs
@@ -29434,25 +29633,25 @@ function send(socket, payload) {
 function defaultShell() {
   if (process.env.OPENPOND_TERMINAL_SHELL) {
     const command2 = process.env.OPENPOND_TERMINAL_SHELL;
-    return shellLaunch(command2, interactiveShellArgs(command2), path26.basename(command2));
+    return shellLaunch(command2, interactiveShellArgs(command2), path27.basename(command2));
   }
   if (process.platform === "win32") {
     return { command: "powershell.exe", args: ["-NoLogo"], label: "PowerShell" };
   }
   const command = process.platform === "darwin" && existsSync10("/bin/zsh") ? "/bin/zsh" : "/bin/bash";
-  return shellLaunch(command, ["-i"], path26.basename(command) || "bash");
+  return shellLaunch(command, ["-i"], path27.basename(command) || "bash");
 }
 function terminalPath() {
   return executableSearchPath();
 }
 function interactiveShellArgs(command) {
   if (process.platform === "win32") return [];
-  const name = path26.basename(command);
+  const name = path27.basename(command);
   return name === "bash" || name === "zsh" || name === "fish" ? ["-i"] : [];
 }
 function safeCwd(input, fallback) {
   if (typeof input !== "string" || !input.trim()) return fallback;
-  const resolved = path26.resolve(input);
+  const resolved = path27.resolve(input);
   try {
     return statSync4(resolved).isDirectory() ? resolved : fallback;
   } catch {
@@ -29470,14 +29669,14 @@ function terminalScopeLogValue(scope) {
 }
 function shellLaunch(command, fallbackArgs, label) {
   if (process.platform === "win32") return { command, args: fallbackArgs, label, integrationDir: null };
-  const name = path26.basename(command);
+  const name = path27.basename(command);
   if (name === "bash") return bashShellLaunch(command, label);
   if (name === "zsh") return zshShellLaunch(command, label);
   if (name === "fish") return fishShellLaunch(command, label);
   return { command, args: fallbackArgs, label, integrationDir: null };
 }
 function createShellIntegrationDir() {
-  return mkdtempSync(path26.join(os7.tmpdir(), "openpond-terminal-"));
+  return mkdtempSync(path27.join(os7.tmpdir(), "openpond-terminal-"));
 }
 function removeShellIntegrationDir(dir) {
   if (!dir) return;
@@ -29488,22 +29687,22 @@ function removeShellIntegrationDir(dir) {
 }
 function bashShellLaunch(command, label) {
   const integrationDir = createShellIntegrationDir();
-  const rcFile = path26.join(integrationDir, "openpond.bashrc");
+  const rcFile = path27.join(integrationDir, "openpond.bashrc");
   writeFileSync3(rcFile, bashIntegrationScript(), "utf8");
   return {
     command,
     args: ["--rcfile", rcFile, "-i"],
     label,
     env: {
-      OPENPOND_ORIGINAL_BASHRC: path26.join(process.env.HOME ?? "", ".bashrc")
+      OPENPOND_ORIGINAL_BASHRC: path27.join(process.env.HOME ?? "", ".bashrc")
     },
     integrationDir
   };
 }
 function zshShellLaunch(command, label) {
   const integrationDir = createShellIntegrationDir();
-  writeFileSync3(path26.join(integrationDir, ".zshenv"), zshEnvScript(), "utf8");
-  writeFileSync3(path26.join(integrationDir, ".zshrc"), zshIntegrationScript(), "utf8");
+  writeFileSync3(path27.join(integrationDir, ".zshenv"), zshEnvScript(), "utf8");
+  writeFileSync3(path27.join(integrationDir, ".zshrc"), zshIntegrationScript(), "utf8");
   return {
     command,
     args: ["-i"],
@@ -29517,7 +29716,7 @@ function zshShellLaunch(command, label) {
 }
 function fishShellLaunch(command, label) {
   const integrationDir = createShellIntegrationDir();
-  const scriptPath = path26.join(integrationDir, "openpond.fish");
+  const scriptPath = path27.join(integrationDir, "openpond.fish");
   writeFileSync3(scriptPath, fishIntegrationScript(), "utf8");
   return {
     command,
@@ -30150,12 +30349,12 @@ import { randomUUID as randomUUID8 } from "node:crypto";
 import { Buffer as Buffer9 } from "node:buffer";
 import { spawn as spawn4 } from "node:child_process";
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { promises as fs15 } from "node:fs";
-import path28 from "node:path";
+import { promises as fs16 } from "node:fs";
+import path29 from "node:path";
 
 // ../server/src/scaffold/sandbox-template-scaffold.ts
-import { promises as fs14 } from "node:fs";
-import path27 from "node:path";
+import { promises as fs15 } from "node:fs";
+import path28 from "node:path";
 async function writeSandboxTemplateScaffold(repoPath, input) {
   const manifestPath = normalizeManifestPath(input.manifestPath);
   const files = sandboxTemplateScaffoldFiles({ name: input.projectName });
@@ -30174,20 +30373,20 @@ async function writeSandboxTemplateScaffold(repoPath, input) {
       if (relativePath !== manifestPath) delete files[relativePath];
     }
   }
-  const existingManifest = path27.join(repoPath, manifestPath);
+  const existingManifest = path28.join(repoPath, manifestPath);
   if (await fileExists3(existingManifest)) {
     throw new Error(`${manifestPath} already exists in this project.`);
   }
   for (const [relativePath, contents] of Object.entries(files)) {
-    const filePath = path27.join(repoPath, relativePath);
-    await fs14.mkdir(path27.dirname(filePath), { recursive: true });
-    await fs14.writeFile(filePath, contents, "utf8");
+    const filePath = path28.join(repoPath, relativePath);
+    await fs15.mkdir(path28.dirname(filePath), { recursive: true });
+    await fs15.writeFile(filePath, contents, "utf8");
   }
   return { files: Object.keys(files).sort((left, right) => left.localeCompare(right)) };
 }
 function normalizeManifestPath(value) {
   const trimmed = value?.trim() || OPENPOND_MANIFEST_FILE_NAME;
-  const normalized = path27.posix.normalize(trimmed.replace(/\\/g, "/")).replace(/^\/+/, "");
+  const normalized = path28.posix.normalize(trimmed.replace(/\\/g, "/")).replace(/^\/+/, "");
   if (!normalized || normalized === "." || normalized.startsWith("../") || normalized.includes("/../")) {
     throw new Error("Manifest path must stay inside the project.");
   }
@@ -30195,7 +30394,7 @@ function normalizeManifestPath(value) {
 }
 async function fileExists3(filePath) {
   try {
-    const stat7 = await fs14.stat(filePath);
+    const stat7 = await fs15.stat(filePath);
     return stat7.isFile();
   } catch {
     return false;
@@ -30258,14 +30457,14 @@ ${diagnostics.map((diagnostic) => `${diagnostic.path}: ${diagnostic.message}`).j
     const template = await readSandboxTemplateFromDisk(project);
     const manifest = validSandboxTemplateManifest(template);
     const rootPath = localProjectSandboxTemplateRootPath(project);
-    const outputPath = path28.join(rootPath, "dist", SANDBOX_TEMPLATE_BUILD_PLAN_FILE_NAME);
+    const outputPath = path29.join(rootPath, "dist", SANDBOX_TEMPLATE_BUILD_PLAN_FILE_NAME);
     const plan = sandboxTemplateBuildPlan({
       manifest,
-      manifestFile: path28.relative(rootPath, template.manifestPath) || OPENPOND_MANIFEST_FILE_NAME,
-      projectRoot: path28.relative(path28.dirname(outputPath), rootPath) || "."
+      manifestFile: path29.relative(rootPath, template.manifestPath) || OPENPOND_MANIFEST_FILE_NAME,
+      projectRoot: path29.relative(path29.dirname(outputPath), rootPath) || "."
     });
-    await fs15.mkdir(path28.dirname(outputPath), { recursive: true });
-    await fs15.writeFile(outputPath, `${JSON.stringify(plan, null, 2)}
+    await fs16.mkdir(path29.dirname(outputPath), { recursive: true });
+    await fs16.writeFile(outputPath, `${JSON.stringify(plan, null, 2)}
 `, "utf8");
     return {
       session,
@@ -30273,7 +30472,7 @@ ${diagnostics.map((diagnostic) => `${diagnostic.path}: ${diagnostic.message}`).j
         ok: true,
         action: input.action,
         appId: session.appId,
-        output: `Built sandbox template ${manifest.name} to ${path28.relative(rootPath, outputPath)}.`,
+        output: `Built sandbox template ${manifest.name} to ${path29.relative(rootPath, outputPath)}.`,
         data: {
           projectId: project.id,
           manifestPath: template.manifestPath,
@@ -30501,7 +30700,7 @@ ${run.execution.output}`,
 async function readSandboxTemplateFromDisk(project) {
   const template = project.sandboxTemplate;
   if (!template?.detected) throw new Error("This project does not contain openpond.yaml.");
-  const validation = validateSandboxTemplateYaml(await fs15.readFile(template.manifestPath, "utf8"));
+  const validation = validateSandboxTemplateYaml(await fs16.readFile(template.manifestPath, "utf8"));
   return {
     rootPath: template.rootPath,
     manifestPath: template.manifestPath,
@@ -31056,7 +31255,7 @@ async function uploadFilesToSandbox(sandboxId2, uploads, reportProgress) {
   return uploaded;
 }
 async function uploadLargeFileToSandbox(sandboxId2, uploadPath, contentsBase64, sizeBytes, reportProgress) {
-  const uploadDir = path28.posix.dirname(uploadPath);
+  const uploadDir = path29.posix.dirname(uploadPath);
   const uploadId = randomUUID6();
   const chunkDir = `.openpond-upload/${uploadId}`;
   await reportSandboxTemplateProgress(
@@ -31270,11 +31469,11 @@ ${result.output}`);
     uploadedFiles.length ? `Prepared ${uploadedFiles.length} local input file${uploadedFiles.length === 1 ? "" : "s"}.` : "No local input files to prepare.",
     { phase: "local_upload", files: uploadedFiles }
   );
-  const replayParamsPath = path28.join(input.rootPath, "openpond-replay-params.json");
+  const replayParamsPath = path29.join(input.rootPath, "openpond-replay-params.json");
   const replayJson = `${JSON.stringify({ input: input.params }, null, 2)}
 `;
-  await fs15.writeFile(replayParamsPath, replayJson, "utf8");
-  await reportSandboxTemplateProgress(input.reportProgress, `Wrote replay parameters to ${path28.relative(input.rootPath, replayParamsPath)}.`, {
+  await fs16.writeFile(replayParamsPath, replayJson, "utf8");
+  await reportSandboxTemplateProgress(input.reportProgress, `Wrote replay parameters to ${path29.relative(input.rootPath, replayParamsPath)}.`, {
     phase: "local_params",
     path: replayParamsPath
   });
@@ -31285,7 +31484,7 @@ ${result.output}`);
   });
   const execution = await runLocalShellCommand(
     input.executable.command,
-    input.executable.cwd ? path28.resolve(input.rootPath, input.executable.cwd) : input.rootPath,
+    input.executable.cwd ? path29.resolve(input.rootPath, input.executable.cwd) : input.rootPath,
     {
       timeoutSeconds: input.executable.timeoutSeconds ?? 900,
       env: {
@@ -31318,10 +31517,10 @@ async function writeLocalSandboxTemplateUploads(rootPath, uploads) {
   const written = [];
   for (const upload of uploads) {
     const relativePath = normalizeLocalWorkspacePath(upload.path);
-    const targetPath = path28.resolve(rootPath, relativePath);
-    await fs15.mkdir(path28.dirname(targetPath), { recursive: true });
+    const targetPath = path29.resolve(rootPath, relativePath);
+    await fs16.mkdir(path29.dirname(targetPath), { recursive: true });
     const contents = Buffer9.from(upload.contentsBase64, "base64");
-    await fs15.writeFile(targetPath, contents);
+    await fs16.writeFile(targetPath, contents);
     written.push({ path: relativePath, sizeBytes: contents.length });
   }
   return written;
@@ -31330,15 +31529,15 @@ async function prepareLocalSandboxTemplateVolumes(rootPath, manifest) {
   for (const volume of manifest.volumes) {
     const mountPath = typeof volume.mountPath === "string" && volume.mountPath.trim() ? volume.mountPath.trim() : volume.name ? `/workspace/volumes/${volume.name}` : "";
     if (!mountPath) continue;
-    await fs15.mkdir(path28.resolve(rootPath, normalizeLocalWorkspacePath(mountPath)), { recursive: true });
+    await fs16.mkdir(path29.resolve(rootPath, normalizeLocalWorkspacePath(mountPath)), { recursive: true });
   }
 }
 async function collectLocalSandboxTemplateArtifacts(rootPath, artifactPaths) {
   const artifacts = [];
   for (const artifactPath2 of artifactPaths) {
-    const localPath2 = path28.resolve(rootPath, normalizeLocalWorkspacePath(artifactPath2));
+    const localPath2 = path29.resolve(rootPath, normalizeLocalWorkspacePath(artifactPath2));
     try {
-      const stat7 = await fs15.stat(localPath2);
+      const stat7 = await fs16.stat(localPath2);
       artifacts.push({ path: artifactPath2, exists: stat7.isFile(), sizeBytes: stat7.size });
     } catch {
       artifacts.push({ path: artifactPath2, exists: false, sizeBytes: null });
@@ -32362,7 +32561,7 @@ async function captureSandboxSourceReadbackArtifact(input) {
     0,
     patchPaths.length - SANDBOX_SOURCE_READBACK_MAX_FILES
   );
-  for (const path63 of patchPaths.slice(0, SANDBOX_SOURCE_READBACK_MAX_FILES)) {
+  for (const path64 of patchPaths.slice(0, SANDBOX_SOURCE_READBACK_MAX_FILES)) {
     const remainingBytes = SANDBOX_SOURCE_READBACK_MAX_TOTAL_BYTES - totalReturnedBytes;
     if (remainingBytes <= 0) {
       skippedFiles += 1;
@@ -32377,7 +32576,7 @@ async function captureSandboxSourceReadbackArtifact(input) {
         await sandboxRequestPayload({
           type: "download_file",
           sandboxId: input.sandboxId,
-          payload: { path: path63, maxBytes }
+          payload: { path: path64, maxBytes }
         })
       );
       const file = asRecord9(downloadPayload.file);
@@ -32385,7 +32584,7 @@ async function captureSandboxSourceReadbackArtifact(input) {
       const returnedBytes = numberValue3(file.returnedBytes);
       const sizeBytes = numberValue3(file.totalSizeBytes) ?? numberValue3(file.sizeBytes);
       const entry = {
-        path: path63,
+        path: path64,
         sizeBytes,
         returnedBytes,
         isBinary,
@@ -32404,7 +32603,7 @@ async function captureSandboxSourceReadbackArtifact(input) {
       files.push(entry);
     } catch (error) {
       files.push({
-        path: path63,
+        path: path64,
         sizeBytes: null,
         returnedBytes: null,
         isBinary: false,
@@ -32606,10 +32805,10 @@ ${message2}` : message2;
     const file = asRecord9(payload.file);
     const contentsBase64 = typeof file.contentsBase64 === "string" ? file.contentsBase64 : "";
     const text3 = contentsBase64 ? Buffer11.from(contentsBase64, "base64").toString("utf8") : "";
-    const path63 = typeof file.path === "string" ? file.path : "file";
-    return text3 ? `${path63}
+    const path64 = typeof file.path === "string" ? file.path : "file";
+    return text3 ? `${path64}
 
-${text3}` : `Read ${path63}`;
+${text3}` : `Read ${path64}`;
   }
   if (action === "sandbox_exec") {
     const command = asRecord9(payload.command);
@@ -32646,31 +32845,31 @@ ${output}` : `Action ${actionName} ${status}`;
   }
   if (action === "sandbox_upload_file") {
     const file = asRecord9(payload.file);
-    const path63 = typeof file.path === "string" ? file.path : "file";
-    return appendPreservation(`Uploaded ${path63}.`);
+    const path64 = typeof file.path === "string" ? file.path : "file";
+    return appendPreservation(`Uploaded ${path64}.`);
   }
   if (action === "sandbox_write_file") {
     const file = asRecord9(payload.file);
-    const path63 = typeof file.path === "string" ? file.path : "file";
-    return appendPreservation(`Wrote ${path63}.`);
+    const path64 = typeof file.path === "string" ? file.path : "file";
+    return appendPreservation(`Wrote ${path64}.`);
   }
   if (action === "sandbox_edit_file") {
     const edit = asRecord9(payload.edit);
-    const path63 = typeof edit.path === "string" ? edit.path : "file";
+    const path64 = typeof edit.path === "string" ? edit.path : "file";
     const replacements = typeof edit.replacements === "number" ? edit.replacements : 0;
     return appendPreservation(
-      `Edited ${path63} with ${replacements} replacement${replacements === 1 ? "" : "s"}.`
+      `Edited ${path64} with ${replacements} replacement${replacements === 1 ? "" : "s"}.`
     );
   }
   if (action === "sandbox_delete_file") {
     const deleted = asRecord9(payload.deleted);
-    const path63 = typeof deleted.path === "string" ? deleted.path : "file";
-    return appendPreservation(`Deleted ${path63}.`);
+    const path64 = typeof deleted.path === "string" ? deleted.path : "file";
+    return appendPreservation(`Deleted ${path64}.`);
   }
   if (action === "sandbox_mkdir") {
     const directory = asRecord9(payload.directory);
-    const path63 = typeof directory.path === "string" ? directory.path : "directory";
-    return appendPreservation(`Created directory ${path63}.`);
+    const path64 = typeof directory.path === "string" ? directory.path : "directory";
+    return appendPreservation(`Created directory ${path64}.`);
   }
   if (action === "sandbox_move_file") {
     const moved = asRecord9(payload.moved);
@@ -33686,10 +33885,10 @@ function createWorkspaceToolExecutor(deps) {
 
 // ../server/src/work/work-output-service.ts
 import { createHash as createHash7, randomUUID as randomUUID9 } from "node:crypto";
-import { promises as fs16 } from "node:fs";
-import path29 from "node:path";
+import { promises as fs17 } from "node:fs";
+import path30 from "node:path";
 function createWorkOutputService(input) {
-  const outputRoot = path29.join(input.storeDir, "work", "outputs");
+  const outputRoot = path30.join(input.storeDir, "work", "outputs");
   const sandboxRequest = input.sandboxRequest ?? sandboxRequestPayload;
   async function saveWorkOutput(request) {
     if (request.session.experience !== "work") {
@@ -33700,7 +33899,7 @@ function createWorkOutputService(input) {
     }
     const sandboxPath = normalizeOutputCandidatePath(request.sandboxPath);
     const title = safeOutputName(
-      request.suggestedName || path29.posix.basename(sandboxPath)
+      request.suggestedName || path30.posix.basename(sandboxPath)
     );
     const payload = asRecord10(
       await sandboxRequest({
@@ -33732,7 +33931,7 @@ function createWorkOutputService(input) {
     if (reportedSize !== null && bytes2.byteLength !== reportedSize) {
       throw new Error("Sandbox output download was incomplete.");
     }
-    const contentType2 = WORK_OUTPUT_CONTENT_TYPES[path29.extname(title).toLowerCase()];
+    const contentType2 = WORK_OUTPUT_CONTENT_TYPES[path30.extname(title).toLowerCase()];
     if (!contentType2) {
       throw new Error(
         `${title} is not an advertised Work output format. Save it as a supported file type or keep it in scratch space.`
@@ -33752,26 +33951,26 @@ function createWorkOutputService(input) {
     });
     const outputId = identity.id;
     const revision = identity.revision;
-    const taskDirectory = path29.join(
+    const taskDirectory = path30.join(
       outputRoot,
       safePathSegment(request.session.id)
     );
-    await fs16.mkdir(taskDirectory, { recursive: true, mode: 448 });
-    const destination = path29.join(
+    await fs17.mkdir(taskDirectory, { recursive: true, mode: 448 });
+    const destination = path30.join(
       taskDirectory,
       `${String(revision).padStart(3, "0")}-${safePathSegment(
         outputId
       )}-${title}`
     );
-    const temporary = path29.join(
+    const temporary = path30.join(
       taskDirectory,
-      `.${path29.basename(destination)}.${randomUUID9()}.tmp`
+      `.${path30.basename(destination)}.${randomUUID9()}.tmp`
     );
-    await fs16.writeFile(temporary, bytes2, { mode: 384, flag: "wx" });
+    await fs17.writeFile(temporary, bytes2, { mode: 384, flag: "wx" });
     try {
-      await fs16.rename(temporary, destination);
+      await fs17.rename(temporary, destination);
     } catch (error) {
-      await fs16.rm(temporary, { force: true });
+      await fs17.rm(temporary, { force: true });
       throw error;
     }
     const outputRef = FileOutputRefSchema.parse({
@@ -33828,7 +34027,7 @@ function createWorkOutputService(input) {
       const file = asRecord10(value);
       if (file.type !== "file" || typeof file.path !== "string") continue;
       const sandboxPath = file.path.replace(/^\/workspace\//, "");
-      const title = safeOutputName(path29.posix.basename(sandboxPath));
+      const title = safeOutputName(path30.posix.basename(sandboxPath));
       if (alreadySaved.has(title)) continue;
       saved.push(
         await saveWorkOutput({
@@ -33887,19 +34086,19 @@ function createWorkOutputService(input) {
     if (outputRef.location.kind !== "local") {
       throw new Error("This Work output is not stored on this device.");
     }
-    const taskDirectory = path29.resolve(
+    const taskDirectory = path30.resolve(
       outputRoot,
       safePathSegment(request.session.id)
     );
-    const target = path29.resolve(outputRef.location.path);
-    if (target === taskDirectory || !target.startsWith(`${taskDirectory}${path29.sep}`)) {
+    const target = path30.resolve(outputRef.location.path);
+    if (target === taskDirectory || !target.startsWith(`${taskDirectory}${path30.sep}`)) {
       throw new Error("Work output path is outside managed local storage.");
     }
     return { outputRef, target };
   }
   async function deleteWorkOutput(request) {
     const { outputRef, target } = await resolveLocalOutput(request);
-    const deleted = await fs16.rm(target).then(() => true).catch((error) => {
+    const deleted = await fs17.rm(target).then(() => true).catch((error) => {
       if (error.code === "ENOENT") return false;
       throw error;
     });
@@ -33907,7 +34106,7 @@ function createWorkOutputService(input) {
   }
   async function readWorkOutput(request) {
     const { outputRef, target } = await resolveLocalOutput(request);
-    const bytes2 = await fs16.readFile(target);
+    const bytes2 = await fs17.readFile(target);
     if (bytes2.byteLength > WORK_OUTPUT_MAX_BYTES) {
       throw new Error(
         `Work output exceeds the ${WORK_OUTPUT_MAX_BYTES.toLocaleString()} byte limit.`
@@ -34091,7 +34290,7 @@ function normalizeOutputCandidatePath(value) {
   if (!normalized || normalized.startsWith("/")) {
     throw new Error("Work output path must be relative to /workspace.");
   }
-  const clean = path29.posix.normalize(normalized);
+  const clean = path30.posix.normalize(normalized);
   if (clean === "." || clean === ".." || clean.startsWith("../") || !clean.startsWith("outputs/") || clean === "outputs/") {
     throw new Error(
       "Completed Work outputs must be inside /workspace/outputs."
@@ -34157,7 +34356,7 @@ function findOutputRefById(value, outputId, revision, depth = 0) {
   return latest;
 }
 function safeOutputName(value) {
-  const base = path29.basename(value.trim()).replace(/[^a-zA-Z0-9._ -]+/g, "-");
+  const base = path30.basename(value.trim()).replace(/[^a-zA-Z0-9._ -]+/g, "-");
   const normalized = base.replace(/\s+/g, " ").trim().slice(0, 180);
   if (!normalized || normalized === "." || normalized === "..") {
     throw new Error("A valid output file name is required.");
@@ -34176,10 +34375,10 @@ function numberValue4(value) {
 
 // ../server/src/work/work-sandbox-lifecycle-service.ts
 import { randomUUID as randomUUID10 } from "node:crypto";
-import { promises as fs17 } from "node:fs";
-import path30 from "node:path";
+import { promises as fs18 } from "node:fs";
+import path31 from "node:path";
 function createWorkSandboxLifecycleService(input) {
-  const outboxPath = path30.join(
+  const outboxPath = path31.join(
     input.storeDir,
     "work",
     "sandbox-cleanup-outbox.json"
@@ -34346,7 +34545,7 @@ function createWorkSandboxLifecycleService(input) {
   }
   async function readOutbox() {
     try {
-      const parsed = JSON.parse(await fs17.readFile(outboxPath, "utf8"));
+      const parsed = JSON.parse(await fs18.readFile(outboxPath, "utf8"));
       if (!Array.isArray(parsed)) return [];
       return parsed.filter(isCleanupEntry);
     } catch (error) {
@@ -34355,13 +34554,13 @@ function createWorkSandboxLifecycleService(input) {
     }
   }
   async function writeOutbox(entries) {
-    await fs17.mkdir(path30.dirname(outboxPath), { recursive: true, mode: 448 });
+    await fs18.mkdir(path31.dirname(outboxPath), { recursive: true, mode: 448 });
     const temporary = `${outboxPath}.${randomUUID10()}.tmp`;
-    await fs17.writeFile(temporary, JSON.stringify(entries, null, 2), {
+    await fs18.writeFile(temporary, JSON.stringify(entries, null, 2), {
       mode: 384,
       flag: "wx"
     });
-    await fs17.rename(temporary, outboxPath);
+    await fs18.rename(temporary, outboxPath);
   }
   return { close, finalizeTurn, retryPending, start };
 }
@@ -35064,14 +35263,14 @@ function processErrorClass(failure) {
 
 // ../server/src/work/work-evidence-service.ts
 import { readFile as readFile4, stat as stat4 } from "node:fs/promises";
-import path32 from "node:path";
+import path33 from "node:path";
 
 // ../server/src/work/work-evidence-artifact-store.ts
 import { randomUUID as randomUUID11 } from "node:crypto";
 import { link, mkdir as mkdir2, readFile as readFile3, rm, writeFile } from "node:fs/promises";
-import path31 from "node:path";
+import path32 from "node:path";
 function createWorkEvidenceArtifactStore(storeDir) {
-  const root = path31.join(storeDir, "work", "evidence");
+  const root = path32.join(storeDir, "work", "evidence");
   async function persistPortableJson(input) {
     const bytes2 = Buffer.from(canonicalJson(input.value), "utf8");
     const hash3 = input.semanticHash ?? contentHash(input.value);
@@ -35141,10 +35340,10 @@ function createWorkEvidenceArtifactStore(storeDir) {
   };
 }
 function artifactPath(root, visibility, hash3, extension2) {
-  return path31.join(root, visibility, hash3.slice(0, 2), `${hash3}.${extension2}`);
+  return path32.join(root, visibility, hash3.slice(0, 2), `${hash3}.${extension2}`);
 }
 async function writeImmutable(target, bytes2) {
-  await mkdir2(path31.dirname(target), { recursive: true, mode: 448 });
+  await mkdir2(path32.dirname(target), { recursive: true, mode: 448 });
   const temporary = `${target}.${randomUUID11()}.tmp`;
   await writeFile(temporary, bytes2, { flag: "wx", mode: 384 });
   try {
@@ -35153,7 +35352,7 @@ async function writeImmutable(target, bytes2) {
     if (error.code !== "EEXIST") throw error;
     const existing = await readFile3(target);
     if (!existing.equals(bytes2)) {
-      throw new Error(`Immutable Work evidence artifact ${path31.basename(target)} changed content.`);
+      throw new Error(`Immutable Work evidence artifact ${path32.basename(target)} changed content.`);
     }
   } finally {
     await rm(temporary, { force: true });
@@ -35306,9 +35505,9 @@ async function recordDesktopWorkFeedback(input) {
   });
 }
 async function verifyManagedOutput(input) {
-  const outputRoot = path32.resolve(input.storeDir, "work", "outputs");
-  const target = path32.resolve(input.path);
-  if (!target.startsWith(`${outputRoot}${path32.sep}`)) {
+  const outputRoot = path33.resolve(input.storeDir, "work", "outputs");
+  const target = path33.resolve(input.path);
+  if (!target.startsWith(`${outputRoot}${path33.sep}`)) {
     throw new Error("Work evidence output is outside managed local output storage.");
   }
   const info = await stat4(target);
@@ -35427,8 +35626,8 @@ function publicFeedback(stored) {
 
 // ../server/src/work/work-agent-package-service.ts
 import { createHash as createHash8, randomUUID as randomUUID12 } from "node:crypto";
-import { promises as fs18 } from "node:fs";
-import path33 from "node:path";
+import { promises as fs19 } from "node:fs";
+import path34 from "node:path";
 var AGENT_PACKAGE_SCHEMA = "openpond.agent-package.v1";
 var MAX_SOURCE_FILES = 1e3;
 var REQUIRED_ARTIFACTS = [
@@ -35438,7 +35637,7 @@ var REQUIRED_ARTIFACTS = [
   ".openpond/validator-report.md"
 ];
 function createWorkAgentPackageService(input) {
-  const packageRoot = path33.join(input.storeDir, "work", "agent-packages");
+  const packageRoot = path34.join(input.storeDir, "work", "agent-packages");
   const sandboxRequest = input.sandboxRequest ?? sandboxRequestPayload;
   async function prepareWorkAgent(request) {
     const sandboxId2 = requireWorkSandbox(request.session);
@@ -35565,9 +35764,9 @@ function createWorkAgentPackageService(input) {
 `,
       "utf8"
     );
-    const packageDirectory = path33.join(packageRoot, digest);
-    const destination = path33.join(packageDirectory, "agent-package.json");
-    await fs18.mkdir(packageDirectory, { recursive: true, mode: 448 });
+    const packageDirectory = path34.join(packageRoot, digest);
+    const destination = path34.join(packageDirectory, "agent-package.json");
+    await fs19.mkdir(packageDirectory, { recursive: true, mode: 448 });
     await writeImmutablePackage(destination, packageBytes);
     const identity = await nextPackageOutputIdentity({
       runtimeEventsForSession: input.runtimeEventsForSession,
@@ -35643,12 +35842,12 @@ function createWorkAgentPackageService(input) {
     if (outputRef.location.kind !== "local") {
       throw new Error("This Agent package is not stored on this device.");
     }
-    const resolvedPackageRoot = path33.resolve(packageRoot);
-    const target = path33.resolve(outputRef.location.path);
-    if (!target.startsWith(`${resolvedPackageRoot}${path33.sep}`)) {
+    const resolvedPackageRoot = path34.resolve(packageRoot);
+    const target = path34.resolve(outputRef.location.path);
+    if (!target.startsWith(`${resolvedPackageRoot}${path34.sep}`)) {
       throw new Error("Agent package path is outside managed local storage.");
     }
-    const bytes2 = await fs18.readFile(target);
+    const bytes2 = await fs19.readFile(target);
     const agentPackage = AgentPackageSchema.parse(
       JSON.parse(bytes2.toString("utf8"))
     );
@@ -35822,7 +36021,7 @@ function normalizeAgentPackageJson(bytes2) {
 }
 function normalizeAgentDirectory(value) {
   const normalized = value.trim().replaceAll("\\", "/");
-  const clean = path33.posix.normalize(normalized);
+  const clean = path34.posix.normalize(normalized);
   if (!clean || clean === "." || clean === ".." || clean.startsWith("/") || clean.startsWith("../") || clean.split("/").some((part) => part === "..") || !/^[a-zA-Z0-9._/-]+$/.test(clean)) {
     throw new Error("Agent directory must stay inside Work scratch space.");
   }
@@ -35832,7 +36031,7 @@ function relativeAgentFilePath(value, root) {
   if (typeof value !== "string") return null;
   const normalized = value.trim().replaceAll("\\", "/");
   const workspaceRelative = normalized.startsWith("/workspace/") ? normalized.slice("/workspace/".length) : normalized.replace(/^\/+/, "");
-  const clean = path33.posix.normalize(workspaceRelative);
+  const clean = path34.posix.normalize(workspaceRelative);
   if (clean === root) return null;
   if (!clean.startsWith(`${root}/`)) {
     throw new Error("Sandbox returned a file outside the Agent source root.");
@@ -35869,7 +36068,7 @@ function assertSandboxCommandPassed(value, label) {
   }
 }
 async function writeImmutablePackage(destination, bytes2) {
-  const existing = await fs18.readFile(destination).catch(() => null);
+  const existing = await fs19.readFile(destination).catch(() => null);
   if (existing) {
     if (!existing.equals(bytes2)) {
       throw new Error(
@@ -35879,12 +36078,12 @@ async function writeImmutablePackage(destination, bytes2) {
     return;
   }
   const temporary = `${destination}.${randomUUID12()}.tmp`;
-  await fs18.writeFile(temporary, bytes2, { mode: 384, flag: "wx" });
+  await fs19.writeFile(temporary, bytes2, { mode: 384, flag: "wx" });
   try {
-    await fs18.rename(temporary, destination);
+    await fs19.rename(temporary, destination);
   } catch (error) {
-    await fs18.rm(temporary, { force: true });
-    const winner = await fs18.readFile(destination).catch(() => null);
+    await fs19.rm(temporary, { force: true });
+    const winner = await fs19.readFile(destination).catch(() => null);
     if (!winner?.equals(bytes2)) throw error;
   }
 }
@@ -35976,8 +36175,8 @@ function numberValue5(value) {
 
 // ../server/src/work/work-agent-sdk-archive.ts
 import { execFile as execFile4 } from "node:child_process";
-import { promises as fs19 } from "node:fs";
-import path34 from "node:path";
+import { promises as fs20 } from "node:fs";
+import path35 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { promisify as promisify3 } from "node:util";
 var execFileAsync3 = promisify3(execFile4);
@@ -35995,15 +36194,15 @@ function createWorkAgentSdkArchiveLoader(input) {
   };
 }
 async function loadWorkAgentSdkArchive(input) {
-  const stagedPath = input.packagePath?.trim() || process.env.OPENPOND_AGENT_SDK_PACKAGE?.trim() || path34.join(
-    path34.dirname(fileURLToPath2(import.meta.url)),
+  const stagedPath = input.packagePath?.trim() || process.env.OPENPOND_AGENT_SDK_PACKAGE?.trim() || path35.join(
+    path35.dirname(fileURLToPath2(import.meta.url)),
     "work-assets",
     "openpond-agent-sdk.tgz"
   );
   const staged = await readBoundedArchive(stagedPath);
   if (staged) return staged;
   const sourceRoot = await resolveAgentSdkSourceRoot(input.sourceRoot);
-  const distCli = path34.join(sourceRoot, "dist", "cli.js");
+  const distCli = path35.join(sourceRoot, "dist", "cli.js");
   if (!await isFile(distCli)) {
     await execFileAsync3(packageManagerCommand("pnpm"), [
       "--dir",
@@ -36015,9 +36214,9 @@ async function loadWorkAgentSdkArchive(input) {
   if (!await isFile(distCli)) {
     throw new Error("OpenPond Agent SDK build did not produce dist/cli.js.");
   }
-  const cacheRoot = path34.join(input.storeDir, "work", "assets");
-  await fs19.mkdir(cacheRoot, { recursive: true, mode: 448 });
-  const packRoot = await fs19.mkdtemp(path34.join(cacheRoot, "agent-sdk-pack-"));
+  const cacheRoot = path35.join(input.storeDir, "work", "assets");
+  await fs20.mkdir(cacheRoot, { recursive: true, mode: 448 });
+  const packRoot = await fs20.mkdtemp(path35.join(cacheRoot, "agent-sdk-pack-"));
   try {
     const { stdout } = await execFileAsync3(packageManagerCommand("npm"), [
       "pack",
@@ -36029,26 +36228,26 @@ async function loadWorkAgentSdkArchive(input) {
     const packed = JSON.parse(stdout);
     const filename = packed[0]?.filename;
     if (!filename) throw new Error("npm pack did not return an SDK archive.");
-    const bytes2 = await readBoundedArchive(path34.join(packRoot, filename));
+    const bytes2 = await readBoundedArchive(path35.join(packRoot, filename));
     if (!bytes2) throw new Error("Packed OpenPond Agent SDK archive is empty.");
     return bytes2;
   } finally {
-    await fs19.rm(packRoot, { recursive: true, force: true });
+    await fs20.rm(packRoot, { recursive: true, force: true });
   }
 }
 async function resolveAgentSdkSourceRoot(override) {
   const candidates = [
     override?.trim(),
     process.env.OPENPOND_AGENT_SDK_ROOT?.trim(),
-    path34.join(process.cwd(), "packages", "agent-sdk"),
-    path34.resolve(
-      path34.dirname(fileURLToPath2(import.meta.url)),
+    path35.join(process.cwd(), "packages", "agent-sdk"),
+    path35.resolve(
+      path35.dirname(fileURLToPath2(import.meta.url)),
       "../../../../packages/agent-sdk"
     )
   ].filter((candidate2) => Boolean(candidate2));
   for (const candidate2 of candidates) {
-    if (await isFile(path34.join(candidate2, "package.json"))) {
-      return path34.resolve(candidate2);
+    if (await isFile(path35.join(candidate2, "package.json"))) {
+      return path35.resolve(candidate2);
     }
   }
   throw new Error(
@@ -36056,23 +36255,23 @@ async function resolveAgentSdkSourceRoot(override) {
   );
 }
 async function readBoundedArchive(filePath) {
-  const stat7 = await fs19.stat(filePath).catch(() => null);
+  const stat7 = await fs20.stat(filePath).catch(() => null);
   if (!stat7?.isFile()) return null;
   if (stat7.size <= 0 || stat7.size > MAX_AGENT_SDK_ARCHIVE_BYTES) {
     throw new Error("OpenPond Agent SDK archive has an invalid size.");
   }
-  return fs19.readFile(filePath);
+  return fs20.readFile(filePath);
 }
 async function isFile(filePath) {
-  return fs19.stat(filePath).then((stat7) => stat7.isFile()).catch(() => false);
+  return fs20.stat(filePath).then((stat7) => stat7.isFile()).catch(() => false);
 }
 function packageManagerCommand(name) {
   return process.platform === "win32" ? `${name}.cmd` : name;
 }
 
 // ../server/src/workspace/server-workspace-managed-workflows.ts
-import { promises as fs20 } from "node:fs";
-import path35 from "node:path";
+import { promises as fs21 } from "node:fs";
+import path36 from "node:path";
 function createWorkspaceManagedWorkflows(deps) {
   const { appendRuntimeEvent } = deps;
   async function runSandboxTemplateCheckActionEvent(session, turnId, source, action, repoPath) {
@@ -36136,16 +36335,16 @@ function createWorkspaceManagedWorkflows(deps) {
 }
 async function hasSandboxTemplateManifest(repoPath) {
   try {
-    await fs20.access(path35.join(repoPath, OPENPOND_MANIFEST_FILE_NAME));
+    await fs21.access(path36.join(repoPath, OPENPOND_MANIFEST_FILE_NAME));
     return true;
   } catch {
     return false;
   }
 }
 async function runSandboxTemplateCheck(repoPath, action) {
-  const manifestPath = path35.join(repoPath, OPENPOND_MANIFEST_FILE_NAME);
+  const manifestPath = path36.join(repoPath, OPENPOND_MANIFEST_FILE_NAME);
   try {
-    const source = await fs20.readFile(manifestPath, "utf8");
+    const source = await fs21.readFile(manifestPath, "utf8");
     const result = validateSandboxTemplateYaml(source);
     if (!result.ok) {
       return {
@@ -36165,20 +36364,20 @@ async function runSandboxTemplateCheck(repoPath, action) {
         stderr: ""
       };
     }
-    const outputPath = path35.join(repoPath, "dist", SANDBOX_TEMPLATE_BUILD_PLAN_FILE_NAME);
+    const outputPath = path36.join(repoPath, "dist", SANDBOX_TEMPLATE_BUILD_PLAN_FILE_NAME);
     const plan = sandboxTemplateBuildPlan({
       manifest: result.manifest,
       manifestFile: OPENPOND_MANIFEST_FILE_NAME,
-      projectRoot: path35.relative(path35.dirname(outputPath), repoPath) || "."
+      projectRoot: path36.relative(path36.dirname(outputPath), repoPath) || "."
     });
-    await fs20.mkdir(path35.dirname(outputPath), { recursive: true });
-    await fs20.writeFile(outputPath, `${JSON.stringify(plan, null, 2)}
+    await fs21.mkdir(path36.dirname(outputPath), { recursive: true });
+    await fs21.writeFile(outputPath, `${JSON.stringify(plan, null, 2)}
 `, "utf8");
     return {
       ok: true,
       command: action,
       code: 0,
-      stdout: `Built sandbox template ${result.manifest.name} to ${path35.relative(repoPath, outputPath)}.`,
+      stdout: `Built sandbox template ${result.manifest.name} to ${path36.relative(repoPath, outputPath)}.`,
       stderr: ""
     };
   } catch (error) {
@@ -36193,7 +36392,7 @@ async function runSandboxTemplateCheck(repoPath, action) {
 }
 
 // ../server/src/workspace/server-workspace-session-workflows.ts
-import path36 from "node:path";
+import path37 from "node:path";
 function createWorkspaceSessionWorkflows(deps) {
   const {
     appendRuntimeEvent,
@@ -36208,7 +36407,7 @@ function createWorkspaceSessionWorkflows(deps) {
     if (subagentRepoPath) {
       const app2 = {
         id: localPathWorkspaceId(subagentRepoPath),
-        name: path36.basename(subagentRepoPath) || "Subagent workspace",
+        name: path37.basename(subagentRepoPath) || "Subagent workspace",
         description: null,
         visibility: "private",
         gitOwner: null,
@@ -36252,7 +36451,7 @@ function createWorkspaceSessionWorkflows(deps) {
       const workspacePath = session.cwd;
       const app2 = {
         id: localPathWorkspaceId(workspacePath),
-        name: path36.basename(workspacePath) || workspacePath,
+        name: path37.basename(workspacePath) || workspacePath,
         description: null,
         visibility: "private",
         gitOwner: null,
@@ -36881,9 +37080,9 @@ async function openTailscaleApp() {
 // ../server/src/voice-transcription.ts
 import { Buffer as Buffer12 } from "node:buffer";
 import { spawn as spawn5 } from "node:child_process";
-import { constants as fsConstants, promises as fs21 } from "node:fs";
+import { constants as fsConstants, promises as fs22 } from "node:fs";
 import os8 from "node:os";
-import path37 from "node:path";
+import path38 from "node:path";
 import { randomUUID as randomUUID13 } from "node:crypto";
 var DEFAULT_MODEL_NAME = "base.en";
 var MAX_AUDIO_BYTES = 32 * 1024 * 1024;
@@ -36893,7 +37092,7 @@ var MODEL_MAX_BYTES = 2 * 1024 * 1024 * 1024;
 var PROCESS_OUTPUT_MAX_CHARS = 64 * 1024;
 function createVoiceTranscriptionService(input) {
   const modelName = normalizedModelName(process.env.OPENPOND_WHISPER_MODEL_NAME);
-  const modelPath = process.env.OPENPOND_WHISPER_MODEL?.trim() || path37.join(input.storeDir, "voice-models", `ggml-${modelName}.bin`);
+  const modelPath = process.env.OPENPOND_WHISPER_MODEL?.trim() || path38.join(input.storeDir, "voice-models", `ggml-${modelName}.bin`);
   let modelDownload = null;
   const closeController = new AbortController();
   const activeProcesses = /* @__PURE__ */ new Set();
@@ -36950,13 +37149,13 @@ function createVoiceTranscriptionService(input) {
       throw new Error("Voice recording is too large. Keep dictation under two minutes.");
     }
     const selectedModelPath = await ensureModel();
-    const workDir = path37.join(input.storeDir, "tmp", "voice");
-    await fs21.mkdir(workDir, { recursive: true });
+    const workDir = path38.join(input.storeDir, "tmp", "voice");
+    await fs22.mkdir(workDir, { recursive: true });
     const id = randomUUID13();
-    const audioPath = path37.join(workDir, `${id}.wav`);
-    const outputPrefix = path37.join(workDir, id);
+    const audioPath = path38.join(workDir, `${id}.wav`);
+    const outputPrefix = path38.join(workDir, id);
     const outputTextPath = `${outputPrefix}.txt`;
-    await fs21.writeFile(audioPath, audio, { mode: 384 });
+    await fs22.writeFile(audioPath, audio, { mode: 384 });
     try {
       await runWhisper({
         audioPath,
@@ -36967,7 +37166,7 @@ function createVoiceTranscriptionService(input) {
         signal: closeController.signal,
         activeProcesses
       });
-      const outputFileText = await fs21.readFile(outputTextPath, "utf8").catch(() => "");
+      const outputFileText = await fs22.readFile(outputTextPath, "utf8").catch(() => "");
       const text3 = cleanWhisperText(outputFileText);
       if (!text3) throw new Error("No speech was detected.");
       return {
@@ -36979,8 +37178,8 @@ function createVoiceTranscriptionService(input) {
       };
     } finally {
       await Promise.all([
-        fs21.rm(audioPath, { force: true }),
-        fs21.rm(outputTextPath, { force: true })
+        fs22.rm(audioPath, { force: true }),
+        fs22.rm(outputTextPath, { force: true })
       ]);
     }
   }
@@ -37106,7 +37305,7 @@ function canDownloadDefaultModel() {
 }
 async function downloadDefaultModel(targetPath, modelName, logger, signal) {
   const url = `https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-${modelName}.bin`;
-  await fs21.mkdir(path37.dirname(targetPath), { recursive: true });
+  await fs22.mkdir(path38.dirname(targetPath), { recursive: true });
   const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
   logger.info("downloading whisper model", { modelName, targetPath });
   const response = await fetch(url, { signal });
@@ -37120,8 +37319,8 @@ async function downloadDefaultModel(targetPath, modelName, logger, signal) {
     minBytes: MODEL_MIN_BYTES,
     maxBytes: MODEL_MAX_BYTES
   });
-  await fs21.rename(tempPath, targetPath);
-  await fs21.chmod(targetPath, 384).catch(() => void 0);
+  await fs22.rename(tempPath, targetPath);
+  await fs22.chmod(targetPath, 384).catch(() => void 0);
   logger.info("whisper model downloaded", { modelName, targetPath, sizeBytes });
   return targetPath;
 }
@@ -37132,7 +37331,7 @@ async function streamVoiceModelResponseToFile(input) {
   }
   const reader = input.response.body?.getReader();
   if (!reader) throw new Error("Whisper model download did not return a response body.");
-  const file = await fs21.open(input.targetPath, "wx", 384);
+  const file = await fs22.open(input.targetPath, "wx", 384);
   let sizeBytes = 0;
   try {
     try {
@@ -37153,14 +37352,14 @@ async function streamVoiceModelResponseToFile(input) {
       await file.close();
     }
   } catch (error) {
-    await fs21.rm(input.targetPath, { force: true });
+    await fs22.rm(input.targetPath, { force: true });
     throw error;
   }
   if (sizeBytes < input.minBytes) {
-    await fs21.rm(input.targetPath, { force: true });
+    await fs22.rm(input.targetPath, { force: true });
     throw new Error("Downloaded Whisper model is incomplete.");
   }
-  await fs21.chmod(input.targetPath, 384).catch(() => void 0);
+  await fs22.chmod(input.targetPath, 384).catch(() => void 0);
   return sizeBytes;
 }
 async function resolveWhisperBinary() {
@@ -37177,22 +37376,22 @@ async function resolveWhisperBinary() {
     "/usr/bin/whisper-cpp"
   ];
   for (const candidate2 of candidates) {
-    const resolved = candidate2.includes(path37.sep) ? candidate2 : await findExecutableOnPath(candidate2);
+    const resolved = candidate2.includes(path38.sep) ? candidate2 : await findExecutableOnPath(candidate2);
     if (resolved && await executableExists2(resolved)) return resolved;
   }
   return null;
 }
 async function findExecutableOnPath(command) {
-  const paths = (process.env.PATH ?? "").split(path37.delimiter).filter(Boolean);
+  const paths = (process.env.PATH ?? "").split(path38.delimiter).filter(Boolean);
   for (const directory of paths) {
-    const candidate2 = path37.join(directory, command);
+    const candidate2 = path38.join(directory, command);
     if (await executableExists2(candidate2)) return candidate2;
   }
   return null;
 }
 async function executableExists2(filePath) {
   try {
-    await fs21.access(filePath, fsConstants.X_OK);
+    await fs22.access(filePath, fsConstants.X_OK);
     return true;
   } catch {
     return false;
@@ -37200,7 +37399,7 @@ async function executableExists2(filePath) {
 }
 async function fileExists4(filePath) {
   try {
-    await fs21.access(filePath);
+    await fs22.access(filePath);
     return true;
   } catch {
     return false;
@@ -37467,8 +37666,8 @@ function headerValue2(value) {
 var import_cron_parser = __toESM(require_dist(), 1);
 import { execFile as execFile6 } from "node:child_process";
 import { randomUUID as randomUUID15 } from "node:crypto";
-import { promises as fs22 } from "node:fs";
-import path38 from "node:path";
+import { promises as fs23 } from "node:fs";
+import path39 from "node:path";
 import { promisify as promisify4 } from "node:util";
 
 // ../server/src/agents/local-agent-scheduler-values.ts
@@ -37925,7 +38124,7 @@ function profileScheduleSourceId(profile, agentId) {
   }).slice(0, 20)}`;
 }
 function profileAgentRootPath(profileSourcePath, agent) {
-  return agent.id === "default" ? profileSourcePath : path38.resolve(profileSourcePath, agent.path);
+  return agent.id === "default" ? profileSourcePath : path39.resolve(profileSourcePath, agent.path);
 }
 async function pauseSchedulesForMissingSources(store, installedSourceIds) {
   const schedules = await store.listLocalAgentSchedules();
@@ -37958,7 +38157,7 @@ async function inspectAgentProject(agentRootPath) {
     agentRootPath,
     manifestHash ?? stableHash(manifest)
   );
-  const projectName = stringValue10(readPath(manifest, ["project", "name"])) ?? path38.basename(agentRootPath) ?? "local-agent";
+  const projectName = stringValue10(readPath(manifest, ["project", "name"])) ?? path39.basename(agentRootPath) ?? "local-agent";
   return {
     projectName,
     manifestHash,
@@ -38000,13 +38199,13 @@ async function runAgentAction(schedule, run, inputOverride) {
   const current = await inspectAgentProject(schedule.agentRootPath);
   assertLocalAgentScheduleVersion(schedule, current);
   const cli = await resolveOpenPondAgentCli(schedule.agentRootPath);
-  const runDir = path38.join(
+  const runDir = path39.join(
     schedule.agentRootPath,
     ".openpond",
     "local-scheduler"
   );
-  await fs22.mkdir(runDir, { recursive: true });
-  const inputPath = path38.join(runDir, `${run.id}.input.json`);
+  await fs23.mkdir(runDir, { recursive: true });
+  const inputPath = path39.join(runDir, `${run.id}.input.json`);
   const input = {
     channel: "schedule",
     ...schedule.input,
@@ -38020,9 +38219,9 @@ async function runAgentAction(schedule, run, inputOverride) {
       trigger: run.trigger
     }
   };
-  await fs22.writeFile(inputPath, `${JSON.stringify(input, null, 2)}
+  await fs23.writeFile(inputPath, `${JSON.stringify(input, null, 2)}
 `, "utf8");
-  const relativeInputPath = path38.relative(schedule.agentRootPath, inputPath);
+  const relativeInputPath = path39.relative(schedule.agentRootPath, inputPath);
   const executed = await runAgentCli(
     cli,
     [
@@ -38032,7 +38231,7 @@ async function runAgentAction(schedule, run, inputOverride) {
       "--cwd",
       schedule.agentRootPath,
       "--out-dir",
-      path38.join(".openpond", "local-scheduler", "artifacts"),
+      path39.join(".openpond", "local-scheduler", "artifacts"),
       "--input-file",
       relativeInputPath
     ],
@@ -38064,7 +38263,7 @@ function assertLocalAgentScheduleVersion(schedule, current) {
 async function runAgentCli(cliPath, args, cwd, timeoutMs) {
   const env = {
     ...process.env,
-    PATH: `${path38.dirname(cliPath)}${path38.delimiter}${process.env.PATH ?? ""}`
+    PATH: `${path39.dirname(cliPath)}${path39.delimiter}${process.env.PATH ?? ""}`
   };
   try {
     const result = await execFileAsync4(cliPath, args, {
@@ -38089,16 +38288,16 @@ async function runAgentCli(cliPath, args, cwd, timeoutMs) {
 }
 async function resolveOpenPondAgentCli(agentRootPath) {
   const override = process.env.OPENPOND_AGENT_CLI?.trim();
-  if (override) return path38.resolve(override);
+  if (override) return path39.resolve(override);
   const candidates = [];
   for (const basePath of ancestorPaths(agentRootPath)) {
     candidates.push(
-      path38.join(basePath, "node_modules", ".bin", "openpond-agent")
+      path39.join(basePath, "node_modules", ".bin", "openpond-agent")
     );
   }
   for (const basePath of ancestorPaths(process.cwd())) {
     candidates.push(
-      path38.join(basePath, "node_modules", ".bin", "openpond-agent")
+      path39.join(basePath, "node_modules", ".bin", "openpond-agent")
     );
   }
   const seen = /* @__PURE__ */ new Set();
@@ -38111,17 +38310,17 @@ async function resolveOpenPondAgentCli(agentRootPath) {
 }
 function ancestorPaths(startPath) {
   const paths = [];
-  let current = path38.resolve(startPath);
+  let current = path39.resolve(startPath);
   while (true) {
     paths.push(current);
-    const parent = path38.dirname(current);
+    const parent = path39.dirname(current);
     if (parent === current) return paths;
     current = parent;
   }
 }
 async function fileExists5(filePath) {
   try {
-    const stat7 = await fs22.stat(filePath);
+    const stat7 = await fs23.stat(filePath);
     return stat7.isFile() || stat7.isSymbolicLink();
   } catch {
     return false;
@@ -38290,11 +38489,11 @@ async function teamChatRequestPayload(action, dependencies = {}) {
   const payload = await requestTeamChatApi(request.path, request.init, dependencies);
   return schemaForAction2(action).parse(payload);
 }
-async function requestTeamChatApi(path63, init = {}, dependencies = {}) {
+async function requestTeamChatApi(path64, init = {}, dependencies = {}) {
   const access5 = await resolveHostedApiAccess(dependencies);
   const headers = hostedApiAuthHeaders(access5.token);
   headers.set("Content-Type", "application/json");
-  const response = await (dependencies.fetchImpl ?? fetch)(`${access5.apiBaseUrl}${path63}`, {
+  const response = await (dependencies.fetchImpl ?? fetch)(`${access5.apiBaseUrl}${path64}`, {
     ...init,
     headers
   });
@@ -38526,11 +38725,11 @@ async function uploadTeamChatAttachment(action, dependencies) {
     )
   );
 }
-function post2(path63, body) {
-  return jsonRequest2(path63, "POST", body);
+function post2(path64, body) {
+  return jsonRequest2(path64, "POST", body);
 }
-function jsonRequest2(path63, method, body) {
-  return { path: path63, init: { method, body: JSON.stringify(body) } };
+function jsonRequest2(path64, method, body) {
+  return { path: path64, init: { method, body: JSON.stringify(body) } };
 }
 
 // ../server/src/openpond/team-chat-executor.ts
@@ -39309,13 +39508,13 @@ function createTaskMinerBackgroundLoop(input) {
 
 // ../server/src/training/training-service.ts
 import { access as access2, cp, mkdir as mkdir8, rename as rename2, rm as rm3 } from "node:fs/promises";
-import path53 from "node:path";
+import path54 from "node:path";
 
 // ../../packages/training-sdk/dist/bundle.js
 import { createHash as createHash10 } from "node:crypto";
 import { createReadStream as createReadStream6 } from "node:fs";
 import { copyFile, mkdir as mkdir3, readFile as readFile5, stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
-import path39 from "node:path";
+import path40 from "node:path";
 async function buildTrainingBundle(input) {
   if (!input.plan.compatibility.compatible)
     throw new Error("Training Plan is incompatible and cannot be bundled.");
@@ -39359,8 +39558,8 @@ async function buildTrainingBundle(input) {
     sizeBytes: taskData.sizeBytes,
     role: "task_data"
   }];
-  const taskDataDestination = path39.join(input.directory, "data/train.jsonl");
-  await mkdir3(path39.dirname(taskDataDestination), { recursive: true });
+  const taskDataDestination = path40.join(input.directory, "data/train.jsonl");
+  await mkdir3(path40.dirname(taskDataDestination), { recursive: true });
   if ("sourcePath" in taskData) {
     await copyFile(taskData.sourcePath, taskDataDestination);
   } else {
@@ -39374,8 +39573,8 @@ async function buildTrainingBundle(input) {
     throw new Error("Projected training data changed while the Bundle was created.");
   }
   for (const asset of assets) {
-    const destination = path39.join(input.directory, asset.path);
-    await mkdir3(path39.dirname(destination), { recursive: true });
+    const destination = path40.join(input.directory, asset.path);
+    await mkdir3(path40.dirname(destination), { recursive: true });
     await writeFile2(destination, asset.content, "utf8");
     files.push({ path: asset.path, sha256: sha256(asset.content), sizeBytes: Buffer.byteLength(asset.content), role: asset.role });
   }
@@ -39384,7 +39583,7 @@ async function buildTrainingBundle(input) {
   const provisional = TrainingBundleManifestSchema.parse(base);
   const manifestHash = contentHash({ ...provisional, contentHash: "", files: provisional.files.map((file) => file.path === "manifest.json" ? { ...file, sha256: "", sizeBytes: 0 } : file) });
   const manifest = TrainingBundleManifestSchema.parse({ ...provisional, contentHash: manifestHash, files: provisional.files.map((file) => file.path === "manifest.json" ? { ...file, sha256: manifestHash, sizeBytes: 0 } : file) });
-  await writeFile2(path39.join(input.directory, "manifest.json"), canonicalJson(manifest), "utf8");
+  await writeFile2(path40.join(input.directory, "manifest.json"), canonicalJson(manifest), "utf8");
   return manifest;
 }
 function inlineTrainingData(taskset, plan, approvedSources) {
@@ -39458,7 +39657,7 @@ async function fileIdentity(filePath) {
   };
 }
 async function inspectTrainingBundle(directory) {
-  return TrainingBundleManifestSchema.parse(JSON.parse(await readFile5(path39.join(directory, "manifest.json"), "utf8")));
+  return TrainingBundleManifestSchema.parse(JSON.parse(await readFile5(path40.join(directory, "manifest.json"), "utf8")));
 }
 async function validateTrainingBundle(directory) {
   const manifest = await inspectTrainingBundle(directory);
@@ -39467,7 +39666,7 @@ async function validateTrainingBundle(directory) {
     if (file.path === "manifest.json")
       continue;
     try {
-      const bytes2 = await readFile5(path39.join(directory, file.path));
+      const bytes2 = await readFile5(path40.join(directory, file.path));
       if (sha256(bytes2) !== file.sha256)
         issues.push(`${file.path}: hash mismatch`);
       if (bytes2.byteLength !== file.sizeBytes)
@@ -39483,7 +39682,7 @@ async function validateTrainingBundle(directory) {
 
 // ../../packages/training-sdk/dist/bundle-export.js
 import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
-import path40 from "node:path";
+import path41 from "node:path";
 async function createTrainingBundleExport(directory) {
   const validation = await validateTrainingBundle(directory);
   if (!validation.valid)
@@ -39492,7 +39691,7 @@ async function createTrainingBundleExport(directory) {
   const files = [];
   for (const item of manifest.files) {
     const relative2 = safeRelativePath(item.path);
-    const bytes2 = await readFile6(path40.join(directory, relative2));
+    const bytes2 = await readFile6(path41.join(directory, relative2));
     files.push({ path: relative2, sha256: sha256(bytes2), sizeBytes: bytes2.byteLength, encoding: "base64", content: bytes2.toString("base64") });
   }
   const base = { schemaVersion: "openpond.trainingBundleExport.v1", manifest, files, contentHash: "00000000" };
@@ -39500,7 +39699,7 @@ async function createTrainingBundleExport(directory) {
 }
 function safeRelativePath(value) {
   const normalized = value.replaceAll("\\", "/");
-  if (path40.posix.isAbsolute(normalized) || normalized.split("/").includes(".."))
+  if (path41.posix.isAbsolute(normalized) || normalized.split("/").includes(".."))
     throw new Error(`Unsafe Training Bundle path: ${value}.`);
   return normalized;
 }
@@ -39903,7 +40102,7 @@ function prepareTrainingSelection(input) {
 import { constants as constants2 } from "node:fs";
 import { randomUUID as randomUUID17 } from "node:crypto";
 import { access, lstat, mkdir as mkdir5, readFile as readFile7, readdir as readdir2, rename, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
-import path41 from "node:path";
+import path42 from "node:path";
 function buildTasksetTrainingBundle(input) {
   const { taskset, modelRun, harnessRelease, tasksetRelease } = input;
   const releasedHarness2 = ImmutableReleaseRefSchema2.parse(harnessRelease);
@@ -40041,13 +40240,13 @@ function buildTasksetTrainingBundle(input) {
 async function materializeResolvedTrainingBundle(input) {
   const manifest = ResolvedTrainingBundleManifestSchema.parse(input.manifest);
   validateBundleManifest(manifest);
-  const directory = path41.join(input.cacheRoot, manifest.contentHash);
-  if (await exists(path41.join(directory, "bundle-manifest.json"))) {
+  const directory = path42.join(input.cacheRoot, manifest.contentHash);
+  if (await exists(path42.join(directory, "bundle-manifest.json"))) {
     await verifyResolvedTrainingBundle(directory, manifest);
     return { directory, manifest, cacheHit: true };
   }
   await mkdir5(input.cacheRoot, { recursive: true });
-  const temporary = path41.join(input.cacheRoot, `.materializing-${manifest.contentHash}-${process.pid}-${randomUUID17()}`);
+  const temporary = path42.join(input.cacheRoot, `.materializing-${manifest.contentHash}-${process.pid}-${randomUUID17()}`);
   await mkdir5(temporary, { recursive: true, mode: 448 });
   try {
     for (const file of manifest.files) {
@@ -40056,10 +40255,10 @@ async function materializeResolvedTrainingBundle(input) {
         throw new Error(`Resolved Training Bundle asset ${file.path} failed verification.`);
       }
       const target = bundleAssetPath(temporary, file.path);
-      await mkdir5(path41.dirname(target), { recursive: true });
+      await mkdir5(path42.dirname(target), { recursive: true });
       await writeFile4(target, value, { mode: 384 });
     }
-    await writeFile4(path41.join(temporary, "bundle-manifest.json"), canonicalJson(manifest), { mode: 384 });
+    await writeFile4(path42.join(temporary, "bundle-manifest.json"), canonicalJson(manifest), { mode: 384 });
     await rename(temporary, directory).catch(async (error) => {
       if (!await exists(directory))
         throw error;
@@ -40071,7 +40270,7 @@ async function materializeResolvedTrainingBundle(input) {
   }
 }
 async function verifyResolvedTrainingBundle(directory, expected) {
-  const manifest = ResolvedTrainingBundleManifestSchema.parse(JSON.parse(await readFile7(path41.join(directory, "bundle-manifest.json"), "utf8")));
+  const manifest = ResolvedTrainingBundleManifestSchema.parse(JSON.parse(await readFile7(path42.join(directory, "bundle-manifest.json"), "utf8")));
   const { contentHash: suppliedHash, ...content } = manifest;
   if (contentHash(content) !== suppliedHash) {
     throw new Error("Resolved Training Bundle manifest hash mismatch.");
@@ -40113,13 +40312,13 @@ function validateBundleManifest(manifest) {
   }
 }
 function bundleAssetPath(root, assetPath) {
-  if (assetPath.includes("\\") || assetPath.includes("\0") || path41.posix.isAbsolute(assetPath) || path41.posix.normalize(assetPath) !== assetPath) {
+  if (assetPath.includes("\\") || assetPath.includes("\0") || path42.posix.isAbsolute(assetPath) || path42.posix.normalize(assetPath) !== assetPath) {
     throw new Error(`Resolved Training Bundle asset ${assetPath} has an invalid path.`);
   }
-  const resolvedRoot = path41.resolve(root);
-  const target = path41.resolve(root, ...assetPath.split("/"));
-  const relative2 = path41.relative(resolvedRoot, target);
-  if (relative2.startsWith("..") || path41.isAbsolute(relative2) || relative2 === "") {
+  const resolvedRoot = path42.resolve(root);
+  const target = path42.resolve(root, ...assetPath.split("/"));
+  const relative2 = path42.relative(resolvedRoot, target);
+  if (relative2.startsWith("..") || path42.isAbsolute(relative2) || relative2 === "") {
     throw new Error(`Resolved Training Bundle asset ${assetPath} escapes its root.`);
   }
   return target;
@@ -40132,8 +40331,8 @@ async function assertExactInventory(directory, expected) {
   const actual = /* @__PURE__ */ new Set();
   const visit = async (current) => {
     for (const entry of await readdir2(current, { withFileTypes: true })) {
-      const target = path41.join(current, entry.name);
-      const relative2 = path41.relative(directory, target).split(path41.sep).join("/");
+      const target = path42.join(current, entry.name);
+      const relative2 = path42.relative(directory, target).split(path42.sep).join("/");
       if (entry.isSymbolicLink()) {
         throw new Error(`Resolved Training Bundle contains a symbolic link at ${relative2}.`);
       }
@@ -40333,7 +40532,7 @@ function modelLabel(modelId) {
 }
 
 // ../server/src/training/training-dataset-selection.ts
-import path42 from "node:path";
+import path43 from "node:path";
 function toProjectedTrainingData(projection) {
   return projection ? {
     path: projection.outputPath,
@@ -40368,7 +40567,7 @@ function createTrainingDatasetSelection(input) {
       seed,
       selectionStrategy: plan.recipe.method === "grpo" ? plan.recipe.dataset.selectionStrategy : "stable_hash_top_n",
       approvedSourceIds: plan.dataPolicy.approvedSourceIds,
-      outputPath: path42.join(
+      outputPath: path43.join(
         input.storeDir,
         "training",
         "projections",
@@ -40382,7 +40581,7 @@ function createTrainingDatasetSelection(input) {
 
 // ../server/src/training/training-service-helpers.ts
 import { readFile as readFile8 } from "node:fs/promises";
-import path43 from "node:path";
+import path44 from "node:path";
 function withAuthoritativeRecipeHashes(taskset, recipe) {
   if (!recipe || typeof recipe !== "object" || Array.isArray(recipe)) {
     return recipe;
@@ -40530,8 +40729,8 @@ function positiveInteger(value, fallback) {
   return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
 }
 function isInside(root, target) {
-  const relative2 = path43.relative(root, target);
-  return relative2 !== "" && !relative2.startsWith("..") && !path43.isAbsolute(relative2);
+  const relative2 = path44.relative(root, target);
+  return relative2 !== "" && !relative2.startsWith("..") && !path44.isAbsolute(relative2);
 }
 async function assertArtifactIntegrity(artifactPath2, expectedHash, expectedSize) {
   const bytes2 = await readFile8(artifactPath2);
@@ -40544,14 +40743,14 @@ async function assertArtifactIntegrity(artifactPath2, expectedHash, expectedSize
 
 // ../server/src/training/openpond-managed-training-adapter.ts
 import { readFile as readFile10 } from "node:fs/promises";
-import path47 from "node:path";
+import path48 from "node:path";
 
 // ../server/src/training/managed-rl-local-rollout-executor.ts
 import { randomUUID as randomUUID18 } from "node:crypto";
 
 // ../server/src/training/marketing-portfolio-managed-rl-adapter.ts
 import { createHash as createHash12 } from "node:crypto";
-import path46 from "node:path";
+import path47 from "node:path";
 
 // ../server/src/training/marketing-portfolio-constraint-repair.ts
 var CHANNEL_IDS = [
@@ -40994,7 +41193,7 @@ function declaredEnvironmentId(taskset) {
 
 // ../server/src/training/marketing-portfolio-runtime-verifier.ts
 import { readFile as readFile9, readdir as readdir3 } from "node:fs/promises";
-import path44 from "node:path";
+import path45 from "node:path";
 var AGENT_ID = "marketing-portfolio-manager";
 var ACTION_IDS = [
   "get-portfolio-snapshot",
@@ -41013,13 +41212,13 @@ async function verifyMarketingPortfolioRuntime(input) {
     scorer.profileRelativeAgentPath,
     "marketing Harness Agent path"
   );
-  const profileRoot = path44.resolve(input.harnessRoot);
-  const agentRoot = path44.resolve(profileRoot, relativeAgentPath);
-  const relative2 = path44.relative(profileRoot, agentRoot);
-  if (relative2.startsWith("..") || path44.isAbsolute(relative2)) {
+  const profileRoot = path45.resolve(input.harnessRoot);
+  const agentRoot = path45.resolve(profileRoot, relativeAgentPath);
+  const relative2 = path45.relative(profileRoot, agentRoot);
+  if (relative2.startsWith("..") || path45.isAbsolute(relative2)) {
     throw new Error("Pinned marketing Agent source escapes the Harness bundle.");
   }
-  const manifestPath = path44.join(agentRoot, ".openpond", "agent-manifest.json");
+  const manifestPath = path45.join(agentRoot, ".openpond", "agent-manifest.json");
   const manifestBytes = await readFile9(manifestPath);
   const manifest = object2(
     JSON.parse(manifestBytes.toString("utf8")),
@@ -41070,9 +41269,9 @@ async function verifyMarketingPortfolioRuntime(input) {
     }
   }
   const scorerModule = requiredString4(scorer.module, "marketing scorer module");
-  const scorerModulePath = path44.resolve(agentRoot, scorerModule);
-  const relativeScorer = path44.relative(agentRoot, scorerModulePath);
-  if (relativeScorer.startsWith("..") || path44.isAbsolute(relativeScorer)) {
+  const scorerModulePath = path45.resolve(agentRoot, scorerModule);
+  const relativeScorer = path45.relative(agentRoot, scorerModulePath);
+  if (relativeScorer.startsWith("..") || path45.isAbsolute(relativeScorer)) {
     throw new Error("Pinned marketing scorer escapes the Agent release.");
   }
   const scorerImplementationHash = sha256(await readFile9(scorerModulePath));
@@ -41098,7 +41297,7 @@ function withoutEpisodeSelector(schema, selector) {
 async function agentReleaseInventory(root) {
   const inventory = [];
   for (const file of await regularFiles(root)) {
-    const relative2 = path44.relative(root, file).split(path44.sep).join("/");
+    const relative2 = path45.relative(root, file).split(path45.sep).join("/");
     if (relative2.startsWith("node_modules/") || relative2.startsWith(".openpond/traces/") || relative2 === ".openpond/eval-results.json") {
       continue;
     }
@@ -41117,7 +41316,7 @@ async function regularFiles(root) {
     if (entry.isSymbolicLink()) {
       throw new Error("Harness Agent releases cannot contain symlinks.");
     }
-    const target = path44.join(root, entry.name);
+    const target = path45.join(root, entry.name);
     if (entry.isDirectory()) {
       if (entry.name !== "node_modules") files.push(...await regularFiles(target));
     } else if (entry.isFile()) {
@@ -41146,14 +41345,14 @@ function requiredString4(value, label) {
 // ../server/src/training/profile-agent-harness-runtime.ts
 import { spawn as spawn6 } from "node:child_process";
 import { mkdir as mkdir6 } from "node:fs/promises";
-import path45 from "node:path";
+import path46 from "node:path";
 var MAX_PROCESS_OUTPUT_BYTES = 4 * 1024 * 1024;
 var SCORER_SCRIPT = "const moduleValue=await import(process.argv[1]);const decision=JSON.parse(Buffer.from(process.argv[2],'base64url').toString('utf8'));const score=moduleValue.scoreBudgetDecision(decision);process.stdout.write(JSON.stringify(score));";
 function createProfileAgentHarnessRuntime(input) {
   const nodePath2 = input.nodePath ?? process.execPath;
-  const agentCliPath = input.agentCliPath ?? path45.resolve(process.cwd(), "node_modules", ".bin", "openpond-agent");
+  const agentCliPath = input.agentCliPath ?? path46.resolve(process.cwd(), "node_modules", ".bin", "openpond-agent");
   async function executeAction2(action) {
-    const actionArtifactRoot = path45.join(
+    const actionArtifactRoot = path46.join(
       input.artifactRoot,
       "agent-actions",
       `${action.binding.actionId}-${contentHash(action.arguments).slice(0, 16)}`
@@ -41240,7 +41439,7 @@ async function runBoundedProcess(input) {
       size += chunk.byteLength;
       if (size > MAX_PROCESS_OUTPUT_BYTES) {
         child.kill("SIGKILL");
-        fail2(new Error(`${path45.basename(input.command)} output exceeded its limit.`));
+        fail2(new Error(`${path46.basename(input.command)} output exceeded its limit.`));
       } else {
         target.push(chunk);
       }
@@ -41255,7 +41454,7 @@ async function runBoundedProcess(input) {
       if (code !== 0) {
         fail2(
           new Error(
-            `${path45.basename(input.command)} failed ${signal ? `with ${signal}` : `with exit code ${code}`}: ${err.slice(0, 2e3)}`
+            `${path46.basename(input.command)} failed ${signal ? `with ${signal}` : `with exit code ${code}`}: ${err.slice(0, 2e3)}`
           )
         );
       } else {
@@ -41310,7 +41509,7 @@ async function executeMarketingPortfolioManagedRl(input) {
   const runtime = createProfileAgentHarnessRuntime({
     agentRoot: verified.agentRoot,
     scorerModulePath: verified.scorerModulePath,
-    artifactRoot: path46.join(input.storeDir, "training", "managed-rl-local", input.claim.jobId, input.claim.executionId)
+    artifactRoot: path47.join(input.storeDir, "training", "managed-rl-local", input.claim.jobId, input.claim.executionId)
   });
   const baseSeed = typeof input.claim.request.seed === "number" && Number.isInteger(input.claim.request.seed) ? input.claim.request.seed : 0;
   const startedAt = (input.timestamp ?? (() => (/* @__PURE__ */ new Date()).toISOString()))();
@@ -41599,25 +41798,25 @@ var ManagedRlLocalRolloutExecutor = class {
     }
     throw lastError;
   }
-  async userRequest(path63, init) {
+  async userRequest(path64, init) {
     const headers = hostedApiAuthHeaders(this.input.access.token);
     headers.set("accept", "application/json");
     headers.set("content-type", "application/json");
     headers.set("x-openpond-team-id", this.input.access.teamId);
-    const requestUrl = `${this.input.access.apiBaseUrl}${path63}`;
+    const requestUrl = `${this.input.access.apiBaseUrl}${path64}`;
     return requestJson(this.input.fetchImpl ?? fetch, requestUrl, {
       ...init,
       headers: withVercelProtectionBypass(requestUrl, headers, this.input.env),
       signal: this.abortController.signal
     });
   }
-  policyRequest(path63, token, request, signal = this.abortController.signal) {
+  policyRequest(path64, token, request, signal = this.abortController.signal) {
     const headers = new Headers({
       accept: "application/json",
       authorization: `Bearer ${token}`,
       "content-type": "application/json"
     });
-    const requestUrl = `${this.input.access.apiBaseUrl}${path63}`;
+    const requestUrl = `${this.input.access.apiBaseUrl}${path64}`;
     return requestJson(
       this.input.fetchImpl ?? fetch,
       requestUrl,
@@ -42210,7 +42409,7 @@ var OpenPondManagedTrainingAdapter = class {
     if (validationTasks.length === 0) {
       throw new Error("OpenPond Managed requires at least one private validation task.");
     }
-    const bundleDirectory = path47.join(
+    const bundleDirectory = path48.join(
       this.dependencies.storeDir,
       "training",
       "portable-releases",
@@ -42218,14 +42417,14 @@ var OpenPondManagedTrainingAdapter = class {
       plan.manifest.resolvedBundleHash
     );
     const bundleManifest = JSON.parse(
-      await this.readFileImpl(path47.join(bundleDirectory, "bundle-manifest.json"), "utf8")
+      await this.readFileImpl(path48.join(bundleDirectory, "bundle-manifest.json"), "utf8")
     );
     if (bundleManifest.contentHash !== plan.manifest.resolvedBundleHash) {
       throw new Error("The managed resolved bundle changed before upload.");
     }
     const files = await Promise.all(
       bundleManifest.files.map(async (file) => {
-        const value = await this.readFileImpl(path47.join(bundleDirectory, file.path));
+        const value = await this.readFileImpl(path48.join(bundleDirectory, file.path));
         if (value.byteLength !== file.sizeBytes || sha256(value) !== file.sha256) {
           throw new Error(`Managed training bundle file ${file.path} changed before upload.`);
         }
@@ -42427,7 +42626,7 @@ var OpenPondManagedTrainingAdapter = class {
       env: this.dependencies.env,
       store: this.dependencies.store,
       storeDir: this.dependencies.storeDir,
-      harnessRoot: path47.join(
+      harnessRoot: path48.join(
         this.dependencies.storeDir,
         "training",
         "harnesses",
@@ -42501,11 +42700,11 @@ function createDestinationTrainingEngineRegistry(input) {
 
 // ../server/src/training/portable-model-run-service.ts
 import { mkdir as mkdir7, readFile as readFile12, writeFile as writeFile5 } from "node:fs/promises";
-import path50 from "node:path";
+import path51 from "node:path";
 
 // ../server/src/training/portable-model-run-artifacts.ts
 import { readFile as readFile11, stat as stat6 } from "node:fs/promises";
-import path48 from "node:path";
+import path49 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 async function importPortableModelRunArtifacts(input) {
   assertArtifacts(input.portable, input.executionRef, input.job);
@@ -42549,7 +42748,7 @@ async function importPortableModelRunArtifacts(input) {
   };
 }
 async function readRecoveredPortableArtifacts(input) {
-  const receipt = path48.join(
+  const receipt = path49.join(
     input.storeDir,
     "training",
     "connected-artifacts",
@@ -42654,7 +42853,7 @@ function localArtifactPath(objectRef) {
   if (/^[a-z][a-z0-9+.-]*:/i.test(objectRef)) {
     throw new Error(`Portable artifact ${objectRef} was not materialized locally.`);
   }
-  return path48.resolve(objectRef);
+  return path49.resolve(objectRef);
 }
 function managedRlCandidateRef(objectRef, expectedJobId) {
   const match = objectRef.match(/^sandbox-managed-rl:\/\/([^/]+)\/([^/?#]+)$/);
@@ -42688,15 +42887,15 @@ function portableFilenameFromRef(objectRef) {
   return basename.match(/^\d+-[a-f0-9]{12}-(.+)$/)?.[1] ?? basename;
 }
 function portableFilename(value) {
-  return typeof value === "string" && value.trim() ? path48.basename(value.replaceAll("\\", "/")) : null;
+  return typeof value === "string" && value.trim() ? path49.basename(value.replaceAll("\\", "/")) : null;
 }
 function isAdapterWeights(name) {
-  const filename = path48.basename(name.replaceAll("\\", "/"));
+  const filename = path49.basename(name.replaceAll("\\", "/"));
   return filename === "adapter_model.safetensors" || /^adapter_model-\d{5}-of-\d{5}\.safetensors$/.test(filename);
 }
 function trainingArtifactKind(kind, filename) {
   if (isAdapterWeights(filename)) return "adapter";
-  if (path48.basename(filename) === "adapter_config.json") {
+  if (path49.basename(filename) === "adapter_config.json") {
     return "manifest";
   }
   if (kind === "trace") return "log";
@@ -42714,7 +42913,7 @@ function objectValue(value) {
 }
 
 // ../server/src/training/portable-model-run-lifecycle.ts
-import path49 from "node:path";
+import path50 from "node:path";
 async function preparePortableModelRunLifecycle(input) {
   const baseModel = input.draft.baseModel;
   const method = input.draft.method;
@@ -43109,9 +43308,9 @@ function jobStatus(state) {
   return state;
 }
 function artifactReceiptPath(storeDir, artifactPath2) {
-  const relative2 = path49.relative(storeDir, artifactPath2);
-  if (relative2 && relative2 !== ".." && !relative2.startsWith(`..${path49.sep}`) && !path49.isAbsolute(relative2)) {
-    return relative2.split(path49.sep).join("/");
+  const relative2 = path50.relative(storeDir, artifactPath2);
+  if (relative2 && relative2 !== ".." && !relative2.startsWith(`..${path50.sep}`) && !path50.isAbsolute(relative2)) {
+    return relative2.split(path50.sep).join("/");
   }
   return artifactPath2;
 }
@@ -43882,9 +44081,9 @@ function assertSubmittedManifest(input, expected) {
   }
 }
 async function publishRunGraph(input) {
-  const manifestDirectory = path50.join(input.storeDir, "training", "portable-releases", "manifests");
+  const manifestDirectory = path51.join(input.storeDir, "training", "portable-releases", "manifests");
   await mkdir7(manifestDirectory, { recursive: true });
-  const manifestPath = path50.join(manifestDirectory, `${input.graph.manifest.contentHash}.json`);
+  const manifestPath = path51.join(manifestDirectory, `${input.graph.manifest.contentHash}.json`);
   const serialized = `${JSON.stringify(input.graph.manifest, null, 2)}
 `;
   await writeFile5(manifestPath, serialized, {
@@ -43899,7 +44098,7 @@ async function publishRunGraph(input) {
   const resolvedBundle = await materializeResolvedTrainingBundle({
     manifest: input.graph.resolvedBundleManifest,
     assets: input.graph.assets,
-    cacheRoot: path50.join(input.storeDir, "training", "portable-releases", "resolved-bundles")
+    cacheRoot: path51.join(input.storeDir, "training", "portable-releases", "resolved-bundles")
   });
   if (resolvedBundle.manifest.contentHash !== input.graph.manifest.resolvedBundleHash) {
     throw new Error("Resolved Training Bundle does not match the Harness Run Manifest.");
@@ -43988,12 +44187,12 @@ function createPortableTrainingServiceSupport(input) {
 
 // ../server/src/training/training-artifact-export-service.ts
 import { readFile as readFile13 } from "node:fs/promises";
-import path51 from "node:path";
+import path52 from "node:path";
 function createTrainingArtifactExportService(deps) {
   async function exportBundle(bundleId) {
     const bundle = await deps.store.getTrainingBundle(bundleId);
     if (!bundle) throw new Error("Training Bundle not found.");
-    const directory = path51.join(
+    const directory = path52.join(
       deps.storeDir,
       "training",
       "bundles",
@@ -44484,7 +44683,7 @@ function createTrainingModelBindingService(deps) {
 }
 
 // ../server/src/training/training-plan-lifecycle-service.ts
-import path52 from "node:path";
+import path53 from "node:path";
 function createTrainingPlanLifecycleService(deps) {
   async function createPlan(input) {
     const taskset = await deps.store.getTaskset(input.tasksetId);
@@ -44542,7 +44741,7 @@ function createTrainingPlanLifecycleService(deps) {
     if (!plan) throw new Error("Training Plan not found.");
     const taskset = await deps.store.getTaskset(plan.tasksetId);
     if (!taskset) throw new Error("Taskset not found.");
-    const directory = path52.join(
+    const directory = path53.join(
       deps.storeDir,
       "training",
       "bundles",
@@ -44832,13 +45031,13 @@ function createTrainingService(deps) {
     const activeJob = relatedJobs.find((job) => ["queued", "starting", "running", "cancelling", "reconciling"].includes(job.status));
     if (activeJob) throw new Error("Cancel the active training job before deleting this model.");
     const jobIds = new Set(relatedJobs.map((job) => job.id));
-    const managedTrainingRoot = path53.resolve(deps.storeDir, "training");
+    const managedTrainingRoot = path54.resolve(deps.storeDir, "training");
     for (const artifact of artifacts.filter((artifact2) => jobIds.has(artifact2.jobId))) {
-      const artifactPath2 = path53.resolve(artifact.path);
+      const artifactPath2 = path54.resolve(artifact.path);
       if (isInside(managedTrainingRoot, artifactPath2)) await rm3(artifactPath2, { force: true, recursive: true });
     }
-    for (const planId of planIds) await rm3(path53.join(managedTrainingRoot, "bundles", planId), { force: true, recursive: true });
-    await rm3(path53.join(managedTrainingRoot, "tasksets", taskset.id), { force: true, recursive: true });
+    for (const planId of planIds) await rm3(path54.join(managedTrainingRoot, "bundles", planId), { force: true, recursive: true });
+    await rm3(path54.join(managedTrainingRoot, "tasksets", taskset.id), { force: true, recursive: true });
     await deps.store.deleteTasksetData(tasksetId);
     return { deleted: true, tasksetId };
   }
@@ -44982,7 +45181,7 @@ function createTrainingService(deps) {
   };
 }
 async function materializeHarnessSource(input) {
-  const root = path53.join(
+  const root = path54.join(
     input.storeDir,
     "training",
     "harnesses",
@@ -44994,11 +45193,11 @@ async function materializeHarnessSource(input) {
     return;
   } catch {
   }
-  await mkdir8(path53.dirname(root), { recursive: true });
+  await mkdir8(path54.dirname(root), { recursive: true });
   const temporary = `${root}.materializing-${process.pid}`;
   await rm3(temporary, { recursive: true, force: true });
   try {
-    await cp(path53.resolve(input.sourcePath), temporary, {
+    await cp(path54.resolve(input.sourcePath), temporary, {
       recursive: true,
       force: false,
       errorOnExist: true
@@ -47083,7 +47282,7 @@ function yieldToRuntime() {
 // ../server/src/training/dataset-artifact-service.ts
 import { spawn as spawn7 } from "node:child_process";
 import { access as access3 } from "node:fs/promises";
-import path54 from "node:path";
+import path55 from "node:path";
 var MAX_WORKER_OUTPUT_BYTES = 12 * 1024 * 1024;
 function createDatasetArtifactService(deps) {
   async function summaries(profileId) {
@@ -47192,7 +47391,7 @@ function createDatasetArtifactService(deps) {
       entry.relativeManifestPath
     );
     await access3(manifestPath);
-    const outputPath = path54.resolve(input.outputPath);
+    const outputPath = path55.resolve(input.outputPath);
     const output = await runDatasetWorker(deps.workerProjectDir, [
       "project",
       "--manifest",
@@ -47283,9 +47482,9 @@ async function summary(entry) {
   });
 }
 function safeArtifactPath(rootValue, relativeValue) {
-  const root = path54.resolve(rootValue);
-  const candidate2 = path54.resolve(root, relativeValue);
-  if (candidate2 !== root && !candidate2.startsWith(`${root}${path54.sep}`)) {
+  const root = path55.resolve(rootValue);
+  const candidate2 = path55.resolve(root, relativeValue);
+  if (candidate2 !== root && !candidate2.startsWith(`${root}${path55.sep}`)) {
     throw new Error("Dataset artifact path escapes its registered storage root.");
   }
   return candidate2;
@@ -47362,7 +47561,7 @@ import {
   rm as rm5,
   writeFile as writeFile6
 } from "node:fs/promises";
-import path55 from "node:path";
+import path56 from "node:path";
 
 // ../server/src/training/dataset-imports/hugging-face.ts
 import { randomUUID as randomUUID20 } from "node:crypto";
@@ -47500,8 +47699,8 @@ ${split.split}`) ?? {
     inspectedAt: (/* @__PURE__ */ new Date()).toISOString(),
     metadata: {
       sourceSchemaHash: contentHash(
-        columns.map(({ path: path63, logicalType: logicalType2, nullable }) => ({
-          path: path63,
+        columns.map(({ path: path64, logicalType: logicalType2, nullable }) => ({
+          path: path64,
           logicalType: logicalType2,
           nullable
         }))
@@ -47550,10 +47749,10 @@ function parquetSourceFile(value, repositoryId, revision) {
   if (item?.dataset !== repositoryId || typeof item.config !== "string" || typeof item.split !== "string" || typeof item.filename !== "string" || !item.filename.toLowerCase().endsWith(".parquet")) {
     return [];
   }
-  const path63 = [item.config, item.split, item.filename].flatMap((segment) => segment.split("/")).map((segment) => segment.trim()).filter(Boolean).join("/");
-  if (!path63 || path63.split("/").includes("..")) return [];
+  const path64 = [item.config, item.split, item.filename].flatMap((segment) => segment.split("/")).map((segment) => segment.trim()).filter(Boolean).join("/");
+  if (!path64 || path64.split("/").includes("..")) return [];
   return [{
-    path: path63,
+    path: path64,
     configuration: item.config,
     split: item.split,
     revision,
@@ -47626,8 +47825,8 @@ function sourceColumns(features, rows) {
       });
     }
   }
-  return [...paths.entries()].map(([path63, value]) => ({
-    path: path63,
+  return [...paths.entries()].map(([path64, value]) => ({
+    path: path64,
     logicalType: value.type,
     nullable: value.nullable,
     sampleValues: value.values.slice(0, 5)
@@ -47645,21 +47844,21 @@ function flattenRecord(value, prefix, paths, rows) {
     return;
   }
   for (const [key, child] of Object.entries(value)) {
-    const path63 = prefix ? `${prefix}.${key}` : key;
+    const path64 = prefix ? `${prefix}.${key}` : key;
     if (child && typeof child === "object" && !Array.isArray(child)) {
-      flattenRecord(child, path63, paths, rows);
+      flattenRecord(child, path64, paths, rows);
     } else {
-      paths.set(path63, {
+      paths.set(path64, {
         type: logicalType(child),
-        nullable: rows.some((row) => nestedValue(row, path63) == null),
-        values: rows.map((row) => nestedValue(row, path63)).filter((item) => item != null)
+        nullable: rows.some((row) => nestedValue(row, path64) == null),
+        values: rows.map((row) => nestedValue(row, path64)).filter((item) => item != null)
       });
     }
   }
 }
-function nestedValue(value, path63) {
+function nestedValue(value, path64) {
   let current = value;
-  for (const segment of path63.split(".")) {
+  for (const segment of path64.split(".")) {
     const record11 = asRecord15(current);
     if (!record11) return null;
     current = record11[segment];
@@ -48346,7 +48545,7 @@ function createDatasetImportService(deps) {
       ...current,
       status: "materializing",
       mapping,
-      targetStorageRoot: path55.resolve(targetStorageRoot),
+      targetStorageRoot: path56.resolve(targetStorageRoot),
       tasksetId: current.tasksetId ?? safeTasksetId(input.name, current.id),
       tasksetRevision: current.status === "ready" ? (existingTaskset?.revision ?? current.tasksetRevision ?? 0) + 1 : current.tasksetRevision ?? 1,
       error: null,
@@ -48405,11 +48604,11 @@ function createDatasetImportService(deps) {
     let job = initial;
     const inspection = job.inspection;
     const mapping = job.mapping;
-    const configuredRoot = path55.resolve(job.targetStorageRoot);
-    const stagingRoot = path55.join(configuredRoot, "staging", job.id);
-    const sourceStaging = path55.join(stagingRoot, "source");
-    const materializedStaging = path55.join(stagingRoot, "materialized");
-    const finalRoot = path55.join(
+    const configuredRoot = path56.resolve(job.targetStorageRoot);
+    const stagingRoot = path56.join(configuredRoot, "staging", job.id);
+    const sourceStaging = path56.join(stagingRoot, "source");
+    const materializedStaging = path56.join(stagingRoot, "materialized");
+    const finalRoot = path56.join(
       configuredRoot,
       "tasksets",
       job.tasksetId,
@@ -48461,7 +48660,7 @@ function createDatasetImportService(deps) {
           });
           continue;
         }
-        const temporary = path55.join(sourceStaging, `${index}.parquet.partial`);
+        const temporary = path56.join(sourceStaging, `${index}.parquet.partial`);
         const result2 = await downloadDatasetFile({
           request,
           url: huggingFaceResolveUrl(
@@ -48484,14 +48683,14 @@ function createDatasetImportService(deps) {
             });
           }
         });
-        const relativeBlob = path55.join(
+        const relativeBlob = path56.join(
           "blobs",
           "sha256",
           result2.contentHash.slice(0, 2),
           result2.contentHash
         );
-        const blobPath = path55.join(configuredRoot, relativeBlob);
-        await mkdir10(path55.dirname(blobPath), { recursive: true });
+        const blobPath = path56.join(configuredRoot, relativeBlob);
+        await mkdir10(path56.dirname(blobPath), { recursive: true });
         await installVerifiedDatasetBlob({
           temporaryPath: temporary,
           blobPath,
@@ -48529,8 +48728,8 @@ function createDatasetImportService(deps) {
       });
       const sourceId = `dataset_source_${sourceHash.slice(0, 24)}`;
       await mkdir10(materializedStaging, { recursive: true });
-      const controlPath = path55.join(stagingRoot, "materialize-control.json");
-      const resultPath = path55.join(stagingRoot, "materialize-result.json");
+      const controlPath = path56.join(stagingRoot, "materialize-control.json");
+      const resultPath = path56.join(stagingRoot, "materialize-result.json");
       await writeFile6(
         controlPath,
         canonicalJson({
@@ -48674,31 +48873,31 @@ function createDatasetImportService(deps) {
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       await writeFile6(
-        path55.join(materializedStaging, "dataset-manifest.json"),
+        path56.join(materializedStaging, "dataset-manifest.json"),
         canonicalJson(manifest),
         "utf8"
       );
       await writeFile6(
-        path55.join(materializedStaging, "taskset.json"),
+        path56.join(materializedStaging, "taskset.json"),
         canonicalJson(taskset),
         "utf8"
       );
       await writeFile6(
-        path55.join(materializedStaging, "receipt.json"),
+        path56.join(materializedStaging, "receipt.json"),
         canonicalJson(receipt),
         "utf8"
       );
       await writeFile6(
-        path55.join(materializedStaging, "mapping.json"),
+        path56.join(materializedStaging, "mapping.json"),
         canonicalJson(mapping),
         "utf8"
       );
       await writeFile6(
-        path55.join(materializedStaging, "quality-report.json"),
+        path56.join(materializedStaging, "quality-report.json"),
         canonicalJson(result.qualityReport),
         "utf8"
       );
-      await mkdir10(path55.dirname(finalRoot), { recursive: true });
+      await mkdir10(path56.dirname(finalRoot), { recursive: true });
       await rm5(finalRoot, { recursive: true, force: true });
       await rename4(materializedStaging, finalRoot);
       await deps.store.upsertExternalDatasetSource(source);
@@ -48775,7 +48974,7 @@ function reusableSourceFiles(taskset, configuredRoot) {
       if (typeof file.sourcePath !== "string" || typeof file.configuration !== "string" || typeof file.upstreamSplit !== "string" || typeof file.revision !== "string" || typeof file.contentHash !== "string" || !Number.isSafeInteger(file.sizeBytes)) {
         continue;
       }
-      const blobPath = path55.join(
+      const blobPath = path56.join(
         configuredRoot,
         "blobs",
         "sha256",
@@ -49029,8 +49228,8 @@ function planItem(stage, split, taskIds, multiplier) {
 }
 
 // ../server/src/training/harness-refiner-benchmark-result-persistence.ts
-import { promises as fs23 } from "node:fs";
-import path56 from "node:path";
+import { promises as fs24 } from "node:fs";
+import path57 from "node:path";
 function createResultManifest(input) {
   const core = {
     schemaVersion: "openpond.harnessRefinerBenchmarkResult.v2",
@@ -49065,25 +49264,25 @@ function createResultManifest(input) {
   return { ...core, contentHash: contentHash(core) };
 }
 async function writeManagedResult(storeDir, modelRunId, manifest) {
-  const root = path56.join(storeDir, "training", "model-runs", modelRunId, "benchmark");
-  await fs23.mkdir(root, { recursive: true });
-  const filePath = path56.join(root, `${manifest.contentHash}.json`);
-  await fs23.writeFile(filePath, `${JSON.stringify(manifest, null, 2)}
+  const root = path57.join(storeDir, "training", "model-runs", modelRunId, "benchmark");
+  await fs24.mkdir(root, { recursive: true });
+  const filePath = path57.join(root, `${manifest.contentHash}.json`);
+  await fs24.writeFile(filePath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-  return path56.relative(storeDir, filePath).replaceAll(path56.sep, "/");
+  return path57.relative(storeDir, filePath).replaceAll(path57.sep, "/");
 }
 async function loadLatestManagedResult(storeDir, modelRunId) {
-  const root = path56.join(storeDir, "training", "model-runs", modelRunId, "benchmark");
+  const root = path57.join(storeDir, "training", "model-runs", modelRunId, "benchmark");
   let entries;
   try {
-    entries = (await fs23.readdir(root)).filter((entry) => entry.endsWith(".json"));
+    entries = (await fs24.readdir(root)).filter((entry) => entry.endsWith(".json"));
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
   }
   const manifests = await Promise.all(entries.map(async (entry) => {
     const value = JSON.parse(
-      await fs23.readFile(path56.join(root, entry), "utf8")
+      await fs24.readFile(path57.join(root, entry), "utf8")
     );
     return value.schemaVersion === "openpond.harnessRefinerBenchmarkResult.v2" && value.modelRunId === modelRunId ? value : null;
   }));
@@ -49110,14 +49309,14 @@ async function preserveProfileResult(input) {
       },
       ...await Promise.all(sourceFiles.map(async (relativePath) => ({
         path: `${prefix}/candidate-harness/${relativePath}`,
-        contents: await fs23.readFile(path56.join(sourceRoot, ...relativePath.split("/")))
+        contents: await fs24.readFile(path57.join(sourceRoot, ...relativePath.split("/")))
       })))
     ]
   });
 }
 async function listFiles(root, relative2 = "") {
-  const directory = path56.join(root, ...relative2.split("/").filter(Boolean));
-  const entries = await fs23.readdir(directory, { withFileTypes: true });
+  const directory = path57.join(root, ...relative2.split("/").filter(Boolean));
+  const entries = await fs24.readdir(directory, { withFileTypes: true });
   const files = [];
   for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
     const next = relative2 ? `${relative2}/${entry.name}` : entry.name;
@@ -49184,8 +49383,8 @@ async function ensureBaseVersion(input) {
 }
 
 // ../server/src/training/harness-refiner-benchmark-service-support.ts
-import { promises as fs24 } from "node:fs";
-import path57 from "node:path";
+import { promises as fs25 } from "node:fs";
+import path58 from "node:path";
 function completedStage(input) {
   return {
     run: input.run,
@@ -49471,15 +49670,15 @@ async function checkpointRefinerUsage(store, modelRunId, usage, observedSpendUsd
   });
 }
 async function checkpointEvidenceSnapshot(store, storeDir, modelRunId, snapshot) {
-  const directory = path57.join(
+  const directory = path58.join(
     storeDir,
     "training",
     "harness-refiner-benchmarks",
     modelRunId
   );
-  await fs24.mkdir(directory, { recursive: true });
-  const artifactPath2 = path57.join(directory, "evidence-snapshot.json");
-  await fs24.writeFile(artifactPath2, `${JSON.stringify(snapshot, null, 2)}
+  await fs25.mkdir(directory, { recursive: true });
+  const artifactPath2 = path58.join(directory, "evidence-snapshot.json");
+  await fs25.writeFile(artifactPath2, `${JSON.stringify(snapshot, null, 2)}
 `, "utf8");
   const run = await store.getModelRun(modelRunId);
   if (!run || run.status !== "running" || !run.evaluationProgress) return run;
@@ -49500,7 +49699,7 @@ async function loadOrReconstructEvidenceSnapshot(input) {
   const ref = input.modelRun.evaluationProgress?.evidenceSnapshot;
   if (ref) {
     const manifest = parseEvidenceSnapshotManifest(
-      JSON.parse(await fs24.readFile(ref.artifactPath, "utf8"))
+      JSON.parse(await fs25.readFile(ref.artifactPath, "utf8"))
     );
     if (manifest.id !== ref.id || manifest.contentHash !== ref.contentHash) {
       throw new Error("Durable benchmark evidence snapshot does not match its admitted ref.");
@@ -51228,7 +51427,7 @@ function usageCost(usage, pricing) {
 // ../server/src/training/benchmark-tasksets.ts
 import { createHash as createHash15 } from "node:crypto";
 import { mkdir as mkdir11, readFile as readFile16, writeFile as writeFile7 } from "node:fs/promises";
-import path58 from "node:path";
+import path59 from "node:path";
 var BUILTIN_DEFINITION_ID = "harness-refiner";
 function createBenchmarkTasksetService(input) {
   const now2 = input.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
@@ -51238,7 +51437,7 @@ function createBenchmarkTasksetService(input) {
     if (existing?.benchmark?.releaseId === harnessRefinerBenchmarkRelease.id && existing.benchmark.releaseHash === harnessRefinerBenchmarkRelease.contentHash) {
       return existing;
     }
-    const tasksetRoot = path58.join(
+    const tasksetRoot = path59.join(
       input.storeDir,
       "training",
       "tasksets",
@@ -51258,7 +51457,7 @@ function createBenchmarkTasksetService(input) {
   }
   async function releaseForTaskset(taskset) {
     if (taskset.purpose !== "benchmark" || !taskset.benchmark) return null;
-    const releasePath = path58.resolve(
+    const releasePath = path59.resolve(
       input.storeDir,
       "training",
       "tasksets",
@@ -51301,12 +51500,12 @@ async function projectRelease(input) {
     input.release.tasks.flatMap((task) => task.artifactRefs)
   );
   const managedAssetById = /* @__PURE__ */ new Map();
-  await mkdir11(path58.join(input.tasksetRoot, "assets"), { recursive: true });
-  await mkdir11(path58.join(input.tasksetRoot, "benchmark"), { recursive: true });
-  await mkdir11(path58.join(input.tasksetRoot, "rubrics"), { recursive: true });
-  await mkdir11(path58.join(input.tasksetRoot, "verifiers"), { recursive: true });
+  await mkdir11(path59.join(input.tasksetRoot, "assets"), { recursive: true });
+  await mkdir11(path59.join(input.tasksetRoot, "benchmark"), { recursive: true });
+  await mkdir11(path59.join(input.tasksetRoot, "rubrics"), { recursive: true });
+  await mkdir11(path59.join(input.tasksetRoot, "verifiers"), { recursive: true });
   await writeFile7(
-    path58.join(input.tasksetRoot, "benchmark", "taskset.release.json"),
+    path59.join(input.tasksetRoot, "benchmark", "taskset.release.json"),
     JSON.stringify(input.release),
     "utf8"
   );
@@ -51315,9 +51514,9 @@ async function projectRelease(input) {
     if (contentHash(contents) !== asset.contentHash) {
       throw new Error(`Benchmark asset ${asset.path} failed its content hash.`);
     }
-    const fileName = `${asset.id}-${path58.basename(asset.path)}`;
-    const artifactRef = path58.posix.join("assets", fileName);
-    await writeFile7(path58.join(input.tasksetRoot, artifactRef), contents, "utf8");
+    const fileName = `${asset.id}-${path59.basename(asset.path)}`;
+    const artifactRef = path59.posix.join("assets", fileName);
+    await writeFile7(path59.join(input.tasksetRoot, artifactRef), contents, "utf8");
     managedAssetById.set(asset.id, {
       artifactRef,
       fileName,
@@ -51544,7 +51743,7 @@ async function copyVerifierAsset(assets, tasksetRoot, asset) {
   if (contentHash(contents) !== asset.contentHash) {
     throw new Error(`Benchmark verifier asset ${asset.path} failed its content hash.`);
   }
-  await writeFile7(path58.join(tasksetRoot, asset.path), contents, "utf8");
+  await writeFile7(path59.join(tasksetRoot, asset.path), contents, "utf8");
   return contents;
 }
 function builtinAsset(assets, assetPath) {
@@ -51615,9 +51814,9 @@ function stringValue11(value) {
 // ../server/src/training/local-taskset-work-runtime.ts
 import { execFile as execFile8 } from "node:child_process";
 import { createHash as createHash16, randomUUID as randomUUID24 } from "node:crypto";
-import { existsSync as existsSync12, promises as fs25 } from "node:fs";
+import { existsSync as existsSync12, promises as fs26 } from "node:fs";
 import os9 from "node:os";
-import path59 from "node:path";
+import path60 from "node:path";
 function createLocalTasksetWorkRuntime(deps) {
   return {
     createSession: async (payload) => {
@@ -51671,7 +51870,7 @@ async function executeLocalWorkspaceTool(input) {
   const request = record10(input.payload);
   const action = string2(request.action);
   const args = record10(request.args);
-  const root = path59.resolve(input.session.cwd);
+  const root = path60.resolve(input.session.cwd);
   await ensureLayout(root);
   try {
     if (action === "sandbox_create" || action === "sandbox_start") {
@@ -51698,8 +51897,8 @@ async function executeLocalWorkspaceTool(input) {
     if (action === "sandbox_upload_file") {
       const target = localPath(root, string2(args.path));
       const bytes2 = Buffer.from(string2(args.contentsBase64), "base64");
-      await fs25.mkdir(path59.dirname(target), { recursive: true, mode: 448 });
-      await fs25.writeFile(target, bytes2, { mode: 384 });
+      await fs26.mkdir(path60.dirname(target), { recursive: true, mode: 448 });
+      await fs26.writeFile(target, bytes2, { mode: 384 });
       return ok(action, `Uploaded ${relative(root, target)}.`, fileData(target, bytes2));
     }
     if (action === "sandbox_list_files") {
@@ -51710,7 +51909,7 @@ async function executeLocalWorkspaceTool(input) {
     if (action === "sandbox_read_file") {
       const target = localPath(root, string2(args.path));
       const maxBytes = integer(args.maxBytes, 512e3, 1, 1e6);
-      const bytes2 = await fs25.readFile(target);
+      const bytes2 = await fs26.readFile(target);
       const bounded = bytes2.subarray(0, maxBytes);
       return ok(action, bounded.toString("utf8"), {
         path: relative(root, target),
@@ -51722,24 +51921,24 @@ async function executeLocalWorkspaceTool(input) {
     if (action === "sandbox_write_file") {
       const target = localPath(root, string2(args.path));
       const contents = string2(args.content, true);
-      await fs25.mkdir(path59.dirname(target), { recursive: true, mode: 448 });
-      await fs25.writeFile(target, contents, { encoding: "utf8", mode: 384 });
+      await fs26.mkdir(path60.dirname(target), { recursive: true, mode: 448 });
+      await fs26.writeFile(target, contents, { encoding: "utf8", mode: 384 });
       return ok(action, `Wrote ${relative(root, target)}.`, fileData(target, Buffer.from(contents)));
     }
     if (action === "sandbox_edit_file") {
       const target = localPath(root, string2(args.path));
-      const contents = await fs25.readFile(target, "utf8");
+      const contents = await fs26.readFile(target, "utf8");
       const oldText = string2(args.oldText);
       if (!contents.includes(oldText)) {
         return fail(action, "The exact text to replace was not found.");
       }
       const next = args.replaceAll === true ? contents.replaceAll(oldText, string2(args.newText, true)) : contents.replace(oldText, string2(args.newText, true));
-      await fs25.writeFile(target, next, { encoding: "utf8", mode: 384 });
+      await fs26.writeFile(target, next, { encoding: "utf8", mode: 384 });
       return ok(action, `Edited ${relative(root, target)}.`, fileData(target, Buffer.from(next)));
     }
     if (action === "sandbox_delete_file") {
       const target = localPath(root, string2(args.path));
-      await fs25.rm(target, { recursive: args.recursive === true, force: true });
+      await fs26.rm(target, { recursive: args.recursive === true, force: true });
       return ok(action, `Deleted ${relative(root, target)}.`, { path: relative(root, target) });
     }
     if (action === "sandbox_exec") {
@@ -51752,7 +51951,7 @@ async function executeLocalWorkspaceTool(input) {
         output: [result.stdout, result.stderr].filter(Boolean).join("\n").trim(),
         data: {
           command,
-          cwd: path59.join(root, "work"),
+          cwd: path60.join(root, "work"),
           exitCode: result.code,
           stdout: result.stdout,
           stderr: result.stderr
@@ -51761,24 +51960,24 @@ async function executeLocalWorkspaceTool(input) {
     }
     if (action === "sandbox_save_output") {
       const source = localPath(root, string2(args.path));
-      const bytes2 = await fs25.readFile(source);
+      const bytes2 = await fs26.readFile(source);
       if (bytes2.byteLength > WORK_OUTPUT_MAX_BYTES) {
         return fail(action, `Work output exceeds ${WORK_OUTPUT_MAX_BYTES.toLocaleString()} bytes.`);
       }
       const title = safeName2(
-        typeof args.suggestedName === "string" && args.suggestedName.trim() ? args.suggestedName : path59.basename(source)
+        typeof args.suggestedName === "string" && args.suggestedName.trim() ? args.suggestedName : path60.basename(source)
       );
-      const contentType2 = WORK_OUTPUT_CONTENT_TYPES[path59.extname(title).toLowerCase()];
+      const contentType2 = WORK_OUTPUT_CONTENT_TYPES[path60.extname(title).toLowerCase()];
       if (!contentType2) return fail(action, `${title} is not a supported Work output format.`);
-      const outputDir = path59.join(
+      const outputDir = path60.join(
         input.deps.storeDir,
         "work",
         "outputs",
         safeName2(input.session.id)
       );
-      await fs25.mkdir(outputDir, { recursive: true, mode: 448 });
-      const destination = path59.join(outputDir, `001-${randomUUID24()}-${title}`);
-      await fs25.writeFile(destination, bytes2, { mode: 384 });
+      await fs26.mkdir(outputDir, { recursive: true, mode: 448 });
+      const destination = path60.join(outputDir, `001-${randomUUID24()}-${title}`);
+      await fs26.writeFile(destination, bytes2, { mode: 384 });
       const outputRef = FileOutputRefSchema.parse({
         kind: "file",
         id: `output-${createHash16("sha256").update(destination).digest("hex").slice(0, 24)}`,
@@ -51815,25 +52014,25 @@ async function executeLocalWorkspaceTool(input) {
 }
 async function ensureLayout(root) {
   await Promise.all(["inputs", "work", "outputs"].map(
-    (area) => fs25.mkdir(path59.join(root, area), { recursive: true, mode: 448 })
+    (area) => fs26.mkdir(path60.join(root, area), { recursive: true, mode: 448 })
   ));
 }
 function localPath(root, value) {
   const normalized = value.replaceAll("\\", "/").replace(/^\/+/, "").replace(/^workspace(?:\/|$)/, "");
-  const target = path59.resolve(root, normalized);
-  if (target !== root && !target.startsWith(`${root}${path59.sep}`)) {
+  const target = path60.resolve(root, normalized);
+  if (target !== root && !target.startsWith(`${root}${path60.sep}`)) {
     throw new Error("Local Work path escaped its isolated workspace.");
   }
   return target;
 }
 async function listFiles2(root, target, recursive) {
-  const stat7 = await fs25.stat(target).catch(() => null);
+  const stat7 = await fs26.stat(target).catch(() => null);
   if (!stat7) return [];
   if (!stat7.isDirectory()) return [relative(root, target)];
-  const entries = await fs25.readdir(target, { withFileTypes: true });
+  const entries = await fs26.readdir(target, { withFileTypes: true });
   const files = [];
   for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
-    const item = path59.join(target, entry.name);
+    const item = path60.join(target, entry.name);
     files.push(relative(root, item));
     if (recursive && entry.isDirectory()) files.push(...await listFiles2(root, item, true));
     if (files.length >= 1e3) break;
@@ -51842,8 +52041,8 @@ async function listFiles2(root, target, recursive) {
 }
 function runCommand5(command, cwd, timeoutMs) {
   return new Promise((resolve) => {
-    const nodeRuntimeRoot = path59.dirname(path59.dirname(process.execPath));
-    const localPythonRoot = path59.join(os9.homedir(), ".local", "lib");
+    const nodeRuntimeRoot = path60.dirname(path60.dirname(process.execPath));
+    const localPythonRoot = path60.join(os9.homedir(), ".local", "lib");
     const sandboxArgs = [
       "--tmpfs",
       "/",
@@ -51962,7 +52161,7 @@ function integer(value, fallback, minimum, maximum) {
   return typeof value === "number" && Number.isInteger(value) ? Math.min(maximum, Math.max(minimum, value)) : fallback;
 }
 function relative(root, target) {
-  return path59.relative(root, target).replaceAll(path59.sep, "/");
+  return path60.relative(root, target).replaceAll(path60.sep, "/");
 }
 function safeName2(value) {
   return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "output";
@@ -52017,12 +52216,12 @@ function createBenchmarkRuntimeComposition(input) {
 // ../server/src/training/dataset-storage-service.ts
 import { constants as constants3 } from "node:fs";
 import { access as access4, mkdir as mkdir12, readFile as readFile18, rename as rename5, statfs as statfs2, writeFile as writeFile8 } from "node:fs/promises";
-import path61 from "node:path";
+import path62 from "node:path";
 
 // ../server/src/training/dataset-storage-discovery.ts
 import { readdir as readdir4, readFile as readFile17 } from "node:fs/promises";
 import os10 from "node:os";
-import path60 from "node:path";
+import path61 from "node:path";
 var NETWORK_FILE_SYSTEMS = /* @__PURE__ */ new Set([
   "9p",
   "afpfs",
@@ -52108,7 +52307,7 @@ function parseLinuxMountInfo(value, storeDir) {
     candidates.push({
       kind,
       label: driveLabel(mountPath, source, kind),
-      datasetStorePath: mountPath === "/" ? path60.join(storeDir, "datasets") : path60.join(mountPath, "OpenPond", "datasets"),
+      datasetStorePath: mountPath === "/" ? path61.join(storeDir, "datasets") : path61.join(mountPath, "OpenPond", "datasets"),
       path: mountPath
     });
   }
@@ -52127,7 +52326,7 @@ function parseMacMountOutput(value, storeDir) {
     candidates.push({
       kind,
       label: driveLabel(mountPath, source, kind),
-      datasetStorePath: mountPath === "/" ? path60.join(storeDir, "datasets") : path60.join(mountPath, "OpenPond", "datasets"),
+      datasetStorePath: mountPath === "/" ? path61.join(storeDir, "datasets") : path61.join(mountPath, "OpenPond", "datasets"),
       path: mountPath
     });
   }
@@ -52150,11 +52349,11 @@ function parseWindowsLogicalDisks(value, storeDir) {
     const root = `${deviceId}\\`;
     const volumeName = typeof record11.VolumeName === "string" ? record11.VolumeName.trim() : "";
     const kind = driveType === 4 ? "network" : driveType === 2 ? "removable" : "local";
-    const storeRoot = path60.win32.parse(path60.win32.resolve(storeDir)).root.toLowerCase();
+    const storeRoot = path61.win32.parse(path61.win32.resolve(storeDir)).root.toLowerCase();
     return [{
       kind,
       label: volumeName || (root.toLowerCase() === storeRoot ? "System disk" : deviceId.toUpperCase()),
-      datasetStorePath: root.toLowerCase() === storeRoot ? path60.win32.join(storeDir, "datasets") : path60.win32.join(root, "OpenPond", "datasets"),
+      datasetStorePath: root.toLowerCase() === storeRoot ? path61.win32.join(storeDir, "datasets") : path61.win32.join(root, "OpenPond", "datasets"),
       path: root
     }];
   });
@@ -52168,25 +52367,25 @@ function storageKindForPath(value) {
 }
 async function discoverGvfsCandidates() {
   const uid = typeof process.getuid === "function" ? process.getuid() : os10.userInfo().uid;
-  const gvfsRoot = path60.join("/run/user", String(uid), "gvfs");
+  const gvfsRoot = path61.join("/run/user", String(uid), "gvfs");
   const entries = await readdir4(gvfsRoot, { withFileTypes: true }).catch(() => []);
   return entries.flatMap((entry) => {
     if (!entry.isDirectory()) return [];
-    const mountedPath = path60.join(gvfsRoot, entry.name);
+    const mountedPath = path61.join(gvfsRoot, entry.name);
     return [{
       kind: "network",
       label: labelForGvfsMount(entry.name),
-      datasetStorePath: path60.join(mountedPath, "OpenPond", "datasets"),
+      datasetStorePath: path61.join(mountedPath, "OpenPond", "datasets"),
       path: mountedPath
     }];
   });
 }
 function systemStorageCandidate(storeDir, platform) {
-  const root = path60.parse(path60.resolve(storeDir)).root;
+  const root = path61.parse(path61.resolve(storeDir)).root;
   return {
     kind: "local",
     label: "System disk",
-    datasetStorePath: path60.join(storeDir, "datasets"),
+    datasetStorePath: path61.join(storeDir, "datasets"),
     path: platform === "win32" ? root : root || "/"
   };
 }
@@ -52205,12 +52404,12 @@ function storageKind(input) {
 }
 function driveLabel(mountPath, source, kind) {
   if (mountPath === "/") return "System disk";
-  const mountName = path60.basename(mountPath);
+  const mountName = path61.basename(mountPath);
   if (kind === "network") {
     const sourceName = source.replace(/\/+$/, "").split("/").pop();
     return decodeSafely(sourceName || mountName || source);
   }
-  return decodeSafely(mountName || path60.basename(source) || source);
+  return decodeSafely(mountName || path61.basename(source) || source);
 }
 function labelForGvfsMount(name) {
   const separator = name.indexOf(":");
@@ -52244,7 +52443,7 @@ function uniqueCandidates2(candidates) {
   return [...unique2.values()];
 }
 function normalizedPath(value) {
-  const normalized = path60.normalize(value);
+  const normalized = path61.normalize(value);
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 
@@ -52305,15 +52504,15 @@ var runCommandProbe = async (executable, args, options = {}) => {
 
 // ../server/src/training/dataset-storage-service.ts
 function createDatasetStorageService(input) {
-  const directory = path61.join(input.storeDir, "datasets");
-  const settingsPath = path61.join(directory, "settings.json");
+  const directory = path62.join(input.storeDir, "datasets");
+  const settingsPath = path62.join(directory, "settings.json");
   async function settings() {
     try {
       return DatasetStorageSettingsSchema.parse(JSON.parse(await readFile18(settingsPath, "utf8")));
     } catch {
       return DatasetStorageSettingsSchema.parse({
         schemaVersion: "openpond.datasetStorageSettings.v1",
-        datasetStorePath: path61.join(input.storeDir, "datasets"),
+        datasetStorePath: path62.join(input.storeDir, "datasets"),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
@@ -52325,7 +52524,7 @@ function createDatasetStorageService(input) {
       platform: process.platform,
       storeDir: input.storeDir
     });
-    if (!candidates.some((candidate2) => path61.resolve(candidate2.datasetStorePath) === path61.resolve(current.datasetStorePath))) {
+    if (!candidates.some((candidate2) => path62.resolve(candidate2.datasetStorePath) === path62.resolve(current.datasetStorePath))) {
       candidates.push({
         datasetStorePath: current.datasetStorePath,
         kind: storageKindForPath(current.datasetStorePath),
@@ -52339,7 +52538,7 @@ function createDatasetStorageService(input) {
       return {
         ...candidate2,
         id: `dataset-storage-${Buffer.from(candidate2.path).toString("base64url").slice(0, 120)}`,
-        configured: path61.resolve(candidate2.datasetStorePath) === path61.resolve(current.datasetStorePath),
+        configured: path62.resolve(candidate2.datasetStorePath) === path62.resolve(current.datasetStorePath),
         mounted: stats !== null,
         freeBytes: stats ? Number(stats.bavail) * Number(stats.bsize) : null,
         totalBytes: stats ? Number(stats.blocks) * Number(stats.bsize) : null,
@@ -52356,7 +52555,7 @@ function createDatasetStorageService(input) {
     const request = UpdateDatasetStorageSettingsRequestSchema.parse(value);
     const updated = DatasetStorageSettingsSchema.parse({
       schemaVersion: "openpond.datasetStorageSettings.v1",
-      datasetStorePath: path61.resolve(request.datasetStorePath),
+      datasetStorePath: path62.resolve(request.datasetStorePath),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     if (!await ensureWritable(updated.datasetStorePath)) {
@@ -52512,10 +52711,10 @@ function createManagedAdapterRegistryClient(dependencies = {}) {
   const fetchImpl = dependencies.fetchImpl ?? fetch;
   const resolveRegistryAccess = dependencies.resolveRegistryAccess ?? ((teamId) => resolveManagedAdapterUserAccess({ teamId }));
   const resolveInferenceAccess = dependencies.resolveInferenceAccess ?? ((teamId) => resolveManagedAdapterUserAccess({ teamId }));
-  async function requestJson2(resolveAccess, teamId, path63, init = {}) {
+  async function requestJson2(resolveAccess, teamId, path64, init = {}) {
     const access5 = await resolveAccess(teamId);
     assertResolvedTeam(access5.teamId, teamId);
-    const requestUrl = `${access5.apiBaseUrl}${path63}`;
+    const requestUrl = `${access5.apiBaseUrl}${path64}`;
     const headers = withVercelProtectionBypass(
       requestUrl,
       hostedApiAuthHeaders(access5.token),
@@ -53145,10 +53344,10 @@ async function createOpenPondServer(options = {}) {
   const harnessEvaluationReviewStream = createLocalHarnessEvaluationReviewModelStream(streamOpenPondHostedChatTurn2);
   const executeWebSearch = createWebSearchExecutorFromEnv();
   const executeConnectedAppTool = createCloudConnectedAppToolExecutor();
-  const attachmentRootDir = path62.join(storeDir, "attachments");
+  const attachmentRootDir = path63.join(storeDir, "attachments");
   const logger = createLogger({
     channel: "server",
-    logDir: path62.join(storeDir, "logs"),
+    logDir: path63.join(storeDir, "logs"),
     metadata: {
       version,
       runtimeVersion
@@ -53270,6 +53469,7 @@ async function createOpenPondServer(options = {}) {
     updateLocalProjectAgentSetupPayload,
     previewLocalProjectCloudSourcePayload,
     uploadLocalProjectCloudSourcePayload,
+    localProjectActionCatalogPayload,
     patchSidebarAppPreference,
     listSidebarFileBookmarksPayload,
     patchSidebarFileBookmarkPayload,
@@ -53321,6 +53521,10 @@ async function createOpenPondServer(options = {}) {
     appendRuntimeEvent,
     isClosing: () => closing
   });
+  const projectActionRunPayload = createProjectActionRunPayload({
+    appendRuntimeEvent,
+    resolveProjectRoot: async (projectId) => (await findLocalProject(store, projectId))?.workspacePath ?? null
+  });
   const {
     createSession,
     patchSession,
@@ -53333,8 +53537,8 @@ async function createOpenPondServer(options = {}) {
     store,
     defaultSessionCwd,
     createManagedLocalWorkCwd: async (sessionId) => {
-      const workspacePath = path62.join(storeDir, "work", "tasks", sessionId);
-      await fs26.mkdir(workspacePath, { recursive: true, mode: 448 });
+      const workspacePath = path63.join(storeDir, "work", "tasks", sessionId);
+      await fs27.mkdir(workspacePath, { recursive: true, mode: 448 });
       return workspacePath;
     },
     loadAppPreferences,
@@ -53437,7 +53641,7 @@ async function createOpenPondServer(options = {}) {
   const tasksetAuthoringSkillText = tasksetAuthoringSkillArtifact.bundle;
   const taskCreatorService = createTaskCreatorService({
     store,
-    tasksetRootDir: path62.join(storeDir, "training", "tasksets"),
+    tasksetRootDir: path63.join(storeDir, "training", "tasksets"),
     authoringSkillHash: contentHash(tasksetAuthoringSkillText),
     loadCodexHistoryThread: (sessionId) => readCodexHistoryThreadPayload(sessionId, {
       attachmentRootDir,
@@ -53466,7 +53670,7 @@ async function createOpenPondServer(options = {}) {
   });
   const datasetArtifactService = createDatasetArtifactService({
     store,
-    workerProjectDir: path62.resolve(process.cwd(), "python", "openpond-datasets")
+    workerProjectDir: path63.resolve(process.cwd(), "python", "openpond-datasets")
   });
   const {
     benchmarkTasksets,
@@ -53570,7 +53774,7 @@ async function createOpenPondServer(options = {}) {
   const trainingChatSearchService = createTrainingChatSearchService({ store });
   const datasetImportService = createDatasetImportService({
     store,
-    workerProjectDir: path62.resolve(
+    workerProjectDir: path63.resolve(
       process.cwd(),
       "python",
       "openpond-datasets"
@@ -53670,6 +53874,7 @@ async function createOpenPondServer(options = {}) {
     workInputsForSession: workOutputService.workInputsForSession,
     executeOpenPondCommand: openPondCommandAccess.executeCommand,
     executeProfileAction: profileRunPayload,
+    executeProjectAction: projectActionRunPayload,
     executeDatasetBuilderAction: async ({
       session,
       provider,
@@ -53793,7 +53998,7 @@ async function createOpenPondServer(options = {}) {
           nextStep: response2.items.length === 0 ? "There are no pinned or saved files." : `Listed ${response2.items.length} sidebar file${response2.items.length === 1 ? "" : "s"}.`
         };
       }
-      const path63 = normalizeSidebarFilePath(requestedPath ?? "");
+      const path64 = normalizeSidebarFilePath(requestedPath ?? "");
       const workspaceId = session.workspaceId ?? session.localProjectId ?? session.appId;
       if (!workspaceId) {
         throw new Error(
@@ -53806,18 +54011,18 @@ async function createOpenPondServer(options = {}) {
         workspaceKind,
         workspaceId,
         workspaceName,
-        path: path63,
+        path: path64,
         status: action === "pin" ? "pinned" : action === "save_for_later" ? "saved_for_later" : "none",
         sourceSessionId: session.id
       });
       const changed = response.items.find(
-        (item) => item.workspaceKind === workspaceKind && item.workspaceId === workspaceId && item.path === path63
+        (item) => item.workspaceKind === workspaceKind && item.workspaceId === workspaceId && item.path === path64
       ) ?? null;
       const verb = action === "pin" ? "Pinned" : action === "save_for_later" ? "Saved" : "Removed";
       return {
         ...response,
         changed,
-        nextStep: `${verb} ${path63}${action === "save_for_later" ? " for later" : ""}.`
+        nextStep: `${verb} ${path64}${action === "save_for_later" ? " for later" : ""}.`
       };
     },
     listIntegrationConnections: listSandboxIntegrationConnections,
@@ -54410,6 +54615,7 @@ async function createOpenPondServer(options = {}) {
       openEventSubscriber,
       refreshCodexStatus,
       bootstrapPayload,
+      localProjectActionCatalogPayload,
       skillSourceFilePayload,
       extensionCatalogPayload,
       extensionPreviewPayload,