@treeseed/cli 0.10.21 → 0.11.0

package/dist/cli/handlers/hosting.js

@@ -0,0 +1,257 @@
+import {
+  applyTreeseedHostingGraph,
+  compileTreeseedHostingGraph,
+  planTreeseedHostingGraph,
+  serializeHostingApplyResult,
+  serializeHostingPlan,
+  serializeHostingUnit
+} from "@treeseed/sdk/hosting";
+import {
+  collectTreeseedConfigSeedValues,
+  collectTreeseedLiveHostedServiceChecks as collectLiveChecks,
+  deleteRailwayProject,
+  listRailwayProjects,
+  resolveRailwayWorkspaceContext
+} from "@treeseed/sdk/workflow-support";
+import { guidedResult } from "./utils.js";
+import { workflowErrorResult } from "./workflow.js";
+function environmentFor(value) {
+  return value === "prod" || value === "production" ? "prod" : value === "staging" ? "staging" : "local";
+}
+function subcommandFor(value) {
+  const subcommand = typeof value === "string" && value.trim() ? value.trim() : "status";
+  if (!["plan", "apply", "verify", "status", "destroy"].includes(subcommand)) {
+    throw new Error(`Unknown hosting subcommand "${subcommand}". Use plan, apply, verify, status, or destroy.`);
+  }
+  return subcommand;
+}
+function listArg(value) {
+  const raw = Array.isArray(value) ? value : value === void 0 || value === null || value === "" ? [] : [value];
+  return [...new Set(raw.flatMap((entry) => String(entry).split(",")).map((entry) => entry.trim()).filter(Boolean))];
+}
+function renderUnitLine(entry) {
+  return `${entry.unit.id}: ${entry.unit.serviceType} -> ${entry.unit.hostId} (${entry.unit.placement})${entry.plan?.action ? ` ${entry.plan.action}` : ""}${entry.verification ? ` verified=${entry.verification.verified ? "yes" : "no"}` : ""}`;
+}
+const handleHosting = async (invocation, context) => {
+  try {
+    const subcommand = subcommandFor(invocation.positionals[0]);
+    const environment = environmentFor(invocation.args.environment);
+    const dryRun = invocation.args.dryRun !== false && invocation.args.execute !== true;
+    const appId = typeof invocation.args.app === "string" && invocation.args.app.trim() ? invocation.args.app.trim() : void 0;
+    const filter = {
+      serviceIds: listArg(invocation.args.service),
+      placements: listArg(invocation.args.placement),
+      hosts: listArg(invocation.args.host)
+    };
+    const filterInput = filter.serviceIds.length || filter.placements.length || filter.hosts.length ? { filter } : {};
+    if (subcommand === "status") {
+      const graph = compileTreeseedHostingGraph({ tenantRoot: context.cwd, environment, appId, ...filterInput });
+      const units = graph.units.map((unit) => serializeHostingUnit(unit));
+      return guidedResult({
+        command: "hosting status",
+        summary: `Hosting graph status for ${environment}`,
+        facts: [
+          { label: "Environment", value: environment },
+          { label: "Application", value: appId ?? "(workspace)" },
+          { label: "Units", value: String(units.length) },
+          { label: "Hosts", value: Object.keys(graph.hosts).join(", ") },
+          { label: "Service types", value: Object.keys(graph.serviceTypes).join(", ") }
+        ],
+        sections: [
+          {
+            title: "Placements",
+            lines: graph.placements.map((placement) => `${placement.label}: ${placement.serviceIds.join(", ")} on ${placement.hostIds.join(", ")}`)
+          },
+          {
+            title: "Units",
+            lines: units.map((unit) => renderUnitLine({ unit }))
+          }
+        ],
+        report: {
+          command: "hosting status",
+          environment,
+          graph: {
+            environment,
+            appId: appId ?? null,
+            applications: graph.applications?.map((app) => ({
+              id: app.id,
+              relativeRoot: app.relativeRoot,
+              roles: app.roles
+            })) ?? [],
+            placements: graph.placements,
+            units,
+            warnings: graph.warnings
+          }
+        }
+      });
+    }
+    if (subcommand === "destroy") {
+      if (!appId) {
+        throw new Error("hosting destroy requires --app so the teardown boundary is explicit.");
+      }
+      const graph = compileTreeseedHostingGraph({ tenantRoot: context.cwd, environment, appId, ...filterInput });
+      const selectedProjectNames = graph.units.filter((unit) => unit.host.id === "railway").map((unit) => unit.projectGroup?.environments?.[environment]?.projectName).filter((value) => typeof value === "string" && value.trim().length > 0);
+      const railwayProjectNames = [...new Set(selectedProjectNames)];
+      const seedEnv = {
+        ...context.env,
+        ...collectTreeseedConfigSeedValues(context.cwd, environment, context.env)
+      };
+      const projects = railwayProjectNames.length === 0 ? [] : await listRailwayProjects({
+        workspaceId: (await resolveRailwayWorkspaceContext({ env: seedEnv })).id,
+        env: seedEnv
+      });
+      const results = [];
+      for (const projectName of railwayProjectNames) {
+        const matchingProjects = projects.filter((entry) => entry.name === projectName || entry.id === projectName);
+        if (matchingProjects.length === 0) {
+          results.push({
+            projectName,
+            projectId: null,
+            action: dryRun ? "destroy" : "noop",
+            result: { status: dryRun ? "planned" : "missing", projectName }
+          });
+          continue;
+        }
+        for (const project of matchingProjects) {
+          const result2 = dryRun ? { status: "planned", projectName, projectId: project.id } : await deleteRailwayProject({ projectId: project.id, env: seedEnv });
+          results.push({
+            projectName,
+            projectId: project.id,
+            action: dryRun ? "destroy" : result2.status === "missing" ? "noop" : "destroy",
+            result: result2
+          });
+        }
+      }
+      return guidedResult({
+        command: "hosting destroy",
+        summary: `${dryRun ? "Planned" : "Destroyed"} hosting resources for ${appId} in ${environment}`,
+        facts: [
+          { label: "Environment", value: environment },
+          { label: "Application", value: appId },
+          { label: "Dry run", value: dryRun ? "yes" : "no" },
+          { label: "Railway projects", value: railwayProjectNames.length ? railwayProjectNames.join(", ") : "(none)" }
+        ],
+        sections: [
+          {
+            title: "Railway Projects",
+            lines: results.length ? results.map((entry) => `${entry.projectName}: ${entry.action}`) : ["No Railway project groups selected."]
+          }
+        ],
+        report: {
+          command: "hosting destroy",
+          environment,
+          appId,
+          dryRun,
+          projects: results
+        }
+      });
+    }
+    if (subcommand === "plan" || subcommand === "verify") {
+      const plan = await planTreeseedHostingGraph({ tenantRoot: context.cwd, environment, appId, dryRun: true, ...filterInput });
+      const report2 = serializeHostingPlan(plan);
+      const liveHostedServices2 = subcommand === "verify" && invocation.args.live === true && environment !== "local" ? await collectLiveChecks({
+        tenantRoot: context.cwd,
+        target: environment,
+        appId,
+        strict: true,
+        requireLiveRailway: !appId || appId === "api",
+        requireLiveHttp: true,
+        env: {
+          ...context.env,
+          ...collectTreeseedConfigSeedValues(context.cwd, environment, context.env)
+        }
+      }) : null;
+      const liveFailures2 = liveHostedServices2 ? [
+        ...liveHostedServices2.checks.filter((check) => check.status === "failed").map((check) => `${check.id}: ${check.issues.join("; ") || "failed"}`),
+        ...liveHostedServices2.liveObservation.issues
+      ] : [];
+      return guidedResult({
+        command: `hosting ${subcommand}`,
+        summary: `${subcommand === "verify" ? "Verified" : "Planned"} hosting graph for ${environment}`,
+        facts: [
+          { label: "Environment", value: environment },
+          { label: "Application", value: appId ?? "(workspace)" },
+          { label: "Dry run", value: "yes" },
+          { label: "Units", value: String(report2.units.length) },
+          { label: "Verified units", value: String(report2.units.filter((entry) => entry.verification.verified).length) }
+        ],
+        sections: [
+          {
+            title: "Placements",
+            lines: report2.placements.map((placement) => `${placement.label}: ${placement.serviceIds.join(", ")} on ${placement.hostIds.join(", ")}`)
+          },
+          {
+            title: "Plan",
+            lines: report2.units.map((entry) => renderUnitLine(entry))
+          }
+        ],
+        report: liveHostedServices2 ? { ...report2, hostedServices: liveHostedServices2 } : report2,
+        exitCode: liveFailures2.length > 0 ? 1 : 0,
+        stderr: liveFailures2
+      });
+    }
+    const result = await applyTreeseedHostingGraph({ tenantRoot: context.cwd, environment, appId, dryRun, ...filterInput });
+    const report = serializeHostingApplyResult(result);
+    const liveHostedServices = !dryRun && environment !== "local" ? await collectLiveChecks({
+      tenantRoot: context.cwd,
+      target: environment,
+      appId,
+      strict: true,
+      requireLiveRailway: !appId || appId === "api",
+      requireLiveHttp: true,
+      env: {
+        ...context.env,
+        ...collectTreeseedConfigSeedValues(context.cwd, environment, context.env)
+      }
+    }) : null;
+    const liveFailures = liveHostedServices ? [
+      ...liveHostedServices.checks.filter((check) => check.status === "failed").map((check) => `${check.id}: ${check.issues.join("; ") || "failed"}`),
+      ...liveHostedServices.liveObservation.issues
+    ] : [];
+    const finalReport = liveHostedServices ? {
+      ...report,
+      liveVerification: {
+        ok: liveFailures.length === 0,
+        source: "live-hosted-service-checks",
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        issues: liveFailures,
+        checks: liveHostedServices.checks
+      },
+      hostedServices: liveHostedServices,
+      ok: report.ok === true && liveFailures.length === 0
+    } : report;
+    return guidedResult({
+      command: "hosting apply",
+      summary: `${dryRun ? "Dry-run applied" : "Applied"} hosting graph for ${environment}`,
+      facts: [
+        { label: "Environment", value: environment },
+        { label: "Application", value: appId ?? "(workspace)" },
+        { label: "Dry run", value: dryRun ? "yes" : "no" },
+        { label: "Units", value: String(finalReport.results.length) },
+        { label: "Verified units", value: String(finalReport.results.filter((entry) => entry.verification.verified).length) },
+        { label: "Selected systems", value: finalReport.selectedSystems?.join(", ") || "(none)" },
+        { label: "Railway reconcile", value: finalReport.transport?.railway?.reconcile ?? "(not selected)" },
+        { label: "Railway deploy", value: finalReport.transport?.railway?.deploy ?? "(not selected)" },
+        { label: "Live verification", value: finalReport.liveVerification?.ok === false ? "failed" : "passed" }
+      ],
+      sections: [
+        {
+          title: "Results",
+          lines: finalReport.results.map((entry) => renderUnitLine({
+            unit: entry.unit,
+            plan: entry.plan,
+            verification: entry.verification
+          }))
+        }
+      ],
+      report: finalReport,
+      exitCode: !dryRun && (liveFailures.length > 0 || finalReport.ok === false) ? 1 : 0,
+      stderr: liveFailures
+    });
+  } catch (error) {
+    return workflowErrorResult(error);
+  }
+};
+export {
+  handleHosting
+};

