openpond 0.0.30-bootstrap.0

package/dist/chunks/chunk-FUP7EGT7.js

@@ -0,0 +1,1845 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  SOURCE_UPLOAD_CACHE_PATH,
+  materializeSourceUploadFile,
+  readSourceUploadCache,
+  writeSourceUploadCache
+} from "./chunk-I6HN3ZGW.js";
+import {
+  yaml
+} from "./chunk-WYDVQOBL.js";
+import {
+  loadGlobalConfig,
+  saveGlobalConfig
+} from "./chunk-XSAXENQD.js";
+
+// ../../packages/cloud/src/profile/profile-setup-gate.ts
+var OpenPondProfileSetupRequiredError = class extends Error {
+  code = "agent_source_setup_required";
+  details;
+  constructor(actionId, setupGate) {
+    const labels = setupGate.blockingRequirements.map((requirement) => requirement.label);
+    super(
+      [
+        "agent_source_setup_required",
+        `Profile action ${actionId} has unresolved required setup.`,
+        labels.length ? `Missing setup: ${labels.join(", ")}` : ""
+      ].filter(Boolean).join("\n")
+    );
+    this.name = "OpenPondProfileSetupRequiredError";
+    this.details = {
+      error: "agent_source_setup_required",
+      actionId,
+      setupGate,
+      missing: labels,
+      blockingSetupRequirements: setupGate.blockingRequirements,
+      setupRequirements: setupGate.requirements
+    };
+  }
+};
+function buildOpenPondProfileSetupGate(input) {
+  const requirements = /* @__PURE__ */ new Map();
+  for (const record2 of input.sourceSetupRequirements ?? []) {
+    const sourceActionId = setupRequirementActionId(record2);
+    if (input.actionId && sourceActionId && sourceActionId !== input.actionId && text(record2.actionName) !== input.actionId && text(record2.sourceActionId) !== input.actionId) {
+      continue;
+    }
+    const requirement = setupRequirementFromRecord({
+      record: record2,
+      source: "source_upload_metadata",
+      actionId: sourceActionId
+    });
+    if (requirement) requirements.set(requirement.ref, requirement);
+  }
+  for (const action of input.actionCatalog) {
+    if (input.actionId && action.id !== input.actionId && action.name !== input.actionId) {
+      continue;
+    }
+    for (const record2 of action.setupRequirements ?? []) {
+      const requirement = setupRequirementFromRecord({
+        record: record2,
+        source: "action_catalog",
+        actionId: action.id
+      });
+      if (requirement) requirements.set(requirement.ref, requirement);
+    }
+  }
+  const allRequirements = Array.from(requirements.values());
+  const blockingRequirements = allRequirements.filter((requirement) => requirement.blocking);
+  const optionalMissingCount = allRequirements.filter(
+    (requirement) => !requirement.required && !isReadyStatus(requirement.status)
+  ).length;
+  const readyCount = allRequirements.filter((requirement) => isReadyStatus(requirement.status)).length;
+  return {
+    status: gateStatus(blockingRequirements),
+    requirementCount: allRequirements.length,
+    blockingCount: blockingRequirements.length,
+    optionalMissingCount,
+    readyCount,
+    requirements: allRequirements,
+    blockingRequirements
+  };
+}
+function assertOpenPondProfileActionReady(actionId, setupGate) {
+  if (setupGate.blockingRequirements.length > 0) {
+    throw new OpenPondProfileSetupRequiredError(actionId, setupGate);
+  }
+}
+function formatOpenPondProfileSetupRequirement(requirement) {
+  const prefix = requirement.actionId ? `${requirement.actionId}: ` : "";
+  const required = requirement.required ? "required" : "optional";
+  return `${prefix}${requirement.label} (${required}, ${requirement.status})`;
+}
+function setupRequirementFromRecord(input) {
+  const source = input.source === "action_catalog" && text(input.record.source) === "source_upload_metadata" ? "source_upload_metadata" : input.source;
+  const kind = text(input.record.kind) ?? text(input.record.type);
+  const label = text(input.record.label) ?? text(input.record.name) ?? text(input.record.key) ?? text(input.record.provider) ?? text(input.record.tool) ?? text(input.record.command) ?? text(input.record.packageName) ?? text(input.record.path) ?? text(input.record.repo) ?? text(input.record.url) ?? text(input.record.id) ?? kind ?? "setup requirement";
+  const required = input.record.required !== false;
+  const status = setupStatus(input.record);
+  const ref = [
+    source,
+    input.actionId ?? "source",
+    kind ?? "requirement",
+    label
+  ].join(":");
+  return {
+    ref,
+    source,
+    actionId: input.actionId,
+    kind,
+    label,
+    status,
+    required,
+    blocking: required && !isReadyStatus(status)
+  };
+}
+function setupRequirementActionId(record2) {
+  return text(record2.actionId) ?? text(record2.sourceActionId) ?? text(record2.actionName);
+}
+function setupStatus(record2) {
+  const explicit = text(record2.status) ?? text(record2.state);
+  if (explicit) {
+    if (explicit === "satisfied" || explicit === "connected" || explicit === "provided") {
+      return "ready";
+    }
+    return explicit;
+  }
+  if (typeof record2.satisfied === "boolean") {
+    return record2.satisfied ? "ready" : "setup_required";
+  }
+  if (typeof record2.ready === "boolean") {
+    return record2.ready ? "ready" : "setup_required";
+  }
+  return "setup_required";
+}
+function gateStatus(blockingRequirements) {
+  if (blockingRequirements.length === 0) return "ready";
+  return blockingRequirements.some(
+    (requirement) => ["blocked", "unsupported", "unsupported_dependency", "stale"].includes(requirement.status)
+  ) ? "blocked" : "setup_required";
+}
+function isReadyStatus(status) {
+  return status === "ready" || status === "disabled";
+}
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+// ../../packages/cloud/src/profile/profile-source-upload.ts
+import { stat } from "node:fs/promises";
+import path2 from "node:path";
+
+// ../../packages/cloud/src/profile/profile-git.ts
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+var PROFILE_REPO_GITIGNORE = [
+  "**/node_modules/",
+  "**/.bun/",
+  "**/.env",
+  "**/.env.*",
+  "**/.openpond/goals/",
+  "**/.openpond/traces/",
+  "**/.openpond/vendor/",
+  "**/.openpond/eval-results.json",
+  "**/.openpond/artifact-index.json",
+  "**/.openpond/source-upload-cache.json",
+  ""
+].join("\n");
+async function ensureProfileGitRepo(repoPath) {
+  if (!existsSync(path.join(repoPath, ".git"))) {
+    const init = await runGitCommand(repoPath, ["init", "-b", "main"]);
+    if (init.code !== 0) {
+      throw new Error(gitFailureMessage("git init", init));
+    }
+  }
+  const gitignorePath = path.join(repoPath, ".gitignore");
+  if (!existsSync(gitignorePath)) {
+    await writeFile(gitignorePath, PROFILE_REPO_GITIGNORE, "utf8");
+  } else {
+    await ensureProfileGitignoreRules(gitignorePath);
+  }
+  if (await hasGitHead(repoPath)) return;
+  const state = await loadProfileGitState(repoPath);
+  if (!state.dirty && state.files.length === 0) return;
+  const add = await runGitCommand(repoPath, ["add", "-A"]);
+  if (add.code !== 0) {
+    throw new Error(gitFailureMessage("git add", add));
+  }
+  const commit = await runGitCommand(repoPath, ["commit", "-m", "Initialize OpenPond profile"], {
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME || "OpenPond",
+      GIT_AUTHOR_EMAIL: process.env.GIT_AUTHOR_EMAIL || "openpond@example.invalid",
+      GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME || "OpenPond",
+      GIT_COMMITTER_EMAIL: process.env.GIT_COMMITTER_EMAIL || "openpond@example.invalid"
+    }
+  });
+  if (commit.code !== 0 && !/nothing to commit/i.test(commit.stdout + commit.stderr)) {
+    throw new Error(gitFailureMessage("git commit", commit));
+  }
+}
+async function ensureProfileGitignoreRules(gitignorePath) {
+  const current = await readFile(gitignorePath, "utf8").catch(() => "");
+  const missing = PROFILE_REPO_GITIGNORE.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).filter((line) => !current.split(/\r?\n/).some((existing) => existing.trim() === line));
+  if (missing.length === 0) return;
+  const suffix = current.endsWith("\n") || current.length === 0 ? "" : "\n";
+  await writeFile(gitignorePath, `${current}${suffix}${missing.join("\n")}
+`, "utf8");
+}
+async function loadProfileGitState(repoPath) {
+  if (!existsSync(path.join(repoPath, ".git"))) {
+    return {
+      isRepo: false,
+      branch: null,
+      head: null,
+      shortHead: null,
+      dirty: false,
+      upstream: null,
+      ahead: null,
+      behind: null,
+      remoteUrl: null,
+      files: [],
+      error: null
+    };
+  }
+  const inside = await runGitCommand(repoPath, ["rev-parse", "--is-inside-work-tree"]);
+  if (inside.code !== 0 || inside.stdout.trim() !== "true") {
+    return {
+      isRepo: false,
+      branch: null,
+      head: null,
+      shortHead: null,
+      dirty: false,
+      upstream: null,
+      ahead: null,
+      behind: null,
+      remoteUrl: null,
+      files: [],
+      error: inside.stderr.trim() || inside.stdout.trim() || "not a Git work tree"
+    };
+  }
+  const [branch, head, status, upstream, remoteUrl] = await Promise.all([
+    gitText(repoPath, ["branch", "--show-current"]),
+    gitText(repoPath, ["rev-parse", "HEAD"]),
+    runGitCommand(repoPath, ["status", "--porcelain=v1", "-uall"]),
+    gitText(repoPath, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]),
+    gitText(repoPath, ["remote", "get-url", "origin"])
+  ]);
+  const files = status.code === 0 ? parsePorcelainStatus(status.stdout) : [];
+  const aheadBehind = upstream ? await loadAheadBehind(repoPath) : { ahead: null, behind: null };
+  const resolvedHead = head || null;
+  return {
+    isRepo: true,
+    branch: branch || null,
+    head: resolvedHead,
+    shortHead: resolvedHead ? resolvedHead.slice(0, 12) : null,
+    dirty: files.length > 0,
+    upstream,
+    ahead: aheadBehind.ahead,
+    behind: aheadBehind.behind,
+    remoteUrl,
+    files,
+    error: status.code === 0 ? null : gitFailureMessage("git status", status)
+  };
+}
+async function commitProfileChanges(repoPath, message) {
+  const before = await loadProfileGitState(repoPath);
+  if (!before.isRepo) {
+    throw new Error(before.error ?? "Active OpenPond profile source is not a Git repo.");
+  }
+  if (!before.dirty) {
+    return {
+      committed: false,
+      stdout: "",
+      stderr: "",
+      state: before
+    };
+  }
+  const add = await runGitCommand(repoPath, ["add", "-A"]);
+  if (add.code !== 0) {
+    throw new Error(gitFailureMessage("git add", add));
+  }
+  const commit = await runGitCommand(repoPath, ["commit", "-m", message]);
+  if (commit.code !== 0) {
+    throw new Error(gitFailureMessage("git commit", commit));
+  }
+  return {
+    committed: true,
+    stdout: commit.stdout,
+    stderr: commit.stderr,
+    state: await loadProfileGitState(repoPath)
+  };
+}
+async function profileGitHead(repoPath) {
+  return gitText(repoPath, ["rev-parse", "HEAD"]);
+}
+async function hasGitHead(repoPath) {
+  const result = await runGitCommand(repoPath, ["rev-parse", "--verify", "HEAD"]);
+  return result.code === 0;
+}
+async function loadAheadBehind(repoPath) {
+  const result = await runGitCommand(repoPath, ["rev-list", "--left-right", "--count", "@{u}...HEAD"]);
+  if (result.code !== 0) return { ahead: null, behind: null };
+  const [behindRaw, aheadRaw] = result.stdout.trim().split(/\s+/);
+  const behind = behindRaw ? Number.parseInt(behindRaw, 10) : Number.NaN;
+  const ahead = aheadRaw ? Number.parseInt(aheadRaw, 10) : Number.NaN;
+  return {
+    ahead: Number.isFinite(ahead) ? ahead : null,
+    behind: Number.isFinite(behind) ? behind : null
+  };
+}
+async function gitText(repoPath, args) {
+  const result = await runGitCommand(repoPath, args);
+  if (result.code !== 0) return null;
+  const text5 = result.stdout.trim();
+  return text5 || null;
+}
+function parsePorcelainStatus(output) {
+  return output.split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean).map((line) => {
+    const rawIndex = line[0] ?? " ";
+    const rawWorktree = line[1] ?? " ";
+    const status = `${rawIndex}${rawWorktree}`.trim() || "changed";
+    const rawPath = line.slice(3);
+    const renameParts = rawPath.split(" -> ");
+    const indexStatus = rawIndex === " " ? null : rawIndex;
+    const worktreeStatus = rawWorktree === " " ? null : rawWorktree;
+    const pathValue = renameParts.length === 2 ? renameParts[1] : rawPath;
+    const originalPath = renameParts.length === 2 ? renameParts[0] : null;
+    return {
+      path: unquoteGitPath(pathValue),
+      originalPath: originalPath ? unquoteGitPath(originalPath) : null,
+      indexStatus,
+      worktreeStatus,
+      status,
+      category: gitChangeCategory(indexStatus, worktreeStatus)
+    };
+  });
+}
+function gitChangeCategory(indexStatus, worktreeStatus) {
+  if (indexStatus === "?" && worktreeStatus === "?") return "untracked";
+  if (indexStatus === "R" || worktreeStatus === "R") return "renamed";
+  if (indexStatus === "A" || worktreeStatus === "A") return "added";
+  if (indexStatus === "D" || worktreeStatus === "D") return "deleted";
+  if (indexStatus === "M" || worktreeStatus === "M") return "modified";
+  return "changed";
+}
+function unquoteGitPath(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith('"') || !trimmed.endsWith('"')) return trimmed;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return trimmed.slice(1, -1);
+  }
+}
+function gitFailureMessage(label, result) {
+  const detail = result.stderr.trim() || result.stdout.trim();
+  return detail || `${label} failed with exit code ${result.code ?? "unknown"}`;
+}
+async function runGitCommand(repoPath, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn("git", args, {
+      cwd: repoPath,
+      env: options.env,
+      stdio: "pipe"
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    proc.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      resolve({ code, stdout, stderr });
+    });
+  });
+}
+
+// ../../packages/cloud/src/profile/profile-source-upload.ts
+var PROFILE_SOURCE_UPLOAD_MAX_FILES = 1500;
+var PROFILE_SOURCE_UPLOAD_MAX_FILE_BYTES = 8 * 1024 * 1024;
+var PROFILE_SOURCE_UPLOAD_MAX_BYTES = 100 * 1024 * 1024;
+var PROFILE_SOURCE_UPLOAD_CONCURRENCY = 8;
+var PROFILE_SOURCE_UPLOAD_LIMITS = {
+  maxFiles: PROFILE_SOURCE_UPLOAD_MAX_FILES,
+  maxFileBytes: PROFILE_SOURCE_UPLOAD_MAX_FILE_BYTES,
+  maxTotalBytes: PROFILE_SOURCE_UPLOAD_MAX_BYTES,
+  concurrency: PROFILE_SOURCE_UPLOAD_CONCURRENCY
+};
+var PROFILE_SOURCE_UPLOAD_TRANSPORT = {
+  mode: "single_json_payload",
+  chunkingSupported: false
+};
+async function collectProfileSourceUploadEntries(repoPath) {
+  const files = await runGitCommand(repoPath, ["ls-files", "-z"]);
+  if (files.code !== 0) {
+    throw new Error(files.stderr.trim() || files.stdout.trim() || "git ls-files failed for profile source upload");
+  }
+  const sourcePaths = files.stdout.split("\0").map((filePath) => filePath.trim()).filter(Boolean).filter((filePath) => {
+    const normalized = filePath.replace(/\\/g, "/");
+    return isSafeProfileSourcePath(normalized) && !shouldSkipProfileSourcePath(normalized);
+  }).sort();
+  if (sourcePaths.length === 0) {
+    throw new Error("No committed profile source files found to upload.");
+  }
+  if (sourcePaths.length > PROFILE_SOURCE_UPLOAD_MAX_FILES) {
+    throw new Error(`Too many profile source files to upload: ${sourcePaths.length} > ${PROFILE_SOURCE_UPLOAD_MAX_FILES}`);
+  }
+  const filesToUpload = (await mapWithConcurrency(sourcePaths, PROFILE_SOURCE_UPLOAD_CONCURRENCY, async (sourcePath) => {
+    const absolutePath = path2.resolve(repoPath, sourcePath);
+    const relative = path2.relative(repoPath, absolutePath).replace(/\\/g, "/");
+    if (!isSafeProfileSourcePath(relative)) {
+      throw new Error(`Profile source path escapes repo: ${sourcePath}`);
+    }
+    const fileStat = await stat(absolutePath);
+    if (!fileStat.isFile()) return null;
+    if (fileStat.size > PROFILE_SOURCE_UPLOAD_MAX_FILE_BYTES) {
+      throw new Error(`Profile source file is too large: ${sourcePath} (${fileStat.size} bytes)`);
+    }
+    return {
+      path: relative,
+      absolutePath,
+      size: fileStat.size,
+      mtimeMs: Math.trunc(fileStat.mtimeMs),
+      ctimeMs: Math.trunc(fileStat.ctimeMs)
+    };
+  })).filter((file) => file !== null);
+  let totalBytes = 0;
+  for (const file of filesToUpload) {
+    totalBytes += file.size;
+    if (totalBytes > PROFILE_SOURCE_UPLOAD_MAX_BYTES) {
+      throw new Error(`Profile source upload is too large: ${totalBytes} > ${PROFILE_SOURCE_UPLOAD_MAX_BYTES}`);
+    }
+  }
+  const cache = await readSourceUploadCache(repoPath);
+  const materialized = await mapWithConcurrency(
+    filesToUpload,
+    PROFILE_SOURCE_UPLOAD_CONCURRENCY,
+    async (file) => materializeSourceUploadFile(file, cache)
+  );
+  await writeSourceUploadCache(repoPath, materialized).catch(() => {
+  });
+  const entries = materialized.map((item) => item.entry);
+  return {
+    entries,
+    fileCount: entries.length,
+    totalBytes,
+    limits: PROFILE_SOURCE_UPLOAD_LIMITS,
+    transport: PROFILE_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;
+}
+function isSafeProfileSourcePath(filePath) {
+  return filePath.length > 0 && !filePath.includes("\0") && !path2.isAbsolute(filePath) && !filePath.split(/[\\/]+/).some((part) => !part || part === "." || part === "..");
+}
+function shouldSkipProfileSourcePath(filePath) {
+  return filePath.split(/[\\/]+/).some((segment, index, segments) => {
+    const lower = segment.toLowerCase();
+    if (lower === ".git" || lower === "node_modules" || lower === ".bun") return true;
+    if (lower === ".env" || lower.startsWith(".env.")) return true;
+    if (filePath.replace(/\\/g, "/") === SOURCE_UPLOAD_CACHE_PATH) return true;
+    if (lower !== ".openpond") return false;
+    const nested = segments[index + 1]?.toLowerCase();
+    return nested === "goals" || nested === "traces" || nested === "vendor" || nested === "eval-results.json" || nested === "artifact-index.json";
+  });
+}
+
+// ../../packages/cloud/src/profile/profile-promotion.ts
+function hostedSourceCheckStatusFromPayload(input) {
+  const checkResult = record(input.checkResult);
+  const deployPlan = record(checkResult?.deployPlan) ?? record(input.deployPlan);
+  const source = record(deployPlan?.source);
+  const checks = record(deployPlan?.checks);
+  const workItem = record(checkResult?.workItem);
+  const sourceCheckStatus = record(checkResult?.sourceCheckStatus);
+  return {
+    status: input.status,
+    agentId: input.agentId,
+    workItemId: text2(workItem?.id),
+    deployPlanStatus: text2(deployPlan?.status),
+    canRun: booleanValue(deployPlan?.canRun),
+    canDeploy: booleanValue(deployPlan?.canDeploy),
+    sourceRef: text2(source?.sourceRef),
+    sourceCommitSha: text2(source?.sourceCommitSha),
+    manifestHash: text2(source?.manifestHash),
+    manifestPath: text2(source?.manifestPath),
+    setupCommands: textArray(checks?.setupCommands),
+    validationCommands: textArray(checks?.validationCommands),
+    requiredChecks: textArray(checks?.requiredChecks),
+    evalNames: textArray(checks?.evalNames),
+    blockedReasons: textArray(deployPlan?.blockedReasons),
+    staleReasons: textArray(deployPlan?.staleReasons),
+    runtimeId: text2(sourceCheckStatus?.latestRuntimeId),
+    sandboxId: text2(sourceCheckStatus?.latestSandboxId),
+    traceArtifactRefs: textArray(sourceCheckStatus?.traceArtifactRefs),
+    evalResultArtifactRefs: textArray(sourceCheckStatus?.evalResultArtifactRefs),
+    validatorArtifactRefs: textArray(sourceCheckStatus?.validatorArtifactRefs),
+    checkedAt: input.checkedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    error: input.error ?? null
+  };
+}
+function hostedPublishStatusFromPayload(input) {
+  const result = record(input.publishResult);
+  const snapshot = record(result?.activeManifestSnapshot) ?? record(result?.manifestSnapshot) ?? record(result?.snapshot);
+  return {
+    status: input.status ?? "published",
+    agentId: input.agentId,
+    snapshotId: text2(snapshot?.id),
+    sourceRef: text2(snapshot?.sourceRef),
+    sourceCommitSha: text2(snapshot?.sourceCommitSha),
+    manifestHash: text2(snapshot?.manifestHash),
+    manifestPath: text2(snapshot?.manifestPath),
+    buildStatus: text2(snapshot?.buildStatus),
+    validationStatus: text2(snapshot?.validationStatus),
+    evalStatus: text2(snapshot?.evalStatus),
+    publishedAt: text2(result?.publishedAt) ?? text2(snapshot?.publishedAt),
+    error: input.error ?? null
+  };
+}
+function hostedRunSummaryFromPayload(input) {
+  const result = record(input.runResult);
+  const run = record(result?.run);
+  const runtimeSource = record(run?.runtimeSource);
+  const metadata = record(run?.metadata);
+  const sourceSummary = record(metadata?.sourceSummary);
+  const setupGate = record(metadata?.setupGate);
+  const responseSummary = record(metadata?.responseSummary);
+  const traceSummary = record(metadata?.traceSummary);
+  const evalSummary = record(metadata?.evalSummary);
+  return {
+    status: text2(run?.status) ?? (input.error ? "failed" : "running"),
+    agentId: text2(run?.agentId) ?? input.agentId,
+    runId: text2(run?.id),
+    runtimeId: text2(run?.runtimeId),
+    sandboxId: text2(run?.sandboxId),
+    sourceRef: text2(runtimeSource?.sourceRef) ?? text2(sourceSummary?.sourceRef) ?? text2(metadata?.sourceRef),
+    sourceCommitSha: text2(runtimeSource?.sourceCommitSha) ?? text2(sourceSummary?.sourceCommitSha) ?? text2(metadata?.hostedHead),
+    manifestHash: text2(runtimeSource?.manifestHash) ?? text2(sourceSummary?.manifestHash),
+    setupGateStatus: text2(setupGate?.status),
+    setupRequirementRefs: setupRequirementRefs(setupGate),
+    artifactRefs: textArray(responseSummary?.artifactRefs),
+    traceArtifactRefs: textArray(traceSummary?.artifactRefs),
+    evalArtifactRefs: textArray(evalSummary?.artifactRefs),
+    startedAt: text2(run?.createdAt),
+    completedAt: text2(run?.completedAt),
+    error: input.error ?? null
+  };
+}
+function hostedRunStatusFromRunSummary(summary) {
+  if (!summary?.status) return "not_started";
+  if (summary.status === "succeeded" || summary.status === "passed") return "passed";
+  if (summary.status === "failed" || summary.status === "cancelled") return "failed";
+  return "running";
+}
+function setupRequirementRefs(setupGate) {
+  if (!setupGate) return [];
+  const requirements = Array.isArray(setupGate.requirements) ? setupGate.requirements : Array.isArray(setupGate.blockingRequirements) ? setupGate.blockingRequirements : [];
+  return requirements.map((item) => {
+    const requirement = record(item);
+    return text2(requirement?.ref) ?? text2(requirement?.id) ?? text2(requirement?.label);
+  }).filter((item) => Boolean(item));
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function text2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function booleanValue(value) {
+  return typeof value === "boolean" ? value : null;
+}
+function textArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+}
+
+// ../../packages/cloud/src/profile/local-profile.ts
+import { createRequire } from "node:module";
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync4 } from "node:fs";
+import { cp, mkdir, readFile as readFile4, readdir as readdir2, symlink, writeFile as writeFile2 } from "node:fs/promises";
+import os from "node:os";
+import path5 from "node:path";
+
+// ../../packages/cloud/src/profile/local-profile-types.ts
+function emptyProfileCatalogState(error = null) {
+  return {
+    actionCount: 0,
+    generatedAt: null,
+    manifestPath: null,
+    registryPath: null,
+    stale: true,
+    error
+  };
+}
+function emptyProfileSkillCatalogState(error = null) {
+  return {
+    skillCount: 0,
+    generatedAt: null,
+    stale: true,
+    error
+  };
+}
+function emptyProfileSetupGate() {
+  return {
+    status: "ready",
+    requirementCount: 0,
+    blockingCount: 0,
+    optionalMissingCount: 0,
+    readyCount: 0,
+    requirements: [],
+    blockingRequirements: []
+  };
+}
+function emptyProfileDiffSummary() {
+  return {
+    changedAgents: [],
+    newAgents: [],
+    deletedAgents: [],
+    changedSkills: [],
+    changedActions: [],
+    changedExtensions: [],
+    setupChanges: [],
+    envRequirementChanges: [],
+    files: []
+  };
+}
+function emptyProfileSummary(error = null) {
+  return {
+    state: error ? "error" : "none",
+    message: error ?? "No active OpenPond profile.",
+    agentCount: 0,
+    actionCount: 0,
+    defaultAction: null,
+    checkFresh: false,
+    checkStaleReason: error ?? "No active profile.",
+    localHead: null,
+    hostedHead: null
+  };
+}
+
+// ../../packages/cloud/src/profile/profile-catalog.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import path3 from "node:path";
+var AGENT_MANIFEST_PATH = ".openpond/agent-manifest.json";
+var ACTION_REGISTRY_PATH = ".openpond/action-registry.json";
+var SOURCE_UPLOAD_METADATA_PATH = ".openpond/source-upload-metadata.json";
+async function loadProfileActionCatalog(sourcePath) {
+  return loadProfileActionCatalogSource({
+    agentId: "default",
+    sourcePath,
+    preferred: true
+  });
+}
+async function loadProfileActionCatalogForSources(sources) {
+  if (sources.length === 0) {
+    return {
+      catalog: {
+        actionCount: 0,
+        generatedAt: null,
+        manifestPath: null,
+        registryPath: null,
+        stale: true,
+        error: "No profile agent sources are enabled."
+      },
+      actionCatalog: [],
+      sourceSetupRequirements: []
+    };
+  }
+  const sortedSources = [
+    ...sources.filter((source) => source.preferred),
+    ...sources.filter((source) => !source.preferred)
+  ];
+  const results = await Promise.all(sortedSources.map(loadProfileActionCatalogSource));
+  const byId = /* @__PURE__ */ new Map();
+  const actionCatalog = [];
+  for (const result of results) {
+    for (const action of result.actionCatalog) {
+      const uniqueId = byId.has(action.id) ? `${action.agentId ?? "agent"}.${action.sourceActionId ?? action.id}` : action.id;
+      const next = uniqueId === action.id ? action : { ...action, id: uniqueId };
+      byId.set(uniqueId, next);
+      actionCatalog.push(next);
+    }
+  }
+  const generatedAt = latestIso(results.map((result) => result.catalog.generatedAt));
+  const errors = results.map((result) => result.catalog.error).filter(Boolean);
+  return {
+    catalog: {
+      actionCount: actionCatalog.length,
+      generatedAt,
+      manifestPath: results.find((result) => result.catalog.manifestPath)?.catalog.manifestPath ?? null,
+      registryPath: results.find((result) => result.catalog.registryPath)?.catalog.registryPath ?? null,
+      stale: results.some((result) => result.catalog.stale),
+      error: errors.length > 0 ? errors.join("; ") : null
+    },
+    actionCatalog,
+    sourceSetupRequirements: results.flatMap((result) => result.sourceSetupRequirements)
+  };
+}
+async function loadProfileActionCatalogSource(source) {
+  const sourcePath = source.sourcePath;
+  const manifestPath = path3.join(sourcePath, AGENT_MANIFEST_PATH);
+  const registryPath = path3.join(sourcePath, ACTION_REGISTRY_PATH);
+  const sourceUploadMetadataPath = path3.join(sourcePath, SOURCE_UPLOAD_METADATA_PATH);
+  try {
+    const manifest = await readJsonIfExists(manifestPath);
+    const registry = await readJsonIfExists(registryPath);
+    const sourceUploadMetadata = await readJsonIfExists(sourceUploadMetadataPath);
+    const sourceSetupRequirements = recordArray(asRecord(sourceUploadMetadata)?.setupRequirements) ?? [];
+    const sourceRequirementsByAction = sourceSetupRequirementsByAction(sourceSetupRequirements);
+    const byId = /* @__PURE__ */ new Map();
+    for (const record2 of [
+      ...records(asRecord(manifest)?.actionCatalog),
+      ...records(asRecord(registry)?.actions),
+      ...records(asRecord(manifest)?.actions)
+    ]) {
+      const id = text3(record2.id) ?? text3(record2.name);
+      if (!id) continue;
+      const existing = byId.get(id);
+      const actionSourceRequirements = setupRequirementsForActionSource({
+        sourceRequirementsByAction,
+        actionId: id,
+        actionName: text3(record2.name)
+      });
+      const setupRequirements = mergeSetupRequirements(
+        recordArray(record2.setupRequirements) ?? existing?.setupRequirements ?? [],
+        actionSourceRequirements
+      );
+      const next = {
+        id,
+        agentId: source.agentId,
+        sourcePath,
+        sourceActionId: id,
+        name: text3(record2.name) ?? existing?.name ?? id,
+        label: text3(record2.label) ?? existing?.label ?? titleFromActionId(id),
+        description: text3(record2.description) ?? existing?.description ?? null,
+        visibility: text3(record2.visibility) ?? existing?.visibility ?? "default",
+        inputSchema: schemaValue(record2.inputSchema) ?? existing?.inputSchema ?? null,
+        outputSchema: schemaValue(record2.outputSchema) ?? existing?.outputSchema ?? null,
+        approvalPolicy: asRecord(record2.approvalPolicy) ?? existing?.approvalPolicy ?? null,
+        artifactPolicy: asRecord(record2.artifactPolicy) ?? existing?.artifactPolicy ?? null,
+        setupRequirements,
+        mcp: asRecord(record2.mcp) ?? existing?.mcp ?? null,
+        schedulePolicy: asRecord(record2.schedulePolicy) ?? existing?.schedulePolicy ?? null,
+        trace: asRecord(record2.trace) ?? existing?.trace ?? null,
+        implementation: asRecord(record2.implementation) ?? existing?.implementation ?? null,
+        invokesModel: typeof record2.invokesModel === "boolean" ? record2.invokesModel : existing?.invokesModel
+      };
+      byId.set(id, next);
+    }
+    const actionCatalog = Array.from(byId.values()).filter(
+      (action) => action.visibility !== "internal" && action.visibility !== "debug"
+    );
+    const missingArtifacts = [
+      ...!manifest ? [AGENT_MANIFEST_PATH] : [],
+      ...!registry ? [ACTION_REGISTRY_PATH] : []
+    ];
+    const generatedAt = await latestMtime([manifestPath, registryPath]);
+    return {
+      catalog: {
+        actionCount: actionCatalog.length,
+        generatedAt,
+        manifestPath: existsSync2(manifestPath) ? manifestPath : null,
+        registryPath: existsSync2(registryPath) ? registryPath : null,
+        stale: missingArtifacts.length > 0,
+        error: missingArtifacts.length > 0 ? missingSourceArtifactsMessage(source, missingArtifacts) : null
+      },
+      actionCatalog,
+      sourceSetupRequirements
+    };
+  } catch (error) {
+    return {
+      catalog: {
+        actionCount: 0,
+        generatedAt: null,
+        manifestPath: existsSync2(manifestPath) ? manifestPath : null,
+        registryPath: existsSync2(registryPath) ? registryPath : null,
+        stale: true,
+        error: error instanceof Error ? error.message : String(error)
+      },
+      actionCatalog: [],
+      sourceSetupRequirements: []
+    };
+  }
+}
+function latestIso(values) {
+  let latest = 0;
+  for (const value of values) {
+    if (!value) continue;
+    const time = Date.parse(value);
+    if (Number.isFinite(time)) latest = Math.max(latest, time);
+  }
+  return latest > 0 ? new Date(latest).toISOString() : null;
+}
+function sourceSetupRequirementsByAction(records2) {
+  const byAction = /* @__PURE__ */ new Map();
+  for (const record2 of records2) {
+    const actionIds = [
+      text3(record2.actionId),
+      text3(record2.sourceActionId),
+      text3(record2.actionName)
+    ].filter((value) => Boolean(value));
+    for (const actionId of actionIds) {
+      const current = byAction.get(actionId) ?? [];
+      current.push(record2);
+      byAction.set(actionId, current);
+    }
+  }
+  return byAction;
+}
+function setupRequirementsForActionSource(input) {
+  const matched = [
+    ...input.sourceRequirementsByAction.get(input.actionId) ?? [],
+    ...input.actionName && input.actionName !== input.actionId ? input.sourceRequirementsByAction.get(input.actionName) ?? [] : []
+  ];
+  return matched.map((record2) => ({
+    ...record2,
+    source: "source_upload_metadata"
+  }));
+}
+function mergeSetupRequirements(primary, sourceUploadMetadata) {
+  if (sourceUploadMetadata.length === 0) return primary;
+  const merged = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const record2 of [...primary, ...sourceUploadMetadata]) {
+    const key = setupRequirementIdentity(record2);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(record2);
+  }
+  return merged;
+}
+function setupRequirementIdentity(record2) {
+  return [
+    text3(record2.actionId) ?? text3(record2.sourceActionId) ?? text3(record2.actionName) ?? "",
+    text3(record2.kind) ?? text3(record2.type) ?? "",
+    text3(record2.name) ?? text3(record2.key) ?? text3(record2.provider) ?? text3(record2.tool) ?? text3(record2.command) ?? text3(record2.packageName) ?? text3(record2.path) ?? text3(record2.repo) ?? text3(record2.url) ?? text3(record2.id) ?? ""
+  ].join(":");
+}
+function missingSourceArtifactsMessage(source, missingArtifacts) {
+  return [
+    `Profile agent ${source.agentId} at ${source.sourcePath} is missing SDK catalog artifact(s): ${missingArtifacts.join(", ")}.`,
+    "Run `openpond profile check --kind all` after source materialization so each enabled profile agent has inspect/build artifacts."
+  ].join(" ");
+}
+async function readJsonIfExists(filePath) {
+  if (!existsSync2(filePath)) return null;
+  return JSON.parse(await readFile2(filePath, "utf8"));
+}
+async function latestMtime(filePaths) {
+  let latest = 0;
+  for (const filePath of filePaths) {
+    if (!existsSync2(filePath)) continue;
+    const fileStat = await stat2(filePath);
+    latest = Math.max(latest, fileStat.mtimeMs);
+  }
+  return latest > 0 ? new Date(latest).toISOString() : null;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function records(value) {
+  return Array.isArray(value) ? value.filter((item) => Boolean(asRecord(item))) : [];
+}
+function recordArray(value) {
+  if (!Array.isArray(value)) return null;
+  return value.filter((item) => Boolean(asRecord(item)));
+}
+function text3(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function schemaValue(value) {
+  return text3(value) ?? asRecord(value);
+}
+function titleFromActionId(id) {
+  const title = id.replace(/[._-]+/g, " ").trim();
+  return title ? title.replace(/\b\w/g, (letter) => letter.toUpperCase()) : id;
+}
+
+// ../../packages/cloud/src/profile/profile-skills.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync3 } from "node:fs";
+import { readdir, readFile as readFile3, stat as stat3 } from "node:fs/promises";
+import path4 from "node:path";
+var PROFILE_SKILLS_DIR = "skills";
+var PROFILE_SKILL_FILE = "SKILL.md";
+var PROFILE_SKILL_MAX_CHARS = 8e4;
+async function loadProfileSkills(profileSourcePath2) {
+  const skillsDir = path4.join(profileSourcePath2, PROFILE_SKILLS_DIR);
+  if (!existsSync3(skillsDir)) {
+    return {
+      skillCatalog: emptyProfileSkillCatalogState2({ stale: false }),
+      skills: []
+    };
+  }
+  try {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    const skills = (await Promise.all(
+      entries.filter((entry) => entry.isDirectory()).map((entry) => loadProfileSkillDirectory(profileSourcePath2, entry.name))
+    )).sort((left, right) => left.name.localeCompare(right.name) || left.path.localeCompare(right.path));
+    markDuplicateSkillNames(skills);
+    const generatedAt = await latestSkillMtime(profileSourcePath2, skills);
+    return {
+      skillCatalog: {
+        skillCount: skills.length,
+        generatedAt,
+        stale: false,
+        error: null
+      },
+      skills
+    };
+  } catch (error) {
+    return {
+      skillCatalog: emptyProfileSkillCatalogState2({
+        stale: true,
+        error: error instanceof Error ? error.message : String(error)
+      }),
+      skills: []
+    };
+  }
+}
+function parseProfileSkillMarkdown(markdown) {
+  const messages = [];
+  const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/.exec(markdown);
+  if (!match) {
+    return {
+      name: null,
+      description: null,
+      body: markdown.trim(),
+      messages: ["SKILL.md must start with YAML frontmatter bounded by ---."]
+    };
+  }
+  const frontmatterSource = match[1] ?? "";
+  const body = (match[2] ?? "").trim();
+  let frontmatter;
+  try {
+    frontmatter = yaml.load(frontmatterSource);
+  } catch (error) {
+    messages.push(`SKILL.md frontmatter is invalid YAML: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const record2 = asRecord2(frontmatter);
+  const name = text4(record2?.name);
+  const description = text4(record2?.description);
+  if (!name) messages.push("Skill frontmatter must include a non-empty name.");
+  if (!description) messages.push("Skill frontmatter must include a non-empty description.");
+  if (!body) messages.push("Skill body must be non-empty markdown.");
+  return {
+    name,
+    description,
+    body,
+    messages
+  };
+}
+function emptyProfileSkillCatalogState2(input = {}) {
+  return {
+    skillCount: 0,
+    generatedAt: null,
+    stale: input.stale ?? true,
+    error: input.error ?? null
+  };
+}
+async function loadProfileSkillDirectory(profileSourcePath2, directoryName) {
+  const relativePath = path4.join(PROFILE_SKILLS_DIR, directoryName, PROFILE_SKILL_FILE).replace(/\\/g, "/");
+  const absolutePath = path4.join(profileSourcePath2, relativePath);
+  const messages = [];
+  const entries = await readdir(path4.join(profileSourcePath2, PROFILE_SKILLS_DIR, directoryName), { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === PROFILE_SKILL_FILE && entry.isFile()) continue;
+    messages.push(`Profile skills only support ${PROFILE_SKILL_FILE}; unsupported entry: ${entry.name}`);
+  }
+  let contents = "";
+  if (!existsSync3(absolutePath)) {
+    messages.push(`Missing ${PROFILE_SKILL_FILE}.`);
+  } else {
+    contents = await readFile3(absolutePath, "utf8");
+  }
+  if (contents.length > PROFILE_SKILL_MAX_CHARS) {
+    messages.push(`Skill markdown exceeds the limit of ${PROFILE_SKILL_MAX_CHARS} characters.`);
+  }
+  const parsed = parseProfileSkillMarkdown(contents);
+  messages.push(...parsed.messages);
+  const name = parsed.name ?? directoryName;
+  const description = parsed.description ?? "";
+  if (!isKebabCaseSkillName(name)) {
+    messages.push("Skill name must be lowercase kebab-case.");
+  }
+  if (name !== directoryName) {
+    messages.push(`Skill name must match its directory name (${directoryName}).`);
+  }
+  return {
+    name,
+    description,
+    path: relativePath,
+    scope: "profile",
+    enabled: messages.length === 0,
+    sourcePath: profileSourcePath2,
+    charCount: contents.length,
+    sourceHash: sha256Hex(contents),
+    validationStatus: messages.length > 0 ? "error" : "valid",
+    validationMessages: messages
+  };
+}
+function markDuplicateSkillNames(skills) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    counts.set(skill.name, (counts.get(skill.name) ?? 0) + 1);
+  }
+  for (const skill of skills) {
+    if ((counts.get(skill.name) ?? 0) <= 1) continue;
+    skill.enabled = false;
+    skill.validationStatus = "error";
+    skill.validationMessages = [
+      ...skill.validationMessages,
+      `Duplicate skill name: ${skill.name}`
+    ];
+  }
+}
+async function latestSkillMtime(profileSourcePath2, skills) {
+  let latest = 0;
+  for (const skill of skills) {
+    const fileStat = await stat3(path4.join(profileSourcePath2, skill.path)).catch(() => null);
+    if (!fileStat?.isFile()) continue;
+    latest = Math.max(latest, fileStat.mtimeMs);
+  }
+  return latest > 0 ? new Date(latest).toISOString() : null;
+}
+function isKebabCaseSkillName(value) {
+  return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
+}
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function text4(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function sha256Hex(contents) {
+  return createHash("sha256").update(contents).digest("hex");
+}
+
+// ../../packages/cloud/src/profile/local-profile.ts
+var PROFILE_REPO_MANIFEST = "openpond-profile.json";
+var PROFILE_MANIFEST = "settings/profile.yaml";
+var DEFAULT_LOCAL_PROFILE = "default";
+var DEFAULT_PROFILE_AGENT = "default";
+function mergeProfileRepoManifestEntry(existing, profilePath) {
+  const defaultAgent = existing?.defaultAgent ?? DEFAULT_PROFILE_AGENT;
+  const enabledAgents = existing?.enabledAgents && existing.enabledAgents.length > 0 ? existing.enabledAgents : [defaultAgent];
+  return {
+    ...existing ?? {},
+    path: profilePath,
+    defaultAgent,
+    enabledAgents
+  };
+}
+function mergeActiveLocalProfileConfig(existing, repoPath, profile) {
+  const next = {
+    repoPath,
+    profile,
+    mode: "local"
+  };
+  if (!existing) return next;
+  if (path5.resolve(existing.repoPath) !== path5.resolve(repoPath) || existing.profile !== profile) {
+    return next;
+  }
+  return {
+    ...existing,
+    ...next
+  };
+}
+var require2 = createRequire(import.meta.url);
+function defaultLocalProfileRepoPath() {
+  return path5.join(os.homedir(), ".openpond", "profiles", "default-repo");
+}
+function emptyProfileState(error = null) {
+  return {
+    mode: "none",
+    repoPath: null,
+    activeProfile: null,
+    sourcePath: null,
+    manifestPath: null,
+    agents: [],
+    skills: [],
+    git: null,
+    catalog: emptyProfileCatalogState(error),
+    skillCatalog: emptyProfileSkillCatalogState(error),
+    actionCatalog: [],
+    sourceSetupRequirements: [],
+    setupGate: emptyProfileSetupGate(),
+    diff: emptyProfileDiffSummary(),
+    hosted: null,
+    summary: emptyProfileSummary(error),
+    lastCheck: null,
+    error
+  };
+}
+async function initLocalProfileRepo(input = {}) {
+  const repoPath = path5.resolve(input.repoPath ?? defaultLocalProfileRepoPath());
+  const profile = normalizeProfileName(input.profile);
+  const profilePath = path5.join("profiles", profile);
+  const profileSourcePath2 = path5.join(repoPath, profilePath);
+  await mkdir(repoPath, { recursive: true });
+  const manifest = await readProfileManifest(repoPath).catch(() => defaultProfileManifest(profile, profilePath));
+  manifest.defaultProfile = manifest.defaultProfile || profile;
+  manifest.profiles[profile] = mergeProfileRepoManifestEntry(manifest.profiles[profile], profilePath);
+  await ensureProfileSource(profileSourcePath2, input.template ?? "blank-agent", Boolean(input.force));
+  await ensureProfileDependencies(profileSourcePath2);
+  await ensureProfileScaffoldFiles(repoPath, profileSourcePath2, profile);
+  await writeProfileManifest(repoPath, manifest);
+  await ensureProfileGitRepo(repoPath);
+  const currentConfig = (await loadGlobalConfig()).openpondProfile;
+  await saveGlobalConfig({
+    openpondProfile: mergeActiveLocalProfileConfig(currentConfig, repoPath, profile)
+  });
+  return loadOpenPondProfileState();
+}
+async function loadLocalProfileRepo(repoPathInput, profileInput) {
+  const repoPath = path5.resolve(repoPathInput);
+  const manifest = await readProfileManifest(repoPath);
+  const profile = normalizeProfileName(profileInput ?? manifest.defaultProfile);
+  profileSourcePath(manifest, repoPath, profile);
+  const currentConfig = (await loadGlobalConfig()).openpondProfile;
+  await saveGlobalConfig({
+    openpondProfile: mergeActiveLocalProfileConfig(currentConfig, repoPath, profile)
+  });
+  return loadOpenPondProfileState();
+}
+async function loadOpenPondProfileState() {
+  const config = await loadGlobalConfig();
+  const active = config.openpondProfile;
+  if (!active) return emptyProfileState();
+  try {
+    const manifest = await readProfileManifest(active.repoPath);
+    const sourcePath = profileSourcePath(manifest, active.repoPath, active.profile);
+    const agents = await listProfileAgents(manifest, active.profile);
+    const [git, catalogResult, skillResult] = await Promise.all([
+      loadProfileGitState(active.repoPath),
+      loadProfileActionCatalogForSources(
+        profileCatalogSources({
+          manifest,
+          profile: active.profile,
+          profileSourcePath: sourcePath,
+          agents
+        })
+      ),
+      loadProfileSkills(sourcePath)
+    ]);
+    const hosted = hostedBindingFromConfig(active);
+    const diff = summarizeProfileDiff(git, active.profile);
+    const setupGate = buildOpenPondProfileSetupGate({
+      actionCatalog: catalogResult.actionCatalog,
+      sourceSetupRequirements: catalogResult.sourceSetupRequirements
+    });
+    const summary = summarizeProfileState({
+      agents,
+      actionCatalog: catalogResult.actionCatalog,
+      catalog: catalogResult.catalog,
+      diff,
+      git,
+      hosted,
+      lastCheck: active.lastCheck ?? null,
+      error: null
+    });
+    return {
+      mode: "local",
+      repoPath: active.repoPath,
+      activeProfile: active.profile,
+      sourcePath,
+      manifestPath: path5.join(active.repoPath, PROFILE_REPO_MANIFEST),
+      agents,
+      skills: skillResult.skills,
+      git,
+      catalog: catalogResult.catalog,
+      skillCatalog: skillResult.skillCatalog,
+      actionCatalog: catalogResult.actionCatalog,
+      sourceSetupRequirements: catalogResult.sourceSetupRequirements,
+      setupGate,
+      diff,
+      hosted,
+      summary,
+      lastCheck: active.lastCheck ?? null,
+      error: null
+    };
+  } catch (error) {
+    const git = await loadProfileGitState(active.repoPath).catch(() => null);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      mode: "local",
+      repoPath: active.repoPath,
+      activeProfile: active.profile,
+      sourcePath: null,
+      manifestPath: path5.join(active.repoPath, PROFILE_REPO_MANIFEST),
+      agents: [],
+      skills: [],
+      git,
+      catalog: emptyProfileCatalogState(errorMessage),
+      skillCatalog: emptyProfileSkillCatalogState(errorMessage),
+      actionCatalog: [],
+      sourceSetupRequirements: [],
+      setupGate: emptyProfileSetupGate(),
+      diff: emptyProfileDiffSummary(),
+      hosted: hostedBindingFromConfig(active),
+      summary: emptyProfileSummary(errorMessage),
+      lastCheck: active.lastCheck ?? null,
+      error: errorMessage
+    };
+  }
+}
+async function requireActiveLocalProfile() {
+  const config = (await loadGlobalConfig()).openpondProfile;
+  if (!config) {
+    throw new Error("No active OpenPond profile. Run `openpond init` or `openpond profile load --path <dir>`.");
+  }
+  const state = await loadOpenPondProfileState();
+  if (state.error) throw new Error(state.error);
+  if (!state.sourcePath) throw new Error("Active OpenPond profile has no source path.");
+  return { config, state };
+}
+async function runProfileSdkCommand(input) {
+  const active = await requireActiveLocalProfile();
+  const requestedRunArgs = input.command === "run" ? input.args ?? [] : [];
+  const selectedAction = input.command === "run" ? active.state.actionCatalog.find((action) => action.id === requestedRunArgs[0]) : null;
+  const cwd = path5.resolve(
+    input.cwd ?? selectedAction?.sourcePath ?? active.state.sourcePath
+  );
+  const runArgs = input.command === "run" ? runCommandArgs(cwd, input.args ?? [], selectedAction?.sourceActionId ?? null) : null;
+  if (input.command === "run" && runArgs) {
+    const actionId = runArgs[0];
+    const catalog = path5.resolve(active.state.sourcePath) === cwd ? {
+      actionCatalog: active.state.actionCatalog,
+      sourceSetupRequirements: active.state.sourceSetupRequirements
+    } : await loadProfileActionCatalog(cwd);
+    assertOpenPondProfileActionReady(
+      actionId,
+      buildOpenPondProfileSetupGate({
+        actionCatalog: catalog.actionCatalog,
+        sourceSetupRequirements: catalog.sourceSetupRequirements,
+        actionId
+      })
+    );
+  }
+  const result = await runAgentSdkProjectCommand({
+    command: input.command,
+    args: input.command === "run" ? runArgs ?? runCommandArgs(cwd, input.args ?? []) : input.args,
+    cwd,
+    inherit: input.inherit,
+    throwOnFailure: false
+  });
+  await saveProfileCheckStatus(input.command, result.code);
+  if (result.code !== 0) {
+    const detail = result.stderr.trim() || result.stdout.trim();
+    throw new Error(detail || `${input.command} failed with exit code ${result.code ?? "unknown"}`);
+  }
+  return result;
+}
+async function runAgentSdkProjectCommand(input) {
+  const cwd = path5.resolve(input.cwd);
+  const cli = resolveAgentSdkCliLaunch();
+  const args = input.command === "run" ? [...cli.args, input.command, ...input.args ?? []] : [...cli.args, input.command, "--cwd", cwd, ...input.args ?? []];
+  const result = await spawnCommand(cli.command, args, {
+    cwd,
+    inherit: input.inherit,
+    timeoutMs: input.timeoutMs,
+    maxOutputBytes: input.maxOutputBytes
+  });
+  if (input.throwOnFailure !== false && result.code !== 0) {
+    const detail = commandFailureDetail(result, input.command);
+    throw new Error(detail || `${input.command} failed with exit code ${result.code ?? "unknown"}`);
+  }
+  return result;
+}
+function runCommandArgs(cwd, args, sourceActionId = null) {
+  const [actionName, ...rest] = args;
+  if (!actionName || actionName.startsWith("--")) {
+    throw new Error("run requires an action name");
+  }
+  return [sourceActionId ?? actionName, "--cwd", cwd, ...rest];
+}
+async function runProfileCheck(kind) {
+  const checks = !kind || kind === "all" ? ["inspect", "build", "validate", "eval"] : [kind];
+  const active = await requireActiveLocalProfile();
+  const manifest = await readProfileManifest(active.config.repoPath);
+  const sources = profileCatalogSources({
+    manifest,
+    profile: active.config.profile,
+    profileSourcePath: active.state.sourcePath,
+    agents: active.state.agents
+  });
+  for (const command of checks) {
+    if (command !== "inspect" && command !== "build" && command !== "validate" && command !== "eval") {
+      throw new Error("check kind must be one of inspect, build, validate, eval, all");
+    }
+    for (const source of sources) {
+      await runProfileCheckForSource({
+        command,
+        source,
+        profileSourcePath: active.state.sourcePath,
+        sourceCount: sources.length
+      });
+    }
+  }
+}
+async function runProfileCheckForSource(input) {
+  const args = input.command === "inspect" || input.command === "validate" || input.command === "eval" ? ["--json"] : [];
+  if (input.sourceCount > 1) {
+    const label = path5.relative(input.profileSourcePath, input.source.sourcePath) || ".";
+    console.log(`
+[profile:${input.source.agentId}] ${input.command} ${label}`);
+  }
+  const result = await runAgentSdkProjectCommand({
+    command: input.command,
+    args,
+    cwd: input.source.sourcePath,
+    inherit: false,
+    throwOnFailure: false
+  });
+  if (result.stdout.trim()) console.log(result.stdout.trim());
+  if (result.stderr.trim()) console.error(result.stderr.trim());
+  await saveProfileCheckStatus(input.command, result.code);
+  if (result.code !== 0) {
+    const detail = commandFailureDetail(result, input.command);
+    throw new Error(
+      [
+        `Profile check failed for enabled agent ${input.source.agentId} at ${input.source.sourcePath}.`,
+        detail || `${input.command} failed with exit code ${result.code ?? "unknown"}`
+      ].join("\n")
+    );
+  }
+}
+async function commitActiveProfileChanges(message) {
+  const active = await requireActiveLocalProfile();
+  if (!active.state.repoPath) {
+    throw new Error("Active OpenPond profile has no repo path.");
+  }
+  const result = await commitProfileChanges(
+    active.state.repoPath,
+    message?.trim() || `Update OpenPond profile ${active.state.activeProfile ?? DEFAULT_LOCAL_PROFILE}`
+  );
+  return {
+    committed: result.committed,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    state: await loadOpenPondProfileState()
+  };
+}
+async function saveProfilePushStatus(status) {
+  const config = (await loadGlobalConfig()).openpondProfile;
+  if (!config) return;
+  await saveGlobalConfig({
+    openpondProfile: {
+      ...config,
+      lastPush: status
+    }
+  });
+}
+async function saveProfileCheckStatus(command, exitCode) {
+  const config = (await loadGlobalConfig()).openpondProfile;
+  if (!config) return;
+  const sourceHead = await profileGitHead(config.repoPath).catch(() => null);
+  await saveGlobalConfig({
+    openpondProfile: {
+      ...config,
+      lastCheck: {
+        command,
+        status: exitCode === 0 ? "passed" : "failed",
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        exitCode,
+        sourceHead
+      }
+    }
+  });
+}
+async function ensureProfileSource(profileSourcePath2, template, force) {
+  await mkdir(profileSourcePath2, { recursive: true });
+  const entries = await readdir2(profileSourcePath2);
+  if (entries.length > 0 && !force) return;
+  const sdkRoot = resolveAgentSdkRoot();
+  const templateDir = path5.join(sdkRoot, "templates", template);
+  if (!existsSync4(templateDir)) {
+    throw new Error(`Unknown agent template "${template}".`);
+  }
+  await cp(templateDir, profileSourcePath2, {
+    recursive: true,
+    force,
+    errorOnExist: false
+  });
+  await rewriteTemplateSdkDependency(profileSourcePath2, sdkRoot);
+}
+async function ensureProfileScaffoldFiles(repoPath, profileSourcePath2, profile) {
+  await mkdir(path5.join(repoPath, "profiles"), { recursive: true });
+  for (const dir of ["agents", "skills", "actions", "extensions", "prompts", "goals", "evals", "settings", "traces"]) {
+    await mkdir(path5.join(profileSourcePath2, dir), { recursive: true });
+  }
+  const profileManifestPath = path5.join(profileSourcePath2, PROFILE_MANIFEST);
+  if (!existsSync4(profileManifestPath)) {
+    await writeFile2(
+      profileManifestPath,
+      [
+        "schema: openpond.profile.v1",
+        `profile: ${profile}`,
+        "agents:",
+        `  - id: ${DEFAULT_PROFILE_AGENT}`,
+        "    path: agent/agent.ts",
+        "    enabled: true",
+        ""
+      ].join("\n"),
+      "utf8"
+    );
+  }
+  const lockPath = path5.join(profileSourcePath2, "openpond.lock");
+  if (!existsSync4(lockPath)) {
+    await writeFile2(lockPath, "# OpenPond profile lockfile placeholder\n", "utf8");
+  }
+}
+async function rewriteTemplateSdkDependency(profileSourcePath2, sdkRoot) {
+  const packageJsonPath = path5.join(profileSourcePath2, "package.json");
+  const raw = await readFile4(packageJsonPath, "utf8");
+  const packageJson = JSON.parse(raw);
+  packageJson.dependencies = {
+    ...packageJson.dependencies ?? {},
+    "openpond-agent-sdk": `file:${sdkRoot}`
+  };
+  await writeFile2(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`, "utf8");
+}
+async function ensureProfileDependencies(profileSourcePath2) {
+  if (!existsSync4(path5.join(profileSourcePath2, "package.json"))) return;
+  const sdkRoot = resolveAgentSdkRoot();
+  await ensureAgentSdkBuilt(sdkRoot);
+  const nodeModulesPath = path5.join(profileSourcePath2, "node_modules");
+  const sdkLinkPath = path5.join(nodeModulesPath, "openpond-agent-sdk");
+  await mkdir(nodeModulesPath, { recursive: true });
+  if (!existsSync4(sdkLinkPath)) {
+    await symlink(sdkRoot, sdkLinkPath, "dir");
+  }
+}
+async function ensureAgentSdkBuilt(sdkRoot) {
+  if (existsSync4(path5.join(sdkRoot, "dist", "cli.js")) && existsSync4(path5.join(sdkRoot, "dist", "primitives", "index.js"))) {
+    return;
+  }
+  const buildScript = path5.join(sdkRoot, "scripts", "build.ts");
+  if (!existsSync4(buildScript)) {
+    throw new Error(`Resolved openpond-agent-sdk at ${sdkRoot}, but built SDK files are missing.`);
+  }
+  const result = await spawnCommand(
+    process.execPath,
+    [resolveTsxCli(sdkRoot), buildScript],
+    { cwd: sdkRoot }
+  );
+  if (result.code !== 0) {
+    const detail = result.stderr.trim() || result.stdout.trim();
+    throw new Error(detail || `openpond-agent-sdk build failed with exit code ${result.code ?? "unknown"}`);
+  }
+}
+async function listProfileAgents(manifest, profile) {
+  const profileConfig = manifest.profiles[profile];
+  if (!profileConfig) return [];
+  const defaultAgent = profileConfig.defaultAgent ?? DEFAULT_PROFILE_AGENT;
+  const enabled = new Set(profileConfig.enabledAgents ?? [defaultAgent]);
+  return Array.from(enabled).map((id) => ({
+    id,
+    name: id,
+    path: id === DEFAULT_PROFILE_AGENT ? "agent/agent.ts" : `agents/${id}`,
+    enabled: true
+  }));
+}
+function profileCatalogSources(input) {
+  const defaultAgent = input.manifest.profiles[input.profile]?.defaultAgent ?? DEFAULT_PROFILE_AGENT;
+  const agents = input.agents.length > 0 ? input.agents : [{
+    id: DEFAULT_PROFILE_AGENT,
+    name: DEFAULT_PROFILE_AGENT,
+    path: "agent/agent.ts",
+    enabled: true
+  }];
+  return agents.map((agent) => ({
+    agentId: agent.id,
+    sourcePath: agent.id === DEFAULT_PROFILE_AGENT ? input.profileSourcePath : path5.join(input.profileSourcePath, "agents", agent.id),
+    preferred: agent.id === defaultAgent
+  }));
+}
+function hostedBindingFromConfig(config) {
+  const push = config.lastPush;
+  if (!push) return null;
+  return {
+    teamId: push.teamId ?? null,
+    projectId: push.projectId ?? null,
+    sourceRef: push.sourceRef ?? null,
+    sourceCommitSha: push.hostedHead ?? null,
+    lastPushedAt: push.pushedAt,
+    lastPushedLocalHead: push.localHead ?? null,
+    lastPushedHostedHead: push.hostedHead ?? null,
+    promotionStatus: push.promotionStatus ?? null,
+    hostedRunStatus: push.hostedRunStatus ?? null,
+    localGoalId: push.localGoalId ?? null,
+    hostedGoalId: push.hostedGoalId ?? null,
+    hostedRunAgentId: push.hostedRunAgentId ?? null,
+    hostedRunId: push.hostedRunId ?? null,
+    hostedRunAt: push.hostedRunAt ?? null,
+    hostedSourceMaterialization: push.hostedSourceMaterialization ?? null,
+    hostedSourceCheck: push.hostedSourceCheck ?? null,
+    hostedPublish: push.hostedPublish ?? null,
+    hostedRun: push.hostedRun ?? null
+  };
+}
+function summarizeProfileState(input) {
+  const defaultAction = input.actionCatalog.find((action) => action.id === "chat")?.id ?? input.actionCatalog.find((action) => action.name === "chat")?.id ?? input.actionCatalog.find((action) => action.id.endsWith(".chat"))?.id ?? null;
+  const checkFresh = Boolean(
+    input.lastCheck && input.lastCheck.status === "passed" && input.lastCheck.sourceHead && input.lastCheck.sourceHead === input.git.head && !input.git.dirty && !input.catalog.stale
+  );
+  const checkStaleReason = profileCheckStaleReason({
+    catalog: input.catalog,
+    git: input.git,
+    lastCheck: input.lastCheck
+  });
+  if (input.error) {
+    return {
+      state: "error",
+      message: input.error,
+      agentCount: input.agents.length,
+      actionCount: input.actionCatalog.length,
+      defaultAction,
+      checkFresh,
+      checkStaleReason,
+      localHead: input.git.head,
+      hostedHead: input.hosted?.sourceCommitSha ?? null
+    };
+  }
+  if (!input.git.isRepo) {
+    return {
+      state: "error",
+      message: "Profile source is not Git-backed.",
+      agentCount: input.agents.length,
+      actionCount: input.actionCatalog.length,
+      defaultAction,
+      checkFresh: false,
+      checkStaleReason: "Profile source is not Git-backed.",
+      localHead: null,
+      hostedHead: input.hosted?.sourceCommitSha ?? null
+    };
+  }
+  if (!input.git.head) {
+    return {
+      state: "pending_commit",
+      message: "Profile source is ready for its first commit.",
+      agentCount: input.agents.length,
+      actionCount: input.actionCatalog.length,
+      defaultAction,
+      checkFresh: false,
+      checkStaleReason: "Profile source has no committed head.",
+      localHead: null,
+      hostedHead: input.hosted?.sourceCommitSha ?? null
+    };
+  }
+  if (input.git.dirty) {
+    return {
+      state: "dirty",
+      message: profileDirtyMessage(input.diff),
+      agentCount: input.agents.length,
+      actionCount: input.actionCatalog.length,
+      defaultAction,
+      checkFresh,
+      checkStaleReason,
+      localHead: input.git.head,
+      hostedHead: input.hosted?.sourceCommitSha ?? null
+    };
+  }
+  return {
+    state: "ready",
+    message: input.catalog.stale ? "Profile source is clean; action catalog needs inspect/build." : "Profile source is clean.",
+    agentCount: input.agents.length,
+    actionCount: input.actionCatalog.length,
+    defaultAction,
+    checkFresh,
+    checkStaleReason,
+    localHead: input.git.head,
+    hostedHead: input.hosted?.sourceCommitSha ?? null
+  };
+}
+function profileCheckStaleReason(input) {
+  if (input.catalog.error) return `Catalog error: ${input.catalog.error}`;
+  if (input.catalog.stale) return "Action catalog artifacts are missing or stale.";
+  if (!input.lastCheck) return "Profile checks have not run.";
+  if (input.lastCheck.status !== "passed") return `Last ${input.lastCheck.command} check failed.`;
+  if (!input.lastCheck.sourceHead) return "Last check did not record a source head.";
+  if (input.git.head && input.lastCheck.sourceHead !== input.git.head) {
+    return "Profile source changed since the last check.";
+  }
+  if (input.git.dirty) return "Profile has uncommitted source changes.";
+  return null;
+}
+function profileDirtyMessage(diff) {
+  const parts = [];
+  if (diff.changedAgents.length > 0) parts.push(`${diff.changedAgents.length} changed agent(s)`);
+  if (diff.newAgents.length > 0) parts.push(`${diff.newAgents.length} new agent(s)`);
+  if (diff.deletedAgents.length > 0) parts.push(`${diff.deletedAgents.length} deleted agent(s)`);
+  if (diff.changedSkills.length > 0) parts.push(`${diff.changedSkills.length} changed skill(s)`);
+  if (diff.changedActions.length > 0) parts.push(`${diff.changedActions.length} changed action(s)`);
+  if (diff.changedExtensions.length > 0) parts.push(`${diff.changedExtensions.length} changed extension(s)`);
+  if (diff.setupChanges.length > 0) parts.push(`${diff.setupChanges.length} setup change(s)`);
+  if (diff.envRequirementChanges.length > 0) parts.push(`${diff.envRequirementChanges.length} env requirement change(s)`);
+  return parts.length > 0 ? `Profile has ${parts.join(", ")}.` : "Profile has uncommitted source changes.";
+}
+function summarizeProfileDiff(git, profile) {
+  const diff = emptyProfileDiffSummary();
+  diff.files = git.files;
+  const profileRoot = `profiles/${profile}/`;
+  for (const file of git.files) {
+    const normalized = file.path.replace(/\\/g, "/");
+    if (normalized === PROFILE_REPO_MANIFEST || normalized === ".gitignore") {
+      addUnique(diff.setupChanges, normalized);
+      continue;
+    }
+    if (!normalized.startsWith(profileRoot)) continue;
+    const relative = normalized.slice(profileRoot.length);
+    classifyProfileFileChange(diff, file, relative);
+  }
+  return diff;
+}
+function classifyProfileFileChange(diff, file, relativePath) {
+  const firstSegment = relativePath.split("/")[0] ?? "";
+  if (firstSegment === "agent") {
+    addAgentChange(diff, DEFAULT_PROFILE_AGENT, file.category);
+  } else if (firstSegment === "agents") {
+    const agentId = relativePath.split("/")[1];
+    if (agentId) addAgentChange(diff, agentId, file.category);
+  } else if (firstSegment === "skills") {
+    addUnique(diff.changedSkills, relativePath.split("/")[1] ?? relativePath);
+  } else if (firstSegment === "actions") {
+    addUnique(diff.changedActions, relativePath.split("/")[1] ?? relativePath);
+  } else if (firstSegment === "extensions") {
+    addUnique(diff.changedExtensions, relativePath.split("/")[1] ?? relativePath);
+  } else if (firstSegment === "settings" || relativePath === "package.json" || relativePath === "openpond.yaml" || relativePath === "openpond.lock") {
+    addUnique(diff.setupChanges, relativePath);
+  }
+  if (relativePath.toLowerCase().includes("env")) {
+    addUnique(diff.envRequirementChanges, relativePath);
+  }
+  if (relativePath.startsWith(".openpond/")) {
+    addUnique(diff.changedActions, "catalog");
+  }
+}
+function addAgentChange(diff, agentId, category) {
+  if (category === "added" || category === "untracked") {
+    addUnique(diff.newAgents, agentId);
+    return;
+  }
+  if (category === "deleted") {
+    addUnique(diff.deletedAgents, agentId);
+    return;
+  }
+  addUnique(diff.changedAgents, agentId);
+}
+function addUnique(values, value) {
+  if (!value || values.includes(value)) return;
+  values.push(value);
+}
+function normalizeProfileName(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) return DEFAULT_LOCAL_PROFILE;
+  if (!/^[a-zA-Z0-9._-]+$/.test(trimmed)) {
+    throw new Error("profile name may only contain letters, numbers, dots, underscores, and hyphens");
+  }
+  return trimmed;
+}
+function defaultProfileManifest(profile, profilePath) {
+  return {
+    schema: "openpond.profileRepo.v1",
+    defaultProfile: profile,
+    profiles: {
+      [profile]: {
+        path: profilePath,
+        defaultAgent: DEFAULT_PROFILE_AGENT,
+        enabledAgents: [DEFAULT_PROFILE_AGENT]
+      }
+    }
+  };
+}
+async function readProfileManifest(repoPath) {
+  const manifestPath = path5.join(repoPath, PROFILE_REPO_MANIFEST);
+  const raw = await readFile4(manifestPath, "utf8");
+  const parsed = JSON.parse(raw);
+  if (parsed.schema !== "openpond.profileRepo.v1" || !parsed.profiles || typeof parsed.profiles !== "object") {
+    throw new Error(`${manifestPath} is not an OpenPond profile repo manifest.`);
+  }
+  return parsed;
+}
+async function writeProfileManifest(repoPath, manifest) {
+  await writeFile2(path5.join(repoPath, PROFILE_REPO_MANIFEST), `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+function profileSourcePath(manifest, repoPath, profile) {
+  const profileConfig = manifest.profiles[profile];
+  if (!profileConfig) {
+    throw new Error(`Profile "${profile}" was not found in ${path5.join(repoPath, PROFILE_REPO_MANIFEST)}.`);
+  }
+  const sourcePath = path5.resolve(repoPath, profileConfig.path);
+  if (!existsSync4(sourcePath)) {
+    throw new Error(`Profile source path does not exist: ${sourcePath}`);
+  }
+  return sourcePath;
+}
+function resolveAgentSdkRoot() {
+  const packageJsonPath = require2.resolve("openpond-agent-sdk/package.json");
+  return path5.dirname(packageJsonPath);
+}
+function resolveAgentSdkCliLaunch() {
+  const sdkRoot = resolveAgentSdkRoot();
+  const distCli = path5.join(sdkRoot, "dist", "cli.js");
+  if (existsSync4(distCli)) return { command: process.execPath, args: [distCli] };
+  const sourceCli = path5.join(sdkRoot, "src", "cli.ts");
+  if (existsSync4(sourceCli)) {
+    return { command: process.execPath, args: [resolveTsxCli(sdkRoot), sourceCli] };
+  }
+  throw new Error(`openpond-agent CLI was not found under ${sdkRoot}`);
+}
+function resolveTsxCli(packageRoot) {
+  return createRequire(path5.join(packageRoot, "package.json")).resolve("tsx/cli");
+}
+async function spawnCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn2(command, args, {
+      cwd: options.cwd,
+      stdio: options.inherit ? "inherit" : "pipe"
+    });
+    let stdout = "";
+    let stderr = "";
+    let stdoutTruncated = false;
+    let stderrTruncated = false;
+    let timedOut = false;
+    const timeoutMs = options.timeoutMs ?? 10 * 60 * 1e3;
+    const maxOutputBytes = options.maxOutputBytes ?? 2 * 1024 * 1024;
+    const timeout = timeoutMs > 0 ? setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGTERM");
+    }, timeoutMs) : null;
+    const forceKill = timeoutMs > 0 ? setTimeout(() => {
+      if (timedOut && proc.exitCode === null) proc.kill("SIGKILL");
+    }, timeoutMs + 5e3) : null;
+    if (!options.inherit) {
+      proc.stdout?.on("data", (chunk) => {
+        const next = appendBoundedOutput(stdout, String(chunk), maxOutputBytes, stdoutTruncated);
+        stdout = next.text;
+        stdoutTruncated = next.truncated;
+      });
+      proc.stderr?.on("data", (chunk) => {
+        const next = appendBoundedOutput(stderr, String(chunk), maxOutputBytes, stderrTruncated);
+        stderr = next.text;
+        stderrTruncated = next.truncated;
+      });
+    }
+    const clearTimers = () => {
+      if (timeout) clearTimeout(timeout);
+      if (forceKill) clearTimeout(forceKill);
+    };
+    proc.on("error", (error) => {
+      clearTimers();
+      reject(error);
+    });
+    proc.on("close", (code) => {
+      clearTimers();
+      resolve({ code, stdout, stderr, timedOut, stdoutTruncated, stderrTruncated });
+    });
+  });
+}
+function appendBoundedOutput(current, chunk, maxBytes, alreadyTruncated) {
+  if (alreadyTruncated) return { text: current, truncated: true };
+  const combined = `${current}${chunk}`;
+  if (Buffer.byteLength(combined, "utf8") <= maxBytes) {
+    return { text: combined, truncated: false };
+  }
+  const text5 = `${Buffer.from(combined).subarray(0, Math.max(0, maxBytes)).toString("utf8")}
+[truncated after ${maxBytes} bytes]
+`;
+  return { text: text5, truncated: true };
+}
+function commandFailureDetail(result, command) {
+  const detail = result.stderr.trim() || result.stdout.trim();
+  const notes = [
+    result.timedOut ? `${command} timed out` : "",
+    result.stdoutTruncated ? "stdout truncated" : "",
+    result.stderrTruncated ? "stderr truncated" : ""
+  ].filter(Boolean);
+  return [detail, ...notes].filter(Boolean).join("\n");
+}
+
+// ../../packages/cloud/src/profile/hosted-run-idempotency.ts
+import { createHash as createHash2, randomUUID } from "node:crypto";
+function buildHostedRunIdempotencyKey(input) {
+  const explicit = input.explicitKey?.trim();
+  if (explicit) return explicit;
+  const sourceHead = input.sourceHead?.trim() || "unknown-source";
+  const targetProjectId = input.targetProjectId?.trim() || "no-target-project";
+  const inputHash = hashStableJson(input.input).slice(0, 16);
+  const base = `profile-push-run:${input.localHead}:${sourceHead}:${input.runtimeAgentId}:${targetProjectId}:${inputHash}`;
+  if (!input.retry) return base;
+  return `${base}:retry:${(input.randomId ?? randomUUID)()}`;
+}
+function hashStableJson(value) {
+  return createHash2("sha256").update(stableJsonStringify(value)).digest("hex");
+}
+function stableJsonStringify(value) {
+  if (value === void 0) return "undefined";
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableJsonStringify(item)).join(",")}]`;
+  }
+  return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableJsonStringify(item)}`).join(",")}}`;
+}
+
+export {
+  formatOpenPondProfileSetupRequirement,
+  collectProfileSourceUploadEntries,
+  hostedSourceCheckStatusFromPayload,
+  hostedPublishStatusFromPayload,
+  hostedRunSummaryFromPayload,
+  hostedRunStatusFromRunSummary,
+  defaultLocalProfileRepoPath,
+  initLocalProfileRepo,
+  loadLocalProfileRepo,
+  loadOpenPondProfileState,
+  runProfileSdkCommand,
+  runProfileCheck,
+  commitActiveProfileChanges,
+  saveProfilePushStatus,
+  buildHostedRunIdempotencyKey
+};