@treeseed/cli 0.1.1

package/README.md

@@ -0,0 +1,115 @@
+# `@treeseed/cli`
+
+Operator-facing Treeseed CLI package.
+
+This package publishes the `treeseed` binary. It provides the unified TypeScript command interface for Treeseed workspace setup, branch workflow, deployment, validation, and release automation.
+
+## Requirements
+
+- Node `>=20`
+- npm as the canonical package manager for install, CI, and release flows
+
+## Install
+
+Install the CLI alongside the Treeseed runtime package:
+
+```bash
+npm install @treeseed/cli @treeseed/core
+```
+
+`@treeseed/cli` depends on `@treeseed/core`, `@treeseed/sdk`, and `@treeseed/agent` at package runtime. In normal consumer installs, npm resolves those package dependencies automatically.
+
+After installation, the published binary is available as:
+
+```bash
+treeseed --help
+```
+
+## Primary Workflow
+
+The main workflow commands exposed by the current CLI are:
+
+- `treeseed setup`
+- `treeseed work <branch-name> [--preview]`
+- `treeseed ship "<commit message>"`
+- `treeseed publish --environment <local|staging|prod>`
+- `treeseed promote --major|--minor|--patch`
+- `treeseed rollback <staging|prod> [--to <deploy-id|commit>]`
+- `treeseed teardown [--environment <local|staging|prod>]`
+- `treeseed status [--json]`
+- `treeseed next [--json]`
+- `treeseed continue [--json]`
+- `treeseed doctor [--fix] [--json]`
+
+The CLI also keeps compatibility commands such as `init`, `config`, `start`, `deploy`, `save`, `release`, `close`, and `destroy`.
+
+Use `treeseed help` for the full command list and `treeseed help <command>` for command-specific usage, options, and examples.
+
+## Common Commands
+
+```bash
+treeseed setup
+treeseed work feature/search-improvements --preview
+treeseed ship "feat: add search filters"
+treeseed publish --environment staging
+treeseed promote --patch
+treeseed status --json
+```
+
+## Maintainer Workflow
+
+All package maintenance commands are npm-based and run from the `cli/` package root.
+
+Install dependencies:
+
+```bash
+npm install
+```
+
+Build the published package output:
+
+```bash
+npm run build
+```
+
+Run the package test suite:
+
+```bash
+npm test
+```
+
+Run full release verification:
+
+```bash
+npm run release:verify
+```
+
+The release verification flow is intentionally stricter than a normal test run:
+
+1. Build `dist`
+2. Validate publishable output for forbidden workspace references
+3. Run the CLI test suite
+4. Run scaffold verification
+5. Pack the CLI tarball
+6. Smoke-test the packed install by running `treeseed --help` from the packed artifact
+
+## CI And Publishing
+
+The GitHub Actions workflows under `.github/workflows/` assume this package is the repository root for the standalone CLI repository.
+
+- `ci.yml` uses `npm ci`, `npm run build`, `npm test`, and `npm run release:verify`
+- `publish.yml` uses the same verification path before publishing to npm
+- `publish.yml` validates that the pushed tag matches the package version before `npm publish`
+
+Release tags must use this format:
+
+```text
+<version>
+```
+
+For example, package version `0.1.0` publishes from tag `0.1.0`.
+
+## Notes
+
+- `package-lock.json` should be committed and kept current so `npm ci` remains reproducible in CI and release jobs.
+- The README intentionally documents the command surface at a high level. The canonical source of command usage and options is the CLI help output generated from `src/cli/registry.ts`.

package/dist/cli/handlers/close.js

