@openagentpack/cli 0.0.0-beta.run-29740517091.sha-65ccfac

package/dist/chunk-W5APGQN3.js

@@ -0,0 +1,1864 @@
+// src/program.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname4, resolve as resolve5 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Command as Command2, Option as Option2 } from "commander";
+
+// src/commands/apply.ts
+import * as p2 from "@clack/prompts";
+import { decideDestructive, executePlannedProject, UserError as UserError2 } from "@openagentpack/sdk";
+import chalk3 from "chalk";
+
+// src/config-loader.ts
+import { createProjectRuntime, resolveProjectConfig, UserError } from "@openagentpack/sdk";
+
+// src/credentials.ts
+import { bootstrapRuntimeCredentialsSync } from "@openagentpack/sdk";
+var bootstrapped = false;
+function ensureCredentials() {
+  if (bootstrapped) return;
+  bootstrapped = true;
+  bootstrapRuntimeCredentialsSync();
+}
+
+// src/file-state-manager.ts
+import { basename, dirname, resolve } from "path";
+import { LocalFileStateBackend, StateManager } from "@openagentpack/sdk";
+function createCliStateScope(configPath, projectName) {
+  const resolved = resolve(configPath);
+  return {
+    projectId: projectName ?? basename(dirname(resolved))
+  };
+}
+async function loadFileState(configPath, statePath, projectName) {
+  const resolved = resolve(configPath);
+  const backend = new LocalFileStateBackend({ configPath: resolved, statePath });
+  const path = backend.getStatePath(createCliStateScope(resolved, projectName));
+  return StateManager.load(path);
+}
+
+// src/config-loader.ts
+async function buildCliRuntime(filePath, options = {}) {
+  ensureCredentials();
+  const { config, configPath, projectName } = await resolveProjectConfig(filePath, options);
+  const state = await loadFileState(configPath, options.statePath, projectName);
+  const ctx = createProjectRuntime({
+    projectName,
+    config,
+    state,
+    configPath,
+    providers: config.providers
+  });
+  return { ...ctx, configPath };
+}
+function assertProviderConfigured(ctx, provider) {
+  if (!provider || provider === "all") return;
+  if (ctx.providers.has(provider)) return;
+  const available = Array.from(ctx.providers.keys()).join(", ") || "none";
+  throw new UserError(`Provider '${provider}' is not configured. Available providers: ${available}.`);
+}
+
+// src/logger.ts
+import chalk from "chalk";
+var PRIORITY = {
+  error: 0,
+  warn: 1,
+  success: 2,
+  info: 3,
+  debug: 4
+};
+var maxLevel = "info";
+function configureLogger(opts) {
+  if (opts.quiet) {
+    maxLevel = "error";
+  } else if ((opts.verbose ?? 0) >= 2) {
+    maxLevel = "debug";
+  } else if ((opts.verbose ?? 0) >= 1) {
+    maxLevel = "success";
+  } else {
+    maxLevel = "info";
+  }
+  if (opts.color === false || process.env.NO_COLOR) {
+    chalk.level = 0;
+  }
+}
+function shouldEmit(level) {
+  return PRIORITY[level] <= PRIORITY[maxLevel];
+}
+function emit(level, icon, msg) {
+  if (!shouldEmit(level)) return;
+  console.error(`${icon} ${msg}`);
+}
+var log = {
+  debug(msg) {
+    emit("debug", chalk.dim("\u2022"), msg);
+  },
+  info(msg) {
+    emit("info", chalk.blue("\u2139"), msg);
+  },
+  success(msg) {
+    emit("success", chalk.green("\u2713"), msg);
+  },
+  warn(msg) {
+    emit("warn", chalk.yellow("\u26A0"), msg);
+  },
+  error(msg) {
+    emit("error", chalk.red("\u2717"), msg);
+  },
+  adopt(msg) {
+    emit("info", chalk.cyan("\u27F3"), msg);
+  },
+  gone(msg) {
+    emit("warn", chalk.yellow("\u2298"), msg);
+  },
+  plain(msg = "") {
+    if (shouldEmit("info")) console.error(msg);
+  }
+};
+
+// src/plan-workflow.ts
+import * as p from "@clack/prompts";
+import { planProjectContext } from "@openagentpack/sdk";
+
+// src/render-feedback.ts
+function createRuntimeFeedbackBuffer() {
+  const events = [];
+  return {
+    onFeedback(event) {
+      events.push(event);
+    },
+    flush() {
+      for (const event of events.splice(0)) {
+        renderRuntimeFeedback(event);
+      }
+    }
+  };
+}
+function renderRuntimeFeedback(event) {
+  if (event.type === "resource_adopted") {
+    log.adopt(event.message);
+    return;
+  }
+  if (event.type === "resource_already_gone" || event.type === "refresh_resource_missing") {
+    log.gone(event.message);
+    return;
+  }
+  if (event.level === "success") {
+    log.success(event.message);
+    return;
+  }
+  if (event.level === "warning") {
+    log.warn(event.message);
+    return;
+  }
+  if (event.level === "error") {
+    log.error(event.message);
+    return;
+  }
+  log.info(event.message);
+}
+
+// src/plan-workflow.ts
+async function planProjectWithRefresh(ctx, options = {}) {
+  const resourceCount = ctx.state.listResources().length;
+  const showRefreshUx = options.refresh !== false && resourceCount > 0 && !options.quiet;
+  let spinner4;
+  if (showRefreshUx) {
+    spinner4 = p.spinner({ output: process.stderr });
+    spinner4.start("Refreshing state...");
+  } else if (options.refresh === false && !options.quiet) {
+    log.warn("Refresh disabled. Remote drift will not be checked.");
+  }
+  const feedbackBuffer = spinner4 ? createRuntimeFeedbackBuffer() : void 0;
+  const planned = await planProjectContext(ctx, {
+    provider: options.provider,
+    refresh: options.refresh,
+    quiet: !!options.quiet,
+    onFeedback: options.quiet ? void 0 : feedbackBuffer?.onFeedback ?? renderRuntimeFeedback
+  });
+  spinner4?.stop("State refreshed.");
+  feedbackBuffer?.flush();
+  return planned;
+}
+
+// src/render-diagnostics.ts
+import chalk2 from "chalk";
+function renderDiagnostics(diagnostics) {
+  if (diagnostics.length === 0) return;
+  console.log("\nDiagnostics:");
+  for (const d of diagnostics) {
+    const icon = d.severity === "error" ? "\u2717" : d.severity === "warning" ? "\u26A0" : "\u2139";
+    const color = d.severity === "error" ? chalk2.red : d.severity === "warning" ? chalk2.yellow : chalk2.blue;
+    console.log(color(`  ${icon} ${d.code}`));
+    if (d.resource) {
+      console.log(`    Resource: ${d.resource.type}.${d.resource.name} (${d.resource.provider})`);
+    }
+    console.log(`    ${d.message}`);
+  }
+  console.log();
+}
+function diagnosticsHaveErrors(diagnostics) {
+  return diagnostics.some((d) => d.severity === "error");
+}
+
+// src/utils/address-utils.ts
+function formatResourceAddress(address) {
+  return `${address.provider}.${address.type}.${address.name}`;
+}
+function formatResourceLabel(address) {
+  return `${address.type}.${address.name} (${address.provider})`;
+}
+
+// src/commands/apply.ts
+function classifyApplyPrompt(actions) {
+  if (actions.some((a) => a.driftKind === "both")) return "combined_drift";
+  if (actions.some((a) => a.driftKind === "remote")) return "remote_drift";
+  if (actions.some((a) => a.driftKind === "local")) return "local_change";
+  return "planned_change";
+}
+async function confirmDestroy(deletes) {
+  log.plain(chalk3.red.bold(`
+Resources will be destroyed.`));
+  log.plain(chalk3.red(`Applying will delete ${deletes.length} resource(s) listed above.`));
+  const shouldApply = await p2.confirm({
+    message: `Apply and destroy ${deletes.length} resource(s)?`,
+    output: process.stderr
+  });
+  return !p2.isCancel(shouldApply) && shouldApply;
+}
+async function confirmDrift(actions, file) {
+  const kind = classifyApplyPrompt(actions);
+  if (kind === "combined_drift" || kind === "remote_drift") {
+    const hasCombinedDrift = kind === "combined_drift";
+    log.plain();
+    if (hasCombinedDrift) {
+      log.plain(chalk3.yellow("Both local YAML and remote resource changed since the last apply."));
+      log.plain(
+        chalk3.yellow(
+          "Applying will update the remote resource to match the current YAML and may overwrite remote-only changes."
+        )
+      );
+    } else {
+      log.plain(chalk3.yellow("Remote-only changes were detected."));
+      log.plain(chalk3.yellow("Applying will overwrite the remote resource with the current YAML."));
+    }
+    const driftActions = actions.filter((a) => a.driftKind === "remote" || a.driftKind === "both");
+    const driftAction = driftActions.length === 1 ? driftActions[0] : void 0;
+    const inspectAddress = driftAction ? formatResourceAddress(driftAction.address) : "<address>";
+    log.plain(
+      chalk3.gray(
+        `OpenAgentPack will not pull remote changes into YAML automatically. To keep them, cancel and inspect with: agents state show ${inspectAddress} -f ${file}`
+      )
+    );
+    const choice = await p2.select({
+      message: hasCombinedDrift ? "How do you want to handle this conflict?" : "How do you want to handle this drift?",
+      output: process.stderr,
+      options: [
+        {
+          value: "apply",
+          label: hasCombinedDrift ? "Apply YAML to remote" : "Overwrite remote with YAML",
+          hint: hasCombinedDrift ? "YAML wins; remote-only changes may be overwritten" : "YAML wins"
+        },
+        {
+          value: "cancel",
+          label: "Cancel and keep remote unchanged",
+          hint: "Update YAML manually if you want to keep remote changes"
+        }
+      ]
+    });
+    return !p2.isCancel(choice) && choice === "apply";
+  }
+  const message = kind === "local_change" ? "Local YAML changes were detected. Apply YAML to remote?" : "Apply planned YAML changes to remote?";
+  const shouldApply = await p2.confirm({ message, output: process.stderr });
+  return !p2.isCancel(shouldApply) && shouldApply;
+}
+async function applyCommand(options) {
+  const ctx = await buildCliRuntime(options.file);
+  assertProviderConfigured(ctx, options.provider);
+  const planned = await planProjectWithRefresh(ctx, {
+    provider: options.provider,
+    refresh: options.refresh
+  });
+  const plan = planned.plan;
+  renderDiagnostics(plan.diagnostics);
+  if (diagnosticsHaveErrors(plan.diagnostics)) {
+    throw new UserError2("Cannot apply: resolve the errors above first.");
+  }
+  const actionable = plan.actions.filter((a) => a.action !== "no-op");
+  if (actionable.length === 0) {
+    log.success("No changes. Infrastructure is up-to-date.");
+    return;
+  }
+  const creates = actionable.filter((a) => a.action === "create");
+  const updates = actionable.filter((a) => a.action === "update");
+  const deletes = planned.destructiveActions;
+  console.log(
+    `
+${chalk3.green(`${creates.length} to create`)}, ${chalk3.yellow(`${updates.length} to update`)}, ${chalk3.red(`${deletes.length} to destroy`)}
+`
+  );
+  for (const a of actionable) {
+    const icon = a.action === "create" ? "+" : a.action === "update" ? "~" : "-";
+    const color = a.action === "create" ? chalk3.green : a.action === "update" ? chalk3.yellow : chalk3.red;
+    console.log(color(`  ${icon} ${formatResourceLabel(a.address)}`));
+    if (a.action === "update") {
+      console.log(color(`    ${a.reason}`));
+    }
+  }
+  if (options.refreshOnly) {
+    log.info("Refresh-only mode: no remote mutations will be performed.");
+    return;
+  }
+  if (deletes.length > 0) {
+    console.log(chalk3.red.bold(`
+  \u26A0 Resources to be DESTROYED:`));
+    for (const a of deletes) {
+      console.log(chalk3.red(`    - ${formatResourceLabel(a.address)}`));
+    }
+    console.log();
+  }
+  const destructiveDecision = await decideDestructive(deletes, {
+    policy: options.yes ? "force" : "prompt",
+    confirm: confirmDestroy
+  });
+  if (destructiveDecision !== "proceed") {
+    p2.cancel("Apply cancelled. No remote resources were changed.", {
+      output: process.stderr
+    });
+    return;
+  }
+  if (!options.yes && deletes.length === 0) {
+    const shouldApply = await confirmDrift(actionable, options.file);
+    if (!shouldApply) {
+      p2.cancel("Apply cancelled. No remote resources were changed.", {
+        output: process.stderr
+      });
+      return;
+    }
+  }
+  const s = p2.spinner({ output: process.stderr });
+  s.start("Applying changes...");
+  const result = await executePlannedProject(planned, {
+    onFeedback: renderRuntimeFeedback,
+    policy: "force",
+    concurrency: options.concurrency
+  });
+  const succeeded = result.results.filter((r) => r.status === "success").length;
+  const failed = result.results.filter((r) => r.status === "failed").length;
+  const skipped = result.results.filter((r) => r.status === "skipped").length;
+  s.stop("Apply finished.");
+  if (failed > 0) {
+    p2.log.warning(`${succeeded} succeeded, ${failed} failed, ${skipped} skipped.`, { output: process.stderr });
+    throw new UserError2("Apply failed.");
+  } else {
+    p2.log.success(`Apply complete! ${succeeded} actions executed successfully.`, { output: process.stderr });
+  }
+}
+
+// src/commands/deployment.ts
+import {
+  getDeploymentDetailsForContext,
+  getDeploymentRuntimeProviderForContext,
+  listDeploymentsForContext,
+  runDeploymentForContext,
+  UserError as UserError3
+} from "@openagentpack/sdk";
+import chalk5 from "chalk";
+
+// src/render-table.ts
+import chalk4 from "chalk";
+var DEFAULT_INDENT = "  ";
+function columnWidth(lengths, min = 4, padding = 2) {
+  if (lengths.length === 0) return min + padding;
+  return Math.max(min, ...lengths) + padding;
+}
+function printTableTitle(title, count) {
+  console.log(`
+${chalk4.bold(title)} (${count}):
+`);
+}
+function printTableHeader(headers, separatorWidth, indent = DEFAULT_INDENT) {
+  console.log(chalk4.gray(`${indent}${headers.join(" ")}`));
+  console.log(chalk4.gray(`${indent}${"\u2500".repeat(separatorWidth)}`));
+}
+function printTableRow(cells, indent = DEFAULT_INDENT) {
+  console.log(`${indent}${cells.join(" ")}`);
+}
+function printTableFooter() {
+  console.log();
+}
+
+// src/commands/deployment.ts
+async function deploymentListCommand(options) {
+  const ctx = await buildCliRuntime(options.file);
+  const rows = listDeploymentsForContext(ctx, options.provider);
+  if (rows.length === 0) {
+    log.info("No deployments in state. Run `agents apply` first.");
+    return;
+  }
+  const nameWidth = columnWidth(rows.map((r) => r.name.length));
+  printTableTitle("Deployments", rows.length);
+  printTableHeader(
+    ["Name".padEnd(nameWidth), "Provider".padEnd(10), "Remote ID".padEnd(28), "Schedule".padEnd(18), "Agent"],
+    nameWidth + 70
+  );
+  for (const r of rows) {
+    const nameCell = chalk5.bold(r.name.padEnd(nameWidth));
+    const provCell = chalk5.cyan(r.provider.padEnd(10));
+    const idCell = r.remoteId ? r.remoteId.slice(0, 26).padEnd(28) : chalk5.dim("(emulated)".padEnd(28));
+    const schedCell = r.scheduleExpression.padEnd(18);
+    printTableRow([nameCell, provCell, idCell, schedCell, r.agent]);
+  }
+  printTableFooter();
+}
+async function deploymentGetCommand(name, options) {
+  const ctx = await buildCliRuntime(options.file);
+  const { bindings, provider, info } = await getDeploymentDetailsForContext(ctx, name, void 0, options.provider);
+  console.log(`  Name:        ${chalk5.bold(name)}`);
+  console.log(`  Provider:    ${provider}`);
+  console.log(`  Remote ID:   ${info.id ?? chalk5.dim("(emulated / local)")}`);
+  console.log(`  Status:      ${info.status}`);
+  if (info.paused_reason) {
+    const pr = info.paused_reason;
+    const detail = pr.error?.type ? `${pr.type} (${pr.error.type})` : pr.type;
+    console.log(`  Paused:      ${detail}`);
+  }
+  if (info.schedule) {
+    const tz = info.schedule.timezone ? ` (${info.schedule.timezone})` : "";
+    console.log(`  Schedule:    ${info.schedule.expression}${tz}`);
+  }
+  console.log(`  Agent:       ${bindings.agentId}`);
+  console.log(`  Environment: ${bindings.environmentId}`);
+  if (bindings.vaultIds.length) console.log(`  Vaults:      ${bindings.vaultIds.join(", ")}`);
+  if (bindings.memoryStoreIds.length) console.log(`  Memory:      ${bindings.memoryStoreIds.join(", ")}`);
+}
+async function deploymentRunCommand(name, options) {
+  const ctx = await buildCliRuntime(options.file);
+  const provider = getDeploymentRuntimeProviderForContext(ctx, name, options.provider);
+  log.info(`Running deployment '${name}' on ${provider}...`);
+  const { result } = await runDeploymentForContext(ctx, name, void 0, options.provider);
+  if (result.error) {
+    if (result.run_id) console.log(`  Run ID:     ${result.run_id}`);
+    throw new UserError3(`Deployment run failed: ${result.error.type} - ${result.error.message}`);
+  }
+  log.success(`Deployment '${name}' run started.`);
+  if (result.run_id) console.log(`  Run ID:     ${chalk5.bold(result.run_id)}`);
+  console.log(`  Session ID: ${result.session_id ? chalk5.bold(result.session_id) : chalk5.dim("(pending)")}`);
+}
+
+// src/commands/destroy.ts
+import * as p3 from "@clack/prompts";
+import {
+  destroyPlannedProjectResources,
+  planDestroyProjectContext
+} from "@openagentpack/sdk";
+import chalk6 from "chalk";
+async function destroyCommand(options) {
+  const ctx = await buildCliRuntime(options.file);
+  const planned = planDestroyProjectContext(ctx);
+  const resources = planned.resources;
+  if (resources.length === 0) {
+    log.info("No resources in state. Nothing to destroy.");
+    return;
+  }
+  console.log(chalk6.red(`
+Destroy ${resources.length} resource(s):
+`));
+  for (const r of resources) {
+    console.log(chalk6.red(`  - ${formatResourceLabel(r.address)} [${r.remote_id}]`));
+  }
+  if (!options.yes) {
+    const shouldDestroy = await p3.confirm({
+      message: "Are you sure you want to destroy ALL resources?",
+      output: process.stderr
+    });
+    if (p3.isCancel(shouldDestroy) || !shouldDestroy) {
+      p3.cancel("Destroy cancelled.", { output: process.stderr });
+      return;
+    }
+  }
+  let activeSpinner;
+  const result = await destroyPlannedProjectResources(planned, {
+    cascade: options.cascade,
+    onResourceStart: (resource) => {
+      activeSpinner = p3.spinner({ output: process.stderr });
+      activeSpinner.start(`Destroying ${formatResourceLabel(resource.address)}`);
+    },
+    onCascadeRequired: async (blocked) => {
+      activeSpinner?.stop(
+        chalk6.yellow(`\u26A0 ${formatResourceLabel(blocked.resource.address)} \u2014 ${blocked.error ?? "cascade required"}`)
+      );
+      activeSpinner = void 0;
+      if (options.yes) {
+        log.info(`Hint: ${chalk6.bold(`agents destroy -f ${options.file} --cascade`)}`);
+        return false;
+      }
+      const cascadeConfirm = await p3.confirm({
+        message: "Delete associated sessions and retry?",
+        output: process.stderr
+      });
+      if (p3.isCancel(cascadeConfirm) || !cascadeConfirm) return false;
+      activeSpinner = p3.spinner({ output: process.stderr });
+      activeSpinner.start(`Destroying ${formatResourceLabel(blocked.resource.address)} with cascade`);
+      return true;
+    },
+    onResourceResult: (item) => {
+      stopResourceSpinner(activeSpinner, item);
+      activeSpinner = void 0;
+    }
+  });
+  const summary = result.destroyed === result.resources.length ? chalk6.green(`Destroy complete. ${result.destroyed}/${result.resources.length} resources removed.`) : chalk6.yellow(`Destroy complete. ${result.destroyed}/${result.resources.length} resources removed.`);
+  p3.outro(summary, { output: process.stderr });
+}
+function stopResourceSpinner(spinner4, result) {
+  const label = formatResourceLabel(result.resource.address);
+  if (!spinner4) {
+    if (result.reason === "provider_missing") {
+      log.warn(result.error ?? `No provider for '${result.resource.address.provider}', skipping ${label}`);
+    }
+    return;
+  }
+  if (result.status === "success") {
+    if (result.reason === "reference_removed") {
+      spinner4.stop(chalk6.green(`\u2713 ${label} \u2014 local reference removed (remote left intact)`));
+    } else if (result.reason === "already_gone") {
+      spinner4.stop(chalk6.yellow(`\u2298 ${label} \u2014 already deleted remotely, cleaned up state`));
+    } else if (result.cascaded) {
+      spinner4.stop(chalk6.green(`\u2713 ${label} \u2014 destroyed (cascaded)`));
+    } else {
+      spinner4.stop(chalk6.green(`\u2713 ${label} \u2014 destroyed`));
+    }
+    return;
+  }
+  if (result.reason === "provider_missing") {
+    spinner4.stop(
+      chalk6.yellow(result.error ?? `No provider for '${result.resource.address.provider}', skipping ${label}`)
+    );
+    return;
+  }
+  if (result.status === "blocked") {
+    spinner4.stop(chalk6.yellow(`\u26A0 ${label} \u2014 ${result.error ?? "blocked"}`));
+    return;
+  }
+  spinner4.stop(chalk6.red(`\u2717 ${label} \u2014 ${result.error ?? "unknown error"}`));
+}
+
+// src/commands/init.ts
+import { readFile, writeFile } from "fs/promises";
+import * as p4 from "@clack/prompts";
+
+// src/utils/file-utils.ts
+import { existsSync } from "fs";
+import { access } from "fs/promises";
+function fileExistsSync(path) {
+  return existsSync(path);
+}
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/init.ts
+var GITIGNORE_ADDITIONS = `
+# agents
+agents.state.json
+.env
+`;
+function buildTemplate(opts) {
+  const providers = {
+    bailian: `  bailian:
+    api_key: \${DASHSCOPE_API_KEY}
+    workspace_id: \${BAILIAN_WORKSPACE_ID}`,
+    claude: `  claude:
+    api_key: \${ANTHROPIC_API_KEY}`,
+    qoder: `  qoder:
+    api_key: \${QODER_PAT}
+    gateway: "https://api.qoder.com/api/v1/cloud"`,
+    ark: `  ark:
+    api_key: \${ARK_API_KEY}`
+  };
+  let providerBlock;
+  if (opts.provider === "all") {
+    providerBlock = `${providers.bailian}
+${providers.claude}
+${providers.qoder}
+${providers.ark}`;
+  } else {
+    providerBlock = providers[opts.provider];
+  }
+  const singleModel = {
+    bailian: `    model: qwen3.7-max`,
+    claude: `    model: claude-sonnet-4-6`,
+    qoder: `    model: ultimate`,
+    ark: `    model: doubao-seed-2-1-pro-260628`
+  };
+  const modelBlock = opts.provider === "all" ? `    model:
+      bailian: qwen3.7-max
+      claude: claude-sonnet-4-6
+      qoder: ultimate
+      ark: doubao-seed-2-1-pro-260628` : singleModel[opts.provider];
+  const toolBlock = opts.provider === "bailian" ? "[bash, read, glob, grep]" : "[read, glob, grep, web_search, web_fetch]";
+  return `version: "1"
+
+providers:
+${providerBlock}
+
+defaults:
+  provider: ${opts.provider === "all" ? "all" : opts.provider}
+
+environments:
+  dev:
+    config:
+      type: cloud
+      networking:
+        type: unrestricted
+
+agents:
+  ${opts.agentName}:
+    description: "General-purpose assistant"
+${modelBlock}
+    instructions: |
+      You are a helpful assistant.
+    environment: dev
+    tools:
+      builtin: ${toolBlock}
+`;
+}
+async function initCommand() {
+  const configPath = "agents.yaml";
+  if (await fileExists(configPath)) {
+    log.warn(`${configPath} already exists, skipping.`);
+    return;
+  }
+  p4.intro("agents init", { output: process.stderr });
+  const answers = await p4.group(
+    {
+      provider: () => p4.select({
+        message: "Which provider(s) do you want to use?",
+        options: [
+          { value: "bailian", label: "Bailian (\u963F\u91CC\u4E91\u767E\u70BC)" },
+          { value: "claude", label: "Claude" },
+          { value: "qoder", label: "Qoder" },
+          { value: "ark", label: "Ark\uFF08\u706B\u5C71\u65B9\u821F\uFF09" },
+          { value: "all", label: "All providers" }
+        ],
+        output: process.stderr
+      }),
+      agentName: () => p4.text({
+        message: "Name your first agent:",
+        placeholder: "assistant",
+        defaultValue: "assistant",
+        output: process.stderr
+      })
+    },
+    {
+      onCancel: () => {
+        p4.cancel("Init cancelled.", { output: process.stderr });
+        process.exit(0);
+      }
+    }
+  );
+  const template = buildTemplate({
+    provider: answers.provider,
+    agentName: answers.agentName
+  });
+  await writeFile(configPath, template, "utf8");
+  p4.log.success(`Created ${configPath}`, { output: process.stderr });
+  const gitignorePath = ".gitignore";
+  if (await fileExists(gitignorePath)) {
+    const content = await readFile(gitignorePath, "utf8");
+    if (!content.includes("agents.state.json")) {
+      await writeFile(gitignorePath, content + GITIGNORE_ADDITIONS, "utf8");
+      p4.log.success("Updated .gitignore", { output: process.stderr });
+    }
+  } else {
+    await writeFile(gitignorePath, `${GITIGNORE_ADDITIONS.trim()}
+`, "utf8");
+    p4.log.success("Created .gitignore", { output: process.stderr });
+  }
+  p4.outro("Done! Next: edit agents.yaml, then run agents plan", {
+    output: process.stderr
+  });
+}
+
+// src/commands/migrate.ts
+import { writeFile as writeFile2 } from "fs/promises";
+import { migrateConfig, UserError as UserError4 } from "@openagentpack/sdk";
+async function migrateCommand(options) {
+  const fromPath = options.from ?? "agents.synced.yaml";
+  const toPath = options.to ?? "agents.yaml";
+  const toExists = await fileExists(toPath);
+  if (!toExists) {
+    throw new UserError4(
+      `Target file '${toPath}' not found. Create a agents.yaml first (e.g. \`agents init\`), then run migrate.`
+    );
+  }
+  const result = await migrateConfig({ fromPath, toPath });
+  await writeFile2(toPath, result.yaml, "utf8");
+  const addedParts = [];
+  for (const [group2, count] of Object.entries(result.added)) {
+    addedParts.push(`${count} ${group2}`);
+  }
+  const skippedParts = [];
+  for (const [group2, count] of Object.entries(result.skipped)) {
+    skippedParts.push(`${count} ${group2}`);
+  }
+  if (addedParts.length) {
+    log.success(`Migrated ${addedParts.join(", ")} into ${toPath}.`);
+  } else {
+    log.info("No new resources to migrate (all already exist in target).");
+  }
+  if (skippedParts.length) {
+    log.info(`Skipped (already exist): ${skippedParts.join(", ")}.`);
+  }
+}
+
+// src/commands/models.ts
+import { listProviderModelsForContext } from "@openagentpack/sdk";
+import chalk7 from "chalk";
+async function modelsListCommand(options) {
+  const ctx = await buildCliRuntime(options.file);
+  const listings = await listProviderModelsForContext(ctx.providers, options.provider);
+  for (const listing of listings) {
+    const name = listing.provider;
+    if (!listing.supportsDynamicListing) {
+      if (options.json) {
+        process.stdout.write(
+          `${JSON.stringify({ provider: name, supportsDynamicListing: false, models: [] }, null, 2)}
+`
+        );
+      } else {
+        console.log(chalk7.yellow(`
+  Provider '${name}' does not support dynamic model listing.`));
+        if (name === "claude") {
+          console.log(chalk7.dim(`  Claude models are specified directly (e.g. claude-sonnet-4-6, claude-opus-4-6).`));
+          console.log(chalk7.dim(`  See: https://docs.anthropic.com/en/docs/about-claude/models
+`));
+        } else if (name === "bailian") {
+          console.log(chalk7.dim(`  Bailian models are specified directly (e.g. qwen-max, qwen-plus).`));
+          console.log(chalk7.dim(`  See: https://help.aliyun.com/zh/model-studio/getting-started/models
+`));
+        } else if (name === "ark") {
+          console.log(chalk7.dim(`  Ark models are specified directly (e.g. doubao-seed-2-1-pro-260628).`));
+          console.log(chalk7.dim(`  See: https://www.volcengine.com/docs/82379
+`));
+        } else {
+          console.log(chalk7.dim(`  Refer to the provider's documentation for available model identifiers.
+`));
+        }
+      }
+      continue;
+    }
+    const models = listing.models;
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify({ provider: name, models }, null, 2)}
+`);
+      continue;
+    }
+    console.log(chalk7.bold(`
+Available models (${name}):
+`));
+    const colId = columnWidth(
+      models.map((m) => m.id.length),
+      4
+    );
+    const colName = columnWidth(
+      models.map((m) => m.display_name.length),
+      12
+    );
+    const colPrice = 7;
+    const colEfforts = columnWidth(
+      models.map((m) => formatEfforts(m.efforts).length),
+      7
+    );
+    printTableHeader(
+      ["ID".padEnd(colId), "Name".padEnd(colName), "Price".padEnd(colPrice), "Efforts".padEnd(colEfforts), "Default"],
+      colId + colName + colPrice + colEfforts + 7 + 4
+    );
+    for (const m of models) {
+      const id = m.id.padEnd(colId);
+      const displayName = m.display_name.padEnd(colName);
+      const price = formatPrice(m.price_factor).padEnd(colPrice);
+      const efforts = formatEfforts(m.efforts).padEnd(colEfforts);
+      const defaultEffort = m.default_effort ?? "\u2014";
+      const isNew = m.is_new ? chalk7.green(" NEW") : "";
+      printTableRow([id, displayName, price, efforts, `${defaultEffort}${isNew}`]);
+    }
+    console.log(chalk7.dim(`
+  Use ${chalk7.reset("model: <ID>")} in your agents.yaml agent configuration.`));
+    console.log(chalk7.dim(`  Use ${chalk7.reset("model: { id: <ID>, effort: <EFFORT> }")} for effort control.
+`));
+  }
+}
+var EFFORT_ORDER = ["none", "low", "medium", "high", "xhigh", "max"];
+function formatEfforts(efforts) {
+  if (!efforts?.length) return "\u2014";
+  return [...efforts].sort((a, b) => EFFORT_ORDER.indexOf(a) - EFFORT_ORDER.indexOf(b)).join(", ");
+}
+function formatPrice(factor) {
+  if (factor === void 0) return "\u2014";
+  if (factor === 0) return "free";
+  return `\xD7${factor}`;
+}
+
+// src/commands/plan.ts
+import { UserError as UserError6 } from "@openagentpack/sdk";
+import chalk8 from "chalk";
+
+// src/runtime.ts
+import { listProviderNames, UserError as UserError5 } from "@openagentpack/sdk";
+import { Command, InvalidArgumentError, Option } from "commander";
+var DEFAULT_CONFIG_FILE = "agents.yaml";
+function isExplicitSource(source) {
+  return source !== void 0 && source !== "default";
+}
+function rootCommand(command) {
+  let current = command;
+  while (current.parent) current = current.parent;
+  return current;
+}
+function configFileArgs(args = process.argv.slice(2)) {
+  const values = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg) continue;
+    if (arg === "--") break;
+    if (arg === "-f" || arg === "--file") {
+      const value = args[i + 1];
+      if (value) {
+        values.push(value);
+        i += 1;
+        continue;
+      }
+    }
+    if (arg.startsWith("--file=")) {
+      values.push(arg.slice("--file=".length));
+      continue;
+    }
+    if (arg.startsWith("-f") && arg.length > 2) {
+      values.push(arg.slice(2));
+    }
+  }
+  return values;
+}
+function configFileOption() {
+  return new Option("-f, --file <path>", "Config file path");
+}
+function resolveConfigFile(command) {
+  const explicitFiles = [...new Set(configFileArgs())];
+  if (explicitFiles.length > 1) {
+    throw new UserError5(
+      `Conflicting config files supplied: ${explicitFiles.join(" and ")}. Use only one --file value.`
+    );
+  }
+  const root = rootCommand(command);
+  const rootFile = root.getOptionValue("file");
+  const rootSource = root.getOptionValueSource("file");
+  const localFile = command.getOptionValue("file");
+  const localSource = command.getOptionValueSource("file");
+  if (isExplicitSource(rootSource) && isExplicitSource(localSource) && rootFile && localFile && rootFile !== localFile) {
+    throw new UserError5(`Conflicting config files supplied: ${rootFile} and ${localFile}. Use only one --file value.`);
+  }
+  if (isExplicitSource(localSource) && localFile) return localFile;
+  if (rootFile) return rootFile;
+  return DEFAULT_CONFIG_FILE;
+}
+function withResolvedConfigFile(handler) {
+  return async (...args) => {
+    const command = args[args.length - 1];
+    if (!(command instanceof Command)) {
+      await handler(...args);
+      return;
+    }
+    const handlerArgs = args.slice(0, -1);
+    const options = handlerArgs[handlerArgs.length - 1];
+    if (options && typeof options === "object") {
+      options.file = resolveConfigFile(command);
+    }
+    await handler(...handlerArgs);
+  };
+}
+function registeredProviderNames() {
+  return listProviderNames();
+}
+function providerOption(description, opts = {}) {
+  const choices = opts.allowAll ? ["all", ...registeredProviderNames()] : registeredProviderNames();
+  const option = new Option("--provider <name>", description).choices(choices);
+  if (opts.defaultValue !== void 0) option.default(opts.defaultValue);
+  return option;
+}
+function parsePositiveInteger(value) {
+  if (!/^\d+$/.test(value)) {
+    throw new InvalidArgumentError("must be a positive integer");
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+    throw new InvalidArgumentError("must be a positive integer");
+  }
+  return parsed;
+}
+function parseBooleanOption(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  throw new InvalidArgumentError("must be true or false");
+}
+function writeJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+function writeJsonLine(value) {
+  process.stdout.write(`${JSON.stringify(value)}
+`);
+}
+
+// src/commands/plan.ts
+async function planCommand(options) {
+  const ctx = await buildCliRuntime(options.file);
+  assertProviderConfigured(ctx, options.provider);
+  const { plan } = await planProjectWithRefresh(ctx, {
+    provider: options.provider,
+    refresh: options.refresh,
+    quiet: !!options.json
+  });
+  if (options.json) {
+    writeJson(plan);
+    if (plan.diagnostics.some((d) => d.severity === "error")) {
+      throw new UserError6("Plan contains errors.");
+    }
+    return;
+  }
+  renderDiagnostics(plan.diagnostics);
+  if (diagnosticsHaveErrors(plan.diagnostics)) {
+    throw new UserError6("Plan contains errors.");
+  }
+  const creates = plan.actions.filter((a) => a.action === "create");
+  const updates = plan.actions.filter((a) => a.action === "update");
+  const deletes = plan.actions.filter((a) => a.action === "delete");
+  const driftByAddress = /* @__PURE__ */ new Map();
+  for (const r of ctx.state.listResources()) {
+    driftByAddress.set(formatResourceAddress(r.address), r.drift_status);
+  }
+  const unverified = plan.actions.filter(
+    (a) => a.action === "no-op" && driftByAddress.get(formatResourceAddress(a.address)) === "unchecked"
+  );
+  const hasChanges = creates.length > 0 || updates.length > 0 || deletes.length > 0;
+  if (!hasChanges && unverified.length === 0) {
+    log.success("No changes. Infrastructure is up-to-date.");
+    return;
+  }
+  if (hasChanges) {
+    console.log("\nPlanned actions:\n");
+    for (const a of creates) {
+      console.log(chalk8.green(`  + ${formatResourceLabel(a.address)}`));
+    }
+    for (const a of updates) {
+      console.log(chalk8.yellow(`  ~ ${formatResourceLabel(a.address)}`));
+      console.log(chalk8.yellow(`    ${a.reason}`));
+    }
+    for (const a of deletes) {
+      console.log(chalk8.red(`  - ${formatResourceLabel(a.address)}`));
+    }
+  } else {
+    console.log("\nNo changes to apply.");
+  }
+  if (unverified.length > 0) {
+    console.log(chalk8.blue("\nUnverified (provider can't compare content):"));
+    for (const a of unverified) {
+      console.log(
+        chalk8.blue(`  ! ${formatResourceLabel(a.address)}`) + chalk8.dim(" \u2014 exists remotely; drift undetectable")
+      );
+    }
+  }
+  if (hasChanges) {
+    console.log(
+      `
+Plan: ${chalk8.green(`${creates.length} to create`)}, ${chalk8.yellow(`${updates.length} to update`)}, ${chalk8.red(`${deletes.length} to destroy`)}.`
+    );
+  }
+  if (options.refreshOnly) {
+    console.log(chalk8.blue("Refresh-only mode: no remote mutations will be performed."));
+  }
+}
+
+// src/commands/playground.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import { AGENTS_CONFIG_PROVIDERS } from "@openagentpack/sdk";
+var CLI_PKG = "@openagentpack/cli";
+var PLAYGROUND_PKG = "@openagentpack/playground";
+var DEFAULT_PORT = 4848;
+var PLAYGROUND_URL_RE = /running at http:\/\/localhost:(\d+)/;
+var SUPPORTED_PLAYGROUND_PROVIDERS = new Set(AGENTS_CONFIG_PROVIDERS);
+function cliVersion() {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  const candidates = [
+    resolve2(here, "../package.json"),
+    // bundled dist/chunk-*.js -> package root
+    resolve2(here, "../../package.json")
+    // source src/commands/*.ts -> package root
+  ];
+  for (const pkgPath of candidates) {
+    if (!existsSync2(pkgPath)) continue;
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    if (pkg.name === CLI_PKG && pkg.version) return pkg.version;
+  }
+  throw new Error(`Unable to determine ${CLI_PKG} version for launching ${PLAYGROUND_PKG}.`);
+}
+function findLocalPlaygroundBin(startDir) {
+  let dir = startDir;
+  for (let depth = 0; depth < 10; depth++) {
+    const candidate = resolve2(dir, "packages/playground/dist/bin/playground.js");
+    if (existsSync2(candidate)) return candidate;
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+function resolveLauncher(version) {
+  const explicit = process.env.AGENTS_PLAYGROUND_BIN?.trim();
+  if (explicit && existsSync2(explicit)) return { cmd: process.execPath, args: [explicit] };
+  try {
+    const require2 = createRequire(import.meta.url);
+    const pkgJsonPath = require2.resolve(`${PLAYGROUND_PKG}/package.json`);
+    const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+    const binRel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.["agents-playground"];
+    if (binRel) {
+      const binPath = resolve2(dirname2(pkgJsonPath), binRel);
+      if (existsSync2(binPath)) return { cmd: process.execPath, args: [binPath] };
+    }
+  } catch {
+  }
+  const monorepoBin = findLocalPlaygroundBin(process.cwd());
+  if (monorepoBin) return { cmd: process.execPath, args: [monorepoBin] };
+  return { cmd: "npx", args: ["-y", `${PLAYGROUND_PKG}@${version}`] };
+}
+function watchPlaygroundPort(stdout, onPort) {
+  let buffer = "";
+  stdout.on("data", (chunk) => {
+    process.stdout.write(chunk);
+    buffer += chunk.toString();
+    const match = buffer.match(PLAYGROUND_URL_RE);
+    if (!match) return;
+    onPort(Number(match[1]));
+  });
+}
+async function waitForPlaygroundReady(child, fallbackPort, timeoutMs) {
+  let port = fallbackPort;
+  let settled = false;
+  return new Promise((resolve6) => {
+    const deadline = Date.now() + timeoutMs;
+    if (child.stdout) {
+      watchPlaygroundPort(child.stdout, (nextPort) => {
+        port = nextPort;
+      });
+    }
+    const poll = async () => {
+      if (settled) return;
+      if (Date.now() > deadline) {
+        settled = true;
+        resolve6(null);
+        return;
+      }
+      try {
+        const res = await fetch(`http://localhost:${port}/health`);
+        if (res.ok) {
+          settled = true;
+          resolve6(port);
+          return;
+        }
+      } catch {
+      }
+      setTimeout(poll, 300);
+    };
+    void poll();
+  });
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  const args = process.platform === "win32" ? ["", url] : [url];
+  try {
+    spawn(cmd, args, { stdio: "ignore", detached: true, shell: process.platform === "win32" }).unref();
+  } catch {
+    log.warn(`Could not open a browser automatically \u2014 visit ${url}`);
+  }
+}
+async function playgroundCommand(options) {
+  const port = options.port ? Number(options.port) : DEFAULT_PORT;
+  if (!Number.isInteger(port) || port <= 0) {
+    throw new Error(`Invalid --port '${options.port}'`);
+  }
+  if (options.provider && !SUPPORTED_PLAYGROUND_PROVIDERS.has(options.provider)) {
+    const supported = [...SUPPORTED_PLAYGROUND_PROVIDERS].join(", ");
+    throw new Error(`Playground supports providers: ${supported}; received '${options.provider}'.`);
+  }
+  const env = { ...process.env, PORT: String(port) };
+  if (options.provider) {
+    env.AGENTS_PROVIDER = options.provider;
+    env.AGENTS_CLI_PROVIDER = options.provider;
+  }
+  const { cmd, args } = resolveLauncher(cliVersion());
+  if (cmd === "npx") log.info(`Fetching ${PLAYGROUND_PKG} (first run may take a moment)...`);
+  const child = spawn(cmd, args, { env, stdio: ["inherit", "pipe", "inherit"] });
+  const forward = (signal) => child.kill(signal);
+  process.on("SIGINT", () => forward("SIGINT"));
+  process.on("SIGTERM", () => forward("SIGTERM"));
+  child.on("exit", (code) => process.exit(code ?? 0));
+  child.on("error", (err) => {
+    log.error(`Failed to start playground: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  });
+  const readyPort = await waitForPlaygroundReady(child, port, 3e4);
+  if (readyPort === null) {
+    log.warn(`Playground did not become ready in time \u2014 check the logs above, then open http://localhost:${port}`);
+    return;
+  }
+  const url = `http://localhost:${readyPort}`;
+  log.success(`Playground ready at ${url}`);
+  if (options.open !== false) openBrowser(url);
+}
+
+// src/commands/session.ts
+import {
+  createSessionForAgent,
+  deleteSession,
+  getSession,
+  isTerminalSessionStatus,
+  listSessionEvents,
+  listSessionSummaries,
+  sendSessionMessagePolling,
+  sendSessionMessageStreaming,
+  startSessionRun,
+  startSessionRunPolling,
+  UserError as UserError7
+} from "@openagentpack/sdk";
+import { sanitizeSessionEvent, sanitizeSessionEvents } from "@openagentpack/sdk/session-events";
+import chalk9 from "chalk";
+
+// src/utils/pagination.ts
+async function fetchAllPages(fetchPage, all) {
+  const first = await fetchPage();
+  const items = [...first.items];
+  let hasMore = first.hasMore;
+  let nextPage = first.nextPage;
+  while (all && nextPage) {
+    const next = await fetchPage(nextPage);
+    items.push(...next.items);
+    hasMore = next.hasMore;
+    nextPage = next.nextPage;
+  }
+  return { items, hasMore, nextPage };
+}
+
+// src/commands/session.ts
+function formatTimestamp(iso) {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return iso;
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function formatDuration(startIso, endIso) {
+  const start = new Date(startIso).getTime();
+  const end = endIso ? new Date(endIso).getTime() : Date.now();
+  if (Number.isNaN(start)) return "-";
+  const sec = Math.max(0, Math.floor((end - start) / 1e3));
+  if (sec < 60) return `${sec}s`;
+  if (sec < 3600) return `${Math.floor(sec / 60)}m${sec % 60}s`;
+  const h = Math.floor(sec / 3600);
+  const m = Math.floor(sec % 3600 / 60);
+  return `${h}h${m}m`;
+}
+async function sessionCreateCommand(agentNameOrOptions, maybeOptions) {
+  const options = maybeOptions ?? agentNameOrOptions;
+  const positionalAgent = typeof agentNameOrOptions === "string" ? agentNameOrOptions : void 0;
+  if (positionalAgent && options.agent && positionalAgent !== options.agent) {
+    throw new UserError7("Specify agent either positionally or with --agent, not both.");
+  }
+  const ctx = await buildCliRuntime(options.file);
+  const run = await createSessionForAgent(ctx, {
+    agent: positionalAgent ?? options.agent,
+    identityId: options.identityId,
+    provider: options.provider,
+    environment: options.environment,
+    environmentId: options.environmentId,
+    tunnel: options.tunnel,
+    tunnelId: options.tunnelId,
+    vault: options.vault,
+    memoryStores: parseMemoryStores(options.memoryStores),
+    title: options.title
+  });
+  const { agentName, session } = run;
+  log.success(`Session created: ${chalk9.bold(session.id)}`);
+  console.log(`  Agent:       ${agentName}`);
+  console.log(`  Environment: ${session.environment_id}`);
+  if (session.tunnel_id) console.log(`  Tunnel:      ${session.tunnel_id}`);
+  console.log(`  Status:      ${session.status}`);
+  if (session.vault_ids.length) console.log(`  Vaults:      ${session.vault_ids.join(", ")}`);
+  if (session.memory_store_ids.length) console.log(`  Memory:      ${session.memory_store_ids.join(", ")}`);
+}
+async function sessionListCommand(options) {
+  const ctx = await buildCliRuntime(options.file);
+  const { items: summaries, hasMore } = await fetchAllPages(async (page) => {
+    const result = page ? await listSessionSummaries(ctx, {
+      agent: options.agent,
+      provider: options.provider,
+      filter: { page }
+    }) : await listSessionSummaries(ctx, {
+      agent: options.agent,
+      provider: options.provider
+    });
+    return { items: result.summaries, hasMore: result.hasMore, nextPage: result.nextPage };
+  }, options.all);
+  const sessions = summaries.map((summary) => summary.session);
+  if (sessions.length === 0) {
+    log.info("No sessions found.");
+    return;
+  }
+  const agentNameMap = new Map(
+    summaries.filter((summary) => summary.agentName).map((summary) => [summary.session.id, summary.agentName])
+  );
+  const idWidth = columnWidth(sessions.map((s) => s.id.length));
+  printTableTitle("Sessions", sessions.length);
+  printTableHeader(
+    [
+      "ID".padEnd(idWidth),
+      "Title".padEnd(20),
+      "Agent".padEnd(14),
+      "Status".padEnd(12),
+      "Created".padEnd(20),
+      "Duration"
+    ],
+    idWidth + 80
+  );
+  for (const s of sessions) {
+    const id = s.id.padEnd(idWidth);
+    const title = (s.title ?? "").slice(0, 18).padEnd(20);
+    const agent = (agentNameMap.get(s.id) ?? s.agent_id.slice(0, 12)).padEnd(14);
+    const statusText = s.status.padEnd(12);
+    const status = s.status === "idle" ? chalk9.green(statusText) : s.status === "processing" ? chalk9.yellow(statusText) : s.status === "failed" ? chalk9.red(statusText) : chalk9.gray(statusText);
+    const created = formatTimestamp(s.created_at).padEnd(20);
+    const duration = formatDuration(s.created_at, s.status === "idle" ? s.updated_at : void 0);
+    printTableRow([chalk9.bold(id), title, chalk9.cyan(agent), status, chalk9.dim(created), duration]);
+  }
+  printTableFooter();
+  if (hasMore) {
+    log.info("More sessions available. Use --all to fetch all.");
+  }
+}
+async function sessionGetCommand(sessionId, options) {
+  const ctx = await buildCliRuntime(options.file);
+  const session = await getSession(ctx, sessionId, options.provider);
+  console.log(`  ID:          ${chalk9.bold(session.id)}`);
+  console.log(`  Agent:       ${session.agent_id}`);
+  console.log(`  Environment: ${session.environment_id}`);
+  if (session.tunnel_id) console.log(`  Tunnel:      ${session.tunnel_id}`);
+  console.log(`  Status:      ${session.status}`);
+  if (session.title) console.log(`  Title:       ${session.title}`);
+  if (session.vault_ids.length) console.log(`  Vaults:      ${session.vault_ids.join(", ")}`);
+  if (session.memory_store_ids.length) console.log(`  Memory:      ${session.memory_store_ids.join(", ")}`);
+  console.log(`  Created:     ${session.created_at}`);
+  console.log(`  Updated:     ${session.updated_at}`);
+}
+async function sessionDeleteCommand(sessionId, options) {
+  const ctx = await buildCliRuntime(options.file);
+  await deleteSession(ctx, sessionId, options.provider);
+  log.success(`Session ${sessionId} deleted.`);
+}
+function shouldRenderLiveEvent(event) {
+  return event.type !== "thinking" && !(event.type === "message" && event.role === "user");
+}
+function renderTerminalStatus(status, json) {
+  if (json) return;
+  const color = status === "idle" || status === "completed" ? chalk9.green : chalk9.red;
+  log.plain(color(`
+[session ${status}]`));
+}
+function toEventListJson(events, hasMore, nextPage) {
+  const out = { events: sanitizeSessionEvents(events), has_more: hasMore };
+  if (nextPage !== void 0) out.next_page = nextPage;
+  return out;
+}
+function renderEvent(event) {
+  if (!shouldRenderLiveEvent(event)) return;
+  if (event.type === "message" && event.content) {
+    process.stdout.write(event.content);
+  } else if (event.type === "tool_use") {
+    log.plain(chalk9.cyan(`
+[tool] ${event.tool_name}`));
+  } else if (event.type === "tool_result" && event.content) {
+    const preview = event.content.length > 200 ? `${event.content.slice(0, 200)}...` : event.content;
+    log.plain(chalk9.dim(preview));
+  } else if (event.type === "status") {
+    if (event.status === "running") {
+      log.plain(chalk9.yellow("\n[session running]"));
+    }
+  } else if (event.type === "error") {
+    log.plain(chalk9.red(`
+[error] ${event.content ?? "unknown error"}`));
+  }
+}
+async function streamAndRender(events, json) {
+  for await (const event of events) {
+    if (json) {
+      writeJsonLine(sanitizeSessionEvent(event));
+    } else {
+      renderEvent(event);
+    }
+    if (event.type === "status" && isTerminalSessionStatus(event.status)) {
+      renderTerminalStatus(event.status, json);
+      break;
+    }
+  }
+}
+function renderCollectedEvents(result, json) {
+  if (json) {
+    writeJson(toEventListJson(result.result.events, result.result.has_more, result.result.next_page));
+  } else {
+    for (const event of result.result.events) {
+      renderEvent(event);
+    }
+    renderTerminalStatus(result.terminalStatus, json);
+  }
+}
+async function sessionRunCommand(promptOrAgent, promptOrOptions, maybeOptions) {
+  const hasPositionalAgent = typeof promptOrOptions === "string";
+  const positionalAgent = hasPositionalAgent ? promptOrAgent : void 0;
+  const prompt = hasPositionalAgent ? promptOrOptions : promptOrAgent;
+  const options = hasPositionalAgent ? maybeOptions : promptOrOptions ?? maybeOptions;
+  if (positionalAgent && options.agent && positionalAgent !== options.agent) {
+    throw new UserError7("Specify agent either positionally or with --agent, not both.");
+  }
+  const runOptions = {
+    agent: positionalAgent ?? options.agent,
+    identityId: options.identityId,
+    provider: options.provider,
+    environment: options.environment,
+    environmentId: options.environmentId,
+    tunnel: options.tunnel,
+    tunnelId: options.tunnelId,
+    vault: options.vault,
+    memoryStores: parseMemoryStores(options.memoryStores),
+    title: options.title
+  };
+  const ctx = await buildCliRuntime(options.file);
+  const run = options.noStream ? await startSessionRunPolling(ctx, prompt, runOptions) : await startSessionRun(ctx, prompt, runOptions);
+  const session = run.session;
+  if (!options.json) {
+    log.success(`Session created: ${chalk9.bold(session.id)}`);
+  }
+  if (options.noStream) {
+    renderCollectedEvents(run, !!options.json);
+  } else {
+    await streamAndRender(run.events, !!options.json);
+  }
+}
+async function sessionSendCommand(sessionId, message, options) {
+  const ctx = await buildCliRuntime(options.file);
+  if (options.noStream) {
+    const result = await sendSessionMessagePolling(ctx, sessionId, message, { provider: options.provider });
+    renderCollectedEvents(result, !!options.json);
+  } else {
+    const events = await sendSessionMessageStreaming(ctx, sessionId, message, { provider: options.provider });
+    await streamAndRender(events, !!options.json);
+  }
+}
+async function sessionEventsCommand(sessionId, options) {
+  const ctx = await buildCliRuntime(options.file);
+  const {
+    items: events,
+    hasMore,
+    nextPage
+  } = await fetchAllPages(async (page) => {
+    const result = page ? await listSessionEvents(ctx, sessionId, {
+      provider: options.provider,
+      limit: options.limit,
+      page_token: page
+    }) : await listSessionEvents(ctx, sessionId, { provider: options.provider, limit: options.limit });
+    return { items: result.events, hasMore: result.has_more, nextPage: result.next_page };
+  }, options.all);
+  if (options.json) {
+    writeJson(toEventListJson(events, hasMore, nextPage));
+    return;
+  }
+  if (events.length === 0) {
+    log.info("No events found.");
+    return;
+  }
+  printTableTitle("Events", events.length);
+  printTableHeader(["#".padEnd(4), "Type".padEnd(14), "Content"], 60);
+  for (let i = 0; i < events.length; i++) {
+    const e = events[i];
+    const idx = String(i + 1).padEnd(4);
+    const typeLabel = e.type.padEnd(14);
+    let preview = "";
+    if (e.type === "message") preview = (e.content ?? "").slice(0, 60);
+    else if (e.type === "tool_use") preview = e.tool_name ?? "";
+    else if (e.type === "tool_result") preview = (e.content ?? "").slice(0, 60);
+    else if (e.type === "status") preview = `${e.status ?? ""}${e.stop_reason ? ` (${e.stop_reason})` : ""}`;
+    else if (e.type === "error") preview = (e.content ?? "").slice(0, 60);
+    else if (e.type === "thinking") preview = chalk9.dim("(thinking)");
+    else preview = e.raw_type;
+    const typeColor = e.type === "error" ? chalk9.red(typeLabel) : e.type === "status" ? chalk9.yellow(typeLabel) : e.type === "tool_use" ? chalk9.cyan(typeLabel) : typeLabel;
+    printTableRow([chalk9.dim(idx), typeColor, preview]);
+  }
+  printTableFooter();
+  if (hasMore) {
+    log.info("More events available. Use --all to fetch all.");
+  }
+}
+function parseMemoryStores(value) {
+  return value ? value.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+}
+
+// src/commands/state.ts
+import { importResource, parseStateAddress, UserError as UserError8 } from "@openagentpack/sdk";
+import chalk10 from "chalk";
+async function stateListCommand(options) {
+  const ctx = await buildCliRuntime(options.file);
+  const resources = ctx.state.listResources();
+  if (resources.length === 0) {
+    log.info("No resources tracked in state.");
+    return;
+  }
+  printTableTitle("Managed resources", resources.length);
+  printTableHeader(["TYPE            NAME                PROVIDER   REMOTE ID"], 70);
+  for (const r of resources) {
+    const type = r.address.type.padEnd(14);
+    const name = r.address.name.padEnd(20);
+    const provider = r.address.provider.padEnd(10);
+    const id = (r.remote_id ?? "(local)").slice(0, 30);
+    console.log(`  ${type}  ${name}${provider} ${chalk10.dim(id)}`);
+  }
+  printTableFooter();
+}
+async function stateShowCommand(address, options) {
+  const ctx = await buildCliRuntime(options.file);
+  const parsed = parseStateAddress(address, { requireProvider: false });
+  const found = ctx.state.findResource(parsed);
+  if (!found) throw new UserError8(`Resource not found: ${address}`);
+  console.log(JSON.stringify(found, null, 2));
+}
+async function stateRemoveCommand(address, options) {
+  const ctx = await buildCliRuntime(options.file);
+  const parsed = parseStateAddress(address, { requireProvider: false });
+  const found = ctx.state.findResource(parsed);
+  if (!found) throw new UserError8(`Resource not found: ${address}`);
+  ctx.state.removeResource(found.address);
+  await ctx.state.save();
+  log.success(`Removed ${address} from state (remote resource not deleted).`);
+}
+async function stateImportCommand(address, remoteId, options) {
+  const ctx = await buildCliRuntime(options.file);
+  const parsed = parseStateAddress(address, { requireProvider: true });
+  await importResource(ctx, parsed, remoteId, { resourceVersion: options.resourceVersion });
+  log.success(`Imported ${address} (remote_id: ${remoteId}) into state.`);
+}
+
+// src/commands/sync.ts
+import { copyFileSync, mkdirSync, readdirSync, readFileSync as readFileSync2, statSync, writeFileSync } from "fs";
+import { writeFile as writeFile3 } from "fs/promises";
+import { basename as basename2, dirname as dirname3, join, resolve as resolve3 } from "path";
+import * as p5 from "@clack/prompts";
+import {
+  resolveSyncProvider,
+  syncProviderResourcesFromContext,
+  syncProviderResourcesFromEnv,
+  UserError as UserError9
+} from "@openagentpack/sdk";
+import { stringify as stringifyYaml } from "yaml";
+var DEFAULT_SYNC_OUTPUT = "agents.synced.yaml";
+function ensureSyncOutputWritable(outPath, force) {
+  if (force) return;
+  if (fileExistsSync(outPath)) {
+    throw new UserError9(
+      `Output file '${outPath}' already exists. Use --force to overwrite, or -o/--out to write elsewhere.`
+    );
+  }
+}
+async function syncCommand(options) {
+  const outPath = options.out ?? DEFAULT_SYNC_OUTPUT;
+  ensureSyncOutputWritable(outPath, options.force);
+  const configPath = resolve3(options.file);
+  const { provider, result } = fileExistsSync(configPath) ? await syncFromConfig(configPath, options.provider) : await syncFromEnv(options.provider);
+  const baseDir = dirname3(outPath);
+  const removedFiles = options.skipMissingFiles ? removeMissingFileAssociations(result.config, baseDir) : await promptFileAssociation(result.config, baseDir);
+  if (removedFiles.length > 0) {
+    const files = result.config.files ?? {};
+    for (const key of removedFiles) {
+      delete files[key];
+    }
+    if (Object.keys(files).length === 0) {
+      delete result.config.files;
+    }
+  }
+  const yamlContent = removedFiles.length > 0 ? await serializeConfig(result.config) : result.yaml;
+  await writeFile3(outPath, yamlContent, "utf8");
+  if (result.skillFiles?.size) {
+    let skillFileCount = 0;
+    for (const [skillName, files] of result.skillFiles) {
+      const skillDir = join(baseDir, "skills", skillName);
+      for (const file of files) {
+        const filePath = join(skillDir, file.relativePath);
+        mkdirSync(dirname3(filePath), { recursive: true });
+        writeFileSync(filePath, file.content);
+        skillFileCount++;
+      }
+    }
+    log.info(`Downloaded ${result.skillFiles.size} skill(s) (${skillFileCount} files) into ./skills/`);
+  }
+  const parts = [];
+  for (const [type, count] of Object.entries(result.counts)) {
+    parts.push(`${count} ${type}(s)`);
+  }
+  log.success(`Synced ${parts.join(", ")} from ${provider} into ${outPath}.`);
+  await promptCustomSkillFiles(result.config, baseDir);
+  if (result.secretPlaceholders?.length) {
+    await promptSecretValues(result.secretPlaceholders);
+  }
+}
+function removeMissingFileAssociations(config, baseDir) {
+  const files = config.files ?? {};
+  const removed = Object.entries(files).filter(([, decl]) => !fileExistsSync(join(baseDir, decl.source))).map(([key]) => key);
+  if (removed.length > 0) {
+    log.info(`${removed.length} file(s) removed (skipped).`);
+  }
+  return removed;
+}
+async function syncFromConfig(configPath, explicitProvider) {
+  const ctx = await buildCliRuntime(configPath);
+  const provider = resolveSyncProvider(ctx.config, explicitProvider);
+  const result = await syncProviderResourcesFromContext(ctx, { provider });
+  return { provider, result };
+}
+async function syncFromEnv(explicitProvider) {
+  if (!explicitProvider) {
+    throw new UserError9(
+      "agents sync requires --provider when no config file exists, e.g. `agents sync --provider claude`."
+    );
+  }
+  ensureCredentials();
+  const result = await syncProviderResourcesFromEnv({ provider: explicitProvider });
+  return { provider: explicitProvider, result };
+}
+async function promptSecretValues(placeholders) {
+  p5.note(
+    "Vault credentials contain secret placeholders.\nEnter values below (stored locally in .env, never uploaded). Press Enter to skip.",
+    "Secrets"
+  );
+  const envPath = ".env";
+  const existingEnv = loadExistingEnv(envPath);
+  let written = 0;
+  let skipped = 0;
+  for (const ph of placeholders) {
+    if (existingEnv.has(ph.envVar)) {
+      skipped++;
+      continue;
+    }
+    const value = await p5.password({
+      message: `${ph.vaultName} / ${ph.credentialName} [${ph.envVar}]`
+    });
+    if (p5.isCancel(value)) {
+      log.info("Cancelled. Remaining secrets skipped.");
+      break;
+    }
+    const trimmed = (value ?? "").trim();
+    appendEnvLine(envPath, ph.envVar, trimmed);
+    if (trimmed) {
+      written++;
+    } else {
+      skipped++;
+    }
+  }
+  if (written > 0 || skipped > 0) {
+    const msg = [];
+    if (written > 0) msg.push(`${written} secret(s) written to .env`);
+    if (skipped > 0) msg.push(`${skipped} skipped`);
+    log.info(msg.join(", ") + ".");
+  }
+}
+function loadExistingEnv(path) {
+  const keys = /* @__PURE__ */ new Set();
+  if (!fileExistsSync(path)) return keys;
+  const content = readFileSync2(path, "utf8");
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx > 0) {
+      keys.add(trimmed.slice(0, eqIdx).trim());
+    }
+  }
+  return keys;
+}
+function appendEnvLine(path, key, value) {
+  let content = "";
+  if (fileExistsSync(path)) {
+    content = readFileSync2(path, "utf8");
+    if (content.length > 0 && !content.endsWith("\n")) {
+      content += "\n";
+    }
+  }
+  content += `${key}=${value}
+`;
+  writeFileSync(path, content);
+}
+async function promptCustomSkillFiles(config, baseDir) {
+  const skills = config.skills ?? {};
+  const missing = [];
+  for (const [key, decl] of Object.entries(skills)) {
+    if (decl.origin !== "custom") continue;
+    const skillName = decl.name ?? key;
+    const skillSource = join(baseDir, decl.source);
+    if (fileExistsSync(skillSource)) {
+      const stat = statSync(skillSource);
+      if (stat.isFile()) continue;
+      if (stat.isDirectory() && readdirSync(skillSource).length > 0) continue;
+    }
+    missing.push({ key, name: skillName, dir: skillSource, decl });
+  }
+  if (missing.length === 0) return;
+  p5.note(
+    "Some custom skills could not be downloaded.\nProvide a local path to the skill directory, or press Enter to create an empty placeholder.",
+    "Skills"
+  );
+  let provided = 0;
+  let skippedCount = 0;
+  for (const skill of missing) {
+    const sourcePath = await p5.text({
+      message: `Skill "${skill.name}" \u2014 local path (or Enter to skip):`,
+      placeholder: "./path/to/skill/"
+    });
+    if (p5.isCancel(sourcePath)) {
+      log.info("Cancelled. Remaining skills skipped.");
+      break;
+    }
+    const trimmed = (sourcePath ?? "").trim();
+    if (trimmed && fileExistsSync(trimmed)) {
+      const stat = statSync(trimmed);
+      if (stat.isDirectory()) {
+        copyDirRecursive(trimmed, skill.dir);
+        provided++;
+      } else if (stat.isFile() && trimmed.endsWith(".zip")) {
+        mkdirSync(skill.dir, { recursive: true });
+        copyFileSync(trimmed, join(skill.dir, basename2(trimmed)));
+        skill.decl.source = `./skills/${skill.name}/${basename2(trimmed)}`;
+        provided++;
+      } else if (stat.isFile()) {
+        mkdirSync(skill.dir, { recursive: true });
+        copyFileSync(trimmed, join(skill.dir, basename2(trimmed)));
+        provided++;
+      } else {
+        createEmptySkill(skill.dir, skill.name);
+        skippedCount++;
+      }
+    } else {
+      createEmptySkill(skill.dir, skill.name);
+      skippedCount++;
+    }
+  }
+  if (provided > 0 || skippedCount > 0) {
+    const msg = [];
+    if (provided > 0) msg.push(`${provided} skill(s) provided`);
+    if (skippedCount > 0) msg.push(`${skippedCount} skipped (empty placeholder created)`);
+    log.info(msg.join(", ") + ".");
+  }
+}
+function createEmptySkill(dir, name) {
+  mkdirSync(dir, { recursive: true });
+  if (!fileExistsSync(join(dir, "SKILL.md"))) {
+    writeFileSync(
+      join(dir, "SKILL.md"),
+      `---
+name: ${name}
+description: ""
+---
+
+# ${name}
+
+> **NOTE**: This is a placeholder file generated by \`agents sync\`. It does NOT contain your original skill content.
+> Please replace this file with the actual skill definition, then run \`agents apply\` to upload it.
+`
+    );
+  }
+}
+function copyDirRecursive(src, dest) {
+  mkdirSync(dest, { recursive: true });
+  for (const entry of readdirSync(src, { withFileTypes: true })) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+async function promptFileAssociation(config, baseDir) {
+  const files = config.files ?? {};
+  const fileEntries = Object.entries(files);
+  if (fileEntries.length === 0) return [];
+  p5.note(
+    "Files cannot be downloaded from the remote platform.\nProvide a local file path, or press Enter to skip (file will be removed from sync).",
+    "Files"
+  );
+  const removed = [];
+  let provided = 0;
+  for (const [key, decl] of fileEntries) {
+    const fileName = decl.name ?? decl.source ?? key;
+    const targetPath = join(baseDir, decl.source);
+    if (fileExistsSync(targetPath)) {
+      provided++;
+      continue;
+    }
+    const sourcePath = await p5.text({
+      message: `File "${fileName}" \u2014 local path (or Enter to skip/remove):`,
+      placeholder: "./path/to/file"
+    });
+    if (p5.isCancel(sourcePath)) {
+      log.info("Cancelled. Remaining files skipped and removed.");
+      for (const [remainingKey] of fileEntries.slice(fileEntries.indexOf([key, decl]))) {
+        removed.push(remainingKey);
+      }
+      break;
+    }
+    const trimmed = (sourcePath ?? "").trim();
+    if (trimmed && fileExistsSync(trimmed)) {
+      mkdirSync(dirname3(targetPath), { recursive: true });
+      copyFileSync(trimmed, targetPath);
+      provided++;
+    } else {
+      removed.push(key);
+    }
+  }
+  if (provided > 0 || removed.length > 0) {
+    const msg = [];
+    if (provided > 0) msg.push(`${provided} file(s) associated`);
+    if (removed.length > 0) msg.push(`${removed.length} removed (skipped)`);
+    log.info(msg.join(", ") + ".");
+  }
+  return removed;
+}
+async function serializeConfig(config) {
+  return stringifyYaml(config, { lineWidth: 0 });
+}
+
+// src/commands/validate.ts
+import { resolve as resolve4 } from "path";
+import { resolveProjectConfig as resolveProjectConfig2, UserError as UserError10, validateProjectConfig } from "@openagentpack/sdk";
+async function validateCommand(options) {
+  ensureCredentials();
+  const configPath = resolve4(options.file);
+  log.info(`Validating ${configPath}...`);
+  const { config } = await resolveProjectConfig2(options.file);
+  const diagnostics = validateProjectConfig(config);
+  for (const d of diagnostics) {
+    const line = d.resource ? `${d.message} (${d.resource.type}.${d.resource.name})` : d.message;
+    if (d.severity === "error") log.error(line);
+    else if (d.severity === "warning") log.warn(line);
+    else log.info(line);
+  }
+  const errorCount = diagnostics.filter((d) => d.severity === "error").length;
+  if (errorCount > 0) {
+    throw new UserError10(`Validation failed with ${errorCount} error(s).`);
+  }
+  log.success("Configuration is valid.");
+}
+
+// src/program.ts
+function formatCliError(message, args = process.argv.slice(2)) {
+  const trimmed = message.trimEnd();
+  if (trimmed.startsWith("error: unknown option")) {
+    return `${trimmed}
+
+Run \`agents --help\` for available commands, or \`agents <command> --help\` for command options.
+`;
+  }
+  if (trimmed.includes("missing required argument")) {
+    const cmd = args.filter((a) => !a.startsWith("-")).join(" ");
+    const examples = {
+      "session run": 'agents session run "your prompt here" -f agents.yaml',
+      "session send": 'agents session send <session-id> "your message" -f agents.yaml',
+      "session get": "agents session get <session-id> -f agents.yaml",
+      "session delete": "agents session delete <session-id> -f agents.yaml"
+    };
+    const example = Object.entries(examples).find(([k]) => cmd.startsWith(k));
+    if (example) {
+      return `${trimmed}
+
+Example:
+  ${example[1]}
+`;
+    }
+    return `${trimmed}
+
+Run \`agents ${cmd} --help\` for usage details.
+`;
+  }
+  return `${message}`;
+}
+function readCliVersion() {
+  const packageJsonPath = resolve5(dirname4(fileURLToPath2(import.meta.url)), "../package.json");
+  const manifest = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
+  return manifest.version ?? "0.0.0-dev";
+}
+function countVerbose(_value, previous) {
+  return previous + 1;
+}
+var program = new Command2().name("agents").version(readCliVersion()).description("Open Agent Pack \u2014 Declaratively manage AI agent infrastructure").option("-v, --verbose", "Increase logging verbosity (repeat: -vv)", countVerbose, 0).option("-q, --quiet", "Suppress non-error output").option("--no-color", "Disable colored output").addOption(configFileOption().default(DEFAULT_CONFIG_FILE)).configureOutput({
+  outputError: (message, write) => write(formatCliError(message))
+}).hook("preAction", (cmd) => {
+  const opts = cmd.opts();
+  configureLogger({
+    verbose: typeof opts.verbose === "number" ? opts.verbose : opts.verbose ? 1 : 0,
+    quiet: !!opts.quiet,
+    color: opts.color !== false
+  });
+});
+program.command("init").description("Create a new agents.yaml template").action(initCommand);
+program.command("playground").description("Launch the local web UI (fetches @openagentpack/playground on demand) and open it in a browser").option("--port <n>", "Port to serve on (default 4848)").addOption(providerOption("Provider the UI targets")).option("--no-open", "Do not open a browser automatically").action(playgroundCommand);
+program.command("validate").description("Validate the configuration file (offline)").addOption(configFileOption()).action(withResolvedConfigFile(validateCommand));
+program.command("plan").description("Show what changes would be applied").addOption(configFileOption()).addOption(providerOption("Target provider", { allowAll: true, defaultValue: "all" })).option("--refresh <value>", "Refresh state from remote before planning (true/false)", parseBooleanOption, true).option("--refresh-only", "Refresh state and show drift without planning remote mutations").option("--json", "Output as JSON").action(withResolvedConfigFile(planCommand));
+program.command("apply").description("Apply the planned changes to create/update/delete resources").addOption(configFileOption()).option("-y, --yes", "Skip confirmation prompt").option("--refresh <value>", "Refresh state from remote before planning (true/false)", parseBooleanOption, true).option("--refresh-only", "Refresh state without mutating remote resources").option(
+  "--concurrency <n>",
+  "Max independent resources to apply in parallel (default 6, max 10)",
+  parsePositiveInteger
+).addOption(providerOption("Target provider", { allowAll: true, defaultValue: "all" })).action(withResolvedConfigFile(applyCommand));
+program.command("destroy").description("Destroy all managed resources").addOption(configFileOption()).option("-y, --yes", "Skip confirmation prompt").option("--cascade", "Auto-delete dependent resources (e.g., sessions referencing an environment)").action(withResolvedConfigFile(destroyCommand));
+program.command("sync").description("Export a provider's remote configuration into a local agents.yaml").addOption(configFileOption()).addOption(providerOption("Source provider to sync from (defaults from config when -f is set)")).option("-o, --out <path>", "Output file path", "agents.synced.yaml").option("--force", "Overwrite the output file if it already exists").option("--skip-missing-files", "Do not prompt for remote files that cannot be downloaded; omit them from output").action(withResolvedConfigFile(syncCommand));
+program.command("migrate").description("Merge synced resources into the project agents.yaml (incremental, skip existing)").option("--from <path>", "Source synced file", "agents.synced.yaml").option("--to <path>", "Target agents.yaml file", "agents.yaml").action(migrateCommand);
+var stateCmd = program.command("state").description("Manage state file");
+stateCmd.command("list").description("List all resources in state").addOption(configFileOption()).action(withResolvedConfigFile(stateListCommand));
+stateCmd.command("show <address>").description("Show details of a resource in state").addOption(configFileOption()).action(withResolvedConfigFile(stateShowCommand));
+stateCmd.command("rm <address>").description("Remove a resource from state without destroying it remotely").addOption(configFileOption()).action(withResolvedConfigFile(stateRemoveCommand));
+stateCmd.command("import <address> <remote-id>").description("Import an existing remote resource into state").addOption(configFileOption()).addOption(
+  new Option2("--resource-version <number>", "Resource version (for versioned resources like agents)").argParser(
+    parsePositiveInteger
+  )
+).action(withResolvedConfigFile(stateImportCommand));
+var sessionCmd = program.command("session").description("Manage agent sessions (runtime)");
+sessionCmd.command("create [agent-name]").description("Create a new session for an agent").addOption(configFileOption()).option("--agent <name>", "Agent name (auto-detected when only one agent is configured)").option("--identity-id <id>", "Override the configured Qoder Forward Identity").option("--environment <name>", "Override agent's declared environment").option("--environment-id <id>", "Use an explicit remote environment id instead of the configured one").option("--tunnel <name>", "Override agent's declared tunnel").option("--tunnel-id <id>", "Use an explicit remote tunnel id instead of the configured one").option("--vault <name>", "Override agent's declared vault").option("--memory-stores <names>", "Override agent's declared memory stores (comma-separated)").option("--title <title>", "Session title").addOption(providerOption("Target provider (required for multi-provider agents)")).action(withResolvedConfigFile(sessionCreateCommand));
+sessionCmd.command("list").description("List sessions from the provider").addOption(configFileOption()).option("--agent <name>", "Filter by agent name").option("--all", "Fetch all pages by following the cursor").addOption(providerOption("Target provider")).action(withResolvedConfigFile(sessionListCommand));
+sessionCmd.command("get <session-id>").description("Get details of a session").addOption(configFileOption()).addOption(providerOption("Target provider")).action(withResolvedConfigFile(sessionGetCommand));
+sessionCmd.command("delete <session-id>").description("Delete a session").addOption(configFileOption()).addOption(providerOption("Target provider")).action(withResolvedConfigFile(sessionDeleteCommand));
+sessionCmd.command("run <prompt-or-agent> [prompt]").description("Create a session, send a message, and stream the response").addOption(configFileOption()).option("--agent <name>", "Agent name (auto-detected when only one agent is configured)").option("--identity-id <id>", "Override the configured Qoder Forward Identity").option("--environment <name>", "Override agent's declared environment").option("--environment-id <id>", "Use an explicit remote environment id instead of the configured one").option("--tunnel <name>", "Override agent's declared tunnel").option("--tunnel-id <id>", "Use an explicit remote tunnel id instead of the configured one").option("--vault <name>", "Override agent's declared vault").option("--memory-stores <names>", "Override agent's declared memory stores (comma-separated)").option("--title <title>", "Session title").addOption(providerOption("Target provider")).option("--json", "Output events as JSONL").option("--no-stream", "Use polling instead of SSE streaming").action(withResolvedConfigFile(sessionRunCommand));
+sessionCmd.command("send <session-id> <message>").description("Send a message to an existing session and stream the response").addOption(configFileOption()).addOption(providerOption("Target provider")).option("--json", "Output events as JSONL").option("--no-stream", "Use polling instead of SSE streaming").action(withResolvedConfigFile(sessionSendCommand));
+sessionCmd.command("events <session-id>").description("List event history for a session").addOption(configFileOption()).addOption(providerOption("Target provider")).addOption(new Option2("--limit <count>", "Maximum number of events to fetch").argParser(parsePositiveInteger)).option("--all", "Fetch all pages by following the cursor").option("--json", "Output as JSON").action(withResolvedConfigFile(sessionEventsCommand));
+var deploymentCmd = program.command("deployment").description("Manage agent deployments (scheduled / triggered runs)");
+deploymentCmd.command("list").description("List deployments tracked in state").addOption(configFileOption()).addOption(providerOption("Filter by provider")).action(withResolvedConfigFile(deploymentListCommand));
+deploymentCmd.command("get <name>").description("Show a deployment's status and resolved bindings").addOption(configFileOption()).addOption(providerOption("Target provider")).action(withResolvedConfigFile(deploymentGetCommand));
+deploymentCmd.command("run <name>").description("Trigger a deployment run (native on Claude, emulated as a session on Qoder)").addOption(configFileOption()).addOption(providerOption("Target provider")).action(withResolvedConfigFile(deploymentRunCommand));
+var modelsCmd = program.command("models").description("Discover available models from providers");
+modelsCmd.command("list").description("List models available on the configured provider(s)").addOption(configFileOption()).addOption(providerOption("Target provider")).option("--json", "Output as JSON").action(withResolvedConfigFile(modelsListCommand));
+
+export {
+  configureLogger,
+  log,
+  program
+};