@treeseed/cli 0.8.19 → 0.9.3

package/dist/cli/handlers/capacity.js

@@ -1,144 +1,288 @@
-import { guidedResult } from "./utils.js";
-import { createMarketClientForInvocation } from "./market-utils.js";
-function required(value, message) {
-  if (typeof value === "string" && value.trim()) return value.trim();
-  throw new Error(message);
-}
-const handleCapacity = async (invocation, context) => {
-  const action = invocation.positionals[0] ?? "status";
-  const { profile, client } = createMarketClientForInvocation(invocation, context, { requireAuth: true });
-  const teamId = typeof invocation.args.team === "string" ? invocation.args.team : typeof profile.teamId === "string" ? profile.teamId : null;
-  if (action === "status") {
-    const team = required(teamId, "Usage: treeseed capacity status --team <team-id>");
-    const response = await client.teamCapacity(team);
-    const summary = response.payload.summary;
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+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 { fail, guidedResult } from "./utils.js";
+const ENTRYPOINT_RELATIVE_PATH = ["dist", "provider", "entrypoint.js"];
+const COMPOSE_FILE_NAME = "compose.capacity-provider.yml";
+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"]);
+function stringArg(invocation, name) {
+  const value = invocation.args[name];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function boolArg(invocation, name) {
+  return invocation.args[name] === true;
+}
+function readPackageName(packageRoot) {
+  const packageJsonPath = resolve(packageRoot, "package.json");
+  if (!existsSync(packageJsonPath)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return parsed.name ?? null;
+  } catch {
+    return null;
+  }
+}
+function agentEntrypoint(packageRoot) {
+  return resolve(packageRoot, ...ENTRYPOINT_RELATIVE_PATH);
+}
+function resolveAgentPackageRoot(invocation, context) {
+  const explicitRoot = stringArg(invocation, "agentPackageRoot");
+  if (explicitRoot) {
+    return resolve(context.cwd, explicitRoot);
+  }
+  if (readPackageName(context.cwd) === "@treeseed/agent") {
+    return context.cwd;
+  }
+  const workspaceRoot = findNearestTreeseedWorkspaceRoot(context.cwd);
+  const workspaceAgentRoot = workspaceRoot ? resolve(workspaceRoot, "packages", "agent") : null;
+  if (workspaceAgentRoot && existsSync(resolve(workspaceAgentRoot, "package.json"))) {
+    return workspaceAgentRoot;
+  }
+  const nearestProjectRoot = findNearestTreeseedRoot(context.cwd);
+  const projectAgentRoot = nearestProjectRoot ? resolve(nearestProjectRoot, "packages", "agent") : null;
+  if (projectAgentRoot && existsSync(resolve(projectAgentRoot, "package.json"))) {
+    return projectAgentRoot;
+  }
+  const installedRoot = resolve(context.cwd, "node_modules", "@treeseed", "agent");
+  if (existsSync(resolve(installedRoot, "package.json"))) {
+    return installedRoot;
+  }
+  return null;
+}
+function resolveAgentPackage(invocation, context, options = {}) {
+  const packageRoot = resolveAgentPackageRoot(invocation, context);
+  if (!packageRoot) {
+    throw new Error(
+      "Unable to locate @treeseed/agent. Build the workspace package, install @treeseed/agent, or pass --agent-package-root."
+    );
+  }
+  const entrypointPath = agentEntrypoint(packageRoot);
+  if (options.requireEntrypoint !== false && !existsSync(entrypointPath)) {
+    throw new Error(
+      `Missing provider runtime at ${entrypointPath}. Run npm -w packages/agent run build:dist or pass --agent-package-root to a built package.`
+    );
+  }
+  const composeFilePath = resolve(packageRoot, COMPOSE_FILE_NAME);
+  return { packageRoot, entrypointPath, composeFilePath };
+}
+function providerSelector(invocation) {
+  return stringArg(invocation, "provider") ?? "local";
+}
+function environmentSelector(invocation) {
+  return stringArg(invocation, "environment") ?? "local";
+}
+function resolveMarket(invocation) {
+  return resolveMarketProfile(stringArg(invocation, "market") ?? "local");
+}
+function resolveTenantRoot(context, agentPackageRoot) {
+  return findNearestTreeseedRoot(context.cwd) ?? (readPackageName(agentPackageRoot) === "@treeseed/agent" ? agentPackageRoot : context.cwd);
+}
+function defaultHostDataDir(context) {
+  const tenantRoot = findNearestTreeseedRoot(context.cwd) ?? context.cwd;
+  return resolve(tenantRoot, DEFAULT_HOST_DATA_DIR);
+}
+function providerProjectName(invocation) {
+  const provider = providerSelector(invocation).replace(/[^A-Za-z0-9_.-]+/gu, "-").replace(/^-+|-+$/gu, "") || "local";
+  return `${DEFAULT_PROJECT_NAME}-${provider}`;
+}
+function composeCommandArgs(composeFilePath, projectName, action) {
+  const base = ["compose", "-f", composeFilePath, "-p", projectName];
+  switch (action) {
+    case "up":
+      return [...base, "up", "-d"];
+    case "down":
+      return [...base, "down"];
+    case "restart":
+      return [...base, "restart"];
+    case "logs":
+      return [...base, "logs", "--tail", "200"];
+    case "status":
+      return [...base, "ps"];
+    default:
+      return base;
+  }
+}
+function lifecycleActionRequiresConnection(action) {
+  return action === "up" || action === "restart";
+}
+function runLifecycleAction(action, invocation, context) {
+  const agentPackage = resolveAgentPackage(invocation, context, { requireEntrypoint: action !== "build" });
+  if (action !== "build" && action !== "test-local" && !existsSync(agentPackage.composeFilePath)) {
+    return fail(`Missing ${COMPOSE_FILE_NAME} in ${agentPackage.packageRoot}. Build or reinstall @treeseed/agent with Phase 3 container assets.`);
+  }
+  if (action === "build" || action === "test-local") {
+    const script = action === "build" ? "capacity-provider:build" : "capacity-provider:test-local";
+    const result2 = context.spawn("npm", ["run", script], {
+      cwd: agentPackage.packageRoot,
+      env: context.env,
+      stdio: "inherit"
+    });
     return guidedResult({
-      command: "capacity",
-      summary: "Team helper capacity status",
+      command: `capacity ${action}`,
+      summary: result2.status === 0 ? `Capacity provider ${action === "build" ? "image build" : "container smoke test"} completed.` : `Capacity provider ${action === "build" ? "image build" : "container smoke test"} failed.`,
       facts: [
-        { label: "Market", value: profile.id },
-        { label: "Team", value: team },
-        { label: "Monthly remaining", value: summary?.monthlyRemainingCredits },
-        { label: "Daily remaining", value: summary?.dailyRemainingCredits },
-        { label: "Active providers", value: summary?.activeProviderCount }
+        { label: "Agent package", value: agentPackage.packageRoot },
+        { label: "Script", value: script },
+        { label: "Exit code", value: result2.status ?? 1 }
       ],
-      report: { marketId: profile.id, teamId: team, capacity: response.payload }
+      exitCode: result2.status ?? 1,
+      report: {
+        action,
+        agentPackageRoot: agentPackage.packageRoot,
+        script
+      }
     });
   }
-  if (action === "providers") {
-    const subcommand = invocation.positionals[1] ?? "list";
-    const team = required(teamId, "Usage: treeseed capacity providers list --team <team-id>");
-    if (subcommand === "list") {
-      const response = await client.teamCapacity(team);
-      const providers = response.payload.providers ?? [];
-      return guidedResult({
-        command: "capacity",
-        summary: `Found ${providers.length} helper capacity provider${providers.length === 1 ? "" : "s"}.`,
-        sections: [{
-          title: "Providers",
-          lines: providers.map((provider) => `${provider.id}  ${provider.name}  ${provider.status}  workers=${provider.maxConcurrentWorkers ?? 0}`)
-        }],
-        report: { marketId: profile.id, teamId: team, providers }
-      });
-    }
-    if (subcommand === "connect") {
-      const response = await client.launchManagedCapacityProvider(team, { launchSource: "cli" });
-      return guidedResult({
-        command: "capacity",
-        summary: "TreeSeed-managed helper capacity is connected.",
-        facts: [
-          { label: "Provider", value: response.payload.provider?.id },
-          { label: "Security code prefix", value: response.payload.apiKey?.keyPrefix }
-        ],
-        report: { marketId: profile.id, teamId: team, result: response.payload }
-      });
+  const diagnostic = boolArg(invocation, "diagnostic") || action === "test-local";
+  const market = resolveMarket(invocation);
+  const hostDataDirInput = stringArg(invocation, "dataDir") ?? context.env.TREESEED_PROVIDER_HOST_DATA_DIR ?? defaultHostDataDir(context);
+  const resolvedHostDataDir = resolve(context.cwd, hostDataDirInput);
+  const tenantRoot = resolveTenantRoot(context, agentPackage.packageRoot);
+  const launch = resolveCapacityProviderLaunchEnvironment({
+    tenantRoot,
+    scope: environmentSelector(invocation),
+    env: context.env,
+    diagnostic,
+    requireConnection: lifecycleActionRequiresConnection(action),
+    overrides: {
+      TREESEED_MARKET_URL: market.baseUrl,
+      TREESEED_MARKET_ID: market.id,
+      TREESEED_PROVIDER_HOST_DATA_DIR: resolvedHostDataDir,
+      TREESEED_PROVIDER_ENVIRONMENT: providerSelector(invocation),
+      ...diagnostic ? { TREESEED_PROVIDER_STARTUP_MODE: "diagnostic" } : {}
     }
-    if (subcommand === "keys") {
-      const keyAction = invocation.positionals[2] ?? "reset";
-      const providerId = required(invocation.args.provider, "Usage: treeseed capacity providers keys reset --provider <provider-id>");
-      if (keyAction === "reset") {
-        const response = await client.resetCapacityProviderApiKey(providerId, { name: "Provider security code" });
-        return guidedResult({
-          command: "capacity",
-          summary: "Provider security code was reset.",
-          facts: [
-            { label: "Provider", value: providerId },
-            { label: "Prefix", value: response.payload.key?.keyPrefix },
-            { label: "Security access code", value: response.payload.plaintextKey }
-          ],
-          report: { marketId: profile.id, providerId, result: response.payload }
-        });
-      }
-      if (keyAction === "revoke") {
-        const keyId = required(invocation.args.key, "Usage: treeseed capacity providers keys revoke --provider <provider-id> --key <key-id>");
-        const response = await client.revokeCapacityProviderApiKey(providerId, keyId);
-        return guidedResult({
-          command: "capacity",
-          summary: "Provider security code was revoked.",
-          facts: [
-            { label: "Provider", value: providerId },
-            { label: "Key", value: keyId }
-          ],
-          report: { marketId: profile.id, providerId, keyId, result: response.payload }
-        });
+  });
+  const hostDataDir = resolvedHostDataDir;
+  mkdirSync(hostDataDir, { recursive: true });
+  const projectName = providerProjectName(invocation);
+  const args = composeCommandArgs(agentPackage.composeFilePath, projectName, action);
+  const result = context.spawn("docker", args, {
+    cwd: agentPackage.packageRoot,
+    env: {
+      ...context.env,
+      ...launch.env
+    },
+    stdio: "inherit"
+  });
+  return guidedResult({
+    command: `capacity ${action}`,
+    summary: result.status === 0 ? `Capacity provider ${action} completed${diagnostic ? " in diagnostic mode" : ""}.` : `Capacity provider ${action} failed.`,
+    facts: [
+      { label: "Market", value: `${market.id} (${market.baseUrl})` },
+      { label: "Provider", value: providerSelector(invocation) },
+      { label: "Mode", value: diagnostic ? "diagnostic" : "live" },
+      { label: "Compose project", value: projectName },
+      { label: "Agent package", value: agentPackage.packageRoot },
+      { label: "Data directory", value: hostDataDir },
+      { label: "Exit code", value: result.status ?? 1 }
+    ],
+    sections: [
+      {
+        title: "Environment",
+        lines: Object.entries(launch.redactedEnv).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}=${value}`)
       }
+    ],
+    exitCode: result.status ?? 1,
+    report: {
+      action,
+      agentPackageRoot: agentPackage.packageRoot,
+      composeFile: agentPackage.composeFilePath,
+      composeProject: projectName,
+      market: { id: market.id, baseUrl: market.baseUrl },
+      provider: providerSelector(invocation),
+      diagnostic,
+      redactedEnv: launch.redactedEnv
     }
-    return { exitCode: 1, stderr: [`Unknown capacity providers action: ${subcommand}`] };
-  }
-  if (action === "grants") {
-    const subcommand = invocation.positionals[1] ?? "list";
-    const team = required(teamId, "Usage: treeseed capacity grants list --team <team-id>");
-    if (subcommand === "list") {
-      const response = await client.capacityGrants(team);
-      return guidedResult({
-        command: "capacity",
-        summary: `Found ${response.payload.length} capacity grant${response.payload.length === 1 ? "" : "s"}.`,
-        sections: [{
-          title: "Grants",
-          lines: response.payload.map((grant) => `${grant.id}  ${grant.grantScope}  daily=${grant.dailyCreditLimit ?? "policy"}  monthly=${grant.monthlyCreditLimit ?? "policy"}`)
-        }],
-        report: { marketId: profile.id, teamId: team, grants: response.payload }
-      });
+  });
+}
+function invokeProviderEntrypoint(action, invocation, context) {
+  const agentPackage = resolveAgentPackage(invocation, context);
+  const market = resolveMarket(invocation);
+  const args = [agentPackage.entrypointPath, action, "--market", market.id, "--provider", providerSelector(invocation)];
+  if (boolArg(invocation, "dryRun") || action === "doctor" || action === "plan") {
+    args.push("--dry-run");
+  }
+  if (context.outputFormat === "json" || boolArg(invocation, "json")) {
+    args.push("--json");
+  }
+  const result = spawnSync(process.execPath, args, {
+    cwd: agentPackage.packageRoot,
+    env: {
+      ...context.env,
+      TREESEED_MARKET_URL: market.baseUrl,
+      TREESEED_MARKET_ID: market.id,
+      TREESEED_PROVIDER_ENVIRONMENT: providerSelector(invocation)
+    },
+    encoding: "utf8"
+  });
+  const stdout = result.stdout.trim();
+  const stderr = result.stderr.trim();
+  let report = null;
+  if (stdout.startsWith("{")) {
+    try {
+      report = JSON.parse(stdout);
+    } catch {
+      report = null;
     }
-    if (subcommand === "create") {
-      const providerId = required(invocation.args.provider, "Usage: treeseed capacity grants create --team <team-id> --provider <provider-id>");
-      const response = await client.createCapacityGrant(team, {
-        capacityProviderId: providerId,
-        projectId: typeof invocation.args.project === "string" ? invocation.args.project : null,
-        environment: typeof invocation.args.environment === "string" ? invocation.args.environment : null,
-        dailyCreditLimit: Number(invocation.args.daily ?? 25),
-        monthlyCreditLimit: Number(invocation.args.monthly ?? 500),
-        overflowPolicy: typeof invocation.args.overflow === "string" ? invocation.args.overflow : "approval_required"
-      });
-      return guidedResult({
-        command: "capacity",
-        summary: "Capacity grant created.",
-        facts: [
-          { label: "Grant", value: response.payload.id },
-          { label: "Provider", value: providerId }
-        ],
-        report: { marketId: profile.id, teamId: team, grant: response.payload }
-      });
+  }
+  if (context.outputFormat === "json") {
+    return {
+      exitCode: result.status ?? 1,
+      stdout: stdout ? [stdout] : [],
+      stderr: stderr ? [stderr] : [],
+      report: report ?? {
+        ok: result.status === 0,
+        action,
+        stdout,
+        stderr,
+        agentPackageRoot: agentPackage.packageRoot
+      }
+    };
+  }
+  return guidedResult({
+    command: `capacity ${action}`,
+    summary: result.status === 0 ? `Capacity provider ${action} completed.` : `Capacity provider ${action} failed.`,
+    facts: [
+      { label: "Market", value: `${market.id} (${market.baseUrl})` },
+      { label: "Provider", value: providerSelector(invocation) },
+      { label: "Agent package", value: agentPackage.packageRoot },
+      { label: "Exit code", value: result.status ?? 1 }
+    ],
+    sections: [
+      { title: "Output", lines: stdout ? stdout.split(/\r?\n/u) : [] },
+      { title: "Errors", lines: stderr ? stderr.split(/\r?\n/u) : [] }
+    ],
+    exitCode: result.status ?? 1,
+    report: report ?? {
+      ok: result.status === 0,
+      action,
+      agentPackageRoot: agentPackage.packageRoot
+    }
+  });
+}
+const handleCapacity = (invocation, context) => {
+  const action = invocation.positionals[0] ?? "doctor";
+  if (PROVIDER_LIFECYCLE_ACTIONS.has(action)) {
+    try {
+      return runLifecycleAction(action, invocation, context);
+    } catch (error) {
+      return fail(error instanceof Error ? error.message : String(error));
     }
-    return { exitCode: 1, stderr: [`Unknown capacity grants action: ${subcommand}`] };
   }
-  if (action === "enqueue") {
-    const projectId = required(invocation.args.project, "Usage: treeseed capacity enqueue --project <project-id> --task-kind <kind>");
-    const response = await client.enqueueAgentTask(projectId, {
-      taskKind: typeof invocation.args.taskKind === "string" ? invocation.args.taskKind : typeof invocation.args.task === "string" ? invocation.args.task : "proposal.draft",
-      environment: typeof invocation.args.environment === "string" ? invocation.args.environment : "staging"
-    });
-    return guidedResult({
-      command: "capacity",
-      summary: "Budgeted agent task enqueued.",
-      facts: [
-        { label: "Task", value: response.payload.task?.id },
-        { label: "Reserved credits", value: response.payload.reservation?.reservedCredits }
-      ],
-      report: { marketId: profile.id, projectId, result: response.payload }
-    });
+  if (PROVIDER_ENTRYPOINT_ACTIONS.has(action)) {
+    try {
+      return invokeProviderEntrypoint(action, invocation, context);
+    } catch (error) {
+      return fail(error instanceof Error ? error.message : String(error));
+    }
   }
-  return { exitCode: 1, stderr: [`Unknown capacity action: ${action}`] };
+  return fail(`Unknown capacity action "${action}". Use doctor, register, plan, build, up, down, restart, logs, status, or test-local.`);
 };
 export {
   handleCapacity

package/dist/cli/handlers/dev.js

@@ -3,6 +3,7 @@ import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
 import { ensureLocalWorkspaceLinks, findNearestTreeseedWorkspaceRoot, resolveTreeseedLaunchEnvironment } from "@treeseed/sdk/workflow-support";
 import { workflowErrorResult } from "./workflow.js";
+import { fail } from "./utils.js";
 const require2 = createRequire(import.meta.url);
 function resolveCoreDevEntrypoint(cwd) {
   const workspacePackageJsonPath = resolve(cwd, "packages", "core", "package.json");
@@ -42,10 +43,16 @@ function resolveCoreDevEntrypoint(cwd) {
 }
 const handleDev = async (invocation, context) => {
   try {
-    const managerMode = invocation.commandName === "dev:manager";
+    if (invocation.commandName !== "dev") {
+      return fail("`trsd dev` only starts the Market web/API dev 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.`);
+    }
     const feedback = typeof invocation.args.feedback === "string" ? invocation.args.feedback : void 0;
     const watch = feedback !== "off";
-    const passthroughArgs = [];
+    const passthroughArgs = ["--surfaces", "web,api"];
     const forwardStringOption = (name, flag) => {
       const value = invocation.args[name];
       if (typeof value === "string" && value.trim().length > 0) {
@@ -57,38 +64,18 @@ const handleDev = async (invocation, context) => {
         passthroughArgs.push(flag);
       }
     };
-    if (managerMode) {
-      const explicitSurfaces = typeof invocation.args.surfaces === "string" && invocation.args.surfaces.trim() ? invocation.args.surfaces.trim() : typeof invocation.args.surface === "string" && invocation.args.surface.trim() ? invocation.args.surface.trim() : null;
-      const surfaces = explicitSurfaces ?? (invocation.args.withWorker === true ? "manager,worker" : "manager");
-      passthroughArgs.push("--surfaces", surfaces);
-    } else {
-      forwardStringOption("surface", "--surface");
-      forwardStringOption("surfaces", "--surfaces");
-    }
     forwardStringOption("host", "--host");
     forwardStringOption("port", "--port");
+    forwardStringOption("webRuntime", "--web-runtime");
     forwardStringOption("apiHost", "--api-host");
     forwardStringOption("apiPort", "--api-port");
-    forwardStringOption("managerPort", "--manager-port");
     forwardStringOption("setup", "--setup");
     forwardStringOption("feedback", "--feedback");
     forwardStringOption("open", "--open");
     forwardBooleanOption("plan", "--plan");
     forwardBooleanOption("reset", "--reset");
+    forwardBooleanOption("force", "--force");
     forwardBooleanOption("json", "--json");
-    const docsAutomationMode = typeof invocation.args.docsAutomation === "string" ? invocation.args.docsAutomation.trim() : "";
-    const workdayId = typeof invocation.args.workdayId === "string" ? invocation.args.workdayId.trim() : "";
-    const capacityBudget = typeof invocation.args.capacityBudget === "string" ? invocation.args.capacityBudget.trim() : "";
-    const approvalPolicy = typeof invocation.args.approvalPolicy === "string" ? invocation.args.approvalPolicy.trim() : "";
-    const devManagerEnv = managerMode ? {
-      TREESEED_DOCS_AUTOMATION_MODE: docsAutomationMode || "on",
-      ...workdayId ? { TREESEED_WORKDAY_ID: workdayId } : {},
-      ...capacityBudget ? {
-        TREESEED_CAPACITY_BUDGET: capacityBudget,
-        TREESEED_WORKDAY_TASK_CREDIT_BUDGET: capacityBudget
-      } : {},
-      TREESEED_APPROVAL_POLICY: approvalPolicy || "manual"
-    } : {};
     const workspaceRoot = findNearestTreeseedWorkspaceRoot(context.cwd);
     const workspaceLinksMode = typeof invocation.args.workspaceLinks === "string" ? invocation.args.workspaceLinks : void 0;
     const workspaceLinks = workspaceRoot ? ensureLocalWorkspaceLinks(workspaceRoot, { env: context.env, mode: workspaceLinksMode }) : null;
@@ -102,7 +89,8 @@ const handleDev = async (invocation, context) => {
       env: resolveTreeseedLaunchEnvironment({
         tenantRoot: context.cwd,
         scope: "local",
-        baseEnv: { ...process.env, ...context.env ?? {}, ...devManagerEnv }
+        baseEnv: { ...process.env, ...context.env ?? {} },
+        overrides: {}
       }),
       stdio: "inherit"
     });
@@ -111,18 +99,11 @@ const handleDev = async (invocation, context) => {
       suppressJsonResult: invocation.args.json === true,
       report: {
         command: "dev",
-        alias: managerMode ? "dev:manager" : invocation.commandName,
+        alias: invocation.commandName,
         ok: (result.status ?? 1) === 0,
         watch,
         executable: resolved.command,
         args,
-        docsAutomation: managerMode ? {
-          mode: docsAutomationMode || "on",
-          workdayId: workdayId || null,
-          capacityBudget: capacityBudget || null,
-          approvalPolicy: approvalPolicy || "manual",
-          withWorker: invocation.args.withWorker === true
-        } : void 0,
         workspaceLinks
       }
     };

package/dist/cli/handlers/seed.js

@@ -2,21 +2,57 @@ import { pathToFileURL } from "node:url";
 import { dirname, resolve } from "node:path";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { formatSeedDiagnostics, formatSeedPlan, loadAndPlanSeed } from "@treeseed/sdk/seeds";
+import { persistCapacityProviderConnectionToTreeseedConfig } from "@treeseed/sdk/capacity-provider";
 import { MarketApiError } from "@treeseed/sdk/market-client";
 import { createMarketClientForInvocation, marketAuthRoot, marketSelector } from "./market-utils.js";
-import { resolveMarketProfile, resolveMarketSession } from "@treeseed/sdk/market-client";
+import { MarketClient, resolveMarketProfile, resolveMarketSession, setMarketSession } from "@treeseed/sdk/market-client";
 async function loadLocalSeedModule(projectRoot) {
   const apiModulePath = resolve(projectRoot, "src", "lib", "market", "seeds", "local-api.js");
-  const moduleUrl = pathToFileURL(existsSync(apiModulePath) ? apiModulePath : resolve(projectRoot, "src", "lib", "market", "seeds", "apply.js")).href;
-  return await import(moduleUrl);
+  const applyModulePath = resolve(projectRoot, "src", "lib", "market", "seeds", "apply.js");
+  const applyModule = await import(pathToFileURL(applyModulePath).href);
+  if (!existsSync(apiModulePath)) {
+    return applyModule;
+  }
+  const apiModule = await import(pathToFileURL(apiModulePath).href);
+  return {
+    ...applyModule,
+    ...apiModule
+  };
+}
+function sessionExpiresSoon(session) {
+  if (!session.expiresAt) return false;
+  const expiresAt = Date.parse(session.expiresAt);
+  return Number.isFinite(expiresAt) && expiresAt <= Date.now() + 6e4;
 }
-function requireLocalSeedSession(invocation, context) {
+async function requireLocalSeedSession(invocation, context) {
   const selector = marketSelector(invocation) ?? "local";
   const profile = resolveMarketProfile(selector);
-  const session = resolveMarketSession(marketAuthRoot(context), profile.id);
+  const tenantRoot = marketAuthRoot(context);
+  const session = resolveMarketSession(tenantRoot, profile.id);
   if (!session?.accessToken) {
     throw new Error(`Not logged in to market "${profile.id}". Run treeseed auth:login --market ${profile.id}.`);
   }
+  if (sessionExpiresSoon(session) && session.refreshToken) {
+    try {
+      const refreshed = await new MarketClient({ profile, userAgent: "treeseed-cli" }).refreshToken({ refreshToken: session.refreshToken });
+      if (refreshed.ok) {
+        const nextSession = {
+          marketId: profile.id,
+          accessToken: refreshed.accessToken,
+          refreshToken: refreshed.refreshToken,
+          expiresAt: refreshed.expiresAt,
+          principal: refreshed.principal
+        };
+        setMarketSession(tenantRoot, nextSession);
+        return { profile, session: nextSession };
+      }
+    } catch {
+      throw new Error(`Login for market "${profile.id}" expired. Run treeseed auth:login --market ${profile.id}.`);
+    }
+  }
+  if (sessionExpiresSoon(session)) {
+    throw new Error(`Login for market "${profile.id}" expired. Run treeseed auth:login --market ${profile.id}.`);
+  }
   return { profile, session };
 }
 function seedRequestBody(invocation) {
@@ -70,11 +106,44 @@ function formatCapacityProviderKeyNotes(result) {
   if (created.length === 0) return [];
   return [
     "",
-    "Provider security codes:",
-    ...created.map((entry) => `  ${String(entry.providerName ?? entry.providerKey ?? entry.providerId)} (${String(entry.keyPrefix ?? "new key")}): ${String(entry.plaintextKey ?? "created")}`),
-    "  Copy these now. TreeSeed will not show the plaintext codes again."
+    "Provider connection:",
+    ...created.map((entry) => `  ${String(entry.providerName ?? entry.providerKey ?? entry.providerId)} (${String(entry.keyPrefix ?? "new key")}): stored in encrypted Treeseed config`),
+    "  Use `treeseed capacity up --market local --provider local` to launch the provider."
   ];
 }
+function redactLocalCapacityProviderKeys(result) {
+  const capacityProviderKeys = result.capacityProviderKeys && typeof result.capacityProviderKeys === "object" ? result.capacityProviderKeys : null;
+  if (!capacityProviderKeys) return result;
+  return {
+    ...result,
+    capacityProviderKeys: {
+      ...capacityProviderKeys,
+      created: Array.isArray(capacityProviderKeys.created) ? capacityProviderKeys.created.map((entry) => {
+        if (!entry || typeof entry !== "object") return entry;
+        const { plaintextKey: _plaintextKey, ...safeEntry } = entry;
+        return {
+          ...safeEntry,
+          storedInTreeseedConfig: true
+        };
+      }) : []
+    }
+  };
+}
+function storeLocalCapacityProviderConnection(input) {
+  const capacityProviderKeys = input.result.capacityProviderKeys && typeof input.result.capacityProviderKeys === "object" ? input.result.capacityProviderKeys : null;
+  const created = Array.isArray(capacityProviderKeys?.created) ? capacityProviderKeys.created : [];
+  const first = created.find((entry) => typeof entry.plaintextKey === "string" && String(entry.plaintextKey).length > 0);
+  if (!first) return null;
+  return persistCapacityProviderConnectionToTreeseedConfig({
+    tenantRoot: input.context.cwd,
+    scope: "local",
+    marketUrl: input.profile.baseUrl,
+    marketId: input.profile.id,
+    apiKey: String(first.plaintextKey),
+    providerHostDataDir: ".treeseed/local-capacity-provider/data",
+    providerEnvironment: "local"
+  });
+}
 function remoteSeedError(error, command) {
   if (error instanceof MarketApiError) {
     const payload = error.payload && typeof error.payload === "object" ? error.payload : { error: error.message };
@@ -127,7 +196,7 @@ async function handleSeedExport(invocation, context) {
       const { client } = createMarketClientForInvocation(invocation, context, { requireAuth: true });
       payload = await client.exportSeed(team, body);
     } else {
-      const { session } = requireLocalSeedSession(invocation, context);
+      const { session } = await requireLocalSeedSession(invocation, context);
       const localModule = await loadLocalSeedModule(context.cwd);
       const exporter = localModule.exportLocalSeedViaApiFromCli ?? localModule.exportSeedFromCli;
       if (typeof exporter !== "function") {
@@ -201,27 +270,16 @@ const handleSeed = async (invocation, context) => {
       }
     };
   }
-  const localAuth = planned.plan.environments.every((environment) => environment === "local") && !wantsValidate ? (() => {
-    try {
-      return requireLocalSeedSession(invocation, context);
-    } catch (error) {
-      return { error };
-    }
-  })() : null;
-  if (localAuth && "error" in localAuth) {
-    return remoteSeedError(localAuth.error, "seed");
-  }
   if (!wantsApply && !wantsValidate && planned.plan.environments.length === 1 && planned.plan.environments[0] === "local") {
     try {
       const localModule = await loadLocalSeedModule(context.cwd);
-      const localPlanner = localModule.planLocalSeedViaApiFromCli ?? localModule.planLocalSeedFromCli;
+      const localPlanner = localModule.planLocalSeedFromCli ?? localModule.planLocalSeedViaApiFromCli;
       if (typeof localPlanner === "function") {
         const localPlanned = await localPlanner({
           projectRoot: context.cwd,
           seedName,
           environments: typeof invocation.args.environments === "string" ? invocation.args.environments : void 0,
           mode,
-          accessToken: localAuth?.session.accessToken,
           env: context.env
         });
         if (localPlanned.plan) {
@@ -250,6 +308,12 @@ const handleSeed = async (invocation, context) => {
         return remoteSeedError(error, "seed");
       }
     }
+    let localAuth;
+    try {
+      localAuth = await requireLocalSeedSession(invocation, context);
+    } catch (error) {
+      return remoteSeedError(error, "seed");
+    }
     const localModule = await loadLocalSeedModule(context.cwd);
     const runner = localModule.applyLocalSeedViaApiFromCli ?? localModule.applyLocalSeedFromCli;
     if (typeof runner !== "function") {
@@ -263,6 +327,26 @@ const handleSeed = async (invocation, context) => {
       accessToken: localAuth?.session.accessToken,
       env: context.env
     });
+    let providerConnection = null;
+    try {
+      providerConnection = storeLocalCapacityProviderConnection({
+        context,
+        profile: localAuth.profile,
+        result: applied.result
+      });
+    } catch (error) {
+      const message2 = `Unable to store local capacity provider connection in encrypted Treeseed config. ${error instanceof Error ? error.message : String(error)}`;
+      return {
+        exitCode: 4,
+        stderr: [message2],
+        report: {
+          command: "seed",
+          ok: false,
+          error: message2
+        }
+      };
+    }
+    const safeResult = redactLocalCapacityProviderKeys(applied.result);
     const message = "Local seed apply completed.";
     return {
       exitCode: 0,
@@ -275,7 +359,7 @@ const handleSeed = async (invocation, context) => {
         `  unchanged: ${applied.plan.summary.unchanged}`,
         `  skipped: ${applied.plan.summary.skip}`,
         `  failed: ${applied.plan.summary.error}`,
-        ...formatCapacityProviderKeyNotes(applied.result)
+        ...formatCapacityProviderKeyNotes(safeResult)
       ],
       report: {
         ...applied.plan,
@@ -283,7 +367,14 @@ const handleSeed = async (invocation, context) => {
         command: "seed",
         result: {
           message,
-          ...applied.result
+          ...safeResult,
+          ...providerConnection ? {
+            capacityProviderConnection: {
+              scope: providerConnection.scope,
+              writtenKeys: providerConnection.writtenKeys,
+              redactedEnv: providerConnection.redactedEnv
+            }
+          } : {}
         }
       }
     };

package/dist/cli/operations-registry.js

@@ -21,30 +21,20 @@ function related(name, why) {
   return { name, why };
 }
 const DEV_RUNTIME_OPTIONS = [
-  { name: "surface", flags: "--surface <surface>", description: "Select one local dev surface to run. Compatibility alias for --surfaces.", kind: "enum", values: ["integrated", "web", "api", "manager", "worker", "agents", "services"] },
-  { name: "surfaces", flags: "--surfaces <surfaces>", description: "Select comma-separated local dev surfaces to run.", kind: "string" },
   { name: "host", flags: "--host <host>", description: "Host for the web dev server.", kind: "string" },
   { name: "port", flags: "--port <port>", description: "Port for the web dev server.", kind: "string" },
+  { name: "webRuntime", flags: "--web-runtime <mode>", description: "Choose the local web runtime. Use local for Astro hot reload or provider for provider parity.", kind: "enum", values: ["auto", "local", "provider"] },
   { name: "apiHost", flags: "--api-host <host>", description: "Host used to construct the local API URL.", kind: "string" },
   { name: "apiPort", flags: "--api-port <port>", description: "Port for the local API server.", kind: "string" },
-  { name: "managerPort", flags: "--manager-port <port>", description: "Port used for the local manager service URL.", kind: "string" },
   { name: "setup", flags: "--setup <mode>", description: "Control automatic local runtime setup.", kind: "enum", values: ["auto", "check", "off"] },
   { name: "feedback", flags: "--feedback <mode>", description: "Control live feedback, service restarts, and browser reload stamps.", kind: "enum", values: ["live", "restart", "off"] },
   { name: "open", flags: "--open <mode>", description: "Control whether dev opens the browser after readiness. Defaults to off; use --open on to launch it.", kind: "enum", values: ["auto", "on", "off"] },
   { name: "plan", flags: "--plan", description: "Print the dev runtime plan and exit without starting services.", kind: "boolean" },
   { name: "reset", flags: "--reset", description: "Clear local dev runtime state before setup, migrations, and service startup.", kind: "boolean" },
+  { name: "force", flags: "--force", description: "Terminate overlapping Treeseed dev runtimes and listeners on required local dev ports before startup.", kind: "boolean" },
   { name: "json", flags: "--json", description: "Emit structured JSON or newline-delimited dev events.", kind: "boolean" },
-  { name: "watch", flags: "--watch", description: "Enable live watch behavior. `dev` defaults to live feedback; this remains for compatibility.", kind: "boolean" },
   { name: "workspaceLinks", flags: "--workspace-links <mode>", description: "Control local workspace package links.", kind: "enum", values: ["auto", "off"] }
 ];
-const DEV_MANAGER_OPTIONS = [
-  ...DEV_RUNTIME_OPTIONS,
-  { name: "docsAutomation", flags: "--docs-automation <mode>", description: "Control governed documentation automation for the local manager.", kind: "enum", values: ["on", "dry-run", "off"] },
-  { name: "withWorker", flags: "--with-worker", description: "Run the local worker alongside the manager in the same dev supervisor.", kind: "boolean" },
-  { name: "workdayId", flags: "--workday-id <id>", description: "Start or resume a specific local documentation automation workday.", kind: "string" },
-  { name: "capacityBudget", flags: "--capacity-budget <credits>", description: "Override the local workday task credit budget.", kind: "string" },
-  { name: "approvalPolicy", flags: "--approval-policy <policy>", description: "Set the local docs automation approval policy.", kind: "enum", values: ["manual", "low-risk-auto"] }
-];
 function genericWorkflowPosition(spec) {
   if (spec.group === "Workflow") {
     if (spec.name === "switch") return "start work";
@@ -1172,34 +1162,32 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
   })],
   ["dev", command({
     options: DEV_RUNTIME_OPTIONS,
-    examples: ["treeseed dev", "treeseed dev --reset", "treeseed dev --reset --plan --json", "treeseed dev --surfaces web,api --plan --json", "treeseed dev --surface web --port 4322"],
+    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 unified local Treeseed runtime as a foreground supervisor so you can work against the integrated web, API, manager, worker, and supporting local surfaces.",
-        "The command keeps streaming logs and dev events until you press Ctrl+C or receive SIGTERM. Required surface failures are restarted with backoff instead of ending the supervisor."
+        "Dev starts the local Treeseed Market web/API runtime 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 selected surfaces, commands, setup steps, readiness checks, watched paths, and restart policy without starting services.",
+        "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.",
         "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 integrated local development", "Run web, API, manager, and worker locally and keep supervising them in the foreground."),
+        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 --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 --surfaces web,api,worker --plan --json", "Inspect selected surfaces", "Plan a comma-separated set of local surfaces without starting the supervisor."),
-        example("treeseed dev --surface api --plan --json", "Inspect the API surface", "Plan the local API runtime without the web UI."),
-        example("treeseed dev --surfaces integrated,agents", "Opt into agents diagnostics", "Start the integrated local platform plus the agents diagnostic loop."),
-        example("treeseed dev --surface web --port 4322", "Run only the web surface", "Start the Astro UI on a specific port and print the URL when ready."),
+        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 --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 the selected local surfaces, waits for readiness, prints the local URL, and then remains attached as the live supervisor.",
+        "Starts fixed local web/API 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."
       ]
@@ -1207,45 +1195,6 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
     executionMode: "handler",
     handlerName: "dev"
   })],
-  ["dev:manager", command({
-    options: DEV_MANAGER_OPTIONS,
-    examples: ["treeseed dev:manager", "treeseed dev:manager --with-worker", "treeseed dev:manager --docs-automation dry-run --plan --json"],
-    help: {
-      longSummary: [
-        "Dev:manager starts the governed local documentation automation manager through the same integrated dev supervisor used by `treeseed dev`.",
-        "It selects the manager surface by default, can supervise a local worker with `--with-worker`, and passes docs automation policy into the existing manager and worker runtime."
-      ],
-      examples: [
-        example("treeseed dev:manager", "Start the local manager", "Run the governed workday manager in the foreground."),
-        example("treeseed dev:manager --with-worker", "Start manager plus worker", "Run scheduling and task execution in the same local supervision session."),
-        example("treeseed dev:manager --docs-automation dry-run --plan --json", "Inspect dry-run manager mode", "Show the manager plan and docs automation settings without starting the supervisor.")
-      ],
-      outcomes: [
-        "Starts or plans the existing manager surface, with optional worker supervision.",
-        "Keeps manual approval as the local default and forwards docs automation mode, workday id, capacity budget, and approval policy through runtime environment variables."
-      ]
-    },
-    executionMode: "handler",
-    handlerName: "dev"
-  })],
-  ["dev:watch", command({
-    options: DEV_RUNTIME_OPTIONS,
-    examples: ["treeseed dev:watch", "treeseed dev:watch --json"],
-    help: {
-      longSummary: [
-        "Dev:watch is a compatibility alias for foreground dev supervision with live feedback enabled.",
-        "It stays attached to the terminal and cleans up supervised services on Ctrl+C just like `dev`."
-      ],
-      examples: [
-        example("treeseed dev:watch", "Start watch mode", "Run the local runtime with watch and rebuild behavior enabled in the foreground."),
-        example("trsd dev:watch", "Use the short alias", "Start the same watch-mode runtime through the shorter entrypoint."),
-        example("treeseed dev:watch --feedback restart", "Restart services without browser reload", "Use watcher-driven service restarts while leaving browser refresh to your own tooling."),
-        example("treeseed dev:watch --help", "Inspect watch help", "Read the help surface before starting a longer watch session.")
-      ]
-    },
-    executionMode: "handler",
-    handlerName: "dev"
-  })],
   ["build", command({ examples: ["treeseed build"], help: { longSummary: ["Build runs the tenant build path and produces the generated output for the current project."], examples: [example("treeseed build", "Build the tenant", "Run the packaged build flow for the current project."), example("trsd build", "Use the short alias", "Run the same build through the shorter entrypoint."), example("treeseed build && treeseed export", "Build before packaging context", "Produce build artifacts first and then capture a code export if needed.")] }, executionMode: "adapter" })],
   ["check", command({ examples: ["treeseed check"], help: { longSummary: ["Check runs the project validation path against the current tenant and shared fixture model."], examples: [example("treeseed check", "Validate the tenant", "Run the project check flow."), example("trsd check", "Use the short alias", "Run the same validation via the short entrypoint."), example("treeseed check && treeseed doctor", "Pair validation with diagnostics", "Follow failed checks with the broader doctor surface.")] }, executionMode: "adapter" })],
   ["preview", command({ examples: ["treeseed preview"], help: { longSummary: ["Preview serves the built tenant output locally so you can inspect the built site rather than the live dev runtime."], examples: [example("treeseed preview", "Preview the built site", "Run the packaged preview flow for the built tenant."), example("treeseed preview -- --help", "Forward preview help", "Pass through additional args when the preview runtime supports them."), example("treeseed build && treeseed preview", "Build then preview", "Generate the build output first and then serve it locally.")] }, executionMode: "adapter", buildAdapterInput: PASS_THROUGH_ARGS })],
@@ -1571,36 +1520,39 @@ const CLI_ONLY_OPERATION_SPECS = [
     name: "capacity",
     aliases: [],
     group: "Utilities",
-    summary: "Manage team helper capacity from the selected market.",
-    description: "Inspect team helper credits, connect managed providers, rotate provider security codes, manage grants, and enqueue budgeted agent tasks.",
+    summary: "Operate the package-owned capacity provider runtime.",
+    description: "Run provider diagnostics, registration, and planning through the built @treeseed/agent capacity provider entrypoint.",
     provider: "default",
     related: ["teams", "projects", "agents"],
-    usage: "treeseed capacity [status|providers|grants|enqueue]",
+    usage: "treeseed capacity [doctor|register|plan|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: "team", flags: "--team <team-id>", description: "Team id for capacity status and grants.", kind: "string" },
-      { name: "provider", flags: "--provider <provider-id>", description: "Capacity provider id for grant or key actions.", kind: "string" },
-      { name: "project", flags: "--project <project-id>", description: "Project id for grant allocation or agent enqueue.", kind: "string" },
-      { name: "key", flags: "--key <key-id>", description: "Provider security code id to revoke.", kind: "string" },
-      { name: "taskKind", flags: "--task-kind <kind>", description: "Agent task signature for budgeted enqueue.", kind: "string" },
-      { name: "environment", flags: "--environment <environment>", description: "Project environment for grants or enqueue.", kind: "enum", values: ["local", "staging", "prod"] },
-      { name: "daily", flags: "--daily <credits>", description: "Daily credit limit for a created grant.", kind: "string" },
-      { name: "monthly", flags: "--monthly <credits>", description: "Monthly credit limit for a created grant.", kind: "string" },
+      { name: "provider", flags: "--provider <provider-id>", description: "Provider id or local provider selector for diagnostics.", 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: "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" },
+      { name: "dryRun", flags: "--dry-run", description: "Ask the provider runtime to render deterministic output without provider secrets or Market mutation.", kind: "boolean" },
       { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
     ],
     examples: [
-      "treeseed capacity status --team team_123",
-      "treeseed capacity providers connect --team team_123",
-      "treeseed capacity providers keys reset --provider provider_123",
-      "treeseed capacity grants create --team team_123 --provider provider_123 --daily 25",
-      "treeseed capacity enqueue --project project_123 --task-kind proposal.draft"
+      "treeseed capacity doctor --market local --provider local",
+      "treeseed capacity register --market local --provider local --dry-run --json",
+      "treeseed capacity plan --market local --provider local --dry-run --json",
+      "treeseed capacity build",
+      "treeseed capacity up --market local --provider local",
+      "treeseed capacity up --market local --provider local --diagnostic",
+      "treeseed capacity status --market local --provider local",
+      "treeseed capacity logs --market local --provider local",
+      "treeseed capacity down --market local --provider local",
+      "treeseed capacity test-local"
     ],
     help: {
-      longSummary: ["Capacity talks to the market control plane so technical stewards can inspect helper credits, provider security codes, and budgeted agent task routing without opening the browser."],
-      whenToUse: ["Use this after connecting to a market when provider health, budget allocation, or budgeted agent enqueue needs to be checked from a terminal."],
-      beforeYouRun: ["Authenticate to the selected market and know the team, project, or provider id for the action you are taking."],
-      automationNotes: ["Use `--json` when capturing provider keys, grant ids, task ids, or dashboard summaries in automation."]
+      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."],
+      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."]
     },
     helpVisible: true,
     helpFeatured: false,

package/dist/cli/registry.d.ts

@@ -10,8 +10,6 @@ export declare const COMMAND_HANDLERS: {
     readonly status: import("./operations-types.js").TreeseedCommandHandler;
     readonly ci: import("./operations-types.js").TreeseedCommandHandler;
     readonly dev: import("./operations-types.js").TreeseedCommandHandler;
-    readonly 'dev:manager': import("./operations-types.js").TreeseedCommandHandler;
-    readonly 'dev:watch': import("./operations-types.js").TreeseedCommandHandler;
     readonly doctor: import("./operations-types.js").TreeseedCommandHandler;
     readonly rollback: import("./operations-types.js").TreeseedCommandHandler;
     readonly template: import("./operations-types.js").TreeseedCommandHandler;

package/dist/cli/registry.js

@@ -54,8 +54,6 @@ const COMMAND_HANDLERS = {
   status: handleStatus,
   ci: handleCi,
   dev: handleDev,
-  "dev:manager": handleDev,
-  "dev:watch": handleDev,
   doctor: handleDoctor,
   rollback: handleRollback,
   template: handleTemplate,

package/dist/cli/runtime.js

@@ -351,6 +351,7 @@ function commandNeedsProjectRoot(spec) {
     "market",
     "teams",
     "projects",
+    "capacity",
     "packs",
     "template"
   ])).has(spec.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/cli",
-  "version": "0.8.19",
+  "version": "0.9.3",
   "description": "Operator-facing Treeseed CLI package.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -45,7 +45,7 @@
     "release:publish": "node ./scripts/run-ts.mjs ./scripts/publish-package.ts"
   },
   "dependencies": {
-    "@treeseed/sdk": "0.8.19",
+    "@treeseed/sdk": "github:treeseed-ai/sdk#0.10.6",
     "ink": "^7.0.0",
     "react": "^19.2.5"
   },