@@ -0,0 +1,60 @@
+import { applyTreeseedEnvironmentToProcess } from "../../scripts/config-runtime-lib.js";
+import {
+  cleanupDestroyedState,
+  createBranchPreviewDeployTarget,
+  destroyCloudflareResources,
+  loadDeployState,
+  printDestroySummary,
+  validateDestroyPrerequisites
+} from "../../scripts/deploy-lib.js";
+import {
+  assertFeatureBranch,
+  deleteLocalBranch,
+  deleteRemoteBranch,
+  mergeCurrentBranchIntoStaging
+} from "../../scripts/git-workflow-lib.js";
+import { loadCliDeployConfig } from "../../scripts/package-tools.js";
+import { runWorkspaceSavePreflight } from "../../scripts/save-deploy-preflight-lib.js";
+import { guidedResult } from "./utils.js";
+const handleClose = (_invocation, context) => {
+  const commandName = _invocation.commandName || "close";
+  const tenantRoot = context.cwd;
+  const featureBranch = assertFeatureBranch(tenantRoot);
+  const previewTarget = createBranchPreviewDeployTarget(featureBranch);
+  const deployConfig = loadCliDeployConfig(tenantRoot);
+  const previewState = loadDeployState(tenantRoot, deployConfig, { target: previewTarget });
+  runWorkspaceSavePreflight({ cwd: tenantRoot });
+  const repoDir = mergeCurrentBranchIntoStaging(tenantRoot, featureBranch);
+  if (previewState.readiness?.initialized) {
+    applyTreeseedEnvironmentToProcess({ tenantRoot, scope: "staging" });
+    validateDestroyPrerequisites(tenantRoot, { requireRemote: true });
+    const result = destroyCloudflareResources(tenantRoot, { target: previewTarget });
+    printDestroySummary(result);
+  }
+  cleanupDestroyedState(tenantRoot, { target: previewTarget });
+  deleteRemoteBranch(repoDir, featureBranch);
+  deleteLocalBranch(repoDir, featureBranch);
+  return {
+    ...guidedResult({
+      command: commandName,
+      summary: `Treeseed ${commandName} completed successfully.`,
+      facts: [
+        { label: "Merged branch", value: featureBranch },
+        { label: "Merge target", value: "staging" },
+        { label: "Preview cleanup", value: previewState.readiness?.initialized ? "performed" : "not needed" }
+      ],
+      nextSteps: [
+        "treeseed deploy --environment staging",
+        "treeseed release --patch"
+      ],
+      report: {
+        branchName: featureBranch,
+        mergeTarget: "staging",
+        previewCleanup: previewState.readiness?.initialized === true
+      }
+    })
+  };
+};
+export {
+  handleClose
+};

package/dist/cli/handlers/config.js

@@ -0,0 +1,76 @@
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { collectCliPreflight } from "../../scripts/workspace-preflight-lib.js";
+import {
+  applyTreeseedEnvironmentToProcess,
+  ensureTreeseedGitignoreEntries,
+  getTreeseedMachineConfigPaths,
+  runTreeseedConfigWizard,
+  writeTreeseedLocalEnvironmentFiles
+} from "../../scripts/config-runtime-lib.js";
+import { guidedResult } from "./utils.js";
+const handleConfig = async (invocation, context) => {
+  const commandName = invocation.commandName || "config";
+  const tenantRoot = context.cwd;
+  const scopes = Array.isArray(invocation.args.environment) ? invocation.args.environment : invocation.args.environment ? [invocation.args.environment] : ["local", "staging", "prod"];
+  const sync = typeof invocation.args.sync === "string" ? invocation.args.sync : "none";
+  ensureTreeseedGitignoreEntries(tenantRoot);
+  const preflight = collectCliPreflight({ cwd: tenantRoot, requireAuth: false });
+  const rl = readline.createInterface({ input, output });
+  try {
+    if (context.outputFormat !== "json") {
+      context.write("Treeseed configuration wizard", "stdout");
+      context.write("This command writes a local machine config, generates .env.local and .dev.vars, and can sync GitHub or Cloudflare settings.", "stdout");
+      context.write('Enter a value to set it, press Enter to keep the current/default value, or enter "-" to clear a value.\n', "stdout");
+    }
+    const result = await runTreeseedConfigWizard({
+      tenantRoot,
+      scopes,
+      sync,
+      authStatus: preflight.checks.auth,
+      write: context.outputFormat === "json" ? () => {
+      } : ((line) => context.write(line, "stdout")),
+      prompt: async (message) => {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+          return "";
+        }
+        try {
+          return await rl.question(message);
+        } catch {
+          return "";
+        }
+      }
+    });
+    writeTreeseedLocalEnvironmentFiles(tenantRoot);
+    applyTreeseedEnvironmentToProcess({ tenantRoot, scope: "local" });
+    const { configPath, keyPath } = getTreeseedMachineConfigPaths(tenantRoot);
+    return guidedResult({
+      command: commandName,
+      summary: `Treeseed ${commandName} completed successfully.`,
+      facts: [
+        { label: "Machine config", value: configPath },
+        { label: "Machine key", value: keyPath },
+        { label: "Updated values", value: result.updated.length },
+        { label: "Initialized environments", value: result.initialized.map((entry) => entry.scope).join(", ") || "(none)" },
+        { label: "GitHub sync", value: result.synced.github ? `${result.synced.github.secrets.length} secrets, ${result.synced.github.variables.length} variables` : "not run" },
+        { label: "Cloudflare sync", value: result.synced.cloudflare ? `${result.synced.cloudflare.secrets.length} secrets, ${result.synced.cloudflare.varsManagedByWranglerConfig.length} vars` : "not run" }
+      ],
+      nextSteps: [
+        ...scopes.includes("local") ? ["treeseed dev"] : [],
+        ...scopes.includes("staging") ? ["treeseed deploy --environment staging"] : [],
+        ...scopes.includes("prod") ? ["treeseed deploy --environment prod"] : []
+      ],
+      report: {
+        scopes,
+        sync,
+        result,
+        preflight
+      }
+    });
+  } finally {
+    rl.close();
+  }
+};
+export {
+  handleConfig
+};