package/dist/cli/handlers/operations.d.ts

@@ -0,0 +1,2 @@
+import type { TreeseedCommandHandler } from '../types.js';
+export declare const handleOperations: TreeseedCommandHandler;

package/dist/cli/handlers/operations.js

@@ -0,0 +1,46 @@
+import { runTreeseedOperationsRunnerSmoke } from "@treeseed/sdk/workflow-support";
+import { guidedResult } from "./utils.js";
+import { workflowErrorResult } from "./workflow.js";
+function environmentFor(value) {
+  const raw = typeof value === "string" && value.trim() ? value.trim() : "staging";
+  return raw === "prod" || raw === "production" ? "prod" : "staging";
+}
+const handleOperations = async (invocation, context) => {
+  try {
+    const action = typeof invocation.positionals[0] === "string" ? invocation.positionals[0] : "smoke";
+    if (action !== "smoke") {
+      throw new Error(`Unsupported operations action "${action}". Use smoke.`);
+    }
+    const service = typeof invocation.args.service === "string" ? invocation.args.service : "operationsRunner";
+    if (service !== "operationsRunner") {
+      throw new Error(`Unsupported operations smoke service "${service}". Use operationsRunner.`);
+    }
+    const environment = environmentFor(invocation.args.environment);
+    const report = await runTreeseedOperationsRunnerSmoke({
+      tenantRoot: context.cwd,
+      environment,
+      env: context.env
+    });
+    return guidedResult({
+      command: "operations smoke",
+      summary: report.ok ? "Treeseed operations runner smoke passed." : "Treeseed operations runner smoke failed.",
+      facts: [
+        { label: "Environment", value: environment },
+        { label: "Base URL", value: report.baseUrl },
+        { label: "Operation", value: report.operationId ?? "(none)" },
+        { label: "Final status", value: report.finalStatus ?? "(none)" },
+        { label: "Runner", value: report.runnerId ?? "(none)" }
+      ],
+      nextSteps: report.ok ? [] : [
+        `npx trsd hosting verify --environment ${environment} --service operationsRunner --live --json`
+      ],
+      report,
+      exitCode: report.ok ? 0 : 1
+    });
+  } catch (error) {
+    return workflowErrorResult(error);
+  }
+};
+export {
+  handleOperations
+};

