@treeseed/cli 0.1.1 → 0.4.2

package/dist/cli/runtime.js

@@ -1,9 +1,10 @@
 import { spawnSync } from "node:child_process";
-import { isWorkspaceRoot, packageScriptPath } from "../scripts/package-tools.js";
-import { writeResult } from "./handlers/utils.js";
-import { renderTreeseedHelp, renderUsage, suggestTreeseedCommands } from "./help.js";
-import { parseTreeseedInvocation, validateTreeseedInvocation } from "./parser.js";
-import { COMMAND_HANDLERS, findCommandSpec } from "./registry.js";
+import { findNearestTreeseedRoot, findNearestTreeseedWorkspaceRoot } from "@treeseed/sdk/workflow-support";
+import { TreeseedOperationsSdk as SdkOperationsRuntime } from "@treeseed/sdk/operations";
+import { COMMAND_HANDLERS } from "./registry.js";
+import { renderTreeseedHelp, renderUsage, suggestTreeseedCommands } from "./operations-help.js";
+import { parseTreeseedInvocation, validateTreeseedInvocation } from "./operations-parser.js";
+import { findTreeseedOperation, TRESEED_OPERATION_SPECS } from "./operations-registry.js";
 function isHelpFlag(value) {
   return value === "--help" || value === "-h";
 }
