openpond 0.0.30-bootstrap.0

package/dist/chunks/profile-NLDZDT3L.js

@@ -0,0 +1,1110 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  collectAgentSdkProjectSourceUploadEntries,
+  collectProjectSourceUploadEntries,
+  mergeProjectSourceUploadEntries,
+  parseAgentSourceCheckDispatch,
+  parseAgentSourceCheckKind
+} from "./chunk-3CC6MH35.js";
+import {
+  buildHostedRunIdempotencyKey,
+  collectProfileSourceUploadEntries,
+  commitActiveProfileChanges,
+  defaultLocalProfileRepoPath,
+  formatOpenPondProfileSetupRequirement,
+  hostedPublishStatusFromPayload,
+  hostedRunStatusFromRunSummary,
+  hostedRunSummaryFromPayload,
+  hostedSourceCheckStatusFromPayload,
+  initLocalProfileRepo,
+  loadLocalProfileRepo,
+  loadOpenPondProfileState,
+  runProfileCheck,
+  runProfileSdkCommand,
+  saveProfilePushStatus
+} from "./chunk-FUP7EGT7.js";
+import "./chunk-I6HN3ZGW.js";
+import "./chunk-VQX33YAG.js";
+import "./chunk-LHYK6QO2.js";
+import "./chunk-OG75GMVO.js";
+import "./chunk-BYAPLT37.js";
+import "./chunk-WYDVQOBL.js";
+import {
+  resolveSandboxClient
+} from "./chunk-XSAXENQD.js";
+import "./chunk-5G4E547X.js";
+import {
+  optionString,
+  parseBooleanOption,
+  requiredTeamId
+} from "./chunk-3Y4EL3P6.js";
+import "./chunk-UACZUFIA.js";
+
+// src/cli/profile.ts
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+async function runOpenPondInitCommand(options) {
+  const state = await initLocalProfileRepo({
+    repoPath: optionString(options, "path") || defaultLocalProfileRepoPath(),
+    profile: optionString(options, "profile") || "default",
+    template: optionString(options, "template") || "blank-agent",
+    force: parseBooleanOption(options.force)
+  });
+  if (parseBooleanOption(options.json)) {
+    console.log(JSON.stringify(state, null, 2));
+    return;
+  }
+  console.log(`Initialized OpenPond profile ${state.activeProfile} at ${state.repoPath}`);
+  console.log(`Profile source: ${state.sourcePath}`);
+}
+async function runOpenPondProfileCommand(options, rest) {
+  const subcommand = rest[0] ?? "current";
+  if (subcommand === "load") {
+    const repoPath = optionString(options, "path") || rest[1];
+    if (!repoPath) {
+      throw new Error("usage: openpond profile load --path <dir> [--profile <name>]");
+    }
+    const state = await loadLocalProfileRepo(repoPath, optionString(options, "profile") || void 0);
+    if (parseBooleanOption(options.json)) {
+      console.log(JSON.stringify(state, null, 2));
+      return;
+    }
+    console.log(`Loaded OpenPond profile ${state.activeProfile} from ${state.repoPath}`);
+    return;
+  }
+  if (subcommand === "current" || subcommand === "status") {
+    const state = await loadOpenPondProfileState();
+    if (parseBooleanOption(options.json)) {
+      console.log(JSON.stringify(state, null, 2));
+      return;
+    }
+    printProfileState(state);
+    return;
+  }
+  if (subcommand === "diff") {
+    const state = await loadOpenPondProfileState();
+    if (parseBooleanOption(options.json)) {
+      console.log(JSON.stringify({ diff: state.diff, profile: state }, null, 2));
+      return;
+    }
+    printProfileDiff(state);
+    return;
+  }
+  if (subcommand === "catalog") {
+    const state = await loadOpenPondProfileState();
+    if (parseBooleanOption(options.json)) {
+      console.log(JSON.stringify({ catalog: state.catalog, actions: state.actionCatalog, profile: state }, null, 2));
+      return;
+    }
+    printProfileCatalog(state);
+    return;
+  }
+  if (subcommand === "commit") {
+    await runProfileCommitCommand(options, rest.slice(1));
+    return;
+  }
+  if (subcommand === "push") {
+    await runProfilePushCommand(options);
+    return;
+  }
+  if (subcommand === "check") {
+    await runProfileCheck(optionString(options, "kind") || rest[1] || "all");
+    return;
+  }
+  if (subcommand === "ensure-hosted") {
+    await runHostedProfileEnsureCommand(options);
+    return;
+  }
+  if (subcommand === "hosted") {
+    const nested = rest[1] ?? "status";
+    if (nested === "ensure") {
+      await runHostedProfileEnsureCommand(options);
+      return;
+    }
+    if (nested === "status" || nested === "current") {
+      await runHostedProfileStatusCommand(options);
+      return;
+    }
+    throw new Error("usage: openpond profile hosted [status|ensure] --team-id <id> [--json]");
+  }
+  if (subcommand === "agents") {
+    const nested = rest[1] ?? "list";
+    if (nested !== "list") {
+      throw new Error("usage: openpond profile agents list [--json]");
+    }
+    await runOpenPondAgentsCommand(options, ["list"]);
+    return;
+  }
+  throw new Error("usage: openpond profile <status|diff|catalog|commit|push|load|check|agents|hosted|ensure-hosted> [args]");
+}
+async function runProfileCommitCommand(options, rest) {
+  const message = optionString(options, "message") || optionString(options, "commitMessage") || rest.join(" ").trim() || void 0;
+  const result = await commitActiveProfileChanges(message);
+  if (parseBooleanOption(options.json)) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (!result.committed) {
+    console.log("No profile changes to commit.");
+    printProfileState(result.state);
+    return;
+  }
+  console.log("Committed OpenPond profile changes.");
+  if (result.stdout.trim()) console.log(result.stdout.trim());
+  printProfileState(result.state);
+}
+async function runProfilePushCommand(options) {
+  const teamId = requiredTeamId(options, "usage: openpond profile push");
+  const state = await loadOpenPondProfileState();
+  if (state.error) throw new Error(state.error);
+  if (!state.repoPath || !state.sourcePath || !state.manifestPath) {
+    throw new Error("No active OpenPond profile. Run `openpond init`.");
+  }
+  if (!state.git?.isRepo) {
+    throw new Error("Active OpenPond profile source is not Git-backed. Run `openpond init` or reload a Git-backed profile.");
+  }
+  if (!state.git.head) {
+    throw new Error("Profile source must have a committed Git head before push. Run `openpond profile commit` first.");
+  }
+  if (state.git.dirty) {
+    throw new Error("Profile source has uncommitted changes. Run `openpond profile commit` before push.");
+  }
+  const client = await resolveSandboxClient(options);
+  const hosted = parseBooleanOption(options.ensureHosted) ? await client.profile.ensureHosted({ teamId }) : await client.profile.get({ teamId });
+  if (!hosted) {
+    throw new Error("No hosted OpenPond profile repo found. Run `openpond profile ensure-hosted --team-id <id>` first, or pass `--ensure-hosted` to push.");
+  }
+  const force = parseBooleanOption(options.force);
+  const currentHostedHead = hosted.sourceUpload?.sourceCommitSha ?? null;
+  const lastPushedHostedHead = state.hosted?.sourceCommitSha ?? null;
+  if (lastPushedHostedHead && currentHostedHead !== lastPushedHostedHead && !force) {
+    throw new Error(
+      [
+        "Hosted profile source changed since the last local push.",
+        `Last pushed hosted head: ${lastPushedHostedHead}`,
+        `Current hosted head: ${currentHostedHead ?? "none"}`,
+        "Inspect hosted changes before pushing, or rerun with --force to overwrite explicitly."
+      ].join("\n")
+    );
+  }
+  const explicitHostedSourceAgentId = optionString(options, "hostedSourceAgentId");
+  const requestHostedSourceChecks = parseBooleanOption(options.hostedSourceChecks);
+  const publishHostedSource = parseBooleanOption(options.publishHostedSource);
+  const hostedRunAgentId = optionString(options, "hostedRunAgentId");
+  const hostedSourceAgentId = explicitHostedSourceAgentId || (requestHostedSourceChecks || publishHostedSource ? hostedRunAgentId : null);
+  const manifest = JSON.parse(await readFile(state.manifestPath, "utf8"));
+  const hostedManifest = normalizeHostedProfileManifest(manifest);
+  const sourcePath = manifest.profiles[state.activeProfile ?? manifest.defaultProfile]?.path ?? "profiles/default";
+  const upload = await collectProfileSourceUploadForPush({
+    state,
+    hostedSourceAgentId
+  });
+  const result = await client.profile.push({
+    teamId,
+    entries: upload.entries,
+    branch: state.git.branch ?? "main",
+    commitMessage: optionString(options, "commitMessage") || optionString(options, "message") || `Push OpenPond profile ${state.activeProfile ?? "default"} at ${state.git.shortHead ?? state.git.head}`,
+    expectedSourceCommitSha: currentHostedHead,
+    localHeadSha: state.git.head,
+    manifest: hostedManifest,
+    sourcePath,
+    agents: state.agents.map((agent) => ({
+      id: agent.id,
+      path: agent.path,
+      enabled: agent.enabled
+    }))
+  });
+  const pushedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const preserveHostedPromotionEvidence = state.hosted?.lastPushedLocalHead === state.git.head && state.hosted?.sourceCommitSha === result.sourceUpload.sourceCommitSha;
+  let pushStatus = {
+    status: "pushed",
+    promotionStatus: preserveHostedPromotionEvidence ? state.hosted?.promotionStatus ?? "uploaded" : "uploaded",
+    hostedRunStatus: preserveHostedPromotionEvidence ? state.hosted?.hostedRunStatus ?? "not_started" : "not_started",
+    pushedAt,
+    teamId,
+    projectId: result.profile.project.id,
+    localHead: state.git.head,
+    hostedHead: result.sourceUpload.sourceCommitSha,
+    sourceRef: result.sourceUpload.sourceRef,
+    hostedRunAgentId: preserveHostedPromotionEvidence ? state.hosted?.hostedRunAgentId ?? null : null,
+    hostedRunId: preserveHostedPromotionEvidence ? state.hosted?.hostedRunId ?? null : null,
+    hostedRunAt: preserveHostedPromotionEvidence ? state.hosted?.hostedRunAt ?? null : null,
+    hostedSourceMaterialization: preserveHostedPromotionEvidence ? state.hosted?.hostedSourceMaterialization ?? null : null,
+    hostedSourceCheck: preserveHostedPromotionEvidence ? state.hosted?.hostedSourceCheck ?? null : null,
+    hostedPublish: preserveHostedPromotionEvidence ? state.hosted?.hostedPublish ?? null : null,
+    hostedRun: preserveHostedPromotionEvidence ? state.hosted?.hostedRun ?? null : null
+  };
+  await saveProfilePushStatus(pushStatus);
+  let hostedRuntimeAgentId = hostedSourceAgentId ?? resolveHostedRuntimeAgentIdForRun(state, hostedRunAgentId);
+  const hostedSourceDispatch = parseAgentSourceCheckDispatch(
+    options.hostedSourceDispatch,
+    "hosted-source-dispatch"
+  ) ?? "coding_core";
+  let hostedSourceDeployPlan = null;
+  let hostedSourceChecks = null;
+  let hostedSourcePublish = null;
+  if (hostedSourceAgentId && (requestHostedSourceChecks || publishHostedSource || explicitHostedSourceAgentId)) {
+    try {
+      const hostedSourceMaterialization = await materializeHostedProfileAgentSource({
+        client,
+        teamId,
+        profileProjectId: result.profile.project.id,
+        profileName: state.activeProfile ?? manifest.defaultProfile,
+        state,
+        agentId: hostedSourceAgentId,
+        sourceRef: result.sourceUpload.sourceRef ?? state.git.branch ?? "main",
+        localHead: state.git.head,
+        hostedHead: result.sourceUpload.sourceCommitSha,
+        projectId: optionString(options, "hostedSourceProjectId") || (state.hosted?.hostedSourceMaterialization?.agentId === hostedSourceAgentId ? state.hosted.hostedSourceMaterialization.projectId : null)
+      });
+      pushStatus = {
+        ...pushStatus,
+        promotionStatus: "hosted_source_materialized",
+        hostedSourceMaterialization
+      };
+      hostedRuntimeAgentId = hostedSourceMaterialization.runtimeAgentId ?? hostedSourceAgentId;
+      await saveProfilePushStatus(pushStatus);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      pushStatus = {
+        ...pushStatus,
+        promotionStatus: "hosted_source_materialize_failed",
+        hostedSourceMaterialization: {
+          status: "failed",
+          agentId: hostedSourceAgentId,
+          projectId: optionString(options, "hostedSourceProjectId") ?? null,
+          error: message
+        },
+        error: message
+      };
+      await saveProfilePushStatus(pushStatus);
+      throw new Error(`Hosted source materialization failed after push: ${message}`);
+    }
+  }
+  if (requestHostedSourceChecks || publishHostedSource) {
+    if (!hostedSourceAgentId) {
+      throw new Error("--hosted-source-agent-id or --hosted-run-agent-id is required for hosted source checks or publish.");
+    }
+    if (!hostedRuntimeAgentId) {
+      throw new Error("Unable to resolve the hosted runtime agent for source checks.");
+    }
+    try {
+      hostedSourceDeployPlan = await client.agents.sourceDeployPlan(hostedRuntimeAgentId, { teamId });
+      if (requestHostedSourceChecks) {
+        const sourceRef = pushStatus.hostedSourceMaterialization?.sourceRef ?? result.sourceUpload.sourceRef;
+        const baseSha = pushStatus.hostedSourceMaterialization?.sourceCommitSha ?? result.sourceUpload.sourceCommitSha;
+        hostedSourceChecks = await client.agents.requestSourceChecks(hostedRuntimeAgentId, {
+          teamId,
+          ...sourceRef ? { sourceRef } : {},
+          ...baseSha ? { baseSha } : {},
+          checkKind: parseAgentSourceCheckKind(
+            optionString(options, "hostedCheckKind") || optionString(options, "checkKind")
+          ) ?? "all",
+          dispatch: hostedSourceDispatch,
+          metadata: {
+            source: "openpond_profile_push_checks",
+            localHead: state.git.head,
+            hostedHead: result.sourceUpload.sourceCommitSha,
+            materializedProjectId: pushStatus.hostedSourceMaterialization?.projectId ?? null,
+            materializedSourceCommitSha: pushStatus.hostedSourceMaterialization?.sourceCommitSha ?? null,
+            sourceRef,
+            dispatch: hostedSourceDispatch
+          }
+        });
+        if (hostedSourceChecks.dispatchResult?.status === "failed") {
+          throw new Error(hostedSourceChecks.dispatchResult.error ?? "hosted_source_check_dispatch_failed");
+        }
+        if (hostedSourceChecks.dispatchResult?.status === "completed") {
+          const refreshed = await refreshHostedSourceCheckStatus({
+            client,
+            teamId,
+            checkResult: hostedSourceChecks
+          });
+          if (refreshed) {
+            hostedSourceChecks = refreshed;
+          }
+          const sourceCheckStatus = record(hostedSourceChecks.sourceCheckStatus);
+          if (sourceCheckStatusPassed(sourceCheckStatus)) {
+            await bindValidatedHostedRuntimeSource({
+              client,
+              teamId,
+              runtimeAgentId: hostedRuntimeAgentId,
+              sourceRef,
+              sourceCommitSha: baseSha,
+              validatedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            hostedSourceDeployPlan = await client.agents.sourceDeployPlan(hostedRuntimeAgentId, { teamId });
+          }
+        }
+      }
+      pushStatus = {
+        ...pushStatus,
+        promotionStatus: requestHostedSourceChecks ? "hosted_source_check_pending" : pushStatus.promotionStatus,
+        hostedSourceCheck: hostedSourceCheckStatusFromPayload({
+          agentId: hostedRuntimeAgentId,
+          status: requestHostedSourceChecks ? "requested" : "deploy_plan_ready",
+          deployPlan: hostedSourceDeployPlan,
+          checkResult: hostedSourceChecks
+        })
+      };
+      await saveProfilePushStatus(pushStatus);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      pushStatus = {
+        ...pushStatus,
+        promotionStatus: "hosted_source_check_failed",
+        hostedSourceCheck: hostedSourceCheckStatusFromPayload({
+          agentId: hostedRuntimeAgentId,
+          status: "failed",
+          deployPlan: hostedSourceDeployPlan,
+          checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          error: message
+        }),
+        error: message
+      };
+      await saveProfilePushStatus(pushStatus);
+      throw new Error(`Hosted source check failed after push: ${message}`);
+    }
+  }
+  if (publishHostedSource) {
+    if (!hostedSourceAgentId) {
+      throw new Error("--hosted-source-agent-id or --hosted-run-agent-id is required for hosted source publish.");
+    }
+    if (!hostedRuntimeAgentId) {
+      throw new Error("Unable to resolve the hosted runtime agent for source publish.");
+    }
+    try {
+      const expectedManifestHash = optionString(options, "expectedManifestHash") || pushStatus.hostedSourceCheck?.manifestHash || hostedSourceDeployPlan?.source.manifestHash || void 0;
+      hostedSourcePublish = await client.agents.publishSource(hostedRuntimeAgentId, {
+        teamId,
+        ...expectedManifestHash ? { expectedManifestHash } : {},
+        ...pushStatus.hostedSourceMaterialization?.sourceCommitSha ?? result.sourceUpload.sourceCommitSha ? { expectedSourceCommitSha: pushStatus.hostedSourceMaterialization?.sourceCommitSha ?? result.sourceUpload.sourceCommitSha } : {},
+        ...optionString(options, "workItemId") ? { workItemId: optionString(options, "workItemId") } : {}
+      });
+      pushStatus = {
+        ...pushStatus,
+        promotionStatus: "hosted_source_published",
+        hostedPublish: hostedPublishStatusFromPayload({
+          agentId: hostedRuntimeAgentId,
+          publishResult: hostedSourcePublish
+        })
+      };
+      await saveProfilePushStatus(pushStatus);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      pushStatus = {
+        ...pushStatus,
+        promotionStatus: "hosted_source_publish_failed",
+        hostedPublish: {
+          status: "failed",
+          agentId: hostedRuntimeAgentId,
+          error: message
+        },
+        error: message
+      };
+      await saveProfilePushStatus(pushStatus);
+      throw new Error(`Hosted source publish failed after push: ${message}`);
+    }
+  }
+  let hostedRun = null;
+  if (hostedRunAgentId) {
+    const hostedRunRuntimeAgentId = hostedRuntimeAgentId || hostedRunAgentId;
+    const hostedRunStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const hostedRunInput = parseJsonObjectOption(options, "hostedRunInput") ?? { prompt: "hello", channel: "openpond_chat" };
+    const hostedRunConversationId = optionString(options, "hostedRunConversationId") || optionString(options, "conversationId");
+    const hostedRunTargetProjectId = optionString(options, "hostedRunTargetProjectId");
+    const hostedRunIdempotencyKey = buildHostedRunIdempotencyKey({
+      explicitKey: optionString(options, "hostedRunIdempotencyKey"),
+      retry: parseBooleanOption(options.hostedRunRetry),
+      localHead: state.git.head,
+      sourceHead: pushStatus.hostedSourceMaterialization?.sourceCommitSha ?? result.sourceUpload.sourceCommitSha,
+      runtimeAgentId: hostedRunRuntimeAgentId,
+      targetProjectId: hostedRunTargetProjectId,
+      input: hostedRunInput
+    });
+    await saveProfilePushStatus({
+      ...pushStatus,
+      promotionStatus: "hosted_run_pending",
+      hostedRunStatus: "running",
+      hostedRunAgentId: hostedRunRuntimeAgentId,
+      hostedRunAt: hostedRunStartedAt
+    });
+    try {
+      hostedRun = await client.agents.run(hostedRunRuntimeAgentId, {
+        teamId,
+        ...hostedRunConversationId ? { conversationId: hostedRunConversationId } : {},
+        ...hostedRunTargetProjectId ? { targetProjectId: hostedRunTargetProjectId } : {},
+        ...hostedRunTargetProjectId ? { targetProject: { id: hostedRunTargetProjectId } } : {},
+        idempotencyKey: hostedRunIdempotencyKey,
+        input: hostedRunInput,
+        metadata: {
+          source: "openpond_profile_push_run",
+          ...hostedRunConversationId ? { conversationId: hostedRunConversationId } : {},
+          targetProjectId: hostedRunTargetProjectId || null,
+          localHead: state.git.head,
+          hostedHead: result.sourceUpload.sourceCommitSha,
+          hostedRunIdempotencyKey,
+          hostedRunRetry: parseBooleanOption(options.hostedRunRetry),
+          materializedProjectId: pushStatus.hostedSourceMaterialization?.projectId ?? null,
+          materializedSourceCommitSha: pushStatus.hostedSourceMaterialization?.sourceCommitSha ?? null,
+          sourceRef: pushStatus.hostedSourceMaterialization?.sourceRef ?? result.sourceUpload.sourceRef,
+          publishedSnapshotId: pushStatus.hostedPublish?.snapshotId ?? null,
+          manifestHash: pushStatus.hostedPublish?.manifestHash ?? pushStatus.hostedSourceCheck?.manifestHash ?? null
+        },
+        runtimeSourcePolicy: publishHostedSource ? {
+          requirePublishedSnapshot: true,
+          source: "diagnostic"
+        } : {
+          allowLatestSource: true,
+          source: "diagnostic"
+        }
+      });
+      const hostedRunSummary = hostedRunSummaryFromPayload({
+        agentId: hostedRunRuntimeAgentId,
+        runResult: hostedRun
+      });
+      const hostedRunStatus = hostedRunStatusFromRunSummary(hostedRunSummary);
+      await saveProfilePushStatus({
+        ...pushStatus,
+        promotionStatus: hostedRunStatus === "passed" ? "hosted_run_passed" : hostedRunStatus === "failed" ? "hosted_run_failed" : "hosted_run_pending",
+        hostedRunStatus,
+        hostedRunAgentId: hostedRunRuntimeAgentId,
+        hostedRunId: hostedRun.run.id,
+        hostedRunAt: hostedRun.run.createdAt ?? hostedRunStartedAt,
+        hostedRun: hostedRunSummary
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      await saveProfilePushStatus({
+        ...pushStatus,
+        promotionStatus: "hosted_run_failed",
+        hostedRunStatus: "failed",
+        hostedRunAgentId: hostedRunRuntimeAgentId,
+        hostedRunAt: (/* @__PURE__ */ new Date()).toISOString(),
+        hostedRun: {
+          status: "failed",
+          agentId: hostedRunRuntimeAgentId,
+          error: message
+        },
+        error: message
+      });
+      throw new Error(`Hosted invocation failed to start after push: ${message}`);
+    }
+  }
+  if (parseBooleanOption(options.json)) {
+    console.log(
+      JSON.stringify(
+        {
+          ...result,
+          uploaded: summarizeProfileSourceUpload(upload),
+          hostedSourceMaterialization: pushStatus.hostedSourceMaterialization ?? null,
+          hostedSourceChecks,
+          hostedSourcePublish,
+          hostedRun
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.log(`Pushed OpenPond profile ${state.activeProfile ?? "default"} to hosted profile repo.`);
+  console.log(`Project id: ${result.profile.project.id}`);
+  console.log(`Local head: ${state.git.head}`);
+  console.log(`Hosted source commit: ${result.sourceUpload.sourceCommitSha ?? "unknown"}`);
+  console.log(
+    `Uploaded ${upload.fileCount} file(s), ${upload.totalBytes} byte(s) via ${upload.transport.mode} (limits: ${upload.limits.maxFiles} files, ${upload.limits.maxFileBytes} bytes/file, ${upload.limits.maxTotalBytes} bytes total).`
+  );
+  console.log(
+    hostedRun ? `Hosted invocation: running ${hostedRun.run.id}` : "Hosted invocation: not started"
+  );
+  if (pushStatus.hostedSourceMaterialization) {
+    console.log(
+      `Hosted materialized: ${pushStatus.hostedSourceMaterialization.status}` + (pushStatus.hostedSourceMaterialization.projectId ? ` ${pushStatus.hostedSourceMaterialization.projectId}` : "") + (pushStatus.hostedSourceMaterialization.sourceCommitSha ? ` ${pushStatus.hostedSourceMaterialization.sourceCommitSha}` : "")
+    );
+  }
+  if (pushStatus.hostedSourceCheck) {
+    console.log(
+      `Hosted source checks: ${pushStatus.hostedSourceCheck.status}` + (pushStatus.hostedSourceCheck.workItemId ? ` ${pushStatus.hostedSourceCheck.workItemId}` : "")
+    );
+  }
+  if (pushStatus.hostedPublish) {
+    console.log(
+      `Hosted publish: ${pushStatus.hostedPublish.status}` + (pushStatus.hostedPublish.snapshotId ? ` ${pushStatus.hostedPublish.snapshotId}` : "")
+    );
+  }
+  console.log(`Uploaded files: ${upload.fileCount}`);
+}
+function summarizeProfileSourceUpload(upload) {
+  return {
+    fileCount: upload.fileCount,
+    totalBytes: upload.totalBytes,
+    limits: upload.limits,
+    transport: upload.transport
+  };
+}
+function normalizeHostedProfileManifest(manifest) {
+  return {
+    ...manifest,
+    profiles: Object.fromEntries(
+      Object.entries(manifest.profiles).map(([name, profile]) => [
+        name,
+        {
+          path: profile.path,
+          defaultAgent: profile.defaultAgent ?? "default",
+          enabledAgents: profile.enabledAgents ?? []
+        }
+      ])
+    )
+  };
+}
+async function collectProfileSourceUploadForPush(input) {
+  const repoPath = input.state.repoPath;
+  if (!repoPath) {
+    throw new Error("Active OpenPond profile is missing a repository path.");
+  }
+  const collected = await collectProfileSourceUploadEntries(repoPath);
+  if (!input.hostedSourceAgentId) return collected;
+  if (!input.state.sourcePath) {
+    throw new Error("Active OpenPond profile is missing a source path.");
+  }
+  const agent = input.state.agents.find(
+    (candidate) => candidate.id === input.hostedSourceAgentId
+  );
+  if (!agent) {
+    throw new Error(
+      `Profile agent not found for hosted source upload: ${input.hostedSourceAgentId}`
+    );
+  }
+  const sourceRoot = resolveProfileAgentSourceRoot(
+    input.state.sourcePath,
+    agent.path
+  );
+  const relativeSourceRoot = path.relative(repoPath, sourceRoot).replace(/\\/g, "/");
+  if (relativeSourceRoot.startsWith("..") || path.isAbsolute(relativeSourceRoot)) {
+    throw new Error(`Profile agent path escapes profile repo: ${agent.path}`);
+  }
+  const agentSdk = await collectAgentSdkProjectSourceUploadEntries(
+    sourceRoot,
+    []
+  );
+  if (agentSdk.entries.length === 0) return collected;
+  return mergeProjectSourceUploadEntries(
+    collected,
+    agentSdk.entries.map((entry) => ({
+      ...entry,
+      path: relativeSourceRoot ? `${relativeSourceRoot}/${entry.path}` : entry.path
+    }))
+  );
+}
+async function materializeHostedProfileAgentSource(input) {
+  if (!input.state.sourcePath) {
+    throw new Error("Active OpenPond profile is missing a source path.");
+  }
+  const agent = input.state.agents.find((candidate) => candidate.id === input.agentId);
+  if (!agent) {
+    throw new Error(`Profile agent not found for hosted materialization: ${input.agentId}`);
+  }
+  const sourceRoot = resolveProfileAgentSourceRoot(input.state.sourcePath, agent.path);
+  const collected = await collectProjectSourceUploadEntries(sourceRoot);
+  const agentSdk = await collectAgentSdkProjectSourceUploadEntries(sourceRoot, collected.entries);
+  const upload = mergeProjectSourceUploadEntries(collected, agentSdk.entries);
+  const materializationProject = await getOrCreateHostedSourceProject({
+    client: input.client,
+    teamId: input.teamId,
+    projectId: input.projectId ?? null,
+    profileProjectId: input.profileProjectId,
+    profileName: input.profileName,
+    agentId: input.agentId,
+    localHead: input.localHead,
+    hostedHead: input.hostedHead
+  });
+  const uploadedProject = await input.client.projects.uploadSource(materializationProject.id, {
+    teamId: input.teamId,
+    entries: upload.entries,
+    branch: input.sourceRef,
+    commitMessage: `Materialize OpenPond profile agent ${input.agentId}`
+  });
+  const syncedProject = await input.client.projects.sync(uploadedProject.id, {
+    teamId: input.teamId
+  });
+  const sourceCommitSha = sandboxProjectSourceCommitSha(syncedProject) ?? sandboxProjectSourceCommitSha(uploadedProject);
+  const sourceRef = sandboxProjectSourceRef(syncedProject) ?? sandboxProjectSourceRef(uploadedProject) ?? input.sourceRef;
+  const selectedEntrypoint = hostedEntrypointForProfileAgent(input.state, input.agentId);
+  const runtimeAgent = await input.client.agents.upsert({
+    teamId: input.teamId,
+    projectId: syncedProject.id,
+    name: agent.name || input.agentId,
+    slug: hostedRuntimeAgentSlug(input.profileName, input.agentId),
+    selectedEntrypoint,
+    triggerType: "manual",
+    runtimeSource: {
+      mode: "latest_source",
+      ...sourceRef ? { sourceRef } : {},
+      ...sourceCommitSha ? { sourceCommitSha } : {}
+    },
+    metadata: {
+      source: "openpond_profile_agent_materialization",
+      profileProjectId: input.profileProjectId,
+      profileName: input.profileName,
+      profileAgentId: input.agentId,
+      profileSourcePath: agent.path,
+      localHead: input.localHead,
+      hostedHead: input.hostedHead
+    },
+    externalId: `openpond-profile-agent:${input.profileProjectId}:${input.profileName}:${input.agentId}`
+  });
+  const uploadMetadata = record(agentSdk.uploadMetadata);
+  const commands = record(uploadMetadata?.commands);
+  const dependencySetup = record(uploadMetadata?.dependencySetup);
+  const setupCommands = stringArray(dependencySetup?.commands);
+  const validationCommands = [
+    text(commands?.validate),
+    text(commands?.eval)
+  ].filter((command) => Boolean(command));
+  return {
+    status: "uploaded",
+    agentId: input.agentId,
+    runtimeAgentId: runtimeAgent.id,
+    projectId: syncedProject.id,
+    sourceRoot,
+    sourceRef,
+    sourceCommitSha: sourceCommitSha ?? null,
+    manifestHash: syncedProject.sandboxManifestHash ?? null,
+    manifestPath: syncedProject.sandboxManifestPath ?? null,
+    manifestSyncedAt: syncedProject.sandboxManifestSyncedAt ?? null,
+    fileCount: upload.fileCount,
+    totalBytes: upload.totalBytes,
+    generatedManifestPath: agentSdk.generatedManifestPath,
+    synthesizedOpenPondYaml: agentSdk.synthesizedOpenPondYaml,
+    uploadMetadataPath: agentSdk.uploadMetadataPath,
+    setupCommands,
+    validationCommands,
+    materializedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function getOrCreateHostedSourceProject(input) {
+  if (input.projectId) {
+    try {
+      return await input.client.projects.get(input.projectId, {
+        teamId: input.teamId
+      });
+    } catch {
+    }
+  }
+  return input.client.projects.upsert({
+    teamId: input.teamId,
+    name: `OpenPond profile ${input.profileName} ${input.agentId}`,
+    sourceType: "manual",
+    externalId: `openpond-profile:${input.profileProjectId}:${input.profileName}:${input.agentId}`,
+    description: `Materialized OpenPond profile agent ${input.agentId} for hosted sandbox checks.`,
+    metadata: {
+      source: "openpond_profile_agent_materialization",
+      profileProjectId: input.profileProjectId,
+      profileName: input.profileName,
+      profileAgentId: input.agentId,
+      localHead: input.localHead,
+      hostedHead: input.hostedHead
+    }
+  });
+}
+function resolveProfileAgentSourceRoot(sourcePath, agentPath) {
+  const normalized = agentPath.replace(/\\/g, "/");
+  const absolute = path.resolve(sourcePath, normalized);
+  const relative = path.relative(sourcePath, absolute);
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error(`Profile agent path escapes profile source: ${agentPath}`);
+  }
+  return normalized === "agent/agent.ts" || normalized.endsWith("/agent.ts") ? sourcePath : absolute;
+}
+function hostedEntrypointForProfileAgent(state, agentId) {
+  const action = state.actionCatalog.find(
+    (candidate) => candidate.agentId === agentId && (candidate.sourceActionId === "chat" || candidate.name === "chat")
+  ) ?? state.actionCatalog.find((candidate) => candidate.agentId === agentId);
+  return {
+    scope: "action",
+    name: typeof action?.sourceActionId === "string" && action.sourceActionId || typeof action?.name === "string" && action.name || "chat"
+  };
+}
+function hostedRuntimeAgentSlug(profileName, agentId) {
+  const slug = `openpond-profile-${profileName}-${agentId}`.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "openpond-profile-agent";
+}
+function sandboxProjectSourceCommitSha(project) {
+  const item = record(project);
+  const sourceConfig = record(item?.sourceConfig);
+  const metadata = record(item?.metadata);
+  return text(sourceConfig?.sourceCommitSha) ?? text(sourceConfig?.commitSha) ?? text(sourceConfig?.remoteSha) ?? text(metadata?.projectSourceUploadCommitSha) ?? text(metadata?.sourceCommitSha) ?? text(item?.templateRemoteSha);
+}
+function sandboxProjectSourceRef(project) {
+  const item = record(project);
+  const sourceConfig = record(item?.sourceConfig);
+  return text(sourceConfig?.sourceRef) ?? text(sourceConfig?.branch) ?? text(item?.gitBranch) ?? text(item?.defaultBranch);
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function resolveHostedRuntimeAgentIdForRun(state, hostedRunAgentId) {
+  if (!hostedRunAgentId) return null;
+  const materialization = state.hosted?.hostedSourceMaterialization;
+  if (materialization?.agentId === hostedRunAgentId && materialization.runtimeAgentId) {
+    return materialization.runtimeAgentId;
+  }
+  return hostedRunAgentId;
+}
+async function refreshHostedSourceCheckStatus(input) {
+  const workItemId = text(record(input.checkResult.workItem)?.id);
+  if (!workItemId) return null;
+  const status = await input.client.workItems.status(workItemId, {
+    teamId: input.teamId,
+    includeArchived: true,
+    limit: 50
+  });
+  return {
+    ...input.checkResult,
+    workItem: status.workItem,
+    activity: status.activity,
+    sourceCheckStatus: status.sourceCheckStatus
+  };
+}
+async function bindValidatedHostedRuntimeSource(input) {
+  if (!input.sourceRef || !input.sourceCommitSha) return;
+  await input.client.agents.update(input.runtimeAgentId, {
+    teamId: input.teamId,
+    runtimeSource: {
+      mode: "latest_source",
+      sourceRef: input.sourceRef,
+      sourceCommitSha: input.sourceCommitSha,
+      buildStatus: "succeeded",
+      validationStatus: "passed",
+      validatedAt: input.validatedAt
+    }
+  });
+}
+function sourceCheckStatusPassed(status) {
+  if (!status) return false;
+  const finalResultState = text(status.finalResultState)?.toLowerCase();
+  if (finalResultState && finalResultState !== "completed" && !passingStatus(finalResultState)) {
+    return false;
+  }
+  const checkRuns = Array.isArray(status.checkRuns) ? status.checkRuns.map(record).filter((item) => Boolean(item)) : [];
+  if (checkRuns.some(checkRunFailed)) return false;
+  const buildPassed = checkRuns.some(
+    (run) => checkRunCommand(run).includes("build") && checkEvidencePassed(run)
+  );
+  const validationPassed = checkEvidencePassed(record(status.validation)) || checkRuns.some(
+    (run) => checkRunCommand(run).includes("validate") && checkEvidencePassed(run)
+  );
+  const evalEvidence = record(status.eval);
+  const evalRequired = (text(status.requestedCheckKind) ?? "all") === "all" || (text(status.requestedCheckKind) ?? "") === "eval" || Boolean(evalEvidence) || checkRuns.some((run) => checkRunCommand(run).includes("eval"));
+  const evalPassed = !evalRequired || checkEvidencePassed(evalEvidence) || checkRuns.some(
+    (run) => checkRunCommand(run).includes("eval") && checkEvidencePassed(run)
+  );
+  return buildPassed && validationPassed && evalPassed;
+}
+function checkRunCommand(run) {
+  return (text(run.command) ?? "").toLowerCase();
+}
+function checkRunFailed(run) {
+  const passed = run.passed;
+  if (typeof passed === "boolean") return !passed;
+  const exitCode = run.exitCode;
+  if (typeof exitCode === "number" && exitCode !== 0) return true;
+  const status = text(run.status)?.toLowerCase();
+  return Boolean(status && failingStatus(status));
+}
+function checkEvidencePassed(evidence) {
+  if (!evidence) return false;
+  if (typeof evidence.passed === "boolean") return evidence.passed;
+  const failed = numericEvidence(evidence.failed) ?? numericEvidence(evidence.failedCount);
+  if (failed !== null && failed > 0) return false;
+  const exitCode = evidence.exitCode;
+  if (typeof exitCode === "number") return exitCode === 0;
+  const status = text(evidence.status)?.toLowerCase();
+  return Boolean(status && passingStatus(status));
+}
+function numericEvidence(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function passingStatus(status) {
+  return status === "passed" || status === "succeeded" || status === "success";
+}
+function failingStatus(status) {
+  return status === "failed" || status === "failure" || status === "cancelled";
+}
+async function runHostedProfileStatusCommand(options) {
+  const teamId = requiredTeamId(
+    options,
+    "usage: openpond profile hosted status"
+  );
+  const client = await resolveSandboxClient(options);
+  const profile = await client.profile.get({ teamId });
+  if (parseBooleanOption(options.json)) {
+    console.log(JSON.stringify({ profile }, null, 2));
+    return;
+  }
+  if (!profile) {
+    console.log("No hosted OpenPond profile repo found.");
+    console.log("Run `openpond profile ensure-hosted --team-id <id>` to create one.");
+    return;
+  }
+  printHostedProfileSummary(profile);
+}
+async function runHostedProfileEnsureCommand(options) {
+  const teamId = requiredTeamId(
+    options,
+    "usage: openpond profile ensure-hosted"
+  );
+  const client = await resolveSandboxClient(options);
+  const profile = await client.profile.ensureHosted({ teamId });
+  if (parseBooleanOption(options.json)) {
+    console.log(JSON.stringify({ profile }, null, 2));
+    return;
+  }
+  printHostedProfileSummary(profile);
+}
+async function runOpenPondAgentsCommand(options, rest) {
+  const subcommand = rest[0] ?? "list";
+  if (subcommand !== "list") {
+    throw new Error("usage: openpond agents list [--json]");
+  }
+  const state = await loadOpenPondProfileState();
+  if (state.error) throw new Error(state.error);
+  if (parseBooleanOption(options.json)) {
+    console.log(JSON.stringify({ agents: state.agents, profile: state }, null, 2));
+    return;
+  }
+  if (state.mode === "none") {
+    console.log("No active OpenPond profile. Run `openpond init`.");
+    return;
+  }
+  if (state.agents.length === 0) {
+    console.log(`No agents found in ${state.activeProfile}.`);
+    return;
+  }
+  for (const agent of state.agents) {
+    console.log(`${agent.id}	${agent.enabled ? "enabled" : "disabled"}	${agent.path}`);
+  }
+}
+async function runOpenPondProfileSdkAlias(command, options, rest) {
+  const cwd = optionString(options, "cwd");
+  const args = [...rest, ...optionArgs(options, /* @__PURE__ */ new Set(["cwd", "account", "profile", "handle", "baseUrl"]))];
+  await runProfileSdkCommand({
+    command,
+    cwd: cwd ? path.resolve(cwd) : void 0,
+    args,
+    inherit: true
+  });
+}
+function printProfileState(state) {
+  if (state.mode === "none") {
+    console.log("No active OpenPond profile.");
+    console.log(`Default location: ${defaultLocalProfileRepoPath()}`);
+    return;
+  }
+  console.log(`Mode: ${state.mode}`);
+  console.log(`Repo: ${state.repoPath}`);
+  console.log(`Profile: ${state.activeProfile}`);
+  console.log(`Source: ${state.sourcePath ?? "missing"}`);
+  console.log(`State: ${state.summary.message}`);
+  if (state.git) {
+    console.log(`Git: ${state.git.branch ?? "detached"} ${state.git.shortHead ?? "no-head"}${state.git.dirty ? " dirty" : " clean"}`);
+    if (state.git.upstream) {
+      console.log(`Upstream: ${state.git.upstream} ahead ${state.git.ahead ?? "?"} behind ${state.git.behind ?? "?"}`);
+    }
+  }
+  if (state.hosted?.projectId || state.hosted?.sourceCommitSha) {
+    console.log(`Hosted: ${state.hosted.projectId ?? "unbound"} ${state.hosted.sourceCommitSha ?? "no-source-head"}`);
+    if (state.hosted.hostedSourceMaterialization) {
+      console.log(
+        `Hosted materialized: ${state.hosted.hostedSourceMaterialization.status}` + (state.hosted.hostedSourceMaterialization.agentId ? ` ${state.hosted.hostedSourceMaterialization.agentId}` : "") + (state.hosted.hostedSourceMaterialization.sourceCommitSha ? ` ${state.hosted.hostedSourceMaterialization.sourceCommitSha}` : "")
+      );
+    }
+    if (state.hosted.hostedSourceCheck) {
+      console.log(
+        `Hosted checks: ${state.hosted.hostedSourceCheck.status}` + (state.hosted.hostedSourceCheck.workItemId ? ` ${state.hosted.hostedSourceCheck.workItemId}` : "") + (state.hosted.hostedSourceCheck.sandboxId ? ` sandbox ${state.hosted.hostedSourceCheck.sandboxId}` : "")
+      );
+    }
+    if (state.hosted.hostedPublish) {
+      console.log(
+        `Hosted publish: ${state.hosted.hostedPublish.status}` + (state.hosted.hostedPublish.snapshotId ? ` ${state.hosted.hostedPublish.snapshotId}` : "")
+      );
+    }
+    if (state.hosted.hostedRun) {
+      console.log(
+        `Hosted run: ${state.hosted.hostedRun.status}` + (state.hosted.hostedRun.runId ? ` ${state.hosted.hostedRun.runId}` : "") + (state.hosted.hostedRun.runtimeId ? ` runtime ${state.hosted.hostedRun.runtimeId}` : "")
+      );
+    }
+  }
+  console.log(`Catalog: ${state.catalog.actionCount} action(s)${state.catalog.stale ? " stale" : ""}`);
+  console.log(
+    `Setup gate: ${state.setupGate.status} (${state.setupGate.blockingCount} blocking, ${state.setupGate.optionalMissingCount} optional missing)`
+  );
+  if (state.summary.defaultAction) {
+    console.log(`Default action: ${state.summary.defaultAction}`);
+  }
+  if (state.setupGate.blockingRequirements.length > 0) {
+    console.log("Blocking setup:");
+    for (const requirement of state.setupGate.blockingRequirements.slice(0, 10)) {
+      console.log(`  ${formatOpenPondProfileSetupRequirement(requirement)}`);
+    }
+    if (state.setupGate.blockingRequirements.length > 10) {
+      console.log(`  ... ${state.setupGate.blockingRequirements.length - 10} more`);
+    }
+  }
+  if (!state.summary.checkFresh && state.summary.checkStaleReason) {
+    console.log(`Checks: stale - ${state.summary.checkStaleReason}`);
+  } else if (state.summary.checkFresh) {
+    console.log("Checks: fresh");
+  }
+  if (state.lastCheck) {
+    console.log(`Last check: ${state.lastCheck.command} ${state.lastCheck.status} at ${state.lastCheck.checkedAt}`);
+  }
+  if (state.error) {
+    console.log(`Error: ${state.error}`);
+  }
+  if (state.agents.length > 0) {
+    console.log("Agents:");
+    for (const agent of state.agents) {
+      console.log(`  ${agent.id} (${agent.enabled ? "enabled" : "disabled"}) ${agent.path}`);
+    }
+  }
+  if (state.skills.length > 0) {
+    console.log("Skills:");
+    for (const skill of state.skills) {
+      const status = skill.validationStatus === "valid" ? "valid" : skill.validationStatus;
+      console.log(`  ${skill.name} (${status}) ${skill.path}`);
+    }
+  }
+}
+function printProfileDiff(state) {
+  if (state.mode === "none") {
+    console.log("No active OpenPond profile.");
+    return;
+  }
+  console.log(`Profile: ${state.activeProfile}`);
+  console.log(`State: ${state.summary.message}`);
+  const groups = [
+    ["Changed agents", state.diff.changedAgents],
+    ["New agents", state.diff.newAgents],
+    ["Deleted agents", state.diff.deletedAgents],
+    ["Changed skills", state.diff.changedSkills],
+    ["Changed actions", state.diff.changedActions],
+    ["Changed extensions", state.diff.changedExtensions],
+    ["Setup changes", state.diff.setupChanges],
+    ["Env requirement changes", state.diff.envRequirementChanges]
+  ];
+  for (const [label, values] of groups) {
+    if (values.length === 0) continue;
+    console.log(`${label}: ${values.join(", ")}`);
+  }
+  if (state.diff.files.length === 0) {
+    console.log("No source changes.");
+    return;
+  }
+  console.log("Files:");
+  for (const file of state.diff.files) {
+    console.log(`  ${file.status.padEnd(2)} ${file.path}`);
+  }
+}
+function printProfileCatalog(state) {
+  if (state.mode === "none") {
+    console.log("No active OpenPond profile.");
+    return;
+  }
+  console.log(`Profile: ${state.activeProfile}`);
+  console.log(`Catalog: ${state.catalog.actionCount} action(s)${state.catalog.stale ? " stale" : ""}`);
+  console.log(
+    `Setup gate: ${state.setupGate.status} (${state.setupGate.blockingCount} blocking, ${state.setupGate.optionalMissingCount} optional missing)`
+  );
+  if (state.catalog.generatedAt) console.log(`Generated at: ${state.catalog.generatedAt}`);
+  if (state.catalog.error) console.log(`Catalog error: ${state.catalog.error}`);
+  if (state.actionCatalog.length === 0) {
+    console.log("No catalog actions found. Run `openpond inspect` or `openpond build`.");
+    return;
+  }
+  for (const action of state.actionCatalog) {
+    const label = action.label ?? action.name ?? action.id;
+    const visibility = action.visibility ?? "default";
+    const actionBlocking = state.setupGate.blockingRequirements.filter(
+      (requirement) => requirement.actionId === action.id
+    );
+    const setup = actionBlocking.length ? `setup_required:${actionBlocking.map((requirement) => requirement.label).join(",")}` : "setup_ready";
+    console.log(`${action.id}	${visibility}	${setup}	${label}`);
+  }
+  const sourceBlocking = state.setupGate.blockingRequirements.filter(
+    (requirement) => requirement.actionId === null
+  );
+  if (sourceBlocking.length > 0) {
+    console.log("Source setup blockers:");
+    for (const requirement of sourceBlocking) {
+      console.log(`  ${formatOpenPondProfileSetupRequirement(requirement)}`);
+    }
+  }
+}
+function printHostedProfileSummary(profile) {
+  console.log(`Hosted profile repo: ${profile.project.name}`);
+  console.log(`Project id: ${profile.project.id}`);
+  console.log(`Role: ${profile.project.role ?? "profile"}`);
+  console.log(`Default profile: ${profile.defaultProfile}`);
+  console.log(`Source path: ${profile.sourcePath}`);
+  console.log(`Seed status: ${profile.seedStatus}`);
+  if (profile.sourceUpload?.sourceRef) {
+    console.log(`Source ref: ${profile.sourceUpload.sourceRef}`);
+  }
+  if (profile.sourceUpload?.sourceCommitSha) {
+    console.log(`Source commit: ${profile.sourceUpload.sourceCommitSha}`);
+  }
+  if (profile.seededAt) {
+    console.log(`Seeded at: ${profile.seededAt}`);
+  }
+  if (profile.agents.length > 0) {
+    console.log("Agents:");
+    for (const agent of profile.agents) {
+      console.log(`  ${agent.id} (${agent.enabled ? "enabled" : "disabled"}) ${agent.path}`);
+    }
+  }
+}
+function optionArgs(options, ignored) {
+  const args = [];
+  const booleanFlags = /* @__PURE__ */ new Set(["force", "json"]);
+  for (const [key, value] of Object.entries(options)) {
+    if (ignored.has(key)) continue;
+    const flag = `--${key.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`)}`;
+    if (value === true || booleanFlags.has(key) && value === "true") {
+      args.push(flag);
+    } else if (booleanFlags.has(key) && value === "false") {
+      continue;
+    } else if (typeof value === "string") {
+      args.push(flag, value);
+    }
+  }
+  return args;
+}
+function parseJsonObjectOption(options, key) {
+  const raw = optionString(options, key);
+  if (!raw) return null;
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`--${key} must be a JSON object`);
+  }
+  return parsed;
+}
+export {
+  collectProfileSourceUploadForPush,
+  runOpenPondAgentsCommand,
+  runOpenPondInitCommand,
+  runOpenPondProfileCommand,
+  runOpenPondProfileSdkAlias
+};