package/dist/cli/handlers/continue.js

@@ -0,0 +1,23 @@
+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
+};

package/dist/cli/handlers/deploy.js

@@ -0,0 +1,139 @@
+import { applyTreeseedEnvironmentToProcess } from "../../scripts/config-runtime-lib.js";
+import {
+  assertDeploymentInitialized,
+  createBranchPreviewDeployTarget,
+  createPersistentDeployTarget,
+  deployTargetLabel,
+  ensureGeneratedWranglerConfig,
+  finalizeDeploymentState,
+  runRemoteD1Migrations
+} from "../../scripts/deploy-lib.js";
+import { currentManagedBranch, PRODUCTION_BRANCH, STAGING_BRANCH } from "../../scripts/git-workflow-lib.js";
+import { packageScriptPath, resolveWranglerBin } from "../../scripts/package-tools.js";
+import { runTenantDeployPreflight } from "../../scripts/save-deploy-preflight-lib.js";
+import { guidedResult } from "./utils.js";
+function inferEnvironmentFromBranch(tenantRoot) {
+  const branch = currentManagedBranch(tenantRoot);
+  if (branch === STAGING_BRANCH) return "staging";
+  if (branch === PRODUCTION_BRANCH) return "prod";
+  return null;
+}
+const handleDeploy = (invocation, context) => {
+  const commandName = invocation.commandName || "deploy";
+  const tenantRoot = context.cwd;
+  const environment = typeof invocation.args.environment === "string" ? invocation.args.environment : void 0;
+  const targetBranch = typeof invocation.args.targetBranch === "string" ? invocation.args.targetBranch : void 0;
+  const dryRun = invocation.args.dryRun === true;
+  const only = typeof invocation.args.only === "string" ? invocation.args.only : null;
+  const name = typeof invocation.args.name === "string" ? invocation.args.name : null;
+  const target = targetBranch ? createBranchPreviewDeployTarget(targetBranch) : createPersistentDeployTarget(environment ?? (context.env.CI ? inferEnvironmentFromBranch(tenantRoot) : null));
+  const scope = targetBranch ? "staging" : String(environment ?? (context.env.CI ? inferEnvironmentFromBranch(tenantRoot) : ""));
+  const executedSteps = [];
+  const nextSteps = [];
+  let deployUrl = null;
+  let migratedDatabase = null;
+  applyTreeseedEnvironmentToProcess({ tenantRoot, scope });
+  const allowedSteps = /* @__PURE__ */ new Set(["migrate", "build", "publish"]);
+  if (only && !allowedSteps.has(only)) {
+    throw new Error(`Unsupported deploy step "${only}". Expected one of ${[...allowedSteps].join(", ")}.`);
+  }
+  const shouldRun = (step) => !only || only === step;
+  if (scope === "local") {
+    runTenantDeployPreflight({ cwd: tenantRoot, scope: "local" });
+    const buildOnly = context.spawn(process.execPath, [packageScriptPath("tenant-build")], {
+      cwd: tenantRoot,
+      env: { ...context.env },
+      stdio: "inherit"
+    });
+    return guidedResult({
+      command: commandName,
+      summary: buildOnly.status === 0 ? "Treeseed local deploy completed as a build-only publish target." : "Treeseed local deploy failed.",
+      exitCode: buildOnly.status ?? 1,
+      facts: [
+        { label: "Target", value: "local" },
+        { label: "Dry run", value: dryRun ? "yes" : "no" }
+      ],
+      nextSteps: buildOnly.status === 0 ? ["treeseed preview", 'treeseed save "describe your change"'] : ["treeseed doctor"],
+      report: {
+        target: "local",
+        dryRun,
+        only,
+        name,
+        executedSteps: ["build"]
+      }
+    });
+  }
+  assertDeploymentInitialized(tenantRoot, { target });
+  runTenantDeployPreflight({ cwd: tenantRoot, scope });
+  const { wranglerPath } = ensureGeneratedWranglerConfig(tenantRoot, { target });
+  if (shouldRun("migrate")) {
+    const result = runRemoteD1Migrations(tenantRoot, { dryRun, target });
+    executedSteps.push("migrate");
+    migratedDatabase = result.databaseName;
+  }
+  if (shouldRun("build")) {
+    if (dryRun) {
+      executedSteps.push("build");
+    } else {
+      const buildResult = context.spawn(process.execPath, [packageScriptPath("tenant-build")], {
+        cwd: tenantRoot,
+        env: { ...context.env },
+        stdio: "inherit"
+      });
+      if ((buildResult.status ?? 1) !== 0) {
+        return { exitCode: buildResult.status ?? 1 };
+      }
+      executedSteps.push("build");
+    }
+  }
+  if (shouldRun("publish")) {
+    if (dryRun) {
+      executedSteps.push("publish");
+    } else {
+      const publishResult = context.spawn(process.execPath, [resolveWranglerBin(), "deploy", "--config", wranglerPath], {
+        cwd: tenantRoot,
+        env: { ...context.env },
+        stdio: "inherit"
+      });
+      if ((publishResult.status ?? 1) !== 0) {
+        return { exitCode: publishResult.status ?? 1 };
+      }
+      const finalizedState = finalizeDeploymentState(tenantRoot, { target });
+      deployUrl = finalizedState.lastDeployedUrl ?? null;
+      executedSteps.push("publish");
+    }
+  }
+  if (scope === "staging") {
+    nextSteps.push("treeseed release --patch");
+  }
+  if (scope !== "local") {
+    nextSteps.push(`treeseed status`);
+  }
+  return guidedResult({
+    command: commandName,
+    summary: dryRun ? `Treeseed ${commandName} dry run completed for ${deployTargetLabel(target)}.` : `Treeseed ${commandName} completed for ${deployTargetLabel(target)}.`,
+    facts: [
+      { label: "Target", value: deployTargetLabel(target) },
+      { label: "Target label", value: name ?? "(none)" },
+      { label: "Dry run", value: dryRun ? "yes" : "no" },
+      { label: "Executed steps", value: executedSteps.join(", ") || "(none)" },
+      { label: "Migrated database", value: migratedDatabase ?? "(none)" },
+      { label: "Preview URL", value: deployUrl ?? (dryRun ? "(dry run)" : "(not reported)") }
+    ],
+    nextSteps,
+    report: {
+      target: deployTargetLabel(target),
+      scope,
+      dryRun,
+      only,
+      name,
+      wranglerPath,
+      executedSteps,
+      migratedDatabase,
+      deployUrl
+    }
+  });
+};
+export {
+  handleDeploy
+};