@@ -15,6 +16,7 @@ function defaultWrite(output, stream = "stdout") {
 function defaultSpawn(command, args, options) {
   return spawnSync(command, args, options);
 }
+const sdkOperationsRuntime = new SdkOperationsRuntime();
 function formatValidationError(spec, errors) {
   return [
     ...errors,
@@ -28,138 +30,265 @@ function createTreeseedCommandContext(overrides = {}) {
     env: overrides.env ?? process.env,
     write: overrides.write ?? defaultWrite,
     spawn: overrides.spawn ?? defaultSpawn,
-    outputFormat: overrides.outputFormat ?? "human"
+    outputFormat: overrides.outputFormat ?? "human",
+    prompt: overrides.prompt,
+    confirm: overrides.confirm
   };
 }
-function resolveAdapter(spec, cwd) {
-  const adapter = spec.adapter;
-  if (!adapter) return { error: `Treeseed command \`${spec.name}\` is missing adapter metadata.` };
-  if (adapter.requireWorkspaceRoot && !isWorkspaceRoot(cwd)) {
-    return {
-      error: [
-        `Treeseed command \`${spec.name}\` must be run from a workspace root.`,
-        `Usage: ${renderUsage(spec)}`,
-        `Run \`treeseed help ${spec.name}\` for details.`
-      ].join("\n")
+function writeTreeseedResult(result, context) {
+  if (context.outputFormat === "json") {
+    const payload = result.report ?? {
+      ok: (result.exitCode ?? 0) === 0,
+      stdout: result.stdout ?? [],
+      stderr: result.stderr ?? []
     };
+    context.write(JSON.stringify(payload, null, 2), (result.exitCode ?? 0) === 0 ? "stdout" : "stderr");
+    return result.exitCode ?? 0;
   }
-  const scriptName = adapter.workspaceScript || adapter.directScript ? isWorkspaceRoot(cwd) ? adapter.workspaceScript ?? adapter.script : adapter.directScript ?? adapter.script : adapter.script;
-  return {
-    scriptPath: packageScriptPath(scriptName),
-    extraArgs: adapter.extraArgs ?? [],
-    rewriteArgs: adapter.rewriteArgs
-  };
+  for (const line of result.stdout ?? []) {
+    context.write(line, "stdout");
+  }
+  for (const line of result.stderr ?? []) {
+    context.write(line, "stderr");
+  }
+  return result.exitCode ?? 0;
 }
-async function executeHandler(spec, argv, context) {
-  try {
-    const invocation = parseTreeseedInvocation(spec, argv);
-    const errors = validateTreeseedInvocation(spec, invocation);
-    const handlerContext = {
-      ...context,
-      outputFormat: invocation.args.json === true ? "json" : context.outputFormat ?? "human"
-    };
-    if (errors.length > 0) {
-      return writeResult({
+class TreeseedOperationsSdk {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  listOperations() {
+    return [...TRESEED_OPERATION_SPECS];
+  }
+  findOperation(name) {
+    return findTreeseedOperation(name);
+  }
+  parseInvocation(spec, argv) {
+    return parseTreeseedInvocation(spec, argv);
+  }
+  validateInvocation(spec, argv) {
+    return validateTreeseedInvocation(spec, parseTreeseedInvocation(spec, argv));
+  }
+  async executeHandler(spec, argv, context) {
+    try {
+      const invocation = parseTreeseedInvocation(spec, argv);
+      const errors = validateTreeseedInvocation(spec, invocation);
+      const handlerContext = {
+        ...context,
+        outputFormat: invocation.args.json === true ? "json" : context.outputFormat ?? "human"
+      };
+      if (errors.length > 0) {
+        return writeTreeseedResult({
+          exitCode: 1,
+          stderr: [formatValidationError(spec, errors)],
+          report: {
+            command: spec.name,
+            ok: false,
+            error: errors.join(" "),
+            errors,
+            usage: renderUsage(spec)
+          }
+        }, handlerContext);
+      }
+      const handlerName = spec.handlerName;
+      if (!handlerName) {
+        return writeTreeseedResult({ exitCode: 1, stderr: [`Treeseed command \`${spec.name}\` is missing a handler binding.`] }, handlerContext);
+      }
+      const handler = this.options.resolveHandler?.(handlerName) ?? null;
+      if (!handler) {
+        return writeTreeseedResult({
+          exitCode: 1,
+          stderr: [`Treeseed command \`${spec.name}\` is not executable in this runtime.`],
+          report: {
+            command: spec.name,
+            ok: false,
+            error: `No handler registered for ${handlerName}.`
+          }
+        }, handlerContext);
+      }
+      const result = await handler(invocation, handlerContext);
+      return writeTreeseedResult(result, handlerContext);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const wantsJson = argv.includes("--json");
+      return writeTreeseedResult({
         exitCode: 1,
-        stderr: [formatValidationError(spec, errors)],
+        stderr: [message, `Run \`treeseed help ${spec.name}\` for details.`],
         report: {
           command: spec.name,
           ok: false,
-          error: errors.join(" "),
-          errors,
-          usage: renderUsage(spec)
+          error: message,
+          hint: `treeseed help ${spec.name}`
         }
-      }, handlerContext);
+      }, { ...context, outputFormat: wantsJson ? "json" : context.outputFormat ?? "human" });
     }
-    const handlerName = spec.handlerName;
-    if (!handlerName) {
-      return writeResult({ exitCode: 1, stderr: [`Treeseed command \`${spec.name}\` is missing a handler binding.`] }, handlerContext);
-    }
-    const handler = COMMAND_HANDLERS[handlerName];
-    const result = await handler(invocation, handlerContext);
-    return writeResult(result, handlerContext);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const wantsJson = argv.includes("--json");
-    return writeResult({
+  }
+  executeAdapter(spec, argv, context) {
+    const invocation = spec.options?.length || spec.arguments?.length ? parseTreeseedInvocation(spec, argv) : {
+      commandName: spec.name,
+      args: {},
+      positionals: argv.filter((value) => value !== "--"),
+      rawArgs: argv
+    };
+    const input = spec.buildAdapterInput?.(invocation, context) ?? {};
+    return sdkOperationsRuntime.execute(
+      { operationName: spec.name, input },
+      {
+        cwd: context.cwd,
+        env: context.env,
+        write: context.write,
+        spawn: context.spawn,
+        outputFormat: context.outputFormat,
+        transport: "cli"
+      }
+    ).then((result) => writeTreeseedResult(result, context)).catch((error) => writeTreeseedResult({
       exitCode: 1,
-      stderr: [message, `Run \`treeseed help ${spec.name}\` for details.`],
-      report: {
-        command: spec.name,
-        ok: false,
-        error: message,
-        hint: `treeseed help ${spec.name}`
+      stderr: [error instanceof Error ? error.message : String(error)]
+    }, context));
+  }
+  async executeAgents(argv, context) {
+    try {
+      const { runTreeseedAgentCli } = await import("@treeseed/agent/cli");
+      return await runTreeseedAgentCli(argv, {
+        cwd: context.cwd,
+        env: context.env,
+        outputFormat: context.outputFormat,
+        write: context.write
+      });
+    } catch (error) {
+      return writeTreeseedResult({
+        exitCode: 1,
+        stderr: [error instanceof Error ? error.message : String(error)],
+        report: {
+          command: "agents",
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      }, context);
+    }
+  }
+  async executeOperation(request, overrides = {}) {
+    const context = createTreeseedCommandContext(overrides);
+    const argv = request.argv ?? [];
+    const commandName = request.commandName;
+    if (commandName === "agents") {
+      return this.executeAgents(argv, context);
+    }
+    const spec = findTreeseedOperation(commandName);
+    if (!spec) {
+      const suggestions = suggestTreeseedCommands(commandName);
+      const lines = [`Unknown treeseed command: ${commandName}`];
+      if (suggestions.length > 0) {
+        lines.push(`Did you mean: ${suggestions.map((value) => `\`${value}\``).join(", ")}?`);
       }
-    }, { ...context, outputFormat: wantsJson ? "json" : context.outputFormat ?? "human" });
+      lines.push("Run `treeseed help` to see the full command list.");
+      return writeTreeseedResult({ exitCode: 1, stderr: [lines.join("\n")] }, context);
+    }
+    if (argv.some(isHelpFlag)) {
+      context.write(renderTreeseedHelp(spec.name), "stdout");
+      return 0;
+    }
+    return spec.executionMode === "adapter" ? this.executeAdapter(spec, argv, context) : this.executeHandler(spec, argv, context);
+  }
+  async run(argv, overrides = {}) {
+    const context = createTreeseedCommandContext(overrides);
+    const [firstArg, ...restArgs] = argv;
+    if (!firstArg || isHelpFlag(firstArg) || firstArg === "help") {
+      const commandName = firstArg === "help" ? restArgs[0] ?? null : null;
+      const helpText = renderTreeseedHelp(commandName);
+      context.write(helpText, "stdout");
+      return commandName && helpText.startsWith("Unknown treeseed command:") ? 1 : 0;
+    }
+    return this.executeOperation({ commandName: firstArg, argv: restArgs }, context);
   }
 }
-function executeAdapter(spec, argv, context) {
-  const resolved = resolveAdapter(spec, context.cwd);
-  if ("error" in resolved) {
-    return writeResult({ exitCode: 1, stderr: [resolved.error] }, context);
-  }
-  const rewritten = resolved.rewriteArgs ? resolved.rewriteArgs(argv) : argv;
-  const result = context.spawn(process.execPath, [resolved.scriptPath, ...resolved.extraArgs, ...rewritten], {
-    cwd: context.cwd,
-    env: { ...context.env },
-    stdio: "inherit"
-  });
-  return result.status ?? 1;
+function formatProjectError(spec) {
+  return [
+    `Treeseed command \`${spec.name}\` must be run inside a Treeseed project.`,
+    "No ancestor directory containing `treeseed.site.yaml` was found.",
+    `Usage: ${renderUsage(spec)}`,
+    `Run \`treeseed help ${spec.name}\` for details.`
+  ].join("\n");
 }
-function executeAgents(argv, context) {
-  if (argv.some(isHelpFlag)) {
-    context.write([
-      "agents  Run the Treeseed agents entrypoint.",
-      "",
-      "Usage",
-      "  treeseed agents [args...]",
-      "",
-      "Notes",
-      "  - Delegates directly to the installed treeseed-agents command."
-    ].join("\n"), "stdout");
-    return 0;
-  }
-  const command = process.platform === "win32" ? "treeseed-agents.cmd" : "treeseed-agents";
-  const result = context.spawn(command, argv, {
-    cwd: context.cwd,
-    env: { ...context.env },
-    stdio: "inherit"
-  });
-  return result.status ?? 1;
+function commandNeedsProjectRoot(spec) {
+  return spec.name !== "init";
 }
-async function executeTreeseedCommand(commandName, argv, context) {
-  if (commandName === "agents") {
-    return executeAgents(argv, context);
+function resolveTreeseedCommandCwd(spec, cwd) {
+  if (!commandNeedsProjectRoot(spec)) {
+    return {
+      cwd,
+      resolvedProjectRoot: null,
+      resolvedWorkspaceRoot: null
+    };
   }
-  const spec = findCommandSpec(commandName);
+  const resolvedProjectRoot = findNearestTreeseedRoot(cwd);
+  const resolvedWorkspaceRoot = resolvedProjectRoot ? findNearestTreeseedWorkspaceRoot(resolvedProjectRoot) : null;
+  return {
+    cwd: resolvedProjectRoot ?? cwd,
+    resolvedProjectRoot,
+    resolvedWorkspaceRoot
+  };
+}
+const cliOperationsSdk = new TreeseedOperationsSdk({
+  resolveHandler: (handlerName) => COMMAND_HANDLERS[handlerName] ?? null
+});
+async function executeTreeseedCommand(commandName, argv, context) {
+  const spec = cliOperationsSdk.findOperation(commandName);
   if (!spec) {
-    const suggestions = suggestTreeseedCommands(commandName);
-    const lines = [`Unknown treeseed command: ${commandName}`];
-    if (suggestions.length > 0) {
-      lines.push(`Did you mean: ${suggestions.map((value) => `\`${value}\``).join(", ")}?`);
-    }
-    lines.push("Run `treeseed help` to see the full command list.");
-    return writeResult({ exitCode: 1, stderr: [lines.join("\n")] }, context);
+    return cliOperationsSdk.executeOperation({ commandName, argv }, context);
   }
   if (argv.some(isHelpFlag)) {
-    context.write(renderTreeseedHelp(spec.name), "stdout");
-    return 0;
+    return cliOperationsSdk.executeOperation({ commandName, argv }, context);
+  }
+  const resolved = resolveTreeseedCommandCwd(spec, context.cwd);
+  if (commandNeedsProjectRoot(spec) && !resolved.resolvedProjectRoot) {
+    return writeTreeseedResult({
+      exitCode: 1,
+      stderr: [formatProjectError(spec)],
+      report: {
+        command: spec.name,
+        ok: false,
+        error: `No ancestor containing treeseed.site.yaml was found from ${context.cwd}.`,
+        hint: `treeseed help ${spec.name}`
+      }
+    }, { ...context, outputFormat: argv.includes("--json") ? "json" : context.outputFormat ?? "human" });
   }
-  return spec.executionMode === "adapter" ? executeAdapter(spec, argv, context) : executeHandler(spec, argv, context);
+  return cliOperationsSdk.executeOperation({ commandName, argv }, { ...context, cwd: resolved.cwd });
 }
 async function runTreeseedCli(argv, overrides = {}) {
-  const context = createTreeseedCommandContext(overrides);
-  const [firstArg, ...restArgs] = argv;
-  if (!firstArg || isHelpFlag(firstArg) || firstArg === "help") {
-    const commandName = firstArg === "help" ? restArgs[0] ?? null : null;
-    const helpText = renderTreeseedHelp(commandName);
-    context.write(helpText, "stdout");
-    return commandName && helpText.startsWith("Unknown treeseed command:") ? 1 : 0;
-  }
-  return executeTreeseedCommand(firstArg, restArgs, context);
+  const [firstArg] = argv;
+  const spec = firstArg ? cliOperationsSdk.findOperation(firstArg) : null;
+  if (!spec) {
+    return cliOperationsSdk.run(argv, overrides);
+  }
+  if (argv.slice(1).some(isHelpFlag)) {
+    return cliOperationsSdk.run(argv, overrides);
+  }
+  const baseCwd = overrides.cwd ?? process.cwd();
+  const resolved = resolveTreeseedCommandCwd(spec, baseCwd);
+  if (commandNeedsProjectRoot(spec) && !resolved.resolvedProjectRoot) {
+    return writeTreeseedResult({
+      exitCode: 1,
+      stderr: [formatProjectError(spec)],
+      report: {
+        command: spec.name,
+        ok: false,
+        error: `No ancestor containing treeseed.site.yaml was found from ${baseCwd}.`,
+        hint: `treeseed help ${spec.name}`
+      }
+    }, createTreeseedCommandContext({
+      ...overrides,
+      outputFormat: argv.includes("--json") ? "json" : overrides.outputFormat ?? "human"
+    }));
+  }
+  const contextOverrides = commandNeedsProjectRoot(spec) && resolved.resolvedProjectRoot ? { ...overrides, cwd: resolved.cwd } : overrides;
+  return cliOperationsSdk.run(argv, contextOverrides);
 }
 export {
+  TreeseedOperationsSdk,
   createTreeseedCommandContext,
   executeTreeseedCommand,
-  runTreeseedCli
+  resolveTreeseedCommandCwd,
+  runTreeseedCli,
+  writeTreeseedResult
 };

package/dist/cli/types.d.ts

@@ -0,0 +1 @@
+export type { TreeseedCommandArgumentSpec, TreeseedCommandContext, TreeseedCommandExample, TreeseedCommandGroup, TreeseedCommandHandler, TreeseedCommandOptionSpec, TreeseedCommandResult, TreeseedCommandSpec, TreeseedExecutionMode, TreeseedParsedInvocation, TreeseedSpawner, TreeseedWriter, } from './operations-types.js';

package/dist/{src/cli → cli}/workflow-state.d.ts

@@ -27,8 +27,17 @@ export type TreeseedWorkflowState = {
     auth: {
         gh: boolean;
         wrangler: boolean;
+        railway: boolean;
         copilot: boolean;
+        remoteApi: boolean;
     };
+    managedServices: Record<string, {
+        enabled: boolean;
+        initialized: boolean;
+        lastDeploymentTimestamp: string | null;
+        lastDeployedUrl: string | null;
+        provider: string | null;
+    }>;
     files: {
         treeseedConfig: boolean;
         machineConfig: boolean;

package/dist/cli/workflow-state.js

@@ -1,16 +1,16 @@
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
-import { getTreeseedMachineConfigPaths } from "../scripts/config-runtime-lib.js";
+import { getTreeseedMachineConfigPaths, resolveTreeseedRemoteSession } from "@treeseed/sdk/workflow-support";
 import {
   createBranchPreviewDeployTarget,
   createPersistentDeployTarget,
   loadDeployState
-} from "../scripts/deploy-lib.js";
-import { PRODUCTION_BRANCH, STAGING_BRANCH } from "../scripts/git-workflow-lib.js";
-import { loadCliDeployConfig } from "../scripts/package-tools.js";
-import { collectCliPreflight } from "../scripts/workspace-preflight-lib.js";
-import { currentBranch, gitStatusPorcelain, repoRoot } from "../scripts/workspace-save-lib.js";
-import { isWorkspaceRoot } from "../scripts/workspace-tools.js";
+} from "@treeseed/sdk/workflow-support";
+import { PRODUCTION_BRANCH, STAGING_BRANCH } from "@treeseed/sdk/workflow-support";
+import { loadCliDeployConfig } from "@treeseed/sdk/workflow-support";
+import { collectCliPreflight } from "@treeseed/sdk/workflow-support";
+import { currentBranch, gitStatusPorcelain, repoRoot } from "@treeseed/sdk/workflow-support";
+import { isWorkspaceRoot } from "@treeseed/sdk/workflow-support";
 function safeResolveRepoRoot(cwd) {
   try {
     return repoRoot(cwd);
@@ -66,7 +66,17 @@ function resolveTreeseedWorkflowState(cwd) {
     auth: {
       gh: preflight.checks.auth.gh?.authenticated === true,
       wrangler: preflight.checks.auth.wrangler?.authenticated === true,
-      copilot: preflight.checks.auth.copilot?.configured === true
+      railway: preflight.checks.auth.railway?.authenticated === true,
+      copilot: preflight.checks.auth.copilot?.configured === true,
+      remoteApi: Boolean(resolveTreeseedRemoteSession(cwd))
+    },
+    managedServices: {
+      api: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
+      agents: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
+      manager: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
+      worker: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
+      workdayStart: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
+      workdayReport: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null }
     },
     files: {
       treeseedConfig: tenantRoot,
@@ -100,6 +110,17 @@ function resolveTreeseedWorkflowState(cwd) {
             url: typeof latestHistory?.url === "string" ? latestHistory.url : deployState.lastDeployedUrl ?? null
           });
         }
+        for (const serviceKey of ["api", "agents", "manager", "worker", "workdayStart", "workdayReport"]) {
+          const service = deployState.services?.[serviceKey];
+          if (!service) continue;
+          state.managedServices[serviceKey] = {
+            enabled: service.enabled === true,
+            initialized: service.initialized === true,
+            lastDeploymentTimestamp: service.lastDeploymentTimestamp ?? null,
+            lastDeployedUrl: service.lastDeployedUrl ?? service.publicBaseUrl ?? null,
+            provider: service.provider ?? null
+          };
+        }
       }
       if (branchRole === "feature" && branchName) {
         const previewState = loadDeployState(cwd, deployConfig, { target: createBranchPreviewDeployTarget(branchName) });
@@ -118,51 +139,54 @@ function resolveTreeseedWorkflowState(cwd) {
 function recommendTreeseedNextSteps(state) {
   const recommendations = [];
   if (!state.workspaceRoot) {
-    return [{ command: "cd docs && treeseed doctor", reason: "Switch to the Treeseed workspace root before using the guided workflow." }];
+    return [{ command: "treeseed status", reason: "Run this command from inside a Treeseed workspace so the CLI can resolve the project root." }];
   }
   if (!state.deployConfigPresent) {
     return [{ command: "treeseed init <directory>", reason: "Create a new Treeseed tenant before configuring or releasing anything." }];
   }
   if (!state.files.machineConfig) {
-    recommendations.push({ command: "treeseed doctor", reason: "Validate tooling, auth, and repository readiness first." });
-    recommendations.push({ command: "treeseed setup", reason: "Bootstrap the local machine config and local environment files." });
+    recommendations.push({ command: "treeseed status", reason: "Validate tooling, auth, and repository readiness first." });
+    recommendations.push({ command: "treeseed config", reason: "Bootstrap the local machine config and local environment files." });
     return recommendations;
   }
   if (state.branchRole === "feature") {
     if (state.dirtyWorktree) {
-      recommendations.push({ command: 'treeseed ship "describe your change"', reason: "Persist and push the current feature branch before closing or releasing." });
+      recommendations.push({ command: 'treeseed save "describe your change"', reason: "Persist, verify, and push the current task branch before staging or closing it." });
     } else {
-      recommendations.push({ command: "treeseed teardown", reason: "Merge this feature branch into staging and clean up branch artifacts." });
+      recommendations.push({ command: 'treeseed stage "describe the resolution"', reason: "Merge this task branch into staging and clean up branch artifacts." });
     }
     if (state.preview.enabled && state.branchName) {
-      recommendations.push({ command: `treeseed publish --target-branch ${state.branchName}`, reason: "Refresh the branch preview deployment when you need a live Cloudflare preview." });
+      recommendations.push({ command: 'treeseed save "describe your change"', reason: "Save refreshes the branch preview deployment when one is enabled." });
     } else {
       recommendations.push({ command: "treeseed dev", reason: "Use the local environment for iterative work on this feature branch." });
     }
+    recommendations.push({ command: 'treeseed close "reason"', reason: "Archive this task without merging if it should be abandoned." });
     return recommendations.slice(0, 3);
   }
   if (state.branchRole === "staging") {
     if (!state.persistentEnvironments.staging.initialized) {
-      recommendations.push({ command: "treeseed prepare --environment staging", reason: "Initialize the staging environment before publishing or promoting." });
+      recommendations.push({ command: "treeseed config --environment staging", reason: "Initialize the staging environment before releasing." });
     } else {
-      recommendations.push({ command: "treeseed publish --environment staging", reason: "Publish the current staging branch to the initialized staging environment." });
-      recommendations.push({ command: "treeseed promote --patch", reason: "Promote staging into main when the integration branch is ready for production." });
+      recommendations.push({ command: "treeseed release --patch", reason: "Promote staging into main when the integration branch is ready for production." });
+      if (state.managedServices.api.enabled || state.managedServices.agents.enabled) {
+        recommendations.push({ command: "treeseed auth:login", reason: "Keep the local CLI authenticated to the remote API used by managed services." });
+      }
     }
     return recommendations.slice(0, 3);
   }
   if (state.branchRole === "main") {
     if (state.dirtyWorktree) {
-      recommendations.push({ command: 'treeseed ship --hotfix "describe the hotfix"', reason: "Only explicit hotfix saves are allowed on main." });
+      recommendations.push({ command: 'treeseed save --hotfix "describe the hotfix"', reason: "Only explicit hotfix saves are allowed on main." });
     } else if (!state.persistentEnvironments.prod.initialized) {
-      recommendations.push({ command: "treeseed prepare --environment prod", reason: "Initialize production before attempting a manual production publish." });
+      recommendations.push({ command: "treeseed config --environment prod", reason: "Initialize production before a release requires it." });
     } else {
-      recommendations.push({ command: "treeseed publish --environment prod", reason: "Run a manual production publish only when you intentionally need to bypass CI." });
+      recommendations.push({ command: "treeseed status", reason: "Inspect production state and release readiness." });
       recommendations.push({ command: "treeseed rollback prod", reason: "Roll back production to the previous recorded deployment if needed." });
     }
     return recommendations.slice(0, 3);
   }
   recommendations.push({ command: "treeseed dev", reason: "Start the local Treeseed development environment." });
-  recommendations.push({ command: "treeseed work feature/my-change", reason: "Create a feature branch from the latest staging commit." });
+  recommendations.push({ command: "treeseed switch feature/my-change", reason: "Create a task branch from the latest staging commit." });
   return recommendations.slice(0, 3);
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/cli",
-  "version": "0.1.1",
+  "version": "0.4.2",
   "description": "Operator-facing Treeseed CLI package.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -15,7 +15,7 @@
   "packageManager": "npm@11.7.0",
   "type": "module",
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "types": "./dist/index.d.ts",
   "files": [
@@ -29,27 +29,27 @@
     "setup": "npm install",
     "setup:ci": "npm ci",
     "build": "npm run build:dist",
-    "test": "npm run test:templates && npm run build:dist && node --test ./scripts/*.test.mjs",
-    "test:templates": "node ./scripts/run-ts.mjs ./scripts/validate-templates.ts",
+    "lint": "npm run build:dist",
+    "test": "npm run build:dist && node --test ./scripts/treeseed-help.test.mjs ./scripts/wrapper-package.test.mjs",
     "build:dist": "node ./scripts/run-ts.mjs ./scripts/build-dist.ts",
-    "prepare": "npm run build:dist",
     "prepack": "npm run build:dist",
-    "test:scaffold": "node ./scripts/run-ts.mjs ./scripts/test-scaffold.ts",
+    "verify:direct": "npm run release:verify",
+    "verify:local": "node --input-type=module -e \"process.env.TREESEED_VERIFY_DRIVER='direct'; await import('@treeseed/sdk/scripts/verify-driver')\"",
+    "verify:action": "node --input-type=module -e \"process.env.TREESEED_VERIFY_DRIVER='act'; await import('@treeseed/sdk/scripts/verify-driver')\"",
+    "verify": "node --input-type=module -e \"await import('@treeseed/sdk/scripts/verify-driver')\"",
     "release:setup": "npm run setup:ci",
     "release:check-tag": "node ./scripts/run-ts.mjs ./scripts/assert-release-tag-version.ts",
     "release:verify": "node ./scripts/run-ts.mjs ./scripts/release-verify.ts",
     "release:publish": "node ./scripts/run-ts.mjs ./scripts/publish-package.ts"
   },
   "dependencies": {
-    "@treeseed/agent": "^0.1.2",
-    "@treeseed/core": "^0.1.2",
-    "@treeseed/sdk": "^0.1.2",
-    "esbuild": "^0.25.10",
-    "typescript": "^5.9.3",
-    "yaml": "^2.8.1"
+    "@treeseed/agent": "^0.4.1",
+    "@treeseed/sdk": "^0.4.2"
   },
   "devDependencies": {
-    "@types/node": "^24.6.0"
+    "@types/node": "^24.6.0",
+    "esbuild": "^0.25.10",
+    "typescript": "^5.9.3"
   },
   "bin": {
     "treeseed": "./dist/cli/main.js"

package/dist/cli/handlers/continue.js

@@ -1,23 +0,0 @@
-import { guidedResult } from "./utils.js";
-import { resolveTreeseedWorkflowState } from "../workflow-state.js";
-const handleContinue = (_invocation, context) => {
-  const state = resolveTreeseedWorkflowState(context.cwd);
-  const next = state.recommendations[0] ?? null;
-  return guidedResult({
-    command: "continue",
-    summary: next ? "Treeseed selected the safest next workflow step." : "Treeseed could not infer a next workflow step.",
-    facts: [
-      { label: "Branch", value: state.branchName ?? "(none)" },
-      { label: "Suggested command", value: next?.command ?? "(none)" }
-    ],
-    nextSteps: next ? [`${next.command}  # ${next.reason}`] : ["treeseed doctor"],
-    report: {
-      state,
-      selected: next
-    },
-    exitCode: next ? 0 : 1
-  });
-};
-export {
-  handleContinue
-};