openpond 0.0.30-bootstrap.0

package/dist/chunks/chunk-3CC6MH35.js

@@ -0,0 +1,1663 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  materializeSourceUploadFile,
+  readSourceUploadCache,
+  writeSourceUploadCache
+} from "./chunk-I6HN3ZGW.js";
+import {
+  CreatePipelineRequestSchema
+} from "./chunk-VQX33YAG.js";
+import {
+  formatSandboxTemplateDiagnostics,
+  validateSandboxTemplateYaml
+} from "./chunk-BYAPLT37.js";
+import {
+  yaml
+} from "./chunk-WYDVQOBL.js";
+import {
+  parseSandboxRuntimePromotionPolicyOption,
+  parseSandboxWorkflowModeOption,
+  runCommand
+} from "./chunk-XSAXENQD.js";
+import {
+  optionString,
+  optionalJsonObject,
+  parseBooleanOption,
+  parseCsvOption,
+  parseIntegerOption,
+  requiredTeamId
+} from "./chunk-3Y4EL3P6.js";
+
+// src/cli/agent-sdk-command.ts
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+function resolveLocalAgentSdkCommand(cwd) {
+  const packageDistCli = path.join(
+    cwd,
+    "node_modules",
+    "openpond-agent-sdk",
+    "dist",
+    "cli.js"
+  );
+  if (existsSync(packageDistCli)) return { command: process.execPath, args: [packageDistCli] };
+  const localBin = path.join(cwd, "node_modules", ".bin", "openpond-agent");
+  if (existsSync(localBin)) return { command: localBin, args: [] };
+  const packageCli = path.join(
+    cwd,
+    "node_modules",
+    "openpond-agent-sdk",
+    "src",
+    "cli.ts"
+  );
+  if (existsSync(packageCli)) {
+    return nodeTypescriptCommand(path.dirname(path.dirname(packageCli)), packageCli);
+  }
+  const packageDependencyCli = resolveAgentSdkDependencyCli(cwd);
+  if (packageDependencyCli) return packageDependencyCli;
+  return { command: "openpond-agent", args: [] };
+}
+function resolveAgentSdkDependencyCli(cwd) {
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (!existsSync(packageJsonPath)) return null;
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    const versionSpec = packageJson.dependencies?.["openpond-agent-sdk"] ?? packageJson.devDependencies?.["openpond-agent-sdk"] ?? packageJson.peerDependencies?.["openpond-agent-sdk"];
+    if (!versionSpec?.startsWith("file:")) return null;
+    const packageRoot = path.resolve(cwd, versionSpec.slice("file:".length));
+    const sourceCli = path.join(packageRoot, "src", "cli.ts");
+    if (existsSync(sourceCli)) return nodeTypescriptCommand(packageRoot, sourceCli);
+    const distCli = path.join(packageRoot, "dist", "cli.js");
+    if (existsSync(distCli)) return { command: process.execPath, args: [distCli] };
+  } catch {
+    return null;
+  }
+  return null;
+}
+function nodeTypescriptCommand(packageRoot, sourceCli) {
+  const tsxCli = createRequire(path.join(packageRoot, "package.json")).resolve("tsx/cli");
+  return { command: process.execPath, args: [tsxCli, sourceCli] };
+}
+
+// src/cli/project-source-upload.ts
+import { Buffer } from "node:buffer";
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, promises as fs, readFileSync as readFileSync2, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path2 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
+};
+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 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;
+}
+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 = 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) {
+      throw new Error(
+        `source file is too large: ${sourcePath} (${stat.size} bytes)`
+      );
+    }
+    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}`
+      );
+    }
+  }
+  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
+  };
+}
+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;
+}
+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);
+  }
+  return files.stdout.split("\0").map((filePath) => filePath.trim()).filter(Boolean).filter((filePath) => {
+    const normalized = filePath.replace(/\\/g, "/");
+    return isSafeProjectSourcePath(normalized) && !shouldSkipProjectSourcePath(normalized);
+  });
+}
+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;
+      }
+      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;
+}
+async function collectAgentSdkProjectSourceUploadEntries(projectPath, existingEntries) {
+  if (!isAgentSdkProject(projectPath)) {
+    return {
+      entries: [],
+      generatedManifestPath: null,
+      synthesizedOpenPondYaml: false,
+      uploadMetadataPath: null,
+      uploadMetadata: null,
+      uploadMetadataHash: null
+    };
+  }
+  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
+      )}`
+    );
+  }
+  const entries = [];
+  if (materializedDependency?.rewrittenPackageJson) {
+    entries.push(
+      projectSourceUploadTextEntry(
+        "package.json",
+        `${JSON.stringify(materializedDependency.rewrittenPackageJson, null, 2)}
+`
+      )
+    );
+  }
+  if (materializedDependency?.pnpmWorkspaceSource) {
+    entries.push(
+      projectSourceUploadTextEntry(
+        "pnpm-workspace.yaml",
+        materializedDependency.pnpmWorkspaceSource
+      )
+    );
+  }
+  for (const tarball of materializedDependency?.tarballs ?? []) {
+    entries.push(
+      projectSourceUploadBufferEntry(tarball.path, tarball.contents)
+    );
+  }
+  const generatedArtifactPaths = await collectAgentSdkGeneratedArtifactPaths(projectPath);
+  for (const artifactPath of generatedArtifactPaths) {
+    entries.push(await projectSourceUploadFileEntry(projectPath, artifactPath));
+  }
+  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
+        )}`
+      );
+    }
+  }
+  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
+  };
+}
+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
+    };
+  }
+  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);
+    }
+  }
+  for (const skillArtifactPath of await collectAgentSdkGeneratedSkillArtifactPaths(projectPath)) {
+    generatedArtifacts.add(skillArtifactPath);
+  }
+  return Array.from(generatedArtifacts).sort((left, right) => left.localeCompare(right));
+}
+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);
+    }
+  }
+  await visit(AGENT_SDK_GENERATED_SKILLS_DIR);
+  return results;
+}
+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;
+}
+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 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 readAgentSdkProjectPackageJson(projectPath) {
+  const packageJsonPath = path2.join(projectPath, "package.json");
+  return JSON.parse(readFileSyncUtf8(packageJsonPath));
+}
+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 buildAgentSdkCommandHints(packageJson, packageManager) {
+  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"
+    )
+  };
+}
+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 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 buildAgentSdkMaterializedDependency(projectPath, packageJson) {
+  const sdkSource = resolveLocalOpenPondAgentSdkMaterializationSource(
+    projectPath,
+    packageJson
+  );
+  if (!sdkSource) return null;
+  const tempDir = await fs.mkdtemp(path2.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 });
+  }
+}
+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));
+}
+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));
+}
+function isSupportedSandboxOptionalDependency(packageName) {
+  if (packageName === "fsevents") return false;
+  if (packageName.startsWith("@esbuild/")) {
+    return packageName === "@esbuild/linux-x64" || packageName === "@esbuild/linux-arm64";
+  }
+  return true;
+}
+function npmPackTargetForDependency(params) {
+  if (params.versionSpec.startsWith("file:")) {
+    return path2.resolve(
+      params.dependencyBaseDir,
+      params.versionSpec.slice("file:".length)
+    );
+  }
+  return `${params.packageName}@${params.versionSpec}`;
+}
+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 = 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"))
+        )
+      };
+    }
+    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
+        };
+      }
+    }
+  }
+  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 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;
+  }
+}
+function isLocalNpmTarball(candidate) {
+  if (!existsSync2(candidate)) return false;
+  try {
+    return statSync(candidate).isFile() && (candidate.endsWith(".tgz") || candidate.endsWith(".tar.gz"));
+  } catch {
+    return false;
+  }
+}
+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;
+  }
+  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;
+  }
+  rewritten.dependencies = dependencies;
+  if (Object.keys(overrides).length > 0) {
+    rewritten.overrides = overrides;
+  }
+  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];
+    }
+  }
+  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 } : {};
+  }
+  if (!Array.isArray(workspace.packages)) workspace.packages = [];
+  const overrides = recordCopy(workspace.overrides);
+  for (const tarball of dependencyTarballs) {
+    overrides[tarball.packageName] = `file:${tarball.path}`;
+  }
+  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;
+  }
+  workspace.allowBuilds = allowBuilds;
+  workspace.supportedArchitectures = {
+    os: ["linux"],
+    cpu: ["x64", "arm64"],
+    libc: ["glibc", "musl"]
+  };
+  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();
+    }
+  }
+  return entries;
+}
+function recordCopy(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return { ...value };
+}
+function recordArray(value) {
+  return Array.isArray(value) ? value.filter(
+    (item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)
+  ) : [];
+}
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+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 sha256Hex(contents) {
+  return createHash("sha256").update(contents).digest("hex");
+}
+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 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 {
+    ...manifest,
+    setup: {
+      ...setup,
+      commands: mergedCommands
+    }
+  };
+}
+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 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 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;
+  }
+}
+function readFileSyncUtf8(filePath) {
+  return readFileSync2(filePath, "utf8");
+}
+async function runAgentSdkProjectCheck(projectPath, commandName) {
+  const command = resolveLocalAgentSdkCommand(projectPath);
+  const result = await runCommand(command.command, [...command.args, commandName, "--cwd", projectPath], {
+    cwd: projectPath
+  });
+  if (result.code !== 0) {
+    const details = [result.stderr.trim(), result.stdout.trim()].filter(Boolean).join("\n");
+    throw new Error(
+      `openpond agent ${commandName} failed for ${projectPath}${details ? `:
+${details}` : ""}`
+    );
+  }
+}
+async function projectSourceUploadFileEntry(projectPath, relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  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);
+  if (!stat.isFile()) {
+    throw new Error(`generated source path is not a file: ${relativePath}`);
+  }
+  if (stat.size > PROJECT_SOURCE_UPLOAD_MAX_FILE_BYTES) {
+    throw new Error(`generated source file is too large: ${relativePath} (${stat.size} bytes)`);
+  }
+  return {
+    path: normalized,
+    type: "file",
+    contentsBase64: Buffer.from(await fs.readFile(absolutePath)).toString("base64")
+  };
+}
+function projectSourceUploadTextEntry(relativePath, contents) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  if (!isSafeProjectSourcePath(normalized) || normalized.startsWith(".env")) {
+    throw new Error(`unsafe generated source path: ${relativePath}`);
+  }
+  const byteLength = Buffer.byteLength(contents, "utf8");
+  if (byteLength > PROJECT_SOURCE_UPLOAD_MAX_FILE_BYTES) {
+    throw new Error(`generated source file is too large: ${relativePath} (${byteLength} bytes)`);
+  }
+  return {
+    path: normalized,
+    type: "file",
+    contentsBase64: Buffer.from(contents, "utf8").toString("base64")
+  };
+}
+function projectSourceUploadBufferEntry(relativePath, contents) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  if (!isSafeProjectSourcePath(normalized) || normalized.startsWith(".env")) {
+    throw new Error(`unsafe generated source path: ${relativePath}`);
+  }
+  if (contents.byteLength > PROJECT_SOURCE_UPLOAD_MAX_FILE_BYTES) {
+    throw new Error(
+      `generated source file is too large: ${relativePath} (${contents.byteLength} bytes)`
+    );
+  }
+  return {
+    path: normalized,
+    type: "file",
+    contentsBase64: contents.toString("base64")
+  };
+}
+function mergeProjectSourceUploadEntries(collected, extraEntries) {
+  const byPath = /* @__PURE__ */ new Map();
+  const regeneratesPnpmLock = extraEntries.some(
+    (entry) => entry.path === "pnpm-workspace.yaml"
+  );
+  for (const entry of collected.entries) {
+    if (regeneratesPnpmLock && entry.path === "pnpm-lock.yaml") continue;
+    byPath.set(entry.path, entry);
+  }
+  for (const entry of extraEntries) byPath.set(entry.path, entry);
+  const entries = Array.from(byPath.values()).sort(
+    (left, right) => left.path.localeCompare(right.path)
+  );
+  const totalBytes = entries.reduce(
+    (sum, entry) => sum + Buffer.byteLength(entry.contentsBase64, "base64"),
+    0
+  );
+  if (entries.length > PROJECT_SOURCE_UPLOAD_MAX_FILES) {
+    throw new Error(`too many source files to upload: ${entries.length} > ${PROJECT_SOURCE_UPLOAD_MAX_FILES}`);
+  }
+  if (totalBytes > PROJECT_SOURCE_UPLOAD_MAX_BYTES) {
+    throw new Error(`source upload is too large: ${totalBytes} > ${PROJECT_SOURCE_UPLOAD_MAX_BYTES}`);
+  }
+  return {
+    entries,
+    fileCount: entries.length,
+    totalBytes,
+    limits: PROJECT_SOURCE_UPLOAD_LIMITS,
+    transport: PROJECT_SOURCE_UPLOAD_TRANSPORT
+  };
+}
+
+// src/cli/project-agent-inputs.ts
+import { randomUUID } from "node:crypto";
+function parseProjectSourceType(value) {
+  const sourceType = typeof value === "string" && value.trim() ? value.trim() : "manual";
+  if (sourceType !== "github_repo" && sourceType !== "internal_repo" && sourceType !== "template" && sourceType !== "manual") {
+    throw new Error(
+      "source-type must be one of github_repo, internal_repo, template, manual"
+    );
+  }
+  return sourceType;
+}
+function parseAgentEntrypointScope(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("entrypoint-scope must be a non-empty value");
+  }
+  const scope = value.trim();
+  if (scope !== "entire_manifest" && scope !== "start" && scope !== "action" && scope !== "service" && scope !== "schedule") {
+    throw new Error(
+      "entrypoint-scope must be one of entire_manifest, start, action, service, schedule"
+    );
+  }
+  return scope;
+}
+function parseAgentTriggerType(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("trigger-type must be a non-empty value");
+  }
+  const triggerType = value.trim();
+  if (triggerType !== "manual" && triggerType !== "schedule" && triggerType !== "endpoint" && triggerType !== "background") {
+    throw new Error(
+      "trigger-type must be one of manual, schedule, endpoint, background"
+    );
+  }
+  return triggerType;
+}
+function parseAgentSourceMode(value, optionName = "source-mode") {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${optionName} must be a non-empty value`);
+  }
+  const mode = value.trim();
+  if (mode !== "latest_source" && mode !== "published_snapshot" && mode !== "auto") {
+    throw new Error(
+      `${optionName} must be one of latest_source, published_snapshot, auto`
+    );
+  }
+  return mode;
+}
+function buildAgentSourceConfig(options) {
+  const hasSourceMode = Object.prototype.hasOwnProperty.call(
+    options,
+    "sourceMode"
+  );
+  const mode = parseAgentSourceMode(
+    hasSourceMode ? options.sourceMode : options.runtimeSourceMode,
+    hasSourceMode ? "source-mode" : "runtime-source-mode"
+  );
+  const sourceRef = optionString(options, "sourceRef");
+  const sourceCommitSha = optionString(options, "sourceCommitSha");
+  const publishedSnapshotId = optionString(options, "publishedSnapshotId") || optionString(options, "snapshotId");
+  const publishedSnapshotName = optionString(options, "publishedSnapshotName") || optionString(options, "snapshotName");
+  const publishedSnapshotVersion = optionString(options, "publishedSnapshotVersion") || optionString(options, "snapshotVersion");
+  const buildStatus = optionString(options, "buildStatus");
+  const validationStatus = optionString(options, "validationStatus");
+  const validatedAt = optionString(options, "validatedAt");
+  const config = {
+    ...mode ? { mode } : {},
+    ...sourceRef ? { sourceRef } : {},
+    ...sourceCommitSha ? { sourceCommitSha } : {},
+    ...publishedSnapshotId ? { publishedSnapshotId } : {},
+    ...publishedSnapshotName ? { publishedSnapshotName } : {},
+    ...publishedSnapshotVersion ? { publishedSnapshotVersion } : {},
+    ...buildStatus ? { buildStatus } : {},
+    ...validationStatus ? { validationStatus } : {},
+    ...validatedAt ? { validatedAt } : {}
+  };
+  return Object.keys(config).length > 0 ? config : void 0;
+}
+function buildAgentSourcePolicy(options, source = "manual") {
+  const requirePublishedSnapshot = parseBooleanOption(
+    options.requirePublishedSnapshot
+  );
+  const allowLatestSource = parseBooleanOption(options.allowLatestSource);
+  if (!requirePublishedSnapshot && !allowLatestSource && source === "manual") {
+    return void 0;
+  }
+  return {
+    source,
+    ...requirePublishedSnapshot ? { requirePublishedSnapshot } : {},
+    ...allowLatestSource || source === "diagnostic" ? { allowLatestSource: allowLatestSource || source === "diagnostic" } : {}
+  };
+}
+function parseAgentSourceCheckKind(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("check-kind must be a non-empty value");
+  }
+  const checkKind = value.trim();
+  if (checkKind !== "validate" && checkKind !== "eval" && checkKind !== "publish_review" && checkKind !== "all") {
+    throw new Error(
+      "check-kind must be one of validate, eval, publish_review, all"
+    );
+  }
+  return checkKind;
+}
+function parseAgentSourceCheckDispatch(value, optionName = "source-check-dispatch") {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${optionName} must be a non-empty value`);
+  }
+  const dispatch = value.trim();
+  if (dispatch !== "request_only" && dispatch !== "coding_core") {
+    throw new Error(
+      `${optionName} must be one of request_only, coding_core`
+    );
+  }
+  return dispatch;
+}
+function parsePositiveLimit(value) {
+  if (value === void 0) return void 0;
+  const parsed = parseIntegerOption(value, "limit");
+  if (parsed === void 0) return void 0;
+  if (parsed <= 0) throw new Error("limit must be greater than 0");
+  return parsed;
+}
+function buildAgentSourceChecksInput(teamId, options) {
+  const metadata = optionalJsonObject(options, "metadata", "metadata");
+  const checkKind = parseAgentSourceCheckKind(options.checkKind);
+  const dispatch = parseAgentSourceCheckDispatch(
+    options.sourceCheckDispatch ?? options.dispatch
+  );
+  return {
+    teamId,
+    ...optionString(options, "sourceRef") ? { sourceRef: optionString(options, "sourceRef") } : {},
+    ...optionString(options, "baseSha") ? { baseSha: optionString(options, "baseSha") } : {},
+    ...checkKind ? { checkKind } : {},
+    ...dispatch ? { dispatch } : {},
+    ...metadata ? { metadata } : {}
+  };
+}
+function buildAgentSourcePublishInput(teamId, options) {
+  return {
+    teamId,
+    ...optionString(options, "expectedManifestHash") ? { expectedManifestHash: optionString(options, "expectedManifestHash") } : {},
+    ...optionString(options, "expectedSourceCommitSha") ? {
+      expectedSourceCommitSha: optionString(
+        options,
+        "expectedSourceCommitSha"
+      )
+    } : {},
+    ...optionString(options, "evalStatus") ? { evalStatus: optionString(options, "evalStatus") } : {},
+    ...optionString(options, "workItemId") ? { workItemId: optionString(options, "workItemId") } : {},
+    ...optionString(options, "taskRunId") ? { taskRunId: optionString(options, "taskRunId") } : {},
+    ...optionString(options, "traceArtifactRef") ? { traceArtifactRef: optionString(options, "traceArtifactRef") } : {},
+    ...optionString(options, "evalResultArtifactRef") ? { evalResultArtifactRef: optionString(options, "evalResultArtifactRef") } : {}
+  };
+}
+function buildAgentEditOpenInput(agentId, teamId, options) {
+  const projectId = optionString(options, "projectId");
+  if (!projectId) {
+    throw new Error(
+      "agent edit open requires --project-id <id> so the edit work item is project scoped"
+    );
+  }
+  const initialMessage = optionString(options, "initialMessage") || optionString(options, "message") || optionString(options, "prompt");
+  const sourceRef = optionString(options, "sourceRef") ?? null;
+  const baseSha = optionString(options, "baseSha") ?? null;
+  return {
+    teamId,
+    projectId,
+    ...initialMessage ? { initialMessage } : {},
+    ...sourceRef ? { sourceRef } : {},
+    ...baseSha ? { baseSha } : {},
+    createPipelineRequest: buildAgentEditCreatePipelineRequest({
+      agentId,
+      teamId,
+      projectId,
+      objective: initialMessage || `Edit hosted agent ${agentId}`,
+      sourceRef,
+      baseSha,
+      activeProfile: optionString(options, "profile") || "default"
+    })
+  };
+}
+function buildAgentEditCreatePipelineRequest(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return CreatePipelineRequestSchema.parse({
+    schemaVersion: "openpond.createPipeline.request.v1",
+    id: `create_request_${randomUUID()}`,
+    operation: "edit",
+    surface: "hosted_edit",
+    command: "/edit",
+    objective: input.objective,
+    adapter: {
+      kind: "hosted",
+      sourceAuthority: "hosted_profile",
+      teamId: input.teamId,
+      projectId: input.projectId,
+      activeProfile: input.activeProfile,
+      sourceRef: input.sourceRef,
+      baseSha: input.baseSha,
+      workItemId: null,
+      confirmationPolicy: "always_require_plan_approval"
+    },
+    actor: {
+      id: null,
+      kind: "user",
+      label: null
+    },
+    scope: {
+      conversationId: null,
+      workItemId: null,
+      projectId: input.projectId,
+      targetProject: {
+        id: input.projectId,
+        name: null,
+        workspacePath: null,
+        sourceRef: input.sourceRef,
+        baseSha: input.baseSha
+      }
+    },
+    context: {
+      messageIds: [],
+      conversationExcerpts: [],
+      attachments: [],
+      apps: [],
+      tools: [],
+      targetRepoAssumptions: [`cloud project: ${input.projectId}`]
+    },
+    targetAgent: {
+      agentId: input.agentId,
+      displayName: null,
+      defaultActionKey: `${input.agentId}.chat`
+    },
+    metadata: {
+      source: "cli_agent_edit_open",
+      selectedCommand: "/edit"
+    },
+    createdAt: now
+  });
+}
+function buildCodingWorkItemChatInput(teamId, options) {
+  const message = optionString(options, "message") || optionString(options, "prompt");
+  if (!message) {
+    throw new Error("agent edit chat requires --message <text>");
+  }
+  const mode = optionString(options, "chatMode") || "queue_cloud";
+  if (mode !== "sync_cloud" && mode !== "queue_cloud") {
+    throw new Error(
+      "agent edit chat --chat-mode must be sync_cloud or queue_cloud"
+    );
+  }
+  const payload = optionalJsonObject(options, "payload", "payload");
+  return {
+    teamId,
+    message,
+    mode,
+    ...optionString(options, "sourceRef") ? { sourceRef: optionString(options, "sourceRef") } : {},
+    ...optionString(options, "baseSha") ? { baseSha: optionString(options, "baseSha") } : {},
+    ...payload ? { payload } : {}
+  };
+}
+function buildCodingWorkItemBackgroundInput(teamId, options) {
+  const payload = optionalJsonObject(options, "payload", "payload");
+  const agentEdit = optionalJsonObject(options, "agentEdit", "agent-edit");
+  const setup = optionalCommandList(options, "setup", "setup");
+  const validation = optionalCommandList(options, "validation", "validation");
+  const branchPolicy = optionalJsonObject(options, "branchPolicy", "branch-policy");
+  return {
+    teamId,
+    ...optionString(options, "prompt") ? { prompt: optionString(options, "prompt") } : {},
+    ...optionString(options, "sourceRef") ? { sourceRef: optionString(options, "sourceRef") } : {},
+    ...optionString(options, "baseSha") ? { baseSha: optionString(options, "baseSha") } : {},
+    ...optionString(options, "sourceRuntimeId") ? { sourceRuntimeId: optionString(options, "sourceRuntimeId") } : {},
+    ...optionString(options, "sourceSandboxId") ? { sourceSandboxId: optionString(options, "sourceSandboxId") } : {},
+    ...optionString(options, "agentId") ? { agentId: optionString(options, "agentId") } : {},
+    ...agentEdit ? { agentEdit } : {},
+    ...setup ? { setup } : {},
+    ...validation ? { validation } : {},
+    ...branchPolicy ? { branchPolicy } : {},
+    ...payload ? { payload } : {}
+  };
+}
+function optionalCommandList(options, key, displayName) {
+  const value = optionalJsonObject(options, key, displayName);
+  if (!value) return null;
+  if (!Array.isArray(value.commands) || value.commands.some((command) => typeof command !== "string")) {
+    throw new Error(`${displayName} must be a JSON object with a string commands array`);
+  }
+  return { commands: value.commands };
+}
+function buildCodingWorkItemPromotionInput(teamId, options) {
+  const ref = optionString(options, "ref") || optionString(options, "artifactRef");
+  if (!ref) throw new Error("result promotion requires --ref <artifact-ref>");
+  const metadata = optionalJsonObject(options, "metadata", "metadata");
+  return {
+    teamId,
+    ref,
+    ...metadata ? { metadata } : {}
+  };
+}
+function buildProjectUpsertInput(options) {
+  const usage = "usage: project create --team-id <id> --name <name>";
+  const teamId = requiredTeamId(options, usage);
+  const name = optionString(options, "name");
+  if (!name) {
+    throw new Error(
+      `${usage} [--source-type manual|github_repo|internal_repo|template]`
+    );
+  }
+  const sourceType = parseProjectSourceType(options.sourceType);
+  const repoUrl = optionString(options, "repoUrl") || optionString(options, "repo");
+  const sourceConfig = {
+    ...optionalJsonObject(options, "sourceConfig", "source-config") ?? {},
+    ...repoUrl ? { repoUrl } : {}
+  };
+  const metadata = optionalJsonObject(options, "metadata", "metadata");
+  return {
+    teamId,
+    name,
+    sourceType,
+    ...optionString(options, "slug") ? { slug: optionString(options, "slug") } : {},
+    ...optionString(options, "description") ? { description: optionString(options, "description") } : {},
+    ...options.status === "active" || options.status === "disabled" || options.status === "archived" ? { status: options.status } : {},
+    ...Object.keys(sourceConfig).length > 0 ? { sourceConfig } : {},
+    ...optionString(options, "normalizedSourceIdentity") ? {
+      normalizedSourceIdentity: optionString(
+        options,
+        "normalizedSourceIdentity"
+      )
+    } : {},
+    ...optionString(options, "externalId") ? { externalId: optionString(options, "externalId") } : {},
+    ...optionString(options, "gitProvider") ? { gitProvider: optionString(options, "gitProvider") } : {},
+    ...optionString(options, "gitHost") ? { gitHost: optionString(options, "gitHost") } : {},
+    ...optionString(options, "gitOwner") ? { gitOwner: optionString(options, "gitOwner") } : {},
+    ...optionString(options, "gitRepo") ? { gitRepo: optionString(options, "gitRepo") } : {},
+    ...optionString(options, "gitBranch") ? { gitBranch: optionString(options, "gitBranch") } : {},
+    ...optionString(options, "defaultBranch") ? { defaultBranch: optionString(options, "defaultBranch") } : {},
+    ...optionString(options, "internalRepoPath") ? { internalRepoPath: optionString(options, "internalRepoPath") } : {},
+    ...optionString(options, "templateSourceProjectId") ? {
+      templateSourceProjectId: optionString(
+        options,
+        "templateSourceProjectId"
+      )
+    } : {},
+    ...optionString(options, "templateRepoUrl") ? { templateRepoUrl: optionString(options, "templateRepoUrl") } : {},
+    ...optionString(options, "templateBranch") ? { templateBranch: optionString(options, "templateBranch") } : {},
+    ...optionString(options, "templateRemoteSha") ? { templateRemoteSha: optionString(options, "templateRemoteSha") } : {},
+    ...metadata ? { metadata } : {}
+  };
+}
+function buildProjectUpdateInput(teamId, options) {
+  const repoUrl = optionString(options, "repoUrl") || optionString(options, "repo");
+  const sourceConfig = optionalJsonObject(
+    options,
+    "sourceConfig",
+    "source-config"
+  );
+  const metadata = optionalJsonObject(options, "metadata", "metadata");
+  return {
+    teamId,
+    ...optionString(options, "name") ? { name: optionString(options, "name") } : {},
+    ...optionString(options, "slug") ? { slug: optionString(options, "slug") } : {},
+    ...optionString(options, "description") ? { description: optionString(options, "description") } : {},
+    ...options.status === "active" || options.status === "disabled" || options.status === "archived" ? { status: options.status } : {},
+    ...options.sourceType !== void 0 ? { sourceType: parseProjectSourceType(options.sourceType) } : {},
+    ...sourceConfig || repoUrl ? {
+      sourceConfig: {
+        ...sourceConfig ?? {},
+        ...repoUrl ? { repoUrl } : {}
+      }
+    } : {},
+    ...optionString(options, "normalizedSourceIdentity") ? {
+      normalizedSourceIdentity: optionString(
+        options,
+        "normalizedSourceIdentity"
+      )
+    } : {},
+    ...optionString(options, "externalId") ? { externalId: optionString(options, "externalId") } : {},
+    ...optionString(options, "gitProvider") ? { gitProvider: optionString(options, "gitProvider") } : {},
+    ...optionString(options, "gitHost") ? { gitHost: optionString(options, "gitHost") } : {},
+    ...optionString(options, "gitOwner") ? { gitOwner: optionString(options, "gitOwner") } : {},
+    ...optionString(options, "gitRepo") ? { gitRepo: optionString(options, "gitRepo") } : {},
+    ...optionString(options, "gitBranch") ? { gitBranch: optionString(options, "gitBranch") } : {},
+    ...optionString(options, "defaultBranch") ? { defaultBranch: optionString(options, "defaultBranch") } : {},
+    ...optionString(options, "internalRepoPath") ? { internalRepoPath: optionString(options, "internalRepoPath") } : {},
+    ...optionString(options, "templateSourceProjectId") ? {
+      templateSourceProjectId: optionString(
+        options,
+        "templateSourceProjectId"
+      )
+    } : {},
+    ...optionString(options, "templateRepoUrl") ? { templateRepoUrl: optionString(options, "templateRepoUrl") } : {},
+    ...optionString(options, "templateBranch") ? { templateBranch: optionString(options, "templateBranch") } : {},
+    ...optionString(options, "templateRemoteSha") ? { templateRemoteSha: optionString(options, "templateRemoteSha") } : {},
+    ...metadata ? { metadata } : {}
+  };
+}
+function buildAgentUpsertInput(options) {
+  const usage = "usage: agent create --team-id <id> --project-id <id> --name <name>";
+  const teamId = requiredTeamId(options, usage);
+  const projectId = optionString(options, "projectId");
+  const name = optionString(options, "name");
+  if (!projectId || !name) {
+    throw new Error(usage);
+  }
+  const entrypointScope = parseAgentEntrypointScope(options.entrypointScope);
+  const entrypointName = optionString(options, "entrypointName");
+  const triggerType = parseAgentTriggerType(options.triggerType);
+  const workflowMode = parseSandboxWorkflowModeOption(options.workflowMode);
+  const promotionPolicy = parseSandboxRuntimePromotionPolicyOption(
+    options.runtimePromotionPolicy
+  );
+  const agentSource = buildAgentSourceConfig(options);
+  const metadata = optionalJsonObject(options, "metadata", "metadata");
+  return {
+    teamId,
+    projectId,
+    name,
+    ...optionString(options, "slug") ? { slug: optionString(options, "slug") } : {},
+    ...optionString(options, "description") ? { description: optionString(options, "description") } : {},
+    ...options.status === "active" || options.status === "disabled" || options.status === "archived" ? { status: options.status } : {},
+    ...entrypointScope ? {
+      selectedEntrypoint: {
+        scope: entrypointScope,
+        name: entrypointName || null
+      }
+    } : {},
+    ...triggerType ? { triggerType } : {},
+    ...workflowMode ? { defaultWorkflowMode: workflowMode } : {},
+    ...optionString(options, "defaultBranch") ? { defaultBranch: optionString(options, "defaultBranch") } : {},
+    ...optionString(options, "sourceRefOverride") ? { sourceRefOverride: optionString(options, "sourceRefOverride") } : {},
+    ...promotionPolicy ? { defaultPromotionPolicy: promotionPolicy } : {},
+    ...agentSource ? { runtimeSource: agentSource } : {},
+    ...optionalJsonObject(options, "endpointPolicy", "endpoint-policy") ? {
+      endpointPolicy: optionalJsonObject(
+        options,
+        "endpointPolicy",
+        "endpoint-policy"
+      )
+    } : {},
+    ...optionalJsonObject(
+      options,
+      "backgroundTaskPolicy",
+      "background-task-policy"
+    ) ? {
+      backgroundTaskPolicy: optionalJsonObject(
+        options,
+        "backgroundTaskPolicy",
+        "background-task-policy"
+      )
+    } : {},
+    ...optionalJsonObject(options, "resourcePolicy", "resource-policy") ? {
+      defaultResourcePolicy: optionalJsonObject(
+        options,
+        "resourcePolicy",
+        "resource-policy"
+      )
+    } : {},
+    ...optionalJsonObject(options, "lifecyclePolicy", "lifecycle-policy") ? {
+      defaultLifecyclePolicy: optionalJsonObject(
+        options,
+        "lifecyclePolicy",
+        "lifecycle-policy"
+      )
+    } : {},
+    ...optionalJsonObject(options, "checkpointPolicy", "checkpoint-policy") ? {
+      defaultCheckpointPolicy: optionalJsonObject(
+        options,
+        "checkpointPolicy",
+        "checkpoint-policy"
+      )
+    } : {},
+    ...parseCsvOption(options.requiredIntegrations).length > 0 ? {
+      requiredIntegrationRefs: parseCsvOption(options.requiredIntegrations)
+    } : {},
+    ...parseCsvOption(options.requiredEnv).length > 0 ? { requiredEnvironmentVariableRefs: parseCsvOption(options.requiredEnv) } : {},
+    ...optionalJsonObject(options, "schedulePolicy", "schedule-policy") ? {
+      schedulePolicy: optionalJsonObject(
+        options,
+        "schedulePolicy",
+        "schedule-policy"
+      )
+    } : {},
+    ...optionString(options, "externalId") ? { externalId: optionString(options, "externalId") } : {},
+    ...metadata ? { metadata } : {}
+  };
+}
+function buildAgentUpdateInput(teamId, options) {
+  const entrypointScope = parseAgentEntrypointScope(options.entrypointScope);
+  const entrypointName = optionString(options, "entrypointName");
+  const triggerType = parseAgentTriggerType(options.triggerType);
+  const workflowMode = parseSandboxWorkflowModeOption(options.workflowMode);
+  const promotionPolicy = parseSandboxRuntimePromotionPolicyOption(
+    options.runtimePromotionPolicy
+  );
+  const agentSource = buildAgentSourceConfig(options);
+  const metadata = optionalJsonObject(options, "metadata", "metadata");
+  return {
+    teamId,
+    ...optionString(options, "projectId") ? { projectId: optionString(options, "projectId") } : {},
+    ...optionString(options, "name") ? { name: optionString(options, "name") } : {},
+    ...optionString(options, "slug") ? { slug: optionString(options, "slug") } : {},
+    ...optionString(options, "description") ? { description: optionString(options, "description") } : {},
+    ...options.status === "active" || options.status === "disabled" || options.status === "archived" ? { status: options.status } : {},
+    ...entrypointScope ? {
+      selectedEntrypoint: {
+        scope: entrypointScope,
+        name: entrypointName || null
+      }
+    } : {},
+    ...triggerType ? { triggerType } : {},
+    ...workflowMode ? { defaultWorkflowMode: workflowMode } : {},
+    ...optionString(options, "defaultBranch") ? { defaultBranch: optionString(options, "defaultBranch") } : {},
+    ...optionString(options, "sourceRefOverride") ? { sourceRefOverride: optionString(options, "sourceRefOverride") } : {},
+    ...promotionPolicy ? { defaultPromotionPolicy: promotionPolicy } : {},
+    ...agentSource ? { runtimeSource: agentSource } : {},
+    ...optionalJsonObject(options, "endpointPolicy", "endpoint-policy") ? {
+      endpointPolicy: optionalJsonObject(
+        options,
+        "endpointPolicy",
+        "endpoint-policy"
+      )
+    } : {},
+    ...optionalJsonObject(
+      options,
+      "backgroundTaskPolicy",
+      "background-task-policy"
+    ) ? {
+      backgroundTaskPolicy: optionalJsonObject(
+        options,
+        "backgroundTaskPolicy",
+        "background-task-policy"
+      )
+    } : {},
+    ...optionalJsonObject(options, "resourcePolicy", "resource-policy") ? {
+      defaultResourcePolicy: optionalJsonObject(
+        options,
+        "resourcePolicy",
+        "resource-policy"
+      )
+    } : {},
+    ...optionalJsonObject(options, "lifecyclePolicy", "lifecycle-policy") ? {
+      defaultLifecyclePolicy: optionalJsonObject(
+        options,
+        "lifecyclePolicy",
+        "lifecycle-policy"
+      )
+    } : {},
+    ...optionalJsonObject(options, "checkpointPolicy", "checkpoint-policy") ? {
+      defaultCheckpointPolicy: optionalJsonObject(
+        options,
+        "checkpointPolicy",
+        "checkpoint-policy"
+      )
+    } : {},
+    ...parseCsvOption(options.requiredIntegrations).length > 0 ? {
+      requiredIntegrationRefs: parseCsvOption(options.requiredIntegrations)
+    } : {},
+    ...parseCsvOption(options.requiredEnv).length > 0 ? { requiredEnvironmentVariableRefs: parseCsvOption(options.requiredEnv) } : {},
+    ...optionalJsonObject(options, "schedulePolicy", "schedule-policy") ? {
+      schedulePolicy: optionalJsonObject(
+        options,
+        "schedulePolicy",
+        "schedule-policy"
+      )
+    } : {},
+    ...optionString(options, "externalId") ? { externalId: optionString(options, "externalId") } : {},
+    ...metadata ? { metadata } : {}
+  };
+}
+
+export {
+  resolveLocalAgentSdkCommand,
+  PROJECT_SOURCE_UPLOAD_MAX_FILES,
+  PROJECT_SOURCE_UPLOAD_MAX_FILE_BYTES,
+  PROJECT_SOURCE_UPLOAD_MAX_BYTES,
+  PROJECT_SOURCE_UPLOAD_CONCURRENCY,
+  PROJECT_SOURCE_UPLOAD_LIMITS,
+  PROJECT_SOURCE_UPLOAD_TRANSPORT,
+  resolveProjectSourceUploadBranch,
+  collectProjectSourceUploadEntries,
+  collectAgentSdkProjectSourceUploadEntries,
+  mergeProjectSourceUploadEntries,
+  parseProjectSourceType,
+  parseAgentEntrypointScope,
+  parseAgentTriggerType,
+  parseAgentSourceMode,
+  buildAgentSourceConfig,
+  buildAgentSourcePolicy,
+  parseAgentSourceCheckKind,
+  parseAgentSourceCheckDispatch,
+  parsePositiveLimit,
+  buildAgentSourceChecksInput,
+  buildAgentSourcePublishInput,
+  buildAgentEditOpenInput,
+  buildCodingWorkItemChatInput,
+  buildCodingWorkItemBackgroundInput,
+  buildCodingWorkItemPromotionInput,
+  buildProjectUpsertInput,
+  buildProjectUpdateInput,
+  buildAgentUpsertInput,
+  buildAgentUpdateInput
+};