package/dist/cli/handlers/destroy.js

@@ -0,0 +1,94 @@
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { applyTreeseedEnvironmentToProcess, assertTreeseedCommandEnvironment } from "../../scripts/config-runtime-lib.js";
+import {
+  cleanupDestroyedState,
+  createPersistentDeployTarget,
+  destroyCloudflareResources,
+  loadDeployState,
+  printDestroySummary,
+  validateDestroyPrerequisites
+} from "../../scripts/deploy-lib.js";
+import { guidedResult } from "./utils.js";
+function printDangerMessage(context, deployConfig, state, expectedConfirmation) {
+  context.write("DANGER: treeseed destroy will permanently delete this site and its Cloudflare resources.", "stderr");
+  context.write(`  Site: ${deployConfig.name}`, "stderr");
+  context.write(`  Slug: ${deployConfig.slug}`, "stderr");
+  context.write(`  Worker: ${state.workerName}`, "stderr");
+  context.write(`  D1: ${state.d1Databases.SITE_DATA_DB.databaseName}`, "stderr");
+  context.write(`  KV FORM_GUARD_KV: ${state.kvNamespaces.FORM_GUARD_KV.name}`, "stderr");
+  context.write(`  KV SESSION: ${state.kvNamespaces.SESSION.name}`, "stderr");
+  context.write("  This action is irreversible.", "stderr");
+  context.write(`  To continue, type exactly: ${expectedConfirmation}`, "stderr");
+}
+const handleDestroy = async (invocation, context) => {
+  const commandName = invocation.commandName || "destroy";
+  const tenantRoot = context.cwd;
+  const scope = String(invocation.args.environment);
+  const target = createPersistentDeployTarget(scope);
+  const dryRun = invocation.args.dryRun === true;
+  const force = invocation.args.force === true;
+  const skipConfirmation = invocation.args.skipConfirmation === true;
+  const confirm = typeof invocation.args.confirm === "string" ? invocation.args.confirm : null;
+  const removeBuildArtifacts = invocation.args.removeBuildArtifacts === true;
+  applyTreeseedEnvironmentToProcess({ tenantRoot, scope });
+  assertTreeseedCommandEnvironment({ tenantRoot, scope, purpose: "destroy" });
+  const deployConfig = validateDestroyPrerequisites(tenantRoot, { requireRemote: !dryRun });
+  const state = loadDeployState(tenantRoot, deployConfig, { target });
+  const expectedConfirmation = deployConfig.slug;
+  if (!skipConfirmation) {
+    printDangerMessage(context, deployConfig, state, expectedConfirmation);
+    const confirmed = confirm !== null ? confirm === expectedConfirmation : await (async () => {
+      const rl = readline.createInterface({ input, output });
+      try {
+        return (await rl.question("Confirmation: ")).trim() === expectedConfirmation;
+      } finally {
+        rl.close();
+      }
+    })();
+    if (!confirmed) {
+      return { exitCode: 1, stderr: ["Destroy aborted: confirmation text did not match."] };
+    }
+  }
+  const result = destroyCloudflareResources(tenantRoot, { dryRun, force, target });
+  printDestroySummary(result);
+  if (dryRun) {
+    return guidedResult({
+      command: commandName,
+      summary: `Treeseed ${commandName} dry run completed.`,
+      facts: [
+        { label: "Environment", value: scope },
+        { label: "Remote deletion", value: "skipped" }
+      ],
+      nextSteps: ["treeseed status"],
+      report: {
+        scope,
+        dryRun: true,
+        force,
+        removeBuildArtifacts
+      }
+    });
+  }
+  cleanupDestroyedState(tenantRoot, { target, removeBuildArtifacts });
+  return guidedResult({
+    command: commandName,
+    summary: `Treeseed ${commandName} completed and local deployment state was removed.`,
+    facts: [
+      { label: "Environment", value: scope },
+      { label: "Removed build artifacts", value: removeBuildArtifacts ? "yes" : "no" }
+    ],
+    nextSteps: [
+      `treeseed config --environment ${scope}`,
+      "treeseed status"
+    ],
+    report: {
+      scope,
+      dryRun: false,
+      force,
+      removeBuildArtifacts
+    }
+  });
+};
+export {
+  handleDestroy
+};

