openpond 0.0.31 → 0.0.32

package/dist/chunks/{chunk-ZIKHE5AY.js → chunk-4M4WAORL.js}

@@ -3,10 +3,10 @@ import {
   materializeSourceUploadFile,
   readSourceUploadCache,
   writeSourceUploadCache
-} from "./chunk-WQ2GF7XT.js";
+} from "./chunk-4HQURM3N.js";
 import {
-  CreatePipelineRequestSchema
-} from "./chunk-VQX33YAG.js";
+  CreateImproveRunSchema
+} from "./chunk-FQW3AQVJ.js";
 import {
   formatSandboxTemplateDiagnostics,
   validateSandboxTemplateYaml
@@ -17,8 +17,8 @@ import {
 import {
   parseSandboxRuntimePromotionPolicyOption,
   parseSandboxWorkflowModeOption,
-  runCommand
-} from "./chunk-NC2GQQOT.js";
+  runProcessCommand
+} from "./chunk-D264OHTR.js";
 import {
   optionString,
   optionalJsonObject,
@@ -26,9 +26,9 @@ import {
   parseCsvOption,
   parseIntegerOption,
   requiredTeamId
-} from "./chunk-7HZBKUUB.js";
+} from "./chunk-OXQG773T.js";
 
-// src/cli/agent-sdk-command.ts
+// ../../packages/cloud/src/profile/agent-sdk-command.ts
 import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
@@ -79,890 +79,926 @@ function nodeTypescriptCommand(packageRoot, sourceCli) {
   return { command: process.execPath, args: [tsxCli, sourceCli] };
 }
 
-// src/cli/project-source-upload.ts
+// ../../packages/cloud/src/profile/project-source-upload.ts
 import { Buffer } from "node:buffer";
+import { existsSync as existsSync4, promises as fs2 } from "node:fs";
+import path4 from "node:path";
+
+// ../../packages/cloud/src/profile/project-source-upload-agent-sdk.ts
 import { createHash } from "node:crypto";
-import { existsSync as existsSync2, promises as fs, readFileSync as readFileSync2, statSync } from "node:fs";
+import { existsSync as existsSync3, promises as fs, readFileSync as readFileSync2, statSync } from "node:fs";
 import { tmpdir } from "node:os";
-import path2 from "node:path";
+import path3 from "node:path";
 import { gunzipSync } from "node:zlib";
-var PROJECT_SOURCE_UPLOAD_MAX_FILES = 1500;
-var PROJECT_SOURCE_UPLOAD_MAX_FILE_BYTES = 8 * 1024 * 1024;
-var PROJECT_SOURCE_UPLOAD_MAX_BYTES = 100 * 1024 * 1024;
-var PROJECT_SOURCE_UPLOAD_CONCURRENCY = 8;
-var PROJECT_SOURCE_UPLOAD_LIMITS = {
-  maxFiles: PROJECT_SOURCE_UPLOAD_MAX_FILES,
-  maxFileBytes: PROJECT_SOURCE_UPLOAD_MAX_FILE_BYTES,
-  maxTotalBytes: PROJECT_SOURCE_UPLOAD_MAX_BYTES,
-  concurrency: PROJECT_SOURCE_UPLOAD_CONCURRENCY
-};
-var PROJECT_SOURCE_UPLOAD_TRANSPORT = {
-  mode: "single_json_payload",
-  chunkingSupported: false
-};
+
+// ../../packages/cloud/src/profile/project-source-upload-bun-compat.ts
+import { existsSync as existsSync2 } from "node:fs";
+import path2 from "node:path";
+function detectAgentSdkPackageManager(projectPath, packageJson) {
+  const packageManager = packageJson.packageManager;
+  if (typeof packageManager === "string") {
+    const name = packageManager.split("@")[0];
+    if (name === "bun" || name === "npm" || name === "pnpm" || name === "yarn") {
+      return name;
+    }
+  }
+  if (existsSync2(path2.join(projectPath, "bun.lock")) || existsSync2(path2.join(projectPath, "bun.lockb"))) {
+    return "bun";
+  }
+  if (existsSync2(path2.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(path2.join(projectPath, "yarn.lock"))) return "yarn";
+  if (existsSync2(path2.join(projectPath, "package-lock.json")) || existsSync2(path2.join(projectPath, "npm-shrinkwrap.json"))) {
+    return "npm";
+  }
+  return "unknown";
+}
+function agentSdkDependencyInstallCommand(packageManager) {
+  if (packageManager === "npm") return "npm install --offline";
+  if (packageManager === "pnpm") return "pnpm install --offline";
+  if (packageManager === "yarn") return "yarn install --offline";
+  if (packageManager === "bun") return "bun install --offline";
+  return "pnpm install --offline";
+}
+function agentSdkRunScriptCommand(packageManager, scriptName) {
+  if (packageManager === "pnpm") return `pnpm run ${scriptName}`;
+  if (packageManager === "yarn") return `yarn ${scriptName}`;
+  if (packageManager === "npm") return `npm run ${scriptName}`;
+  if (packageManager === "bun") return `bun run ${scriptName}`;
+  return `pnpm run ${scriptName}`;
+}
+
+// ../../packages/cloud/src/profile/project-source-upload-agent-sdk.ts
 var OPENPOND_PNPM_PACKAGE_MANAGER = "pnpm@11.13.0";
-var AGENT_SDK_SOURCE_UPLOAD_METADATA_PATH = ".openpond/source-upload-metadata.json";
 var AGENT_SDK_VENDOR_TARBALL_PATH = ".openpond/vendor/openpond-agent-sdk.tgz";
 var AGENT_SDK_VENDOR_NPM_DEPENDENCY_DIR = ".openpond/vendor/npm";
 var AGENT_SDK_MATERIALIZED_DEPENDENCY_SPEC = `file:${AGENT_SDK_VENDOR_TARBALL_PATH}`;
 var AGENT_SDK_SYNTHESIZED_OPENPOND_YAML_SENTINEL = "# openpond-agent-sdk-source-upload: synthesized-openpond-yaml";
-var AGENT_SDK_GENERATED_SKILLS_DIR = ".openpond/skills";
-var AGENT_SDK_GENERATED_ARTIFACTS = [
-  ".openpond/agent-inspect.json",
-  ".openpond/agent-manifest.json",
-  ".openpond/action-registry.json",
-  ".openpond/openpond-manifest.preview.yaml",
-  ".openpond/runtime-bridge.mjs",
-  ".openpond/validator-report.md"
-];
-function isSafeProjectSourcePath(filePath) {
-  return filePath.length > 0 && !filePath.includes("\0") && !path2.isAbsolute(filePath) && !filePath.split(/[\\/]+/).some((part) => !part || part === "." || part === "..");
-}
-function shouldSkipProjectSourcePath(filePath) {
-  return filePath.split(/[\\/]+/).some((segment) => {
-    const lower = segment.toLowerCase();
-    return lower === ".git" || lower === ".openpond" || lower === "node_modules" || lower === ".next" || lower === ".turbo" || lower.startsWith(".env");
-  });
+async function runCommand(command, args, options = {}) {
+  return runProcessCommand(command, args, { cwd: options.cwd });
 }
-async function resolveProjectSourceUploadBranch(projectPath, options) {
-  const explicit = optionString(options, "branch");
-  if (explicit) return explicit;
-  const branch = await runCommand("git", ["branch", "--show-current"], {
-    cwd: projectPath
-  });
-  if (branch.code !== 0) return null;
-  return branch.stdout.trim() || null;
+function readOpenPondAgentSdkVersionSpec(packageJson) {
+  for (const key of ["dependencies", "devDependencies", "peerDependencies"]) {
+    const dependencies = packageJson[key];
+    if (!dependencies || typeof dependencies !== "object" || Array.isArray(dependencies)) {
+      continue;
+    }
+    const value = dependencies["openpond-agent-sdk"];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return null;
 }
-async function collectProjectSourceUploadEntries(projectPath) {
-  const sourcePaths = await collectProjectSourceUploadPaths(projectPath);
-  if (sourcePaths.length === 0) {
-    throw new Error("no source files found to upload");
+async function buildAgentSdkMaterializedDependency(projectPath, packageJson) {
+  const sdkSource = resolveLocalOpenPondAgentSdkMaterializationSource(
+    projectPath,
+    packageJson
+  );
+  if (!sdkSource) return null;
+  const tempDir = await fs.mkdtemp(path3.join(tmpdir(), "openpond-agent-sdk-pack-"));
+  try {
+    const sdkContents = sdkSource.kind === "package_root" ? await packOpenPondAgentSdkPackageRoot(sdkSource.packageRoot, tempDir) : sdkSource.tarballContents;
+    const sdkDependencyTarballs = await packAgentSdkRuntimeDependencyTarballs({
+      sdkPackageJson: sdkSource.packageJson,
+      dependencyBaseDir: sdkSource.dependencyBaseDir,
+      tempDir
+    });
+    const packageManager = detectAgentSdkPackageManager(projectPath, packageJson);
+    const rewrittenPackageJson = rewriteAgentSdkPackageJsonForMaterialization(
+      packageJson,
+      sdkDependencyTarballs,
+      packageManager
+    );
+    const pnpmWorkspaceSource = packageManager === "pnpm" || packageManager === "unknown" ? buildAgentSdkPnpmWorkspaceSource(projectPath, sdkDependencyTarballs) : null;
+    const installCommand = agentSdkDependencyInstallCommand(packageManager);
+    const sdkPackage = {
+      packageName: "openpond-agent-sdk",
+      source: "uploaded_tarball",
+      path: AGENT_SDK_VENDOR_TARBALL_PATH,
+      sha256: sha256Hex(sdkContents),
+      sizeBytes: sdkContents.byteLength
+    };
+    return {
+      rewrittenPackageJson,
+      pnpmWorkspaceSource,
+      tarballs: [
+        {
+          ...sdkPackage,
+          contents: sdkContents
+        },
+        ...sdkDependencyTarballs
+      ],
+      dependencySetup: {
+        required: true,
+        packageManager,
+        installCommand,
+        commands: [installCommand],
+        packageJsonPath: "package.json",
+        expectedBinaryPath: "node_modules/.bin/openpond-agent",
+        generatedArtifactDirectory: ".openpond",
+        sdkPackage,
+        dependencyPackages: sdkDependencyTarballs.map((tarball) => ({
+          packageName: tarball.packageName,
+          source: tarball.source,
+          versionSpec: tarball.versionSpec,
+          path: tarball.path,
+          sha256: tarball.sha256,
+          sizeBytes: tarball.sizeBytes
+        }))
+      }
+    };
+  } finally {
+    await fs.rm(tempDir, { recursive: true, force: true });
   }
-  if (sourcePaths.length > PROJECT_SOURCE_UPLOAD_MAX_FILES) {
+}
+async function packOpenPondAgentSdkPackageRoot(sdkPackageRoot, tempDir) {
+  const pack = await runCommand(
+    "npm",
+    ["pack", "--silent", "--pack-destination", tempDir, sdkPackageRoot],
+    { cwd: sdkPackageRoot }
+  );
+  if (pack.code !== 0) {
+    const details = [pack.stderr.trim(), pack.stdout.trim()].filter(Boolean).join("\n");
     throw new Error(
-      `too many source files to upload: ${sourcePaths.length} > ${PROJECT_SOURCE_UPLOAD_MAX_FILES}`
+      `failed to pack openpond-agent-sdk for source upload${details ? `:
+${details}` : ""}`
     );
   }
-  const sortedSourcePaths = sourcePaths.sort();
-  const filesToUpload = (await mapWithConcurrency(sortedSourcePaths, PROJECT_SOURCE_UPLOAD_CONCURRENCY, async (sourcePath) => {
-    const absolutePath = path2.resolve(projectPath, sourcePath);
-    const relative = path2.relative(projectPath, absolutePath);
-    if (relative.startsWith("..") || path2.isAbsolute(relative)) {
-      throw new Error(`source path escapes project: ${sourcePath}`);
-    }
-    const stat = await fs.stat(absolutePath);
-    if (!stat.isFile()) return null;
-    if (stat.size > PROJECT_SOURCE_UPLOAD_MAX_FILE_BYTES) {
+  const tarballName = pack.stdout.trim().split(/\r?\n/).filter(Boolean).pop();
+  if (!tarballName) {
+    throw new Error("failed to pack openpond-agent-sdk for source upload: npm pack did not return a tarball name");
+  }
+  return fs.readFile(path3.join(tempDir, tarballName));
+}
+async function packAgentSdkRuntimeDependencyTarballs(params) {
+  const dependencies = recordStringMap(params.sdkPackageJson.dependencies);
+  const pending = Object.entries(dependencies).sort(([left], [right]) => left.localeCompare(right)).map(([packageName, versionSpec]) => ({ packageName, versionSpec }));
+  const seen = /* @__PURE__ */ new Set();
+  const tarballs = [];
+  while (pending.length > 0) {
+    const { packageName, versionSpec } = pending.shift();
+    if (seen.has(packageName)) continue;
+    seen.add(packageName);
+    const packTarget = npmPackTargetForDependency({
+      packageName,
+      versionSpec,
+      dependencyBaseDir: params.dependencyBaseDir
+    });
+    const pack = await runCommand(
+      "npm",
+      ["pack", "--silent", "--pack-destination", params.tempDir, packTarget],
+      { cwd: params.dependencyBaseDir }
+    );
+    if (pack.code !== 0) {
+      const details = [pack.stderr.trim(), pack.stdout.trim()].filter(Boolean).join("\n");
       throw new Error(
-        `source file is too large: ${sourcePath} (${stat.size} bytes)`
+        `failed to pack openpond-agent-sdk dependency ${packageName}${details ? `:
+${details}` : ""}`
       );
     }
-    return {
-      path: sourcePath.replace(/\\/g, "/"),
-      absolutePath,
-      size: stat.size,
-      mtimeMs: Math.trunc(stat.mtimeMs),
-      ctimeMs: Math.trunc(stat.ctimeMs)
-    };
-  })).filter((file) => file !== null);
-  let totalBytes = 0;
-  for (const file of filesToUpload) {
-    totalBytes += file.size;
-    if (totalBytes > PROJECT_SOURCE_UPLOAD_MAX_BYTES) {
+    const tarballName = pack.stdout.trim().split(/\r?\n/).filter(Boolean).pop();
+    if (!tarballName) {
       throw new Error(
-        `source upload is too large: ${totalBytes} > ${PROJECT_SOURCE_UPLOAD_MAX_BYTES}`
+        `failed to pack openpond-agent-sdk dependency ${packageName}: npm pack did not return a tarball name`
       );
     }
+    const contents = await fs.readFile(path3.join(params.tempDir, tarballName));
+    const packedPackageJson = readPackageJsonFromNpmTarball(contents);
+    tarballs.push({
+      packageName,
+      source: "npm_dependency_tarball",
+      versionSpec,
+      path: `${AGENT_SDK_VENDOR_NPM_DEPENDENCY_DIR}/${sanitizeNpmPackageNameForVendor(
+        packageName
+      )}.tgz`,
+      contents,
+      sha256: sha256Hex(contents),
+      sizeBytes: contents.byteLength
+    });
+    for (const [dependencyName, dependencySpec] of Object.entries(
+      recordStringMap(packedPackageJson.dependencies)
+    )) {
+      pending.push({ packageName: dependencyName, versionSpec: dependencySpec });
+    }
+    for (const [dependencyName, dependencySpec] of Object.entries(
+      recordStringMap(packedPackageJson.optionalDependencies)
+    )) {
+      if (!isSupportedSandboxOptionalDependency(dependencyName)) continue;
+      pending.push({ packageName: dependencyName, versionSpec: dependencySpec });
+    }
   }
-  const cache = await readSourceUploadCache(projectPath);
-  const materialized = await mapWithConcurrency(
-    filesToUpload,
-    PROJECT_SOURCE_UPLOAD_CONCURRENCY,
-    async (file) => materializeSourceUploadFile(file, cache)
-  );
-  await writeSourceUploadCache(projectPath, materialized).catch(() => {
-  });
-  const entries = materialized.map((item) => item.entry);
-  return {
-    entries,
-    fileCount: entries.length,
-    totalBytes,
-    limits: PROJECT_SOURCE_UPLOAD_LIMITS,
-    transport: PROJECT_SOURCE_UPLOAD_TRANSPORT
-  };
+  return tarballs.sort((left, right) => left.packageName.localeCompare(right.packageName));
 }
-async function mapWithConcurrency(items, concurrency, mapper) {
-  const results = new Array(items.length);
-  let nextIndex = 0;
-  const workerCount = Math.max(1, Math.min(concurrency, items.length));
-  await Promise.all(
-    Array.from({ length: workerCount }, async () => {
-      while (nextIndex < items.length) {
-        const index = nextIndex;
-        nextIndex += 1;
-        results[index] = await mapper(items[index], index);
-      }
-    })
-  );
-  return results;
+function isSupportedSandboxOptionalDependency(packageName) {
+  if (packageName === "fsevents") return false;
+  if (packageName.startsWith("@esbuild/")) {
+    return packageName === "@esbuild/linux-x64" || packageName === "@esbuild/linux-arm64";
+  }
+  return true;
 }
-async function collectProjectSourceUploadPaths(projectPath) {
-  const files = await runCommand(
-    "git",
-    ["ls-files", "-z", "--cached", "--others", "--exclude-standard"],
-    { cwd: projectPath }
-  );
-  if (files.code !== 0) {
-    if (existsSync2(path2.join(projectPath, ".git"))) {
-      throw new Error(
-        `git ls-files failed: ${files.stderr.trim() || files.stdout.trim() || "unknown error"}`
-      );
-    }
-    return collectFilesystemProjectSourceUploadPaths(projectPath);
+function npmPackTargetForDependency(params) {
+  if (params.versionSpec.startsWith("file:")) {
+    return path3.resolve(
+      params.dependencyBaseDir,
+      params.versionSpec.slice("file:".length)
+    );
   }
-  return files.stdout.split("\0").map((filePath) => filePath.trim()).filter(Boolean).filter((filePath) => {
-    const normalized = filePath.replace(/\\/g, "/");
-    return isSafeProjectSourcePath(normalized) && !shouldSkipProjectSourcePath(normalized);
-  });
+  return `${params.packageName}@${params.versionSpec}`;
 }
-async function collectFilesystemProjectSourceUploadPaths(projectPath) {
-  const sourcePaths = [];
-  async function visit(relativeDir) {
-    const absoluteDir = path2.join(projectPath, relativeDir);
-    const entries = await fs.readdir(absoluteDir, { withFileTypes: true });
-    for (const entry of entries) {
-      const relativePath = path2.join(relativeDir, entry.name).replace(/\\/g, "/");
-      if (!isSafeProjectSourcePath(relativePath) || shouldSkipProjectSourcePath(relativePath)) {
-        continue;
-      }
-      if (entry.isDirectory()) {
-        await visit(relativePath);
-        continue;
+function sanitizeNpmPackageNameForVendor(packageName) {
+  return packageName.replace(/^@/, "").replace(/[\/\\]/g, "__").replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function resolveLocalOpenPondAgentSdkMaterializationSource(projectPath, packageJson) {
+  const versionSpec = readOpenPondAgentSdkVersionSpec(packageJson);
+  if (versionSpec?.startsWith("file:")) {
+    const candidate = path3.resolve(projectPath, versionSpec.slice("file:".length));
+    if (isOpenPondAgentSdkPackageRoot(candidate)) {
+      return {
+        kind: "package_root",
+        packageRoot: candidate,
+        dependencyBaseDir: candidate,
+        packageJson: JSON.parse(
+          readFileSyncUtf8(path3.join(candidate, "package.json"))
+        )
+      };
+    }
+    if (isLocalNpmTarball(candidate)) {
+      const tarballContents = readFileSync2(candidate);
+      const tarballPackageJson = readPackageJsonFromNpmTarball(tarballContents);
+      if (tarballPackageJson.name === "openpond-agent-sdk") {
+        return {
+          kind: "tarball",
+          tarballPath: candidate,
+          tarballContents,
+          dependencyBaseDir: path3.dirname(candidate),
+          packageJson: tarballPackageJson
+        };
       }
-      if (entry.isFile()) sourcePaths.push(relativePath);
     }
   }
-  try {
-    await visit("");
-  } catch (error) {
-    throw new Error(
-      `filesystem source scan failed: ${error instanceof Error ? error.message : String(error)}`
-    );
+  if (versionSpec?.startsWith("workspace:")) {
+    const candidate = findOpenPondAgentSdkPackageRootInAncestors(projectPath);
+    if (candidate) {
+      return {
+        kind: "package_root",
+        packageRoot: candidate,
+        dependencyBaseDir: candidate,
+        packageJson: JSON.parse(
+          readFileSyncUtf8(path3.join(candidate, "package.json"))
+        )
+      };
+    }
   }
-  return sourcePaths;
+  return null;
 }
-async function collectAgentSdkProjectSourceUploadEntries(projectPath, existingEntries) {
-  if (!isAgentSdkProject(projectPath)) {
-    return {
-      entries: [],
-      generatedManifestPath: null,
-      synthesizedOpenPondYaml: false,
-      uploadMetadataPath: null,
-      uploadMetadata: null,
-      uploadMetadataHash: null
-    };
+function findOpenPondAgentSdkPackageRootInAncestors(projectPath) {
+  let current = path3.resolve(projectPath);
+  while (true) {
+    if (isOpenPondAgentSdkPackageRoot(current)) return current;
+    const parent = path3.dirname(current);
+    if (parent === current) return null;
+    current = parent;
   }
-  await runAgentSdkProjectCheck(projectPath, "build");
-  await runAgentSdkProjectCheck(projectPath, "validate");
-  await runAgentSdkProjectCheck(projectPath, "eval");
-  const packageJson = readAgentSdkProjectPackageJson(projectPath);
-  const materializedDependency = await buildAgentSdkMaterializedDependency(
-    projectPath,
-    packageJson
-  );
-  const manifestPath = ".openpond/openpond-manifest.preview.yaml";
-  const manifestSource = await fs.readFile(path2.join(projectPath, manifestPath), "utf8");
-  const openPondYamlSource = sanitizeAgentSdkRuntimeManifestForOpenPondYaml(
-    manifestSource,
-    materializedDependency?.dependencySetup ?? null
-  );
-  const manifestResult = validateSandboxTemplateYaml(openPondYamlSource);
-  if (!manifestResult.ok) {
-    throw new Error(
-      `generated ${manifestPath} failed sandbox-template validation after openpond.yaml sanitization:
-${formatSandboxTemplateDiagnostics(
-        manifestResult.diagnostics
-      )}`
-    );
+}
+function isOpenPondAgentSdkPackageRoot(candidate) {
+  const packageJsonPath = path3.join(candidate, "package.json");
+  if (!existsSync3(packageJsonPath)) return false;
+  try {
+    const parsed = JSON.parse(readFileSyncUtf8(packageJsonPath));
+    return parsed.name === "openpond-agent-sdk";
+  } catch {
+    return false;
   }
-  const entries = [];
-  if (materializedDependency?.rewrittenPackageJson) {
-    entries.push(
-      projectSourceUploadTextEntry(
-        "package.json",
-        `${JSON.stringify(materializedDependency.rewrittenPackageJson, null, 2)}
-`
-      )
-    );
+}
+function isLocalNpmTarball(candidate) {
+  if (!existsSync3(candidate)) return false;
+  try {
+    return statSync(candidate).isFile() && (candidate.endsWith(".tgz") || candidate.endsWith(".tar.gz"));
+  } catch {
+    return false;
   }
-  if (materializedDependency?.pnpmWorkspaceSource) {
-    entries.push(
-      projectSourceUploadTextEntry(
-        "pnpm-workspace.yaml",
-        materializedDependency.pnpmWorkspaceSource
-      )
-    );
+}
+function readPackageJsonFromNpmTarball(tarballContents) {
+  const tarContents = gunzipSync(tarballContents);
+  let offset = 0;
+  while (offset + 512 <= tarContents.length) {
+    const header = tarContents.subarray(offset, offset + 512);
+    if (header.every((byte) => byte === 0)) break;
+    const name = readTarString(header, 0, 100);
+    const prefix = readTarString(header, 345, 155);
+    const entryPath = prefix ? `${prefix}/${name}` : name;
+    const sizeText = readTarString(header, 124, 12).trim();
+    const size = Number.parseInt(sizeText || "0", 8);
+    if (!Number.isFinite(size) || size < 0) {
+      throw new Error("failed to read openpond-agent-sdk tarball: invalid entry size");
+    }
+    const dataStart = offset + 512;
+    const dataEnd = dataStart + size;
+    if (entryPath === "package/package.json") {
+      return JSON.parse(
+        tarContents.subarray(dataStart, dataEnd).toString("utf8")
+      );
+    }
+    offset = dataStart + Math.ceil(size / 512) * 512;
   }
-  for (const tarball of materializedDependency?.tarballs ?? []) {
-    entries.push(
-      projectSourceUploadBufferEntry(tarball.path, tarball.contents)
-    );
+  throw new Error("failed to read openpond-agent-sdk tarball: missing package.json");
+}
+function readTarString(header, start, length) {
+  const field = header.subarray(start, start + length);
+  const nullIndex = field.indexOf(0);
+  return field.subarray(0, nullIndex === -1 ? field.length : nullIndex).toString("utf8");
+}
+function rewriteAgentSdkPackageJsonForMaterialization(packageJson, dependencyTarballs, packageManager) {
+  const rewritten = { ...packageJson };
+  const dependencies = recordCopy(rewritten.dependencies);
+  const overrides = recordCopy(rewritten.overrides);
+  dependencies["openpond-agent-sdk"] = AGENT_SDK_MATERIALIZED_DEPENDENCY_SPEC;
+  for (const tarball of dependencyTarballs) {
+    const dependencySpec = `file:${tarball.path}`;
+    dependencies[tarball.packageName] = dependencySpec;
+    overrides[tarball.packageName] = dependencySpec;
   }
-  const generatedArtifactPaths = await collectAgentSdkGeneratedArtifactPaths(projectPath);
-  for (const artifactPath of generatedArtifactPaths) {
-    entries.push(await projectSourceUploadFileEntry(projectPath, artifactPath));
+  rewritten.dependencies = dependencies;
+  if (Object.keys(overrides).length > 0) {
+    rewritten.overrides = overrides;
   }
-  const hasAuthoredOpenPondYaml = existingEntries.some((entry) => entry.path === "openpond.yaml") || existsSync2(path2.join(projectPath, "openpond.yaml"));
-  if (!hasAuthoredOpenPondYaml) {
-    entries.push(projectSourceUploadTextEntry("openpond.yaml", openPondYamlSource));
-  } else {
-    const authoredSource = await fs.readFile(path2.join(projectPath, "openpond.yaml"), "utf8");
-    const authoredResult = validateSandboxTemplateYaml(authoredSource);
-    if (!authoredResult.ok) {
-      throw new Error(
-        `authored openpond.yaml failed sandbox-template validation:
-${formatSandboxTemplateDiagnostics(
-          authoredResult.diagnostics
-        )}`
-      );
+  if (packageManager === "unknown") {
+    rewritten.packageManager = OPENPOND_PNPM_PACKAGE_MANAGER;
+  }
+  for (const key of ["devDependencies", "peerDependencies"]) {
+    const entries = recordCopy(rewritten[key]);
+    delete entries["openpond-agent-sdk"];
+    if (Object.keys(entries).length > 0) {
+      rewritten[key] = entries;
+    } else {
+      delete rewritten[key];
     }
   }
-  const uploadMetadata = await buildAgentSdkSourceUploadMetadata(projectPath, {
-    packageJson,
-    generatedManifestPath: manifestPath,
-    generatedArtifactPaths,
-    synthesizedOpenPondYaml: !hasAuthoredOpenPondYaml,
-    openPondYamlSource,
-    dependencySetup: materializedDependency?.dependencySetup ?? null
-  });
-  const uploadMetadataSource = `${JSON.stringify(uploadMetadata, null, 2)}
-`;
-  const uploadMetadataHash = {
-    sha256: sha256Hex(Buffer.from(uploadMetadataSource, "utf8")),
-    sizeBytes: Buffer.byteLength(uploadMetadataSource, "utf8")
-  };
-  entries.push(
-    projectSourceUploadTextEntry(
-      AGENT_SDK_SOURCE_UPLOAD_METADATA_PATH,
-      uploadMetadataSource
-    )
-  );
-  return {
-    entries,
-    generatedManifestPath: manifestPath,
-    synthesizedOpenPondYaml: !hasAuthoredOpenPondYaml,
-    uploadMetadataPath: AGENT_SDK_SOURCE_UPLOAD_METADATA_PATH,
-    uploadMetadata,
-    uploadMetadataHash
-  };
+  return rewritten;
 }
-async function buildAgentSdkSourceUploadMetadata(projectPath, params) {
-  const packageManager = detectAgentSdkPackageManager(projectPath, params.packageJson);
-  const commandHints = buildAgentSdkCommandHints(params.packageJson, packageManager);
-  const setupRequirements = await collectAgentSdkSourceSetupRequirements(projectPath);
-  const artifactHashes = {};
-  for (const artifactPath of params.generatedArtifactPaths) {
-    const absolutePath = path2.join(projectPath, artifactPath);
-    if (!existsSync2(absolutePath)) continue;
-    const contents = await fs.readFile(absolutePath);
-    artifactHashes[artifactPath] = {
-      sha256: sha256Hex(contents),
-      sizeBytes: contents.byteLength
-    };
+function buildAgentSdkPnpmWorkspaceSource(projectPath, dependencyTarballs) {
+  const workspacePath = path3.join(projectPath, "pnpm-workspace.yaml");
+  let workspace = {};
+  if (existsSync3(workspacePath)) {
+    const parsed = yaml.load(readFileSyncUtf8(workspacePath));
+    workspace = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? { ...parsed } : {};
   }
-  artifactHashes["openpond.yaml"] = {
-    sha256: sha256Hex(Buffer.from(params.openPondYamlSource, "utf8")),
-    sizeBytes: Buffer.byteLength(params.openPondYamlSource, "utf8")
-  };
-  return {
-    schema: "openpond.agent.source_upload.v1",
-    sourceTreeMode: "typescript_agent_sdk",
-    packageManager,
-    sdk: {
-      packageName: "openpond-agent-sdk",
-      versionSpec: readOpenPondAgentSdkVersionSpec(params.packageJson)
-    },
-    commands: commandHints,
-    ...params.dependencySetup ? { dependencySetup: params.dependencySetup } : {},
-    ...setupRequirements.length > 0 ? { setupRequirements } : {},
-    generatedManifestPath: params.generatedManifestPath,
-    synthesizedOpenPondYaml: params.synthesizedOpenPondYaml,
-    openPondYamlMode: params.synthesizedOpenPondYaml ? "synthesized" : "authored",
-    artifactHashes
-  };
-}
-async function collectAgentSdkGeneratedArtifactPaths(projectPath) {
-  const generatedArtifacts = /* @__PURE__ */ new Set();
-  for (const artifactPath of AGENT_SDK_GENERATED_ARTIFACTS) {
-    if (existsSync2(path2.join(projectPath, artifactPath))) {
-      generatedArtifacts.add(artifactPath);
-    }
+  if (!Array.isArray(workspace.packages)) workspace.packages = [];
+  const overrides = recordCopy(workspace.overrides);
+  for (const tarball of dependencyTarballs) {
+    overrides[tarball.packageName] = `file:${tarball.path}`;
   }
-  for (const skillArtifactPath of await collectAgentSdkGeneratedSkillArtifactPaths(projectPath)) {
-    generatedArtifacts.add(skillArtifactPath);
+  workspace.overrides = overrides;
+  const allowBuilds = recordCopy(workspace.allowBuilds);
+  allowBuilds.esbuild = true;
+  const vendoredEsbuild = dependencyTarballs.find(
+    (tarball) => tarball.packageName === "esbuild"
+  );
+  if (vendoredEsbuild) {
+    allowBuilds[`esbuild@file:${vendoredEsbuild.path}`] = true;
   }
-  return Array.from(generatedArtifacts).sort((left, right) => left.localeCompare(right));
+  workspace.allowBuilds = allowBuilds;
+  workspace.supportedArchitectures = {
+    os: ["linux"],
+    cpu: ["x64", "arm64"],
+    libc: ["glibc", "musl"]
+  };
+  return yaml.dump(workspace, { lineWidth: 120, noRefs: true });
 }
-async function collectAgentSdkGeneratedSkillArtifactPaths(projectPath) {
-  const skillsRoot = path2.join(projectPath, AGENT_SDK_GENERATED_SKILLS_DIR);
-  if (!existsSync2(skillsRoot)) return [];
-  const results = [];
-  async function visit(relativeDir) {
-    const absoluteDir = path2.join(projectPath, relativeDir);
-    const entries = await fs.readdir(absoluteDir, { withFileTypes: true });
-    entries.sort((left, right) => left.name.localeCompare(right.name));
-    for (const entry of entries) {
-      const relativePath = path2.join(relativeDir, entry.name).replace(/\\/g, "/");
-      if (!isSafeProjectSourcePath(relativePath)) continue;
-      if (entry.isDirectory()) {
-        await visit(relativePath);
-        continue;
-      }
-      if (entry.isFile()) results.push(relativePath);
+function recordStringMap(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const entries = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (typeof entryValue === "string" && entryValue.trim()) {
+      entries[key] = entryValue.trim();
     }
   }
-  await visit(AGENT_SDK_GENERATED_SKILLS_DIR);
-  return results;
+  return entries;
 }
-async function collectAgentSdkSourceSetupRequirements(projectPath) {
-  const requirements = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const relativePath of [
-    ".openpond/action-registry.json",
-    ".openpond/agent-manifest.json"
-  ]) {
-    const payload = await readJsonFileIfExists(path2.join(projectPath, relativePath));
-    if (!payload) continue;
-    for (const actionRecord of [
-      ...recordArray(payload.actions),
-      ...recordArray(payload.actionCatalog)
-    ]) {
-      const actionId = text(actionRecord.id) ?? text(actionRecord.name);
-      const actionName = text(actionRecord.name) ?? actionId;
-      if (!actionId && !actionName) continue;
-      for (const setupRecord of recordArray(actionRecord.setupRequirements)) {
-        const setupRequirement = { ...setupRecord };
-        if (actionId) setupRequirement.actionId = actionId;
-        if (actionName && actionName !== actionId) setupRequirement.actionName = actionName;
-        const key = setupRequirementIdentity(setupRequirement);
-        if (seen.has(key)) continue;
-        seen.add(key);
-        requirements.push(setupRequirement);
-      }
-    }
-  }
-  return requirements;
+function recordCopy(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return { ...value };
 }
-async function readJsonFileIfExists(filePath) {
-  try {
-    const parsed = JSON.parse(await fs.readFile(filePath, "utf8"));
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
+function recordArray(value) {
+  return Array.isArray(value) ? value.filter(
+    (item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)
+  ) : [];
 }
-function setupRequirementIdentity(record) {
-  return [
-    text(record.actionId) ?? "",
-    text(record.actionName) ?? "",
-    text(record.kind) ?? text(record.type) ?? "",
-    text(record.label) ?? text(record.name) ?? text(record.key) ?? text(record.provider) ?? text(record.tool) ?? text(record.command) ?? text(record.packageName) ?? ""
-  ].join(":");
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function readAgentSdkProjectPackageJson(projectPath) {
-  const packageJsonPath = path2.join(projectPath, "package.json");
-  return JSON.parse(readFileSyncUtf8(packageJsonPath));
+function sha256Hex(contents) {
+  return createHash("sha256").update(contents).digest("hex");
 }
-function detectAgentSdkPackageManager(projectPath, packageJson) {
-  const packageManager = packageJson.packageManager;
-  if (typeof packageManager === "string") {
-    const name = packageManager.split("@")[0];
-    if (name === "bun" || name === "npm" || name === "pnpm" || name === "yarn") {
-      return name;
-    }
-  }
-  if (existsSync2(path2.join(projectPath, "bun.lock")) || existsSync2(path2.join(projectPath, "bun.lockb"))) {
-    return "bun";
-  }
-  if (existsSync2(path2.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync2(path2.join(projectPath, "yarn.lock"))) return "yarn";
-  if (existsSync2(path2.join(projectPath, "package-lock.json")) || existsSync2(path2.join(projectPath, "npm-shrinkwrap.json"))) {
-    return "npm";
+function dependencySetupCommands(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+  const record = value;
+  if (Array.isArray(record.commands)) {
+    return record.commands.filter(
+      (command) => typeof command === "string" && command.trim() !== ""
+    );
   }
-  return "unknown";
+  return typeof record.installCommand === "string" && record.installCommand.trim() ? [record.installCommand.trim()] : [];
 }
-function buildAgentSdkCommandHints(packageJson, packageManager) {
+function mergeManifestSetupCommands(manifest, commands) {
+  if (commands.length === 0) return manifest;
+  const setup = manifest.setup && typeof manifest.setup === "object" && !Array.isArray(manifest.setup) ? recordCopy(manifest.setup) : {};
+  const existingCommands = Array.isArray(setup.commands) ? setup.commands.filter(
+    (command) => typeof command === "string" && command.trim() !== ""
+  ) : [];
+  const mergedCommands = [...commands];
+  for (const command of existingCommands) {
+    if (!mergedCommands.includes(command)) mergedCommands.push(command);
+  }
   return {
-    inspect: buildAgentSdkCommandHint(
-      packageJson,
-      packageManager,
-      "agent:inspect",
-      "openpond-agent inspect --json"
-    ),
-    build: buildAgentSdkCommandHint(
-      packageJson,
-      packageManager,
-      "agent:build",
-      "openpond-agent build"
-    ),
-    validate: buildAgentSdkCommandHint(
-      packageJson,
-      packageManager,
-      "agent:validate",
-      "openpond-agent validate"
-    ),
-    eval: buildAgentSdkCommandHint(
-      packageJson,
-      packageManager,
-      "agent:eval",
-      "openpond-agent eval"
-    )
+    ...manifest,
+    setup: {
+      ...setup,
+      commands: mergedCommands
+    }
   };
 }
-function buildAgentSdkCommandHint(packageJson, packageManager, scriptName, fallback) {
-  const scripts = packageJson.scripts;
-  const hasScript = scripts && typeof scripts === "object" && !Array.isArray(scripts) && typeof scripts[scriptName] === "string";
-  if (!hasScript) return fallback;
-  if (packageManager === "pnpm") return `pnpm run ${scriptName}`;
-  if (packageManager === "yarn") return `yarn ${scriptName}`;
-  if (packageManager === "npm") return `npm run ${scriptName}`;
-  if (packageManager === "bun") return `bun run ${scriptName}`;
-  return `pnpm run ${scriptName}`;
+function sanitizeAgentSdkRuntimeManifestForOpenPondYaml(source, dependencySetup) {
+  const parsed = yaml.load(source);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return `${AGENT_SDK_SYNTHESIZED_OPENPOND_YAML_SENTINEL}
+${source}`;
+  }
+  const manifest = mergeManifestSetupCommands(
+    { ...parsed },
+    dependencySetupCommands(dependencySetup)
+  );
+  delete manifest.schema;
+  sanitizeGeneratedManifestNamedCommands(manifest, "actions");
+  sanitizeGeneratedManifestNamedCommands(manifest, "services");
+  return `${AGENT_SDK_SYNTHESIZED_OPENPOND_YAML_SENTINEL}
+${yaml.dump(manifest, { lineWidth: -1, noRefs: true })}`;
 }
-function readOpenPondAgentSdkVersionSpec(packageJson) {
-  for (const key of ["dependencies", "devDependencies", "peerDependencies"]) {
-    const dependencies = packageJson[key];
-    if (!dependencies || typeof dependencies !== "object" || Array.isArray(dependencies)) {
-      continue;
+function sanitizeGeneratedManifestNamedCommands(manifest, key) {
+  if (!Array.isArray(manifest[key])) return;
+  manifest[key] = manifest[key].map((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      return entry;
     }
-    const value = dependencies["openpond-agent-sdk"];
-    if (typeof value === "string" && value.trim()) return value.trim();
-  }
-  return null;
+    const sanitized = { ...entry };
+    delete sanitized.id;
+    delete sanitized.label;
+    return sanitized;
+  });
 }
-async function buildAgentSdkMaterializedDependency(projectPath, packageJson) {
-  const sdkSource = resolveLocalOpenPondAgentSdkMaterializationSource(
-    projectPath,
-    packageJson
-  );
-  if (!sdkSource) return null;
-  const tempDir = await fs.mkdtemp(path2.join(tmpdir(), "openpond-agent-sdk-pack-"));
+function isAgentSdkProject(projectPath) {
+  if (!existsSync3(path3.join(projectPath, "agent", "agent.ts"))) return false;
+  const packageJsonPath = path3.join(projectPath, "package.json");
+  if (!existsSync3(packageJsonPath)) return false;
   try {
-    const sdkContents = sdkSource.kind === "package_root" ? await packOpenPondAgentSdkPackageRoot(sdkSource.packageRoot, tempDir) : sdkSource.tarballContents;
-    const sdkDependencyTarballs = await packAgentSdkRuntimeDependencyTarballs({
-      sdkPackageJson: sdkSource.packageJson,
-      dependencyBaseDir: sdkSource.dependencyBaseDir,
-      tempDir
-    });
-    const packageManager = detectAgentSdkPackageManager(projectPath, packageJson);
-    const rewrittenPackageJson = rewriteAgentSdkPackageJsonForMaterialization(
-      packageJson,
-      sdkDependencyTarballs,
-      packageManager
+    const parsed = JSON.parse(readFileSyncUtf8(packageJsonPath));
+    return Boolean(
+      parsed.dependencies?.["openpond-agent-sdk"] || parsed.devDependencies?.["openpond-agent-sdk"] || parsed.peerDependencies?.["openpond-agent-sdk"]
     );
-    const pnpmWorkspaceSource = packageManager === "pnpm" || packageManager === "unknown" ? buildAgentSdkPnpmWorkspaceSource(projectPath, sdkDependencyTarballs) : null;
-    const installCommand = agentSdkDependencyInstallCommand(packageManager);
-    const sdkPackage = {
-      packageName: "openpond-agent-sdk",
-      source: "uploaded_tarball",
-      path: AGENT_SDK_VENDOR_TARBALL_PATH,
-      sha256: sha256Hex(sdkContents),
-      sizeBytes: sdkContents.byteLength
-    };
-    return {
-      rewrittenPackageJson,
-      pnpmWorkspaceSource,
-      tarballs: [
-        {
-          ...sdkPackage,
-          contents: sdkContents
-        },
-        ...sdkDependencyTarballs
-      ],
-      dependencySetup: {
-        required: true,
-        packageManager,
-        installCommand,
-        commands: [installCommand],
-        packageJsonPath: "package.json",
-        expectedBinaryPath: "node_modules/.bin/openpond-agent",
-        generatedArtifactDirectory: ".openpond",
-        sdkPackage,
-        dependencyPackages: sdkDependencyTarballs.map((tarball) => ({
-          packageName: tarball.packageName,
-          source: tarball.source,
-          versionSpec: tarball.versionSpec,
-          path: tarball.path,
-          sha256: tarball.sha256,
-          sizeBytes: tarball.sizeBytes
-        }))
-      }
-    };
-  } finally {
-    await fs.rm(tempDir, { recursive: true, force: true });
+  } catch {
+    return false;
   }
 }
-async function packOpenPondAgentSdkPackageRoot(sdkPackageRoot, tempDir) {
-  const pack = await runCommand(
-    "npm",
-    ["pack", "--silent", "--pack-destination", tempDir, sdkPackageRoot],
-    { cwd: sdkPackageRoot }
-  );
-  if (pack.code !== 0) {
-    const details = [pack.stderr.trim(), pack.stdout.trim()].filter(Boolean).join("\n");
-    throw new Error(
-      `failed to pack openpond-agent-sdk for source upload${details ? `:
-${details}` : ""}`
-    );
-  }
-  const tarballName = pack.stdout.trim().split(/\r?\n/).filter(Boolean).pop();
-  if (!tarballName) {
-    throw new Error("failed to pack openpond-agent-sdk for source upload: npm pack did not return a tarball name");
-  }
-  return fs.readFile(path2.join(tempDir, tarballName));
+function readFileSyncUtf8(filePath) {
+  return readFileSync2(filePath, "utf8");
 }
-async function packAgentSdkRuntimeDependencyTarballs(params) {
-  const dependencies = recordStringMap(params.sdkPackageJson.dependencies);
-  const pending = Object.entries(dependencies).sort(([left], [right]) => left.localeCompare(right)).map(([packageName, versionSpec]) => ({ packageName, versionSpec }));
-  const seen = /* @__PURE__ */ new Set();
-  const tarballs = [];
-  while (pending.length > 0) {
-    const { packageName, versionSpec } = pending.shift();
-    if (seen.has(packageName)) continue;
-    seen.add(packageName);
-    const packTarget = npmPackTargetForDependency({
-      packageName,
-      versionSpec,
-      dependencyBaseDir: params.dependencyBaseDir
-    });
-    const pack = await runCommand(
-      "npm",
-      ["pack", "--silent", "--pack-destination", params.tempDir, packTarget],
-      { cwd: params.dependencyBaseDir }
-    );
-    if (pack.code !== 0) {
-      const details = [pack.stderr.trim(), pack.stdout.trim()].filter(Boolean).join("\n");
-      throw new Error(
-        `failed to pack openpond-agent-sdk dependency ${packageName}${details ? `:
-${details}` : ""}`
-      );
-    }
-    const tarballName = pack.stdout.trim().split(/\r?\n/).filter(Boolean).pop();
-    if (!tarballName) {
-      throw new Error(
-        `failed to pack openpond-agent-sdk dependency ${packageName}: npm pack did not return a tarball name`
-      );
-    }
-    const contents = await fs.readFile(path2.join(params.tempDir, tarballName));
-    const packedPackageJson = readPackageJsonFromNpmTarball(contents);
-    tarballs.push({
-      packageName,
-      source: "npm_dependency_tarball",
-      versionSpec,
-      path: `${AGENT_SDK_VENDOR_NPM_DEPENDENCY_DIR}/${sanitizeNpmPackageNameForVendor(
-        packageName
-      )}.tgz`,
-      contents,
-      sha256: sha256Hex(contents),
-      sizeBytes: contents.byteLength
-    });
-    for (const [dependencyName, dependencySpec] of Object.entries(
-      recordStringMap(packedPackageJson.dependencies)
-    )) {
-      pending.push({ packageName: dependencyName, versionSpec: dependencySpec });
-    }
-    for (const [dependencyName, dependencySpec] of Object.entries(
-      recordStringMap(packedPackageJson.optionalDependencies)
-    )) {
-      if (!isSupportedSandboxOptionalDependency(dependencyName)) continue;
-      pending.push({ packageName: dependencyName, versionSpec: dependencySpec });
-    }
-  }
-  return tarballs.sort((left, right) => left.packageName.localeCompare(right.packageName));
+
+// ../../packages/cloud/src/profile/project-source-upload.ts
+function optionString2(options, key) {
+  const value = options[key];
+  return typeof value === "string" ? value.trim() : "";
 }
-function isSupportedSandboxOptionalDependency(packageName) {
-  if (packageName === "fsevents") return false;
-  if (packageName.startsWith("@esbuild/")) {
-    return packageName === "@esbuild/linux-x64" || packageName === "@esbuild/linux-arm64";
-  }
-  return true;
+async function runCommand2(command, args, options = {}) {
+  return runProcessCommand(command, args, { cwd: options.cwd });
 }
-function npmPackTargetForDependency(params) {
-  if (params.versionSpec.startsWith("file:")) {
-    return path2.resolve(
-      params.dependencyBaseDir,
-      params.versionSpec.slice("file:".length)
-    );
-  }
-  return `${params.packageName}@${params.versionSpec}`;
+var PROJECT_SOURCE_UPLOAD_MAX_FILES = 1500;
+var PROJECT_SOURCE_UPLOAD_MAX_FILE_BYTES = 8 * 1024 * 1024;
+var PROJECT_SOURCE_UPLOAD_MAX_BYTES = 100 * 1024 * 1024;
+var PROJECT_SOURCE_UPLOAD_CONCURRENCY = 8;
+var PROJECT_SOURCE_UPLOAD_LIMITS = {
+  maxFiles: PROJECT_SOURCE_UPLOAD_MAX_FILES,
+  maxFileBytes: PROJECT_SOURCE_UPLOAD_MAX_FILE_BYTES,
+  maxTotalBytes: PROJECT_SOURCE_UPLOAD_MAX_BYTES,
+  concurrency: PROJECT_SOURCE_UPLOAD_CONCURRENCY
+};
+var PROJECT_SOURCE_UPLOAD_TRANSPORT = {
+  mode: "single_json_payload",
+  chunkingSupported: false
+};
+var AGENT_SDK_SOURCE_UPLOAD_METADATA_PATH = ".openpond/source-upload-metadata.json";
+var AGENT_SDK_GENERATED_SKILLS_DIR = ".openpond/skills";
+var AGENT_SDK_GENERATED_ARTIFACTS = [
+  ".openpond/agent-inspect.json",
+  ".openpond/agent-manifest.json",
+  ".openpond/action-registry.json",
+  ".openpond/openpond-manifest.preview.yaml",
+  ".openpond/runtime-bridge.mjs",
+  ".openpond/validator-report.md"
+];
+function isSafeProjectSourcePath(filePath) {
+  return filePath.length > 0 && !filePath.includes("\0") && !path4.isAbsolute(filePath) && !filePath.split(/[\\/]+/).some((part) => !part || part === "." || part === "..");
 }
-function sanitizeNpmPackageNameForVendor(packageName) {
-  return packageName.replace(/^@/, "").replace(/[\/\\]/g, "__").replace(/[^a-zA-Z0-9._-]/g, "_");
+function shouldSkipProjectSourcePath(filePath) {
+  return filePath.split(/[\\/]+/).some((segment) => {
+    const lower = segment.toLowerCase();
+    return lower === ".git" || lower === ".openpond" || lower === "node_modules" || lower === ".next" || lower === ".turbo" || lower.startsWith(".env");
+  });
 }
-function resolveLocalOpenPondAgentSdkMaterializationSource(projectPath, packageJson) {
-  const versionSpec = readOpenPondAgentSdkVersionSpec(packageJson);
-  if (versionSpec?.startsWith("file:")) {
-    const candidate = path2.resolve(projectPath, versionSpec.slice("file:".length));
-    if (isOpenPondAgentSdkPackageRoot(candidate)) {
-      return {
-        kind: "package_root",
-        packageRoot: candidate,
-        dependencyBaseDir: candidate,
-        packageJson: JSON.parse(
-          readFileSyncUtf8(path2.join(candidate, "package.json"))
-        )
-      };
+async function resolveProjectSourceUploadBranch(projectPath, options) {
+  const explicit = optionString2(options, "branch");
+  if (explicit) return explicit;
+  const branch = await runCommand2("git", ["branch", "--show-current"], {
+    cwd: projectPath
+  });
+  if (branch.code !== 0) return null;
+  return branch.stdout.trim() || null;
+}
+async function collectProjectSourceUploadEntries(projectPath) {
+  const sourcePaths = await collectProjectSourceUploadPaths(projectPath);
+  if (sourcePaths.length === 0) {
+    throw new Error("no source files found to upload");
+  }
+  if (sourcePaths.length > PROJECT_SOURCE_UPLOAD_MAX_FILES) {
+    throw new Error(
+      `too many source files to upload: ${sourcePaths.length} > ${PROJECT_SOURCE_UPLOAD_MAX_FILES}`
+    );
+  }
+  const sortedSourcePaths = sourcePaths.sort();
+  const filesToUpload = (await mapWithConcurrency(sortedSourcePaths, PROJECT_SOURCE_UPLOAD_CONCURRENCY, async (sourcePath) => {
+    const absolutePath = path4.resolve(projectPath, sourcePath);
+    const relative = path4.relative(projectPath, absolutePath);
+    if (relative.startsWith("..") || path4.isAbsolute(relative)) {
+      throw new Error(`source path escapes project: ${sourcePath}`);
     }
-    if (isLocalNpmTarball(candidate)) {
-      const tarballContents = readFileSync2(candidate);
-      const tarballPackageJson = readPackageJsonFromNpmTarball(tarballContents);
-      if (tarballPackageJson.name === "openpond-agent-sdk") {
-        return {
-          kind: "tarball",
-          tarballPath: candidate,
-          tarballContents,
-          dependencyBaseDir: path2.dirname(candidate),
-          packageJson: tarballPackageJson
-        };
-      }
+    const stat = await fs2.stat(absolutePath);
+    if (!stat.isFile()) return null;
+    if (stat.size > PROJECT_SOURCE_UPLOAD_MAX_FILE_BYTES) {
+      throw new Error(
+        `source file is too large: ${sourcePath} (${stat.size} bytes)`
+      );
     }
-  }
-  if (versionSpec?.startsWith("workspace:")) {
-    const candidate = findOpenPondAgentSdkPackageRootInAncestors(projectPath);
-    if (candidate) {
-      return {
-        kind: "package_root",
-        packageRoot: candidate,
-        dependencyBaseDir: candidate,
-        packageJson: JSON.parse(
-          readFileSyncUtf8(path2.join(candidate, "package.json"))
-        )
-      };
+    return {
+      path: sourcePath.replace(/\\/g, "/"),
+      absolutePath,
+      size: stat.size,
+      mtimeMs: Math.trunc(stat.mtimeMs),
+      ctimeMs: Math.trunc(stat.ctimeMs)
+    };
+  })).filter((file) => file !== null);
+  let totalBytes = 0;
+  for (const file of filesToUpload) {
+    totalBytes += file.size;
+    if (totalBytes > PROJECT_SOURCE_UPLOAD_MAX_BYTES) {
+      throw new Error(
+        `source upload is too large: ${totalBytes} > ${PROJECT_SOURCE_UPLOAD_MAX_BYTES}`
+      );
     }
   }
-  return null;
-}
-function findOpenPondAgentSdkPackageRootInAncestors(projectPath) {
-  let current = path2.resolve(projectPath);
-  while (true) {
-    if (isOpenPondAgentSdkPackageRoot(current)) return current;
-    const parent = path2.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-function isOpenPondAgentSdkPackageRoot(candidate) {
-  const packageJsonPath = path2.join(candidate, "package.json");
-  if (!existsSync2(packageJsonPath)) return false;
-  try {
-    const parsed = JSON.parse(readFileSyncUtf8(packageJsonPath));
-    return parsed.name === "openpond-agent-sdk";
-  } catch {
-    return false;
-  }
+  const cache = await readSourceUploadCache(projectPath);
+  const materialized = await mapWithConcurrency(
+    filesToUpload,
+    PROJECT_SOURCE_UPLOAD_CONCURRENCY,
+    async (file) => materializeSourceUploadFile(file, cache)
+  );
+  await writeSourceUploadCache(projectPath, materialized).catch(() => {
+  });
+  const entries = materialized.map((item) => item.entry);
+  return {
+    entries,
+    fileCount: entries.length,
+    totalBytes,
+    limits: PROJECT_SOURCE_UPLOAD_LIMITS,
+    transport: PROJECT_SOURCE_UPLOAD_TRANSPORT
+  };
 }
-function isLocalNpmTarball(candidate) {
-  if (!existsSync2(candidate)) return false;
-  try {
-    return statSync(candidate).isFile() && (candidate.endsWith(".tgz") || candidate.endsWith(".tar.gz"));
-  } catch {
-    return false;
-  }
+async function mapWithConcurrency(items, concurrency, mapper) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const workerCount = Math.max(1, Math.min(concurrency, items.length));
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      while (nextIndex < items.length) {
+        const index = nextIndex;
+        nextIndex += 1;
+        results[index] = await mapper(items[index], index);
+      }
+    })
+  );
+  return results;
 }
-function readPackageJsonFromNpmTarball(tarballContents) {
-  const tarContents = gunzipSync(tarballContents);
-  let offset = 0;
-  while (offset + 512 <= tarContents.length) {
-    const header = tarContents.subarray(offset, offset + 512);
-    if (header.every((byte) => byte === 0)) break;
-    const name = readTarString(header, 0, 100);
-    const prefix = readTarString(header, 345, 155);
-    const entryPath = prefix ? `${prefix}/${name}` : name;
-    const sizeText = readTarString(header, 124, 12).trim();
-    const size = Number.parseInt(sizeText || "0", 8);
-    if (!Number.isFinite(size) || size < 0) {
-      throw new Error("failed to read openpond-agent-sdk tarball: invalid entry size");
-    }
-    const dataStart = offset + 512;
-    const dataEnd = dataStart + size;
-    if (entryPath === "package/package.json") {
-      return JSON.parse(
-        tarContents.subarray(dataStart, dataEnd).toString("utf8")
+async function collectProjectSourceUploadPaths(projectPath) {
+  const files = await runCommand2(
+    "git",
+    ["ls-files", "-z", "--cached", "--others", "--exclude-standard"],
+    { cwd: projectPath }
+  );
+  if (files.code !== 0) {
+    if (existsSync4(path4.join(projectPath, ".git"))) {
+      throw new Error(
+        `git ls-files failed: ${files.stderr.trim() || files.stdout.trim() || "unknown error"}`
       );
     }
-    offset = dataStart + Math.ceil(size / 512) * 512;
+    return collectFilesystemProjectSourceUploadPaths(projectPath);
   }
-  throw new Error("failed to read openpond-agent-sdk tarball: missing package.json");
+  return files.stdout.split("\0").map((filePath) => filePath.trim()).filter(Boolean).filter((filePath) => {
+    const normalized = filePath.replace(/\\/g, "/");
+    return isSafeProjectSourcePath(normalized) && !shouldSkipProjectSourcePath(normalized);
+  });
 }
-function readTarString(header, start, length) {
-  const field = header.subarray(start, start + length);
-  const nullIndex = field.indexOf(0);
-  return field.subarray(0, nullIndex === -1 ? field.length : nullIndex).toString("utf8");
+async function collectFilesystemProjectSourceUploadPaths(projectPath) {
+  const sourcePaths = [];
+  async function visit(relativeDir) {
+    const absoluteDir = path4.join(projectPath, relativeDir);
+    const entries = await fs2.readdir(absoluteDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const relativePath = path4.join(relativeDir, entry.name).replace(/\\/g, "/");
+      if (!isSafeProjectSourcePath(relativePath) || shouldSkipProjectSourcePath(relativePath)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await visit(relativePath);
+        continue;
+      }
+      if (entry.isFile()) sourcePaths.push(relativePath);
+    }
+  }
+  try {
+    await visit("");
+  } catch (error) {
+    throw new Error(
+      `filesystem source scan failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return sourcePaths;
 }
-function rewriteAgentSdkPackageJsonForMaterialization(packageJson, dependencyTarballs, packageManager) {
-  const rewritten = { ...packageJson };
-  const dependencies = recordCopy(rewritten.dependencies);
-  const overrides = recordCopy(rewritten.overrides);
-  dependencies["openpond-agent-sdk"] = AGENT_SDK_MATERIALIZED_DEPENDENCY_SPEC;
-  for (const tarball of dependencyTarballs) {
-    const dependencySpec = `file:${tarball.path}`;
-    dependencies[tarball.packageName] = dependencySpec;
-    overrides[tarball.packageName] = dependencySpec;
+async function collectAgentSdkProjectSourceUploadEntries(projectPath, existingEntries) {
+  if (!isAgentSdkProject(projectPath)) {
+    return {
+      entries: [],
+      generatedManifestPath: null,
+      synthesizedOpenPondYaml: false,
+      uploadMetadataPath: null,
+      uploadMetadata: null,
+      uploadMetadataHash: null
+    };
   }
-  rewritten.dependencies = dependencies;
-  if (Object.keys(overrides).length > 0) {
-    rewritten.overrides = overrides;
+  await runAgentSdkProjectCheck(projectPath, "build");
+  await runAgentSdkProjectCheck(projectPath, "validate");
+  await runAgentSdkProjectCheck(projectPath, "eval");
+  const packageJson = readAgentSdkProjectPackageJson(projectPath);
+  const materializedDependency = await buildAgentSdkMaterializedDependency(
+    projectPath,
+    packageJson
+  );
+  const manifestPath = ".openpond/openpond-manifest.preview.yaml";
+  const manifestSource = await fs2.readFile(path4.join(projectPath, manifestPath), "utf8");
+  const openPondYamlSource = sanitizeAgentSdkRuntimeManifestForOpenPondYaml(
+    manifestSource,
+    materializedDependency?.dependencySetup ?? null
+  );
+  const manifestResult = validateSandboxTemplateYaml(openPondYamlSource);
+  if (!manifestResult.ok) {
+    throw new Error(
+      `generated ${manifestPath} failed sandbox-template validation after openpond.yaml sanitization:
+${formatSandboxTemplateDiagnostics(
+        manifestResult.diagnostics
+      )}`
+    );
   }
-  if (packageManager === "unknown") {
-    rewritten.packageManager = OPENPOND_PNPM_PACKAGE_MANAGER;
+  const entries = [];
+  if (materializedDependency?.rewrittenPackageJson) {
+    entries.push(
+      projectSourceUploadTextEntry(
+        "package.json",
+        `${JSON.stringify(materializedDependency.rewrittenPackageJson, null, 2)}
+`
+      )
+    );
   }
-  for (const key of ["devDependencies", "peerDependencies"]) {
-    const entries = recordCopy(rewritten[key]);
-    delete entries["openpond-agent-sdk"];
-    if (Object.keys(entries).length > 0) {
-      rewritten[key] = entries;
-    } else {
-      delete rewritten[key];
-    }
+  if (materializedDependency?.pnpmWorkspaceSource) {
+    entries.push(
+      projectSourceUploadTextEntry(
+        "pnpm-workspace.yaml",
+        materializedDependency.pnpmWorkspaceSource
+      )
+    );
   }
-  return rewritten;
-}
-function buildAgentSdkPnpmWorkspaceSource(projectPath, dependencyTarballs) {
-  const workspacePath = path2.join(projectPath, "pnpm-workspace.yaml");
-  let workspace = {};
-  if (existsSync2(workspacePath)) {
-    const parsed = yaml.load(readFileSyncUtf8(workspacePath));
-    workspace = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? { ...parsed } : {};
+  for (const tarball of materializedDependency?.tarballs ?? []) {
+    entries.push(
+      projectSourceUploadBufferEntry(tarball.path, tarball.contents)
+    );
   }
-  if (!Array.isArray(workspace.packages)) workspace.packages = [];
-  const overrides = recordCopy(workspace.overrides);
-  for (const tarball of dependencyTarballs) {
-    overrides[tarball.packageName] = `file:${tarball.path}`;
+  const generatedArtifactPaths = await collectAgentSdkGeneratedArtifactPaths(projectPath);
+  for (const artifactPath of generatedArtifactPaths) {
+    entries.push(await projectSourceUploadFileEntry(projectPath, artifactPath));
   }
-  workspace.overrides = overrides;
-  const allowBuilds = recordCopy(workspace.allowBuilds);
-  allowBuilds.esbuild = true;
-  const vendoredEsbuild = dependencyTarballs.find(
-    (tarball) => tarball.packageName === "esbuild"
+  const hasAuthoredOpenPondYaml = existingEntries.some((entry) => entry.path === "openpond.yaml") || existsSync4(path4.join(projectPath, "openpond.yaml"));
+  if (!hasAuthoredOpenPondYaml) {
+    entries.push(projectSourceUploadTextEntry("openpond.yaml", openPondYamlSource));
+  } else {
+    const authoredSource = await fs2.readFile(path4.join(projectPath, "openpond.yaml"), "utf8");
+    const authoredResult = validateSandboxTemplateYaml(authoredSource);
+    if (!authoredResult.ok) {
+      throw new Error(
+        `authored openpond.yaml failed sandbox-template validation:
+${formatSandboxTemplateDiagnostics(
+          authoredResult.diagnostics
+        )}`
+      );
+    }
+  }
+  const uploadMetadata = await buildAgentSdkSourceUploadMetadata(projectPath, {
+    packageJson,
+    generatedManifestPath: manifestPath,
+    generatedArtifactPaths,
+    synthesizedOpenPondYaml: !hasAuthoredOpenPondYaml,
+    openPondYamlSource,
+    dependencySetup: materializedDependency?.dependencySetup ?? null
+  });
+  const uploadMetadataSource = `${JSON.stringify(uploadMetadata, null, 2)}
+`;
+  const uploadMetadataHash = {
+    sha256: sha256Hex(Buffer.from(uploadMetadataSource, "utf8")),
+    sizeBytes: Buffer.byteLength(uploadMetadataSource, "utf8")
+  };
+  entries.push(
+    projectSourceUploadTextEntry(
+      AGENT_SDK_SOURCE_UPLOAD_METADATA_PATH,
+      uploadMetadataSource
+    )
   );
-  if (vendoredEsbuild) {
-    allowBuilds[`esbuild@file:${vendoredEsbuild.path}`] = true;
+  return {
+    entries,
+    generatedManifestPath: manifestPath,
+    synthesizedOpenPondYaml: !hasAuthoredOpenPondYaml,
+    uploadMetadataPath: AGENT_SDK_SOURCE_UPLOAD_METADATA_PATH,
+    uploadMetadata,
+    uploadMetadataHash
+  };
+}
+async function buildAgentSdkSourceUploadMetadata(projectPath, params) {
+  const packageManager = detectAgentSdkPackageManager(projectPath, params.packageJson);
+  const commandHints = buildAgentSdkCommandHints(params.packageJson, packageManager);
+  const setupRequirements = await collectAgentSdkSourceSetupRequirements(projectPath);
+  const artifactHashes = {};
+  for (const artifactPath of params.generatedArtifactPaths) {
+    const absolutePath = path4.join(projectPath, artifactPath);
+    if (!existsSync4(absolutePath)) continue;
+    const contents = await fs2.readFile(absolutePath);
+    artifactHashes[artifactPath] = {
+      sha256: sha256Hex(contents),
+      sizeBytes: contents.byteLength
+    };
   }
-  workspace.allowBuilds = allowBuilds;
-  workspace.supportedArchitectures = {
-    os: ["linux"],
-    cpu: ["x64", "arm64"],
-    libc: ["glibc", "musl"]
+  artifactHashes["openpond.yaml"] = {
+    sha256: sha256Hex(Buffer.from(params.openPondYamlSource, "utf8")),
+    sizeBytes: Buffer.byteLength(params.openPondYamlSource, "utf8")
+  };
+  return {
+    schema: "openpond.agent.source_upload.v1",
+    sourceTreeMode: "typescript_agent_sdk",
+    packageManager,
+    sdk: {
+      packageName: "openpond-agent-sdk",
+      versionSpec: readOpenPondAgentSdkVersionSpec2(params.packageJson)
+    },
+    commands: commandHints,
+    ...params.dependencySetup ? { dependencySetup: params.dependencySetup } : {},
+    ...setupRequirements.length > 0 ? { setupRequirements } : {},
+    generatedManifestPath: params.generatedManifestPath,
+    synthesizedOpenPondYaml: params.synthesizedOpenPondYaml,
+    openPondYamlMode: params.synthesizedOpenPondYaml ? "synthesized" : "authored",
+    artifactHashes
   };
-  return yaml.dump(workspace, { lineWidth: 120, noRefs: true });
 }
-function recordStringMap(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-  const entries = {};
-  for (const [key, entryValue] of Object.entries(value)) {
-    if (typeof entryValue === "string" && entryValue.trim()) {
-      entries[key] = entryValue.trim();
+async function collectAgentSdkGeneratedArtifactPaths(projectPath) {
+  const generatedArtifacts = /* @__PURE__ */ new Set();
+  for (const artifactPath of AGENT_SDK_GENERATED_ARTIFACTS) {
+    if (existsSync4(path4.join(projectPath, artifactPath))) {
+      generatedArtifacts.add(artifactPath);
     }
   }
-  return entries;
-}
-function recordCopy(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-  return { ...value };
+  for (const skillArtifactPath of await collectAgentSdkGeneratedSkillArtifactPaths(projectPath)) {
+    generatedArtifacts.add(skillArtifactPath);
+  }
+  return Array.from(generatedArtifacts).sort((left, right) => left.localeCompare(right));
 }
-function recordArray(value) {
-  return Array.isArray(value) ? value.filter(
-    (item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)
-  ) : [];
+async function collectAgentSdkGeneratedSkillArtifactPaths(projectPath) {
+  const skillsRoot = path4.join(projectPath, AGENT_SDK_GENERATED_SKILLS_DIR);
+  if (!existsSync4(skillsRoot)) return [];
+  const results = [];
+  async function visit(relativeDir) {
+    const absoluteDir = path4.join(projectPath, relativeDir);
+    const entries = await fs2.readdir(absoluteDir, { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      const relativePath = path4.join(relativeDir, entry.name).replace(/\\/g, "/");
+      if (!isSafeProjectSourcePath(relativePath)) continue;
+      if (entry.isDirectory()) {
+        await visit(relativePath);
+        continue;
+      }
+      if (entry.isFile()) results.push(relativePath);
+    }
+  }
+  await visit(AGENT_SDK_GENERATED_SKILLS_DIR);
+  return results;
 }
-function text(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : null;
+async function collectAgentSdkSourceSetupRequirements(projectPath) {
+  const requirements = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const relativePath of [
+    ".openpond/action-registry.json",
+    ".openpond/agent-manifest.json"
+  ]) {
+    const payload = await readJsonFileIfExists(path4.join(projectPath, relativePath));
+    if (!payload) continue;
+    for (const actionRecord of [
+      ...recordArray(payload.actions),
+      ...recordArray(payload.actionCatalog)
+    ]) {
+      const actionId = text(actionRecord.id) ?? text(actionRecord.name);
+      const actionName = text(actionRecord.name) ?? actionId;
+      if (!actionId && !actionName) continue;
+      for (const setupRecord of recordArray(actionRecord.setupRequirements)) {
+        const setupRequirement = { ...setupRecord };
+        if (actionId) setupRequirement.actionId = actionId;
+        if (actionName && actionName !== actionId) setupRequirement.actionName = actionName;
+        const key = setupRequirementIdentity(setupRequirement);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        requirements.push(setupRequirement);
+      }
+    }
+  }
+  return requirements;
 }
-function agentSdkDependencyInstallCommand(packageManager) {
-  if (packageManager === "npm") return "npm install --offline";
-  if (packageManager === "pnpm") return "pnpm install --offline";
-  if (packageManager === "yarn") return "yarn install --offline";
-  if (packageManager === "bun") return "bun install --offline";
-  return "pnpm install --offline";
+async function readJsonFileIfExists(filePath) {
+  try {
+    const parsed = JSON.parse(await fs2.readFile(filePath, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
 }
-function sha256Hex(contents) {
-  return createHash("sha256").update(contents).digest("hex");
+function setupRequirementIdentity(record) {
+  return [
+    text(record.actionId) ?? "",
+    text(record.actionName) ?? "",
+    text(record.kind) ?? text(record.type) ?? "",
+    text(record.label) ?? text(record.name) ?? text(record.key) ?? text(record.provider) ?? text(record.tool) ?? text(record.command) ?? text(record.packageName) ?? ""
+  ].join(":");
 }
-function dependencySetupCommands(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return [];
-  const record = value;
-  if (Array.isArray(record.commands)) {
-    return record.commands.filter(
-      (command) => typeof command === "string" && command.trim() !== ""
-    );
-  }
-  return typeof record.installCommand === "string" && record.installCommand.trim() ? [record.installCommand.trim()] : [];
+function readAgentSdkProjectPackageJson(projectPath) {
+  const packageJsonPath = path4.join(projectPath, "package.json");
+  return JSON.parse(readFileSyncUtf8(packageJsonPath));
 }
-function mergeManifestSetupCommands(manifest, commands) {
-  if (commands.length === 0) return manifest;
-  const setup = manifest.setup && typeof manifest.setup === "object" && !Array.isArray(manifest.setup) ? recordCopy(manifest.setup) : {};
-  const existingCommands = Array.isArray(setup.commands) ? setup.commands.filter(
-    (command) => typeof command === "string" && command.trim() !== ""
-  ) : [];
-  const mergedCommands = [...commands];
-  for (const command of existingCommands) {
-    if (!mergedCommands.includes(command)) mergedCommands.push(command);
-  }
+function buildAgentSdkCommandHints(packageJson, packageManager) {
   return {
-    ...manifest,
-    setup: {
-      ...setup,
-      commands: mergedCommands
-    }
+    inspect: buildAgentSdkCommandHint(
+      packageJson,
+      packageManager,
+      "agent:inspect",
+      "openpond-agent inspect --json"
+    ),
+    build: buildAgentSdkCommandHint(
+      packageJson,
+      packageManager,
+      "agent:build",
+      "openpond-agent build"
+    ),
+    validate: buildAgentSdkCommandHint(
+      packageJson,
+      packageManager,
+      "agent:validate",
+      "openpond-agent validate"
+    ),
+    eval: buildAgentSdkCommandHint(
+      packageJson,
+      packageManager,
+      "agent:eval",
+      "openpond-agent eval"
+    )
   };
 }
-function sanitizeAgentSdkRuntimeManifestForOpenPondYaml(source, dependencySetup) {
-  const parsed = yaml.load(source);
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    return `${AGENT_SDK_SYNTHESIZED_OPENPOND_YAML_SENTINEL}
-${source}`;
-  }
-  const manifest = mergeManifestSetupCommands(
-    { ...parsed },
-    dependencySetupCommands(dependencySetup)
-  );
-  delete manifest.schema;
-  sanitizeGeneratedManifestNamedCommands(manifest, "actions");
-  sanitizeGeneratedManifestNamedCommands(manifest, "services");
-  return `${AGENT_SDK_SYNTHESIZED_OPENPOND_YAML_SENTINEL}
-${yaml.dump(manifest, { lineWidth: -1, noRefs: true })}`;
+function buildAgentSdkCommandHint(packageJson, packageManager, scriptName, fallback) {
+  const scripts = packageJson.scripts;
+  const hasScript = scripts && typeof scripts === "object" && !Array.isArray(scripts) && typeof scripts[scriptName] === "string";
+  if (!hasScript) return fallback;
+  return agentSdkRunScriptCommand(packageManager, scriptName);
 }
-function sanitizeGeneratedManifestNamedCommands(manifest, key) {
-  if (!Array.isArray(manifest[key])) return;
-  manifest[key] = manifest[key].map((entry) => {
-    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
-      return entry;
+function readOpenPondAgentSdkVersionSpec2(packageJson) {
+  for (const key of ["dependencies", "devDependencies", "peerDependencies"]) {
+    const dependencies = packageJson[key];
+    if (!dependencies || typeof dependencies !== "object" || Array.isArray(dependencies)) {
+      continue;
     }
-    const sanitized = { ...entry };
-    delete sanitized.id;
-    delete sanitized.label;
-    return sanitized;
-  });
-}
-function isAgentSdkProject(projectPath) {
-  if (!existsSync2(path2.join(projectPath, "agent", "agent.ts"))) return false;
-  const packageJsonPath = path2.join(projectPath, "package.json");
-  if (!existsSync2(packageJsonPath)) return false;
-  try {
-    const parsed = JSON.parse(readFileSyncUtf8(packageJsonPath));
-    return Boolean(
-      parsed.dependencies?.["openpond-agent-sdk"] || parsed.devDependencies?.["openpond-agent-sdk"] || parsed.peerDependencies?.["openpond-agent-sdk"]
-    );
-  } catch {
-    return false;
+    const value = dependencies["openpond-agent-sdk"];
+    if (typeof value === "string" && value.trim()) return value.trim();
   }
-}
-function readFileSyncUtf8(filePath) {
-  return readFileSync2(filePath, "utf8");
+  return null;
 }
 async function runAgentSdkProjectCheck(projectPath, commandName) {
   const command = resolveLocalAgentSdkCommand(projectPath);
-  const result = await runCommand(command.command, [...command.args, commandName, "--cwd", projectPath], {
+  const result = await runCommand2(command.command, [...command.args, commandName, "--cwd", projectPath], {
     cwd: projectPath
   });
   if (result.code !== 0) {
@@ -978,8 +1014,8 @@ async function projectSourceUploadFileEntry(projectPath, relativePath) {
   if (!isSafeProjectSourcePath(normalized) || normalized.startsWith(".env")) {
     throw new Error(`unsafe generated source path: ${relativePath}`);
   }
-  const absolutePath = path2.join(projectPath, normalized);
-  const stat = await fs.stat(absolutePath);
+  const absolutePath = path4.join(projectPath, normalized);
+  const stat = await fs2.stat(absolutePath);
   if (!stat.isFile()) {
     throw new Error(`generated source path is not a file: ${relativePath}`);
   }
@@ -989,7 +1025,7 @@ async function projectSourceUploadFileEntry(projectPath, relativePath) {
   return {
     path: normalized,
     type: "file",
-    contentsBase64: Buffer.from(await fs.readFile(absolutePath)).toString("base64")
+    contentsBase64: Buffer.from(await fs2.readFile(absolutePath)).toString("base64")
   };
 }
 function projectSourceUploadTextEntry(relativePath, contents) {
@@ -1230,7 +1266,7 @@ function buildAgentEditOpenInput(agentId, teamId, options) {
     ...initialMessage ? { initialMessage } : {},
     ...sourceRef ? { sourceRef } : {},
     ...baseSha ? { baseSha } : {},
-    createPipelineRequest: buildAgentEditCreatePipelineRequest({
+    createImproveRun: buildAgentEditCreateImproveRun({
       agentId,
       teamId,
       projectId,
@@ -1241,15 +1277,17 @@ function buildAgentEditOpenInput(agentId, teamId, options) {
     })
   };
 }
-function buildAgentEditCreatePipelineRequest(input) {
+function buildAgentEditCreateImproveRun(input) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  return CreatePipelineRequestSchema.parse({
-    schemaVersion: "openpond.createPipeline.request.v1",
-    id: `create_request_${randomUUID()}`,
-    operation: "edit",
-    surface: "hosted_edit",
+  return CreateImproveRunSchema.parse({
+    schemaVersion: "openpond.createImprove.run.v1",
+    id: `create_improve_${randomUUID()}`,
+    revision: 0,
+    operation: "improve",
+    surface: "hosted_improve",
     command: "/edit",
     objective: input.objective,
+    state: "planning",
     adapter: {
       kind: "hosted",
       sourceAuthority: "hosted_profile",
@@ -1267,7 +1305,9 @@ function buildAgentEditCreatePipelineRequest(input) {
       label: null
     },
     scope: {
+      profileId: input.activeProfile,
       conversationId: null,
+      originTurnId: null,
       workItemId: null,
       projectId: input.projectId,
       targetProject: {
@@ -1284,18 +1324,54 @@ function buildAgentEditCreatePipelineRequest(input) {
       attachments: [],
       apps: [],
       tools: [],
+      signalRefs: [],
+      evalRefs: [],
       targetRepoAssumptions: [`cloud project: ${input.projectId}`]
     },
-    targetAgent: {
-      agentId: input.agentId,
+    target: {
+      kind: "agent",
+      id: input.agentId,
       displayName: null,
       defaultActionKey: `${input.agentId}.chat`
     },
+    plan: null,
+    workflowCapture: null,
+    executionPolicy: {
+      mode: "background",
+      pauseAllowed: true,
+      cancellationAllowed: true
+    },
+    iterationPolicy: {
+      mode: "single",
+      maximumAttempts: 1,
+      currentAttempt: 0
+    },
+    approvalIds: [],
+    questionIds: [],
+    questions: [],
+    candidates: [],
+    evaluationReceipts: [],
+    checkRefs: [],
+    sourceRefs: [],
+    externalExecutionRefs: [],
+    localProfileCommit: null,
+    hostedSourceCommit: input.baseSha,
+    hostedSourceRef: input.sourceRef,
+    releaseOutcome: {
+      status: "not_requested",
+      profileCommit: null,
+      profileTag: null,
+      releaseReceiptRef: null,
+      updatedAt: null
+    },
+    blockedReason: null,
+    appliedActionIds: [],
     metadata: {
       source: "cli_agent_edit_open",
       selectedCommand: "/edit"
     },
-    createdAt: now
+    createdAt: now,
+    updatedAt: now
   });
 }
 function buildCodingWorkItemChatInput(teamId, options) {