@treeseed/cli 0.10.5 → 0.10.7

package/dist/cli/handlers/capacity.js

@@ -4,6 +4,7 @@ import { resolve } from "node:path";
 import { resolveCapacityProviderLaunchEnvironment } from "@treeseed/sdk/capacity-provider";
 import { resolveMarketProfile } from "@treeseed/sdk/market-client";
 import { findNearestTreeseedRoot, findNearestTreeseedWorkspaceRoot } from "@treeseed/sdk/workflow-support";
+import { createMarketClientForInvocation } from "./market-utils.js";
 import { fail, guidedResult } from "./utils.js";
 const ENTRYPOINT_RELATIVE_PATH = ["dist", "provider", "entrypoint.js"];
 const COMPOSE_FILE_NAME = "compose.capacity-provider.yml";
@@ -11,6 +12,7 @@ const DEFAULT_PROJECT_NAME = "treeseed-capacity-provider";
 const DEFAULT_HOST_DATA_DIR = ".treeseed/local-capacity-provider/data";
 const PROVIDER_LIFECYCLE_ACTIONS = /* @__PURE__ */ new Set(["build", "up", "down", "restart", "logs", "status", "test-local"]);
 const PROVIDER_ENTRYPOINT_ACTIONS = /* @__PURE__ */ new Set(["doctor", "register", "plan"]);