package/dist/cli/handlers/doctor.js

@@ -0,0 +1,48 @@
+import { collectCliPreflight } from "../../scripts/workspace-preflight-lib.js";
+import { guidedResult } from "./utils.js";
+import { resolveTreeseedWorkflowState } from "../workflow-state.js";
+import { applyTreeseedSafeRepairs } from "../repair.js";
+const handleDoctor = (invocation, context) => {
+  const performedFixes = invocation.args.fix === true && resolveTreeseedWorkflowState(context.cwd).deployConfigPresent ? applyTreeseedSafeRepairs(context.cwd) : [];
+  const state = resolveTreeseedWorkflowState(context.cwd);
+  const preflight = collectCliPreflight({ cwd: context.cwd, requireAuth: false });
+  const mustFixNow = [];
+  const optional = [];
+  if (!state.workspaceRoot) mustFixNow.push("Run Treeseed from the workspace root so package commands and workflow state resolve correctly.");
+  if (!state.repoRoot) mustFixNow.push("Initialize or clone the git repository before using save, close, deploy, or release flows.");
+  if (!state.deployConfigPresent) mustFixNow.push("Create or restore treeseed.site.yaml so the tenant contract can be loaded.");
+  if (preflight.missingCommands.includes("git")) mustFixNow.push("Install Git.");
+  if (preflight.missingCommands.includes("npm")) mustFixNow.push("Install npm 10 or newer.");
+  if (!state.files.machineConfig) mustFixNow.push("Run `treeseed config --environment local` to create the local machine config.");
+  if (!state.files.envLocal) optional.push("Create `.env.local` or run `treeseed config --environment local` to generate it.");
+  if (!state.files.devVars) optional.push("Generate `.dev.vars` by running `treeseed config --environment local`.");
+  if (!state.auth.gh) optional.push("Authenticate `gh` if you want GitHub-backed save or release automation.");
+  if (!state.auth.wrangler) optional.push("Authenticate `wrangler` before staging, preview, or production deployment work.");
+  if (!state.auth.copilot) optional.push("Configure Copilot CLI only if you rely on local Copilot-assisted workflows.");
+  return guidedResult({
+    command: "doctor",
+    summary: mustFixNow.length === 0 ? "Treeseed doctor found no blocking issues." : "Treeseed doctor found issues that need attention.",
+    facts: [
+      { label: "Must fix now", value: mustFixNow.length },
+      { label: "Optional follow-up", value: optional.length },
+      { label: "Safe fixes applied", value: performedFixes.length },
+      { label: "Branch", value: state.branchName ?? "(none)" },
+      { label: "Workspace root", value: state.workspaceRoot ? "yes" : "no" }
+    ],
+    nextSteps: [
+      ...mustFixNow.map((item) => item),
+      ...mustFixNow.length === 0 ? optional : optional.map((item) => `Optional: ${item}`)
+    ],
+    report: {
+      state,
+      preflight,
+      performedFixes,
+      mustFixNow,
+      optional
+    },
+    exitCode: mustFixNow.length === 0 ? 0 : 1
+  });
+};
+export {
+  handleDoctor
+};