package/dist/cli/handlers/package-image.d.ts

@@ -0,0 +1,10 @@
+import type { TreeseedCommandHandler, TreeseedParsedInvocation } from '../types.js';
+export declare function runPackageImageCommand(invocation: TreeseedParsedInvocation, context: Parameters<TreeseedCommandHandler>[1], options?: {
+    packageId?: string | null;
+    commandName?: string;
+}): Promise<import("../operations-types.js").TreeseedCommandResult | {
+    exitCode: number;
+    stdout: string[];
+    stderr: never[];
+    report: Record<string, unknown>;
+}>;

package/dist/cli/handlers/package-image.js

@@ -0,0 +1,132 @@
+import {
+  createGitHubApiClient,
+  dispatchGitHubWorkflowRun,
+  ensureGitHubActionsEnvironment,
+  getLatestGitHubWorkflowRun,
+  listGitHubEnvironmentSecretNames,
+  listGitHubEnvironmentVariableNames,
+  planTreeseedPackageDevelopmentImage,
+  resolveGitHubCredentialForRepository,
+  resolveTreeseedLaunchEnvironment,
+  upsertGitHubEnvironmentSecret,
+  upsertGitHubEnvironmentVariable
+} from "@treeseed/sdk/workflow-support";
+import { fail, guidedResult } from "./utils.js";
+function stringArg(invocation, key) {
+  const value = invocation.args[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function boolArg(invocation, key) {
+  return invocation.args[key] === true;
+}
+function jsonResult(invocation, context, report) {
+  if (context.outputFormat === "json" || boolArg(invocation, "json")) {
+    return { exitCode: 0, stdout: [JSON.stringify(report, null, 2)], stderr: [], report };
+  }
+  return null;
+}
+async function runPackageImageCommand(invocation, context, options = {}) {
+  const packageId = options.packageId ?? stringArg(invocation, "package") ?? stringArg(invocation, "packageId");
+  if (!packageId) {
+    return fail("Missing --package. Use `trsd package image --package <package-id>`.");
+  }
+  const branch = stringArg(invocation, "branch") ?? "staging";
+  const workflow = stringArg(invocation, "workflow") ?? null;
+  const execute = boolArg(invocation, "execute");
+  const syncConfig = boolArg(invocation, "syncConfig");
+  const planOnly = boolArg(invocation, "plan") || !execute;
+  const imagePlan = planTreeseedPackageDevelopmentImage(context.cwd, packageId, { branch });
+  const selectedWorkflow = workflow ?? imagePlan.workflow;
+  const configEnv = resolveTreeseedLaunchEnvironment({
+    tenantRoot: context.cwd,
+    scope: "staging",
+    baseEnv: context.env
+  });
+  const dockerHub = {
+    usernameConfigured: Boolean(String(configEnv.DOCKERHUB_USERNAME ?? "").trim()),
+    tokenConfigured: Boolean(String(configEnv.DOCKERHUB_TOKEN ?? "").trim()),
+    requiredSecrets: ["DOCKERHUB_TOKEN"],
+    requiredVariables: ["DOCKERHUB_USERNAME"]
+  };
+  const credential = resolveGitHubCredentialForRepository(imagePlan.repository, { values: configEnv, env: context.env });
+  const githubClientEnv = credential.token ? { ...configEnv, GH_TOKEN: credential.token, GITHUB_TOKEN: credential.token } : configEnv;
+  const report = {
+    ok: true,
+    action: planOnly ? "plan" : "dispatch",
+    package: imagePlan.package,
+    repository: imagePlan.repository,
+    workflow: selectedWorkflow,
+    branch: imagePlan.branch,
+    refs: imagePlan.refs,
+    credential: {
+      repository: credential.repository,
+      envName: credential.envName,
+      configured: credential.configured,
+      source: credential.source,
+      fallbackUsed: credential.fallbackUsed
+    },
+    dockerHub,
+    hosting: imagePlan.hosting
+  };
+  if (syncConfig) {
+    const client = createGitHubApiClient({ env: githubClientEnv });
+    const environment = imagePlan.hosting?.environment ?? "staging";
+    await ensureGitHubActionsEnvironment(imagePlan.repository, environment, {
+      client,
+      branchName: imagePlan.branch
+    });
+    const [secretNames, variableNames] = await Promise.all([
+      listGitHubEnvironmentSecretNames(imagePlan.repository, environment, { client }),
+      listGitHubEnvironmentVariableNames(imagePlan.repository, environment, { client })
+    ]);
+    const synced = {
+      environment,
+      secrets: [],
+      variables: []
+    };
+    if (configEnv.DOCKERHUB_TOKEN) {
+      await upsertGitHubEnvironmentSecret(imagePlan.repository, environment, "DOCKERHUB_TOKEN", configEnv.DOCKERHUB_TOKEN, { client });
+      synced.secrets.push({ name: "DOCKERHUB_TOKEN", existed: secretNames.has("DOCKERHUB_TOKEN") });
+    }
+    if (configEnv.DOCKERHUB_USERNAME) {
+      await upsertGitHubEnvironmentVariable(imagePlan.repository, environment, "DOCKERHUB_USERNAME", configEnv.DOCKERHUB_USERNAME, { client });
+      synced.variables.push({ name: "DOCKERHUB_USERNAME", existed: variableNames.has("DOCKERHUB_USERNAME") });
+    }
+    report.syncedConfig = synced;
+  }
+  if (execute) {
+    const client = createGitHubApiClient({ env: githubClientEnv });
+    report.dispatch = await dispatchGitHubWorkflowRun(imagePlan.repository, {
+      client,
+      workflow: selectedWorkflow,
+      branch: imagePlan.branch
+    });
+    report.latestWorkflowRun = await getLatestGitHubWorkflowRun(imagePlan.repository, {
+      client,
+      workflow: selectedWorkflow,
+      branch: imagePlan.branch
+    });
+  }
+  const json = jsonResult(invocation, context, report);
+  if (json) return json;
+  return guidedResult({
+    command: options.commandName ?? "package image",
+    summary: execute ? "Package development image workflow dispatched." : "Package development image plan ready.",
+    facts: [
+      { label: "Package", value: `${imagePlan.package.id} (${imagePlan.package.path})` },
+      { label: "Workflow", value: `${selectedWorkflow} @ ${imagePlan.branch}` },
+      { label: "Image", value: imagePlan.refs.imageRef },
+      { label: "Moving tag", value: imagePlan.refs.movingImageRef ?? "disabled" },
+      { label: "GitHub credential", value: credential.configured ? `${credential.envName}${credential.fallbackUsed ? " (fallback)" : ""}` : `${credential.envName} missing` },
+      { label: "Docker Hub config", value: dockerHub.usernameConfigured && dockerHub.tokenConfigured ? "configured" : "missing" },
+      { label: "Hosting override", value: imagePlan.hosting ? `${imagePlan.hosting.overrideEnvVar}=${imagePlan.refs.imageRef}` : "not declared" }
+    ],
+    sections: [
+      { title: "Next", lines: imagePlan.hosting ? [imagePlan.hosting.command] : [] }
+    ],
+    report
+  });
+}
+export {
+  runPackageImageCommand
+};

package/dist/cli/handlers/package.d.ts

@@ -0,0 +1,2 @@
+import type { TreeseedCommandHandler } from '../types.js';
+export declare const handlePackage: TreeseedCommandHandler;

package/dist/cli/handlers/package.js

@@ -0,0 +1,14 @@
+import { runPackageImageCommand } from "./package-image.js";
+import { fail } from "./utils.js";
+const handlePackage = async (invocation, context) => {
+  const action = invocation.positionals[0] ?? "status";
+  try {
+    if (action === "image") return runPackageImageCommand(invocation, context, { commandName: "package image" });
+    return fail("Unknown package action. Use image.");
+  } catch (error) {
+    return fail(error instanceof Error ? error.message : String(error));
+  }
+};
+export {
+  handlePackage
+};

package/dist/cli/handlers/projects.js

@@ -1,4 +1,4 @@
-import { MarketApiError } from "@treeseed/sdk/market-client";
+import { MarketClientError } from "@treeseed/sdk/market-client";
 import { parseProjectLaunchHostBindingSpecs } from "@treeseed/sdk";
 import { fail, guidedResult } from "./utils.js";
 import { createMarketClientForInvocation } from "./market-utils.js";
@@ -47,7 +47,7 @@ function projectUsage(action) {
   }
 }
 function authFailure(error) {
-  if (error instanceof MarketApiError && [401, 403].includes(error.status)) {
+  if (error instanceof MarketClientError && [401, 403].includes(error.status)) {
     return fail(error.message, 2);
   }
   const message = error instanceof Error ? error.message : String(error);
@@ -57,7 +57,7 @@ function authFailure(error) {
   return null;
 }
 function deploymentApiExitCode(error) {
-  if (error instanceof MarketApiError) {
+  if (error instanceof MarketClientError) {
     if ([401, 403].includes(error.status)) return 2;
     const payload = error.payload;
     const code = payload?.error?.code ?? payload?.code;

package/dist/cli/handlers/ready.d.ts

@@ -0,0 +1,2 @@
+import type { TreeseedCommandHandler } from '../types.js';
+export declare const handleReady: TreeseedCommandHandler;

package/dist/cli/handlers/ready.js

@@ -0,0 +1,84 @@
+import {
+  collectTreeseedDeploymentReadiness,
+  collectTreeseedLiveHostedServiceChecks,
+  collectTreeseedHostedServiceChecks,
+  formatTreeseedReadinessReport,
+  runTreeseedOperationsRunnerSmoke
+} from "@treeseed/sdk/workflow-support";
+import { guidedResult } from "./utils.js";
+import { createWorkflowSdk, workflowErrorResult } from "./workflow.js";
+function environmentFor(value) {
+  const raw = typeof value === "string" && value.trim() ? value.trim() : "staging";
+  if (raw === "prod" || raw === "production") return "prod";
+  if (raw === "local") return "local";
+  return "staging";
+}
+function failedCount(section) {
+  return Number(section?.summary?.failed ?? 0);
+}
+const handleReady = async (invocation, context) => {
+  try {
+    const environment = environmentFor(invocation.positionals[0] ?? invocation.args.environment);
+    const live = invocation.args.live === true || environment !== "local";
+    const strict = invocation.args.strict === true || environment !== "local";
+    const status = await createWorkflowSdk(context).status();
+    const readiness = collectTreeseedDeploymentReadiness({ tenantRoot: context.cwd, environment });
+    const hostedServices = live ? await collectTreeseedLiveHostedServiceChecks({
+      tenantRoot: context.cwd,
+      target: environment,
+      strict,
+      requireLiveRailway: strict,
+      requireLiveHttp: strict,
+      env: context.env
+    }) : collectTreeseedHostedServiceChecks({ tenantRoot: context.cwd, target: environment });
+    const runnerSmoke = live && environment !== "local" && readiness.ok ? await runTreeseedOperationsRunnerSmoke({
+      tenantRoot: context.cwd,
+      environment,
+      env: context.env
+    }) : null;
+    const ok = readiness.ok && failedCount(hostedServices) === 0 && (runnerSmoke ? runnerSmoke.ok : true);
+    const nextActions = [
+      ...readiness.checks.filter((check) => check.status === "failed" && check.remediation).map((check) => check.remediation),
+      ...runnerSmoke && !runnerSmoke.ok ? [
+        `npx trsd operations smoke --environment ${environment} --service operationsRunner --json`,
+        `npx trsd hosting verify --environment ${environment} --service operationsRunner --live --json`
+      ] : []
+    ];
+    const report = {
+      ok,
+      environment,
+      live,
+      strict,
+      workflow: status.payload,
+      deploymentReadiness: readiness,
+      hostedServices,
+      runnerSmoke,
+      nextActions
+    };
+    return guidedResult({
+      command: "ready",
+      summary: ok ? `Treeseed ${environment} readiness passed.` : `Treeseed ${environment} readiness failed.`,
+      facts: [
+        { label: "Environment", value: environment },
+        { label: "Live", value: live ? "yes" : "no" },
+        { label: "Readiness failed", value: readiness.summary.failed },
+        { label: "Hosted checks failed", value: hostedServices.summary.failed },
+        { label: "Runner smoke", value: runnerSmoke ? runnerSmoke.ok ? "passed" : "failed" : "skipped" }
+      ],
+      sections: [
+        {
+          title: "Deployment readiness",
+          lines: formatTreeseedReadinessReport(readiness).split("\n")
+        }
+      ],
+      nextSteps: nextActions,
+      report,
+      exitCode: ok ? 0 : 1
+    });
+  } catch (error) {
+    return workflowErrorResult(error);
+  }
+};
+export {
+  handleReady
+};

package/dist/cli/handlers/reconcile.d.ts

@@ -0,0 +1,2 @@
+import type { TreeseedCommandHandler } from '../types.js';
+export declare const handleReconcile: TreeseedCommandHandler;