+const MARKET_CAPACITY_ACTIONS = /* @__PURE__ */ new Set(["migrate"]);
 function stringArg(invocation, name) {
   const value = invocation.args[name];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
@@ -18,6 +20,24 @@ function stringArg(invocation, name) {
 function boolArg(invocation, name) {
   return invocation.args[name] === true;
 }
+function numberArg(invocation, name) {
+  const value = invocation.args[name];
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim().length > 0 && Number.isFinite(Number(value))) return Number(value);
+  return null;
+}
+function formatNumber(value, digits = 2) {
+  if (value === null || value === void 0 || value === "") return "n/a";
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return String(value);
+  return numeric.toLocaleString("en-US", { maximumFractionDigits: digits });
+}
+function recordValue(record, key) {
+  return record && typeof record === "object" && key in record ? record[key] : void 0;
+}
+function marketRequest(client, path, options = {}) {
+  return client.request(path, options);
+}
 function readPackageName(packageRoot) {
   const packageJsonPath = resolve(packageRoot, "package.json");
   if (!existsSync(packageJsonPath)) return null;
@@ -108,6 +128,212 @@ function composeCommandArgs(composeFilePath, projectName, action) {
       return base;
   }
 }
+function nativeBudgetSummaryLines(report) {
+  const budgets = recordValue(report, "budgets");
+  const nativeCapacity = recordValue(budgets, "nativeCapacity") ?? recordValue(budgets, "native_capacity");
+  const executionProviders = recordValue(nativeCapacity, "executionProviders") ?? recordValue(nativeCapacity, "execution_providers");
+  if (!Array.isArray(executionProviders)) return [];
+  return executionProviders.flatMap((provider) => {
+    const name = recordValue(provider, "name") ?? recordValue(provider, "id") ?? "execution provider";
+    const kind = recordValue(provider, "kind") ?? "custom";
+    const nativeUnit = recordValue(provider, "nativeUnit") ?? recordValue(provider, "native_unit") ?? "native unit";
+    const workers = recordValue(provider, "maxConcurrentWorkers") ?? recordValue(provider, "max_concurrent_workers");
+    const limits = recordValue(provider, "nativeLimits") ?? recordValue(provider, "native_limits");
+    const lines = [`${name}: ${kind}, ${nativeUnit}${workers ? `, workers ${workers}` : ""}`];
+    if (Array.isArray(limits)) {
+      for (const limit of limits) {
+        lines.push(`  ${recordValue(limit, "scope") ?? recordValue(limit, "limitScope") ?? "limit"}: ${formatNumber(recordValue(limit, "limitAmount") ?? recordValue(limit, "limit_amount"))} ${recordValue(limit, "nativeUnit") ?? nativeUnit}, reserve ${formatNumber(recordValue(limit, "reserveBufferPercent") ?? recordValue(limit, "reserve_buffer_percent"))}%`);
+      }
+    }
+    return lines;
+  });
+}
+function derivedCapacityLines(plan) {
+  const derivedCapacity = recordValue(plan, "derivedCapacity");
+  const entries = recordValue(derivedCapacity, "entries");
+  if (!Array.isArray(entries) || entries.length === 0) {
+    return ["No derived native capacity entries are available yet."];
+  }
+  return entries.map((entry) => [
+    `${recordValue(entry, "executionProviderKind") ?? "provider"}:${recordValue(entry, "nativeUnit") ?? "native"}`,
+    `limit ${formatNumber(recordValue(entry, "configuredNativeLimit"))}`,
+    `observed ${formatNumber(recordValue(entry, "observedNativeRemaining"))}`,
+    `reserved ${formatNumber(recordValue(entry, "activeReservedNativeAmount"))}`,
+    `reserve ${formatNumber(recordValue(entry, "reserveBufferPercent"))}%`,
+    `conversion ${formatNumber(recordValue(entry, "nativeUnitsPerCredit"))} native/credit`,
+    `derived ${formatNumber(recordValue(entry, "derivedAvailableCredits"))} credits`,
+    `confidence ${recordValue(entry, "confidence") ?? "unknown"}`
+  ].join(" | "));
+}
+function grantAllocationLines(plan) {
+  const grants = recordValue(plan, "grants");
+  if (!Array.isArray(grants) || grants.length === 0) return [];
+  return grants.map((grant) => [
+    `${recordValue(grant, "grantScope") ?? "grant"} ${recordValue(grant, "environment") ?? "all"}`,
+    `allocation ${formatNumber(recordValue(grant, "portfolioAllocationPercent"))}%`,
+    `reserve pool ${formatNumber(recordValue(grant, "reservePoolPercent"))}%`,
+    `max daily project credits ${formatNumber(recordValue(grant, "maxDailyProjectCredits"))}`,
+    `overflow ${recordValue(grant, "overflowPolicy") ?? "soft_grant"}`,
+    `emergency ${recordValue(grant, "emergencyOverride") === true ? "on" : "off"}`
+  ].join(" | "));
+}
+async function runProjectCapacityPlan(invocation, context) {
+  const projectId = stringArg(invocation, "project");
+  if (!projectId) return fail("Missing --project. Use `trsd capacity plan --project <project-id> --environment local`.");
+  const { profile, client } = createMarketClientForInvocation(invocation, context, { requireAuth: true });
+  const environment = environmentSelector(invocation);
+  const response = await marketRequest(
+    client,
+    `/v1/projects/${encodeURIComponent(projectId)}/capacity-plan?environment=${encodeURIComponent(environment)}`,
+    { requireAuth: true }
+  );
+  const plan = response.payload;
+  return guidedResult({
+    command: "capacity plan",
+    summary: `Capacity plan for project ${projectId} in ${environment}.`,
+    facts: [
+      { label: "Market", value: `${profile.id} (${profile.baseUrl})` },
+      { label: "Project", value: projectId },
+      { label: "Environment", value: environment },
+      { label: "Derived credits", value: formatNumber(recordValue(recordValue(plan, "derivedCapacity"), "totalDerivedAvailableCredits")) }
+    ],
+    sections: [
+      { title: "Native projection", lines: derivedCapacityLines(plan) },
+      { title: "Allocation grants", lines: grantAllocationLines(plan) }
+    ],
+    report: { action: "plan", projectId, environment, market: { id: profile.id, baseUrl: profile.baseUrl }, plan }
+  });
+}
+function providerMatcher(selector) {
+  return (provider) => {
+    const id = String(recordValue(provider, "id") ?? "");
+    const name = String(recordValue(provider, "name") ?? "");
+    return id === selector || name === selector;
+  };
+}
+function migrationMissingFields(invocation) {
+  const missing = [];
+  if (!stringArg(invocation, "team")) missing.push("--team");
+  if (!stringArg(invocation, "provider")) missing.push("--provider");
+  if (!stringArg(invocation, "kind")) missing.push("--kind");
+  if (!stringArg(invocation, "nativeUnit")) missing.push("--native-unit");
+  if (numberArg(invocation, "limit") === null) missing.push("--limit");
+  return missing;
+}
+async function runMigrateToDerived(invocation, context) {
+  if (!boolArg(invocation, "toDerived")) {
+    return fail("Missing --to-derived. Phase 8 supports `trsd capacity migrate --to-derived`.");
+  }
+  const missing = migrationMissingFields(invocation);
+  const example = "trsd capacity migrate --to-derived --team team_123 --provider provider_123 --kind codex_subscription --native-unit wall_minute --limit 480 --scope daily --reset-cadence daily --quota-visibility opaque --reserve-buffer-percent 20 --max-concurrent-workers 4 --project project_123 --portfolio-allocation-percent 100 --dry-run";
+  if (missing.length > 0) {
+    return fail(`Missing native capacity facts: ${missing.join(", ")}.
+Example: ${example}`);
+  }
+  const teamId = stringArg(invocation, "team");
+  const providerSelectorValue = stringArg(invocation, "provider");
+  const kind = stringArg(invocation, "kind");
+  const nativeUnit = stringArg(invocation, "nativeUnit");
+  const limitAmount = numberArg(invocation, "limit");
+  const scope = stringArg(invocation, "scope") ?? "daily";
+  const resetCadence = stringArg(invocation, "resetCadence") ?? "daily";
+  const quotaVisibility = stringArg(invocation, "quotaVisibility") ?? "opaque";
+  const reserveBufferPercent = numberArg(invocation, "reserveBufferPercent") ?? 20;
+  const maxConcurrentWorkers = Math.max(1, Math.floor(numberArg(invocation, "maxConcurrentWorkers") ?? 1));
+  const environment = environmentSelector(invocation);
+  const projectId = stringArg(invocation, "project");
+  const allocationPercent = numberArg(invocation, "portfolioAllocationPercent");
+  const dryRun = boolArg(invocation, "dryRun");
+  const { profile, client } = createMarketClientForInvocation(invocation, context, { requireAuth: !dryRun });
+  const providerList = dryRun ? { payload: [{ id: providerSelectorValue, name: providerSelectorValue }] } : await marketRequest(
+    client,
+    `/v1/teams/${encodeURIComponent(teamId)}/capacity-providers`,
+    { requireAuth: true }
+  );
+  const provider = providerList.payload.find(providerMatcher(providerSelectorValue));
+  if (!provider) return fail(`Capacity provider "${providerSelectorValue}" was not found in team ${teamId}.`);
+  const providerId = String(recordValue(provider, "id"));
+  const executionProvider = {
+    name: `${kind.replace(/_/gu, " ")} ${nativeUnit}`,
+    kind,
+    nativeUnit,
+    quotaVisibility,
+    maxConcurrentWorkers,
+    resetCadence,
+    nativeLimits: [{
+      scope,
+      nativeUnit,
+      limitAmount,
+      reserveBufferPercent,
+      resetCadence,
+      confidence: "estimated",
+      source: "operator_migration"
+    }],
+    metadata: {
+      source: "trsd capacity migrate --to-derived",
+      staticCreditBudgetsPreservedAs: "hybrid_fallback_cap"
+    }
+  };
+  const grant = allocationPercent === null ? null : {
+    capacityProviderId: providerId,
+    teamId,
+    projectId,
+    environment,
+    grantScope: projectId ? "project" : "team",
+    portfolioAllocationPercent: allocationPercent,
+    overflowPolicy: "soft_grant",
+    metadata: {
+      source: "trsd capacity migrate --to-derived"
+    }
+  };
+  if (!dryRun) {
+    await marketRequest(client, `/v1/teams/${encodeURIComponent(teamId)}/capacity-providers/${encodeURIComponent(providerId)}`, {
+      method: "PATCH",
+      body: {
+        name: String(recordValue(provider, "name") ?? providerId),
+        creditBudgetMode: "hybrid"
+      },
+      requireAuth: true
+    });
+    await marketRequest(client, `/v1/teams/${encodeURIComponent(teamId)}/capacity-providers/${encodeURIComponent(providerId)}/execution-providers`, {
+      method: "POST",
+      body: executionProvider,
+      requireAuth: true
+    });
+    if (grant) {
+      await marketRequest(client, `/v1/teams/${encodeURIComponent(teamId)}/capacity-grants`, {
+        method: "POST",
+        body: grant,
+        requireAuth: true
+      });
+    }
+  }
+  return guidedResult({
+    command: "capacity migrate",
+    summary: dryRun ? "Dry run: derived native capacity migration plan." : "Derived native capacity migration applied.",
+    facts: [
+      { label: "Market", value: `${profile.id} (${profile.baseUrl})` },
+      { label: "Team", value: teamId },
+      { label: "Provider", value: providerId },
+      { label: "Native limit", value: `${formatNumber(limitAmount)} ${nativeUnit} / ${scope}` },
+      { label: "Reserve buffer", value: `${formatNumber(reserveBufferPercent)}%` },
+      { label: "Allocation percent", value: allocationPercent === null ? null : `${formatNumber(allocationPercent)}%` },
+      { label: "Dry run", value: dryRun }
+    ],
+    sections: [
+      { title: "Execution provider", lines: [`${executionProvider.name}: ${kind}, ${nativeUnit}, ${maxConcurrentWorkers} workers, ${quotaVisibility} quota visibility`] },
+      ...grant ? [{ title: "Allocation grant", lines: [`${grant.grantScope} ${projectId ?? teamId} in ${environment}: ${formatNumber(allocationPercent)}%`] }] : []
+    ],
+    report: {
+      action: "migrate",
+      dryRun,
+      teamId,
+      providerId,
+      executionProvider,
+      grant
+    }
+  });
+}
 function lifecycleActionRequiresConnection(action) {
   return action === "up" || action === "restart";
 }
@@ -256,6 +482,7 @@ function invokeProviderEntrypoint(action, invocation, context) {
     ],
     sections: [
       { title: "Output", lines: stdout ? stdout.split(/\r?\n/u) : [] },
+      { title: "Native budget file", lines: nativeBudgetSummaryLines(report) },
       { title: "Errors", lines: stderr ? stderr.split(/\r?\n/u) : [] }
     ],
     exitCode: result.status ?? 1,
@@ -268,6 +495,21 @@ function invokeProviderEntrypoint(action, invocation, context) {
 }
 const handleCapacity = (invocation, context) => {
   const action = invocation.positionals[0] ?? "doctor";
+  if (action === "plan" && stringArg(invocation, "project")) {
+    try {
+      return runProjectCapacityPlan(invocation, context);
+    } catch (error) {
+      return fail(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (MARKET_CAPACITY_ACTIONS.has(action)) {
+    try {
+      if (action === "migrate") return runMigrateToDerived(invocation, context);
+      return fail(`Unknown capacity action "${action}".`);
+    } catch (error) {
+      return fail(error instanceof Error ? error.message : String(error));
+    }
+  }
   if (PROVIDER_LIFECYCLE_ACTIONS.has(action)) {
     try {
       return runLifecycleAction(action, invocation, context);
@@ -282,7 +524,7 @@ const handleCapacity = (invocation, context) => {
       return fail(error instanceof Error ? error.message : String(error));
     }
   }
-  return fail(`Unknown capacity action "${action}". Use doctor, register, plan, build, up, down, restart, logs, status, or test-local.`);
+  return fail(`Unknown capacity action "${action}". Use doctor, register, plan, migrate, build, up, down, restart, logs, status, or test-local.`);
 };
 export {
   handleCapacity

package/dist/cli/handlers/dev.js

@@ -44,11 +44,11 @@ function resolveCoreDevEntrypoint(cwd) {
 const handleDev = async (invocation, context) => {
   try {
     if (invocation.commandName !== "dev") {
-      return fail("`trsd dev` only starts the Market web/API dev runtime. Use `trsd capacity ...` for capacity provider lifecycle commands.");
+      return fail("`trsd dev` starts the Market web/API/dev-runner runtime. Use `trsd capacity ...` for capacity provider lifecycle commands.");
     }
     const removedOptions = ["surface", "surfaces", "withWorker"].filter((name) => invocation.args[name] !== void 0);
     if (removedOptions.length > 0) {
-      return fail(`\`trsd dev\` no longer accepts ${removedOptions.map((name) => `--${name.replace(/[A-Z]/gu, (char) => `-${char.toLowerCase()}`)}`).join(", ")}. It always starts fixed Market web/API surfaces; use \`trsd capacity ...\` for providers.`);
+      return fail(`\`trsd dev\` no longer accepts ${removedOptions.map((name) => `--${name.replace(/[A-Z]/gu, (char) => `-${char.toLowerCase()}`)}`).join(", ")}. It always starts fixed Market web/API/dev-runner surfaces; use \`trsd capacity ...\` for providers.`);
     }
     const feedback = typeof invocation.args.feedback === "string" ? invocation.args.feedback : void 0;
     const watch = feedback !== "off";

package/dist/cli/handlers/projects.js

@@ -1,47 +1,402 @@
-import { guidedResult } from "./utils.js";
+import { MarketApiError } from "@treeseed/sdk/market-client";
+import { fail, guidedResult } from "./utils.js";
 import { createMarketClientForInvocation } from "./market-utils.js";
+const DEPLOYMENT_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled", "timed_out"]);
+const FORBIDDEN_OUTPUT_FIELDS = /* @__PURE__ */ new Set([
+  "capacityProviderId",
+  "laneId",
+  "grantId",
+  "workerPoolId",
+  "runtimeHostId",
+  "railwayServiceId",
+  "runnerToken"
+]);
+const ACTIONS = {
+  deploy: "deploy_web",
+  publish: "publish_content",
+  monitor: "monitor"
+};
+function stringArg(invocation, key) {
+  const value = invocation.args[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function boolArg(invocation, key) {
+  return invocation.args[key] === true;
+}
+function environmentArg(invocation) {
+  const value = stringArg(invocation, "environment") ?? "staging";
+  return value === "prod" ? "prod" : "staging";
+}
+function projectUsage(action) {
+  switch (action) {
+    case "deploy":
+      return "Usage: treeseed projects deploy <project-id> --environment staging|prod";
+    case "publish":
+      return "Usage: treeseed projects publish <project-id> --environment staging|prod";
+    case "monitor":
+      return "Usage: treeseed projects monitor <project-id> --environment staging|prod";
+    case "deployments":
+      return "Usage: treeseed projects deployments <project-id>";
+    case "deployment":
+      return "Usage: treeseed projects deployment <project-id> <deployment-id>";
+    default:
+      return "Usage: treeseed projects [list|access|deploy|publish|monitor|deployments|deployment]";
+  }
+}
+function authFailure(error) {
+  if (error instanceof MarketApiError && [401, 403].includes(error.status)) {
+    return fail(error.message, 2);
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  if (/not logged in|unauthori[sz]ed|forbidden/iu.test(message)) {
+    return fail(message, 2);
+  }
+  return null;
+}
+function deploymentApiExitCode(error) {
+  if (error instanceof MarketApiError) {
+    if ([401, 403].includes(error.status)) return 2;
+    const payload = error.payload;
+    const code = payload?.error?.code ?? payload?.code;
+    if (code === "operation_not_retryable" || code === "operation_not_cancellable") return 1;
+  }
+  return 1;
+}
+function redact(value) {
+  if (Array.isArray(value)) return value.map((item) => redact(item));
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).filter(([key]) => !FORBIDDEN_OUTPUT_FIELDS.has(key)).filter(([key]) => !/(?:secret|token|password|apiKey|privateKey)/iu.test(key)).map(([key, entry]) => [key, redact(entry)]));
+}
+function text(value, fallback = "") {
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function actionLabel(action) {
+  switch (action) {
+    case "deploy_web":
+      return "deploy_web";
+    case "publish_content":
+      return "publish_content";
+    case "monitor":
+      return "monitor";
+    default:
+      return text(action, "deployment");
+  }
+}
+function deploymentUrl(deployment) {
+  return text(deployment?.target?.url, text(deployment?.target?.previewUrl, ""));
+}
+function workflowUrl(deployment) {
+  return text(deployment?.externalWorkflow?.url, text(deployment?.externalWorkflow?.htmlUrl, text(deployment?.externalWorkflow?.runUrl, "")));
+}
+function inspectCommand(projectId, deploymentId) {
+  return `trsd projects deployment ${projectId} ${deploymentId}`;
+}
+function retryCommand(projectId, deploymentId) {
+  return `trsd projects deployment retry ${projectId} ${deploymentId}`;
+}
+function deploymentLine(deployment) {
+  return [
+    deployment.id,
+    deployment.environment,
+    actionLabel(deployment.action),
+    deployment.status,
+    deployment.monitor?.status ? `monitor=${deployment.monitor.status}` : "",
+    deployment.completedAt ?? deployment.finishedAt ?? deployment.updatedAt ?? "",
+    workflowUrl(deployment),
+    deploymentUrl(deployment)
+  ].filter(Boolean).join("  ");
+}
+function waitExitCode(status) {
+  if (status === "succeeded") return 0;
+  if (status === "timed_out") return 4;
+  if (status === "cancelled") return 5;
+  return 3;
+}
+function monitorExitCode(deployment, fallback) {
+  if (deployment?.monitor?.status === "failed") return 3;
+  if (["healthy", "degraded", "unknown"].includes(String(deployment?.monitor?.status))) return 0;
+  return fallback;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForDeployment(input) {
+  const started = Date.now();
+  let current = (await input.client.projectDeployment(input.projectId, input.deploymentId)).payload;
+  while (!DEPLOYMENT_TERMINAL_STATUSES.has(String(current.status))) {
+    if (Date.now() - started >= input.timeoutSeconds * 1e3) {
+      return {
+        exitCode: 4,
+        deployment: current,
+        timedOut: true
+      };
+    }
+    await delay(input.pollIntervalMs);
+    current = (await input.client.projectDeployment(input.projectId, input.deploymentId)).payload;
+  }
+  return {
+    exitCode: waitExitCode(String(current.status)),
+    deployment: current,
+    timedOut: false
+  };
+}
+function timeoutSeconds(invocation) {
+  const value = Number(stringArg(invocation, "timeoutSeconds") ?? 300);
+  return Number.isFinite(value) && value > 0 ? value : 300;
+}
+function pollIntervalMs(invocation) {
+  const value = Number(stringArg(invocation, "pollIntervalMs") ?? 1e3);
+  return Number.isFinite(value) && value > 0 ? value : 1e3;
+}
+function deploymentRequestBody(invocation, action, environment) {
+  const body = {
+    environment,
+    action,
+    source: "cli"
+  };
+  const reason = stringArg(invocation, "reason");
+  const idempotencyKey = stringArg(invocation, "idempotencyKey");
+  if (boolArg(invocation, "dryRun")) body.dryRun = true;
+  if (reason) body.reason = reason;
+  if (idempotencyKey) body.idempotencyKey = idempotencyKey;
+  if (environment === "prod" && action !== "monitor") body.confirmProduction = true;
+  return body;
+}
+function monitorFacts(deployment) {
+  const monitor = deployment?.monitor && typeof deployment.monitor === "object" ? deployment.monitor : null;
+  if (!monitor) return [];
+  return [
+    { label: "Monitor", value: monitor.status ?? null },
+    { label: "Checked", value: monitor.checkedAt ?? null },
+    { label: "Checks", value: Array.isArray(monitor.checks) ? `${monitor.checks.filter((check) => check.status === "passed").length} passed, ${monitor.checks.filter((check) => check.status === "warning").length} warnings, ${monitor.checks.filter((check) => check.status === "failed").length} failed` : null }
+  ];
+}
+function monitorSection(deployment) {
+  const checks = Array.isArray(deployment?.monitor?.checks) ? deployment.monitor.checks : [];
+  if (checks.length === 0) return [];
+  return [{
+    title: "Monitor checks",
+    lines: checks.map((check) => [
+      check.status ?? "skipped",
+      check.key ?? check.label ?? "check",
+      check.summary ?? "",
+      check.inspectCommand ?? check.url ?? ""
+    ].filter(Boolean).join("  "))
+  }];
+}
 const handleProjects = async (invocation, context) => {
   const action = invocation.positionals[0] ?? "list";
-  const { profile, client } = createMarketClientForInvocation(invocation, context, { requireAuth: true });
-  if (action === "list") {
-    const teamId = typeof invocation.args.team === "string" ? invocation.args.team : null;
-    const response = await client.projects(teamId);
-    return guidedResult({
-      command: "projects",
-      summary: "Treeseed market projects",
-      sections: [{
-        title: "Projects",
-        lines: response.payload.map((project) => `${project.id}  ${project.name ?? project.slug}  team=${project.teamId}`)
-      }],
-      report: { marketId: profile.id, teamId, projects: response.payload }
-    });
+  let market;
+  try {
+    market = createMarketClientForInvocation(invocation, context, { requireAuth: true });
+  } catch (error) {
+    return authFailure(error) ?? fail(error instanceof Error ? error.message : String(error), 1);
   }
-  if (action === "access") {
-    const projectId = invocation.positionals[1];
-    if (!projectId) return { exitCode: 1, stderr: ["Usage: treeseed projects access <project-id>"] };
-    const response = await client.projectAccess(projectId);
+  const { profile, client } = market;
+  try {
+    if (action === "list") {
+      const teamId = typeof invocation.args.team === "string" ? invocation.args.team : null;
+      const response = await client.projects(teamId);
+      return guidedResult({
+        command: "projects",
+        summary: "Treeseed market projects",
+        sections: [{
+          title: "Projects",
+          lines: response.payload.map((project) => `${project.id}  ${project.name ?? project.slug}  team=${project.teamId}`)
+        }],
+        report: { marketId: profile.id, teamId, projects: redact(response.payload) }
+      });
+    }
+    if (action === "access") {
+      const projectId = invocation.positionals[1];
+      if (!projectId) return fail(projectUsage(action));
+      const response = await client.projectAccess(projectId);
+      return guidedResult({
+        command: "projects",
+        summary: "Treeseed market project access",
+        facts: [
+          { label: "Project", value: response.payload.projectId },
+          { label: "Staging admin", value: response.payload.team.summary.canAdminStaging },
+          { label: "Production admin", value: response.payload.team.summary.canAdminProduction }
+        ],
+        sections: [{
+          title: "Environments",
+          lines: response.payload.environments.map((entry) => `${entry.environment}: ${entry.role}`)
+        }],
+        report: { marketId: profile.id, access: redact(response.payload) }
+      });
+    }
+    if (action === "connect") {
+      return fail("Use treeseed config --connect-market --market-project-id <project-id> for project pairing.");
+    }
+    if (action in ACTIONS) {
+      const projectId = invocation.positionals[1];
+      if (!projectId) return fail(projectUsage(action));
+      const environment = environmentArg(invocation);
+      const deploymentAction = ACTIONS[action];
+      if (environment === "prod" && deploymentAction !== "monitor" && !boolArg(invocation, "yes")) {
+        return fail(`Production ${action} requires --yes and was not queued.`);
+      }
+      const response = await client.createProjectWebDeployment(projectId, deploymentRequestBody(invocation, deploymentAction, environment));
+      let deployment = response.deployment;
+      let waitResult = null;
+      if (boolArg(invocation, "wait")) {
+        waitResult = await waitForDeployment({
+          client,
+          projectId,
+          deploymentId: deployment.id,
+          timeoutSeconds: timeoutSeconds(invocation),
+          pollIntervalMs: pollIntervalMs(invocation)
+        });
+        deployment = waitResult.deployment;
+      }
+      const exitCode = monitorExitCode(deployment, waitResult?.exitCode ?? 0);
+      const summary = waitResult ? waitResult.timedOut ? "Treeseed project deployment wait timed out" : deployment.status === "succeeded" ? "Treeseed project deployment completed" : `Treeseed project deployment ${deployment.status}` : "Treeseed project deployment queued";
+      const nextSteps = [
+        inspectCommand(projectId, deployment.id),
+        ...["failed", "timed_out", "cancelled"].includes(deployment.status) ? [retryCommand(projectId, deployment.id)] : []
+      ];
+      return guidedResult({
+        command: "projects",
+        summary,
+        exitCode,
+        facts: [
+          { label: "Project", value: projectId },
+          { label: "Environment", value: deployment.environment },
+          { label: "Action", value: deployment.action },
+          { label: "Deployment", value: deployment.id },
+          { label: "Operation", value: deployment.platformOperationId ?? response.operation?.id ?? null },
+          { label: "Status", value: deployment.status },
+          { label: "URL", value: deploymentUrl(deployment) || null },
+          { label: "Workflow", value: workflowUrl(deployment) || null },
+          ...monitorFacts(deployment)
+        ],
+        sections: monitorSection(deployment),
+        nextSteps,
+        report: {
+          marketId: profile.id,
+          projectId,
+          deployment: redact(deployment),
+          operation: redact(response.operation),
+          pollUrl: response.pollUrl,
+          eventsUrl: response.eventsUrl,
+          stateUrl: response.stateUrl,
+          wait: waitResult ? { timedOut: waitResult.timedOut, exitCode } : null
+        }
+      });
+    }
+    if (action === "deployments") {
+      const projectId = invocation.positionals[1];
+      if (!projectId) return fail(projectUsage(action));
+      const response = await client.projectDeployments(projectId, {
+        environment: stringArg(invocation, "environment"),
+        limit: stringArg(invocation, "limit")
+      });
+      return guidedResult({
+        command: "projects",
+        summary: "Treeseed project deployments",
+        sections: [{
+          title: "Deployments",
+          lines: response.payload.map(deploymentLine)
+        }],
+        report: { marketId: profile.id, projectId, deployments: redact(response.payload) }
+      });
+    }
+    if (action === "deployment") {
+      const subaction = invocation.positionals[1];
+      const projectId = ["retry", "resume", "cancel"].includes(String(subaction)) ? invocation.positionals[2] : invocation.positionals[1];
+      const deploymentId = ["retry", "resume", "cancel"].includes(String(subaction)) ? invocation.positionals[3] : invocation.positionals[2];
+      if (!projectId || !deploymentId) return fail(projectUsage(action));
+      if (subaction === "retry") {
+        const response = await client.retryProjectDeployment(projectId, deploymentId, {
+          ...stringArg(invocation, "idempotencyKey") ? { idempotencyKey: stringArg(invocation, "idempotencyKey") } : {}
+        });
+        return guidedResult({
+          command: "projects",
+          summary: "Treeseed project deployment retry queued",
+          facts: [
+            { label: "Original deployment", value: response.originalDeployment.id },
+            { label: "Retry deployment", value: response.retryDeployment.id },
+            { label: "Operation", value: response.operation?.id ?? response.retryDeployment.platformOperationId },
+            { label: "Status", value: response.retryDeployment.status }
+          ],
+          nextSteps: [inspectCommand(projectId, response.retryDeployment.id)],
+          report: { marketId: profile.id, projectId, originalDeployment: redact(response.originalDeployment), retryDeployment: redact(response.retryDeployment), operation: redact(response.operation) }
+        });
+      }
+      if (subaction === "resume") {
+        try {
+          const response = await client.resumeProjectDeployment(projectId, deploymentId);
+          return guidedResult({
+            command: "projects",
+            summary: "Treeseed project deployment resume queued",
+            report: { marketId: profile.id, projectId, response: redact(response) }
+          });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return guidedResult({
+            command: "projects",
+            summary: message,
+            exitCode: deploymentApiExitCode(error),
+            stderr: [message],
+            report: { marketId: profile.id, projectId, deploymentId, ok: false, error: message }
+          });
+        }
+      }
+      if (subaction === "cancel") {
+        const response = await client.cancelProjectDeployment(projectId, deploymentId);
+        const exitCode = response.deployment.status === "cancelled" ? 5 : 0;
+        return guidedResult({
+          command: "projects",
+          summary: response.deployment.status === "cancelled" ? "Treeseed project deployment cancelled" : "Treeseed project deployment cancellation requested",
+          exitCode,
+          facts: [
+            { label: "Deployment", value: response.deployment.id },
+            { label: "Status", value: response.deployment.status },
+            { label: "Cancellation", value: response.cancellation }
+          ],
+          report: { marketId: profile.id, projectId, deployment: redact(response.deployment), cancellation: response.cancellation }
+        });
+      }
+      const [deploymentResponse, eventsResponse] = await Promise.all([
+        client.projectDeployment(projectId, deploymentId),
+        client.projectDeploymentEvents(projectId, deploymentId)
+      ]);
+      const deployment = deploymentResponse.payload;
+      return guidedResult({
+        command: "projects",
+        summary: "Treeseed project deployment",
+        facts: [
+          { label: "Project", value: projectId },
+          { label: "Deployment", value: deployment.id },
+          { label: "Environment", value: deployment.environment },
+          { label: "Action", value: deployment.action },
+          { label: "Status", value: deployment.status },
+          { label: "URL", value: deploymentUrl(deployment) || null },
+          { label: "Workflow", value: workflowUrl(deployment) || null },
+          ...monitorFacts(deployment)
+        ],
+        sections: [{
+          title: "Events",
+          lines: eventsResponse.payload.map((event) => `${event.sequence}  ${event.kind}  ${event.status ?? ""}  ${event.message}`)
+        }, ...monitorSection(deployment)],
+        nextSteps: ["failed", "timed_out", "cancelled"].includes(deployment.status) ? [retryCommand(projectId, deployment.id)] : [],
+        report: { marketId: profile.id, projectId, deployment: redact(deployment), events: redact(eventsResponse.payload) }
+      });
+    }
+    return fail(`Unknown projects action: ${action}`);
+  } catch (error) {
+    const auth = authFailure(error);
+    if (auth) return auth;
+    const message = error instanceof Error ? error.message : String(error);
     return guidedResult({
       command: "projects",
-      summary: "Treeseed market project access",
-      facts: [
-        { label: "Project", value: response.payload.projectId },
-        { label: "Staging admin", value: response.payload.team.summary.canAdminStaging },
-        { label: "Production admin", value: response.payload.team.summary.canAdminProduction }
-      ],
-      sections: [{
-        title: "Environments",
-        lines: response.payload.environments.map((entry) => `${entry.environment}: ${entry.role}`)
-      }],
-      report: { marketId: profile.id, access: response.payload }
+      summary: message,
+      exitCode: deploymentApiExitCode(error),
+      stderr: [message],
+      report: { marketId: profile.id, ok: false, error: message }
     });
   }
-  if (action === "connect") {
-    return {
-      exitCode: 1,
-      stderr: ["Use treeseed config --connect-market --market-project-id <project-id> for project pairing."]
-    };
-  }
-  return { exitCode: 1, stderr: [`Unknown projects action: ${action}`] };
 };
 export {
   handleProjects

package/dist/cli/operations-registry.js

@@ -1168,29 +1168,30 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
     examples: ["treeseed dev", "treeseed dev --reset", "treeseed dev --reset --plan --json", "treeseed dev --web-runtime local --plan --json", "treeseed dev --port 4322"],
     help: {
       longSummary: [
-        "Dev starts the local Treeseed Market web/API runtime as a foreground supervisor.",
+        "Dev starts the local Treeseed Market web/API/runtime services as a foreground supervisor.",
         "Capacity provider lifecycle is package-owned and runs through `treeseed capacity ...`, not through `treeseed dev`."
       ],
       beforeYouRun: [
         "Run from the tenant or workspace root you want to develop.",
-        "Use `--plan --json` when you want to inspect fixed web/API commands, setup steps, readiness checks, watched paths, and restart policy without starting services.",
-        "Use `--reset` when you want a fresh local D1 database, Mailpit inbox, generated worker bundle, and Wrangler temp output without deleting configuration.",
+        "From the Market repo root, dev automatically starts the local Market API, managed local PostgreSQL, and Market operations runner alongside the web UI.",
+        "Use `--plan --json` when you want to inspect fixed web/API/runner commands, setup steps, readiness checks, watched paths, and restart policy without starting services.",
+        "Use `--reset` when you want a fresh local D1 database, Market PostgreSQL state, Mailpit inbox, generated worker bundle, and Wrangler temp output without deleting configuration.",
         "Dev prints the local web URL after readiness; it does not open a browser unless you pass `--open on` or `--open auto`.",
         "Keep the foreground process running while you test. Press Ctrl+C to stop the supervised stack and free the local ports."
       ],
       examples: [
-        example("treeseed dev", "Start local Market development", "Run web and API locally and keep supervising them in the foreground."),
-        example("treeseed dev --reset", "Start from a fresh local runtime", "Clear disposable local dev state, rerun setup and D1 migrations, then start the dev supervisor."),
+        example("treeseed dev", "Start local Market development", "Run web, API, managed PostgreSQL setup, and the Market operations runner locally."),
+        example("treeseed dev --reset", "Start from a fresh local runtime", "Clear disposable local dev state, rerun setup and database migrations, then start the dev supervisor."),
         example("treeseed dev --reset --plan --json", "Inspect reset actions", "Emit the reset, setup, readiness, command, and watch plan without deleting local state or starting services."),
         example("treeseed dev --plan --json", "Inspect the runtime plan", "Emit a structured plan with setup steps, commands, ports, URLs, readiness checks, and watch entries."),
-        example("treeseed dev --web-runtime local --plan --json", "Inspect local web runtime", "Plan fixed web/API startup using the local Astro web runtime."),
-        example("treeseed dev --port 4322", "Change the web port", "Start the fixed web/API runtime with the Astro UI on a specific port."),
+        example("treeseed dev --web-runtime local --plan --json", "Inspect local web runtime", "Plan fixed web/API/runner startup using the local Astro web runtime."),
+        example("treeseed dev --port 4322", "Change the web port", "Start the fixed web/API/runner runtime with the Astro UI on a specific port."),
         example("treeseed dev --open on", "Open the browser explicitly", "Start the integrated runtime and launch the local web URL after readiness."),
         example("trsd dev", "Use the short alias", "Start the same local runtime through the shorter entrypoint."),
         example("treeseed dev --json", "Stream dev events", "Emit newline-delimited events while the long-running dev process supervises local services.")
       ],
       outcomes: [
-        "Starts fixed local web/API surfaces, waits for readiness, prints the local URL, and then remains attached as the live supervisor.",
+        "Starts fixed local web/API/runner surfaces, waits for readiness, prints the local URL, and then remains attached as the live supervisor.",
         "Restarts required crashed surfaces with capped exponential backoff and keeps setup/readiness failures alive for retry.",
         "Stops watchers first and then terminates service process groups when the foreground command exits."
       ]
@@ -1495,23 +1496,44 @@ const CLI_ONLY_OPERATION_SPECS = [
     name: "projects",
     aliases: [],
     group: "Utilities",
-    summary: "Inspect projects and access controls from the selected market.",
-    description: "List market projects and inspect staging/production access through the market API client.",
+    summary: "Inspect projects and run web deployment operations from the selected market.",
+    description: "List market projects, inspect access, and queue or inspect project web deployment operations through the Market API.",
     provider: "default",
     related: ["market", "teams", "config"],
-    usage: "treeseed projects [list|access|connect]",
-    arguments: [{ name: "action", description: "Projects action.", required: false }],
+    usage: "treeseed projects [list|access|deploy|publish|monitor|deployments|deployment]",
+    arguments: [
+      { name: "action", description: "Projects action.", required: false },
+      { name: "project-id", description: "Project id for deployment and access actions.", required: false },
+      { name: "deployment-id", description: "Deployment id for deployment detail, retry, resume, or cancel.", required: false }
+    ],
     options: [
       { name: "market", flags: "--market <id-or-url>", description: "Select a configured market id or direct market API URL.", kind: "string" },
       { name: "team", flags: "--team <team-id>", description: "Limit project list to a team.", kind: "string" },
+      { name: "environment", flags: "--environment <environment>", description: "Deployment environment for project web actions.", kind: "enum", values: ["staging", "prod"] },
+      { name: "wait", flags: "--wait", description: "Poll the queued deployment until it reaches a terminal state.", kind: "boolean" },
+      { name: "timeoutSeconds", flags: "--timeout-seconds <seconds>", description: "Maximum seconds to wait before returning timeout.", kind: "string" },
+      { name: "pollIntervalMs", flags: "--poll-interval-ms <milliseconds>", description: "Polling interval for --wait.", kind: "string" },
+      { name: "dryRun", flags: "--dry-run", description: "Queue a dry-run deployment request when supported.", kind: "boolean" },
+      { name: "reason", flags: "--reason <text>", description: "Presentation-safe reason stored on the deployment request.", kind: "string" },
+      { name: "idempotencyKey", flags: "--idempotency-key <key>", description: "Deterministic idempotency key for the deployment request.", kind: "string" },
+      { name: "yes", flags: "--yes", description: "Required confirmation for production deploy and publish actions.", kind: "boolean" },
+      { name: "limit", flags: "--limit <count>", description: "Maximum number of deployments to list.", kind: "string" },
       { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
     ],
-    examples: ["treeseed projects list", "treeseed projects access project_123"],
+    examples: [
+      "treeseed projects list",
+      "treeseed projects access project_123",
+      "treeseed projects deploy project_123 --environment staging --wait",
+      "treeseed projects publish project_123 --environment prod --yes",
+      "treeseed projects deployments project_123 --json",
+      "treeseed projects deployment project_123 dep_123"
+    ],
     help: {
-      longSummary: ["Projects reads project and environment access data from the selected market API using the SDK market client."],
-      whenToUse: ["Use this to confirm which market projects you can see and whether your account has staging or production admin access."],
-      beforeYouRun: ["Authenticate to the market and know the project id when inspecting a single project access summary."],
-      automationNotes: ["Use `--json` to capture project lists and access summaries for automation."]
+      longSummary: ["Projects reads project, access, and deployment state from the selected market API using the SDK market client."],
+      whenToUse: ["Use this to inspect projects, queue staging or production web deployment operations, and inspect the same deployment state shown in the Market UI."],
+      beforeYouRun: ["Authenticate to the market with `treeseed auth:login --market <selector>` and know the project id before queueing deployment work."],
+      automationNotes: ["Use `--json` to capture project lists, deployment records, events, and wait results for automation."],
+      warnings: ["Production deploy and publish require `--yes`; without it the CLI exits before calling the API."]
     },
     helpVisible: true,
     helpFeatured: false,
@@ -1523,16 +1545,28 @@ const CLI_ONLY_OPERATION_SPECS = [
     name: "capacity",
     aliases: [],
     group: "Utilities",
-    summary: "Operate the package-owned capacity provider runtime.",
-    description: "Run provider diagnostics, registration, and planning through the built @treeseed/agent capacity provider entrypoint.",
+    summary: "Inspect capacity plans and operate the package-owned capacity provider runtime.",
+    description: "Read Market capacity plans, migrate static providers to derived native capacity, and run provider diagnostics through the built @treeseed/agent entrypoint.",
     provider: "default",
     related: ["teams", "projects", "agents"],
-    usage: "treeseed capacity [doctor|register|plan|up|down|restart|logs|status|build|test-local]",
+    usage: "treeseed capacity [doctor|register|plan|migrate|up|down|restart|logs|status|build|test-local]",
     arguments: [{ name: "action", description: "Capacity action.", required: false }],
     options: [
       { name: "market", flags: "--market <id-or-url>", description: "Select a configured market id or direct market API URL.", kind: "string" },
       { name: "provider", flags: "--provider <provider-id>", description: "Provider id or local provider selector for diagnostics.", kind: "string" },
+      { name: "team", flags: "--team <team-id>", description: "Team id for Market capacity migration.", kind: "string" },
+      { name: "project", flags: "--project <project-id>", description: "Project id for Market capacity plan or allocation migration.", kind: "string" },
       { name: "environment", flags: "--environment <scope>", description: "Treeseed config scope used when resolving encrypted provider launch values.", kind: "enum", values: ["local", "staging", "prod"] },
+      { name: "toDerived", flags: "--to-derived", description: "Migrate a static provider to derived native capacity facts.", kind: "boolean" },
+      { name: "kind", flags: "--kind <provider-kind>", description: "Execution provider kind such as codex_subscription or openrouter.", kind: "string" },
+      { name: "nativeUnit", flags: "--native-unit <unit>", description: "Native unit humans can forecast, such as wall_minute, usd, or billable_token.", kind: "string" },
+      { name: "limit", flags: "--limit <amount>", description: "Native limit amount for the selected scope.", kind: "string" },
+      { name: "scope", flags: "--scope <scope>", description: "Native limit scope, usually daily or monthly.", kind: "string" },
+      { name: "resetCadence", flags: "--reset-cadence <cadence>", description: "Native limit reset cadence.", kind: "string" },
+      { name: "quotaVisibility", flags: "--quota-visibility <mode>", description: "Whether quota remaining is visible, sampled, or opaque.", kind: "string" },
+      { name: "reserveBufferPercent", flags: "--reserve-buffer-percent <percent>", description: "Native reserve buffer percentage.", kind: "string" },
+      { name: "maxConcurrentWorkers", flags: "--max-concurrent-workers <count>", description: "Maximum workers this execution provider can run concurrently.", kind: "string" },
+      { name: "portfolioAllocationPercent", flags: "--portfolio-allocation-percent <percent>", description: "Optional project/team allocation percent to create during migration.", kind: "string" },
       { name: "dataDir", flags: "--data-dir <path>", description: "Host data directory mounted into the provider container at /data.", kind: "string" },
       { name: "agentPackageRoot", flags: "--agent-package-root <path>", description: "Path to a built @treeseed/agent package root.", kind: "string" },
       { name: "diagnostic", flags: "--diagnostic", description: "Start lifecycle commands without live Market registration or provider credentials.", kind: "boolean" },
@@ -1541,8 +1575,10 @@ const CLI_ONLY_OPERATION_SPECS = [
     ],
     examples: [
       "treeseed capacity doctor --market local --provider local",
+      "treeseed capacity plan --market local --project project_123 --environment local",
       "treeseed capacity register --market local --provider local --dry-run --json",
       "treeseed capacity plan --market local --provider local --dry-run --json",
+      "treeseed capacity migrate --to-derived --market local --team team_123 --provider provider_123 --kind codex_subscription --native-unit wall_minute --limit 480 --scope daily --dry-run",
       "treeseed capacity build",
       "treeseed capacity up --market local --provider local",
       "treeseed capacity up --market local --provider local --diagnostic",
@@ -1552,8 +1588,8 @@ const CLI_ONLY_OPERATION_SPECS = [
       "treeseed capacity test-local"
     ],
     help: {
-      longSummary: ["Capacity invokes the package-owned @treeseed/agent provider runtime for local diagnostics, registration previews, portfolio planning, and Docker/Compose lifecycle commands."],
-      whenToUse: ["Use this when validating a self-hosted capacity provider install, checking provider runtime output, or running the local provider stack."],
+      longSummary: ["Capacity reads Market project capacity plans, migrates provider setup toward derived native facts, and invokes the package-owned @treeseed/agent provider runtime for local diagnostics and Docker/Compose lifecycle commands."],
+      whenToUse: ["Use this when inspecting native-to-credit projection, validating a self-hosted capacity provider install, checking provider runtime output, or running the local provider stack."],
       beforeYouRun: ["Build @treeseed/agent first, or pass --agent-package-root to a built package. Use `trsd config` for encrypted provider values; capacity commands do not write plaintext env files."],
       automationNotes: ["Use `--json` for stable provider runtime output. `up` runs live local provider mode by default; pass `--diagnostic` or use `test-local` for diagnostics without provider secrets."]
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/cli",
-  "version": "0.10.5",
+  "version": "0.10.7",
   "description": "Operator-facing Treeseed CLI package.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -31,7 +31,7 @@
     "setup:ci": "npm ci",
     "build": "npm run build:dist",
     "lint": "npm run build:dist",
-    "test": "npm run build:dist && node --test --test-concurrency=1 ./scripts/treeseed-help.test.mjs ./scripts/seed.test.mjs ./scripts/wrapper-package.test.mjs",
+    "test": "npm run build:dist && node --test --test-concurrency=1 ./scripts/treeseed-help.test.mjs ./scripts/seed.test.mjs ./scripts/projects-deploy.test.mjs ./scripts/wrapper-package.test.mjs",
     "build:dist": "node ./scripts/run-ts.mjs ./scripts/build-dist.ts",
     "prepare": "node ./scripts/prepare.mjs",
     "prepack": "npm run build:dist",
@@ -45,7 +45,7 @@
     "release:publish": "node ./scripts/run-ts.mjs ./scripts/publish-package.ts"
   },
   "dependencies": {
-    "@treeseed/sdk": "github:treeseed-ai/sdk#0.10.11",
+    "@treeseed/sdk": "github:treeseed-ai/sdk#0.10.13",
     "ink": "^7.0.0",
     "react": "^19.2.5"
   },