package/dist/cli/handlers/init.js

@@ -0,0 +1,30 @@
+import { packageScriptPath } from "../../scripts/package-tools.js";
+import { guidedResult } from "./utils.js";
+const handleInit = (invocation, context) => {
+  const directory = invocation.positionals[0];
+  const result = context.spawn(process.execPath, [packageScriptPath("scaffold-site"), ...invocation.rawArgs], {
+    cwd: context.cwd,
+    env: { ...context.env },
+    stdio: "inherit"
+  });
+  if ((result.status ?? 1) !== 0) {
+    return { exitCode: result.status ?? 1 };
+  }
+  return guidedResult({
+    command: "init",
+    summary: "Treeseed init completed successfully.",
+    facts: [{ label: "Directory", value: directory ?? "(current directory)" }],
+    nextSteps: [
+      `cd ${directory}`,
+      "treeseed doctor",
+      "treeseed config --environment local",
+      "treeseed dev"
+    ],
+    report: {
+      directory: directory ?? null
+    }
+  });
+};
+export {
+  handleInit
+};

package/dist/cli/handlers/next.js

@@ -0,0 +1,27 @@
+import { guidedResult } from "./utils.js";
+import { resolveTreeseedWorkflowState } from "../workflow-state.js";
+const handleNext = (_invocation, context) => {
+  const state = resolveTreeseedWorkflowState(context.cwd);
+  return guidedResult({
+    command: "next",
+    summary: "Treeseed next-step recommendations",
+    facts: [
+      { label: "Branch", value: state.branchName ?? "(none)" },
+      { label: "Branch role", value: state.branchRole },
+      { label: "Dirty worktree", value: state.dirtyWorktree ? "yes" : "no" }
+    ],
+    nextSteps: state.recommendations.map((item) => `${item.command}  # ${item.reason}`),
+    report: {
+      state: {
+        branchName: state.branchName,
+        branchRole: state.branchRole,
+        dirtyWorktree: state.dirtyWorktree,
+        environment: state.environment
+      },
+      recommendations: state.recommendations
+    }
+  });
+};
+export {
+  handleNext
+};

package/dist/cli/handlers/prepare.js

@@ -0,0 +1,8 @@
+import { handleConfig } from "./config.js";
+const handlePrepare = (invocation, context) => handleConfig({
+  ...invocation,
+  commandName: invocation.commandName || "prepare"
+}, context);
+export {
+  handlePrepare
+};

package/dist/cli/handlers/promote.js

@@ -0,0 +1,8 @@
+import { handleRelease } from "./release.js";
+const handlePromote = (invocation, context) => handleRelease({
+  ...invocation,
+  commandName: invocation.commandName || "promote"
+}, context);
+export {
+  handlePromote
+};

package/dist/cli/handlers/publish.js

@@ -0,0 +1,8 @@
+import { handleDeploy } from "./deploy.js";
+const handlePublish = (invocation, context) => handleDeploy({
+  ...invocation,
+  commandName: invocation.commandName || "publish"
+}, context);
+export {
+  handlePublish
+};