@tdk-landscape/tdk-cli-core 1.3.75 → 1.3.77

package/CHANGELOG.md

@@ -4,6 +4,12 @@ Notable changes to the `tdk` CLI. Versions match [npm](https://www.npmjs.com/pac
 
 ## Unreleased
 
+- `tdk up` no longer leaves `nats` (and any other service in `services/platform/messaging/docker-compose.yml`, e.g. a local mail catcher) disabled in Tilt. The pre-alpha default always goes through a focus-filter path that only re-enabled `init-networks`/`postgres`/`traefik`/`golden-layers-build`, so a resource with the `nats` feature retried its broker connection forever until you ran `tilt enable nats` by hand. Fixes #155.
+
+- `tdk doctor` now catches wiring mistakes that used to surface minutes into `tdk up`: a resource with no `package.json` (the image build stops at "COPY ... not found"), a `params` URL such as `http://auth-emulator:4000` whose port is not the one the target listens on (its `service.json` `port`), a frontend calling a backend through `localhost:<port>` (TDK publishes no backend ports on localhost; use the Traefik route), the `nats` feature without `services/platform/messaging/docker-compose.yml` (TDK does not generate it, so no NATS server starts), two Tilt processes running for one project, and Docker having no address pool left for the networks a project needs. Found while building [tdk-ecommerce-example](https://github.com/tdk-landscape/tdk-ecommerce-example) and a queue/auth example.
+
+- `tdk project ecommerce` clones [tdk-ecommerce-example](https://github.com/tdk-landscape/tdk-ecommerce-example), a Vue 3 storefront and Hono catalog API. Before, only restaurant, saas, erp, user-management and example were accepted.
+
 ## 1.3.73 (2026-09-28)
 
 - Free-tier projects no longer start the `sablier` and `wake-gateway` containers, and Traefik no longer downloads the Sablier plugin from GitHub on every start. They were always launched (the `sablier` one with a read-write Docker socket) even though the license only gated the per-service labels, so nothing could use them. They are now generated only when a license grants Sablier. Fewer containers, one image build less, and no network fetch at Traefik boot. Spotted in the ERP CI run log.

package/README.md

@@ -2,14 +2,31 @@
 
 # TDK — Tilt Development Kit
 
-**Run your whole microservice landscape locally. No Kubernetes.**
+TDK is a local development kit. It scaffolds services and runs a stack on your
+laptop with Docker and Tilt (hot reload, health, Traefik, Postgres).
 
-One CLI that scaffolds your services and runs the whole landscape locally with hot reload, health checks, a proxy, and Postgres, all built on [Tilt](https://tilt.dev). Tested at scale: a 100-service fixture (small generated `/health` services) boots from nothing on a clean CI runner in about 8 minutes, and holds about 1.7 GiB of memory ([details](#cold-boot-on-a-clean-machine-ci)).
+It is not a Kubernetes packager. It does not replace Helm, Argo CD,
+Kustomize, or your production charts.
+
+Use TDK when local bring-up of many services is painful and you do not want a
+cluster on the laptop.
+
+Skip TDK if `helm install` (or your existing compose/Tilt/Skaffold) already
+gives you a working local or shared-dev environment.
+
+## Status
+
+Supported: macOS, Linux, Windows via WSL2 Ubuntu.
+Native Windows: CLI inspect only; `tdk up` unsupported.
+WSL2 smoke: local script only (no GitHub WSL runner).
+Stability: 1.x — generated files are a contract; verify in CI.
+Check your machine: `tdk doctor`
+Known limits: [docs/compare-honest.md](docs/compare-honest.md)
 
 [![npm version](https://img.shields.io/npm/v/@tdk-landscape/tdk-cli-core.svg?style=flat&color=blue)](https://www.npmjs.com/package/@tdk-landscape/tdk-cli-core)
 [![CI](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/ci.yml/badge.svg)](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/ci.yml)
 [![Quickstart E2E](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/quickstart-e2e.yml/badge.svg)](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/quickstart-e2e.yml)
-[![ERP scale E2E](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/erp-scale-e2e.yml/badge.svg)](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/erp-scale-e2e.yml)
+[![ERP fixture scale E2E](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/erp-scale-e2e.yml/badge.svg)](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/erp-scale-e2e.yml)
 [![Example apps E2E](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/examples-e2e.yml/badge.svg?branch=main)](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/examples-e2e.yml)
 [![Known Vulnerabilities](https://snyk.io/test/github/tdk-landscape/tdk-cli-core/badge.svg)](https://snyk.io/test/github/tdk-landscape/tdk-cli-core)
 [![Socket Badge](https://badge.socket.dev/npm/package/@tdk-landscape/tdk-cli-core/latest)](https://socket.dev/npm/package/@tdk-landscape/tdk-cli-core/overview)
@@ -19,8 +36,23 @@ One CLI that scaffolds your services and runs the whole landscape locally with h
 
 </div>
 
+## When not to use TDK
+
+- Production or shared-cluster deploy is Helm/Argo/Kustomize — keep it.
+- Your local or namespace-per-dev environment already works.
+- You will not adopt `service.json` and generated files.
+
+## TDK is for you if
+
+- You have many services and want `tdk up <one stack>` on Docker.
+- You do not want kind or minikube as your daily path.
+- You want to generate services, run `tdk config verify`, and use Traefik `*.localhost` routes.
+
+Start with the [bundled product example](examples/tdk-example/README.md); its write path is covered by [example-e2e](.github/workflows/example-e2e.yml).
+
 ```bash
 npm install -g @tdk-landscape/tdk-cli-core
+npx @tdk-landscape/tdk-cli-core
 mkdir shop && cd shop                                   # tdk writes files into the current directory
 tdk project --yes                                       # set up the project
 tdk resource orders-api --type backend --stack shop     # scaffold a service
@@ -29,9 +61,11 @@ tdk up shop                                             # run it with hot reload
 
 ![tdk scaffolding a backend and a frontend, then listing the stack](docs/demo.svg)
 
+Want to inspect a stack before starting containers? `tdk up shop --dry-run` shows the services and local URLs without Docker or Tilt installed.
+
 ![npm downloads, last month](docs/npm-downloads.svg)
 
-**Requirements:** Docker (Desktop, OrbStack or Colima; Engine 25+, Compose 2.20+), [Tilt](https://docs.tilt.dev/install.html), [Bun](https://bun.sh) for the generated services, and Node.js 22.12+ for the CLI. Ports 80, 443 and 5432 must be free (a local Postgres is the usual conflict). macOS and Linux are supported. Windows is untested (WSL2 may work). Run `tdk doctor` to check all of it.
+**Requirements:** Docker (Desktop, OrbStack or Colima; Engine 25+, Compose 2.20+), [Tilt](https://docs.tilt.dev/install.html), [Bun](https://bun.sh) for the generated services, and Node.js 22.12+ for npm installs. Ports 80, 443 and 5432 must be free (a local Postgres is the usual conflict). macOS and Linux releases are available. Windows native is unsupported. WSL2 Ubuntu is supported. See docs/wsl2.md. Run `tdk doctor` to check your setup.
 
 This is the core monorepo for TDK: the `tdk` CLI, the Starlark-based Tilt orchestration engine that powers it, and the discovery system that turns a directory of services into a running local landscape.
 
@@ -48,9 +82,9 @@ This is the core monorepo for TDK: the `tdk` CLI, the Starlark-based Tilt orches
 
 TDK is not a replacement for Tilt: it generates the Tiltfile, Dockerfiles and compose files and then runs Tilt. If you already have a hand-written Tiltfile or compose setup you're happy with, TDK mostly saves you the boilerplate for the next service.
 
-## Benchmark: 100 services on one laptop
+## Fixture bench: 100 generated services on one laptop
 
-Measured with [`scripts/benchmark/container-scale.ts`](scripts/benchmark/README.md) against the 100-service [ERP example](https://github.com/tdk-landscape/tdk-erp-system) on a 16 GB machine (Docker VM: 7.75 GiB). Raw results are in [`benchmarks/results/`](benchmarks/results).
+Measured with [`scripts/benchmark/container-scale.ts`](scripts/benchmark/README.md) against the 100-service [`tdk-erp-system` fixture bench](https://github.com/tdk-landscape/tdk-erp-system), a scale fixture of generated `/health` services rather than an ERP product, on a 16 GB machine (Docker VM: 7.75 GiB). Raw results are in [`benchmarks/results/`](benchmarks/results).
 
 | Services | All healthy after | Total memory | Avg memory / service | Crashes / OOM kills |
 |---:|---:|---:|---:|---:|
@@ -70,9 +104,9 @@ What this does and doesn't measure:
 The table above is a warm start. Two workflows install the published CLI on a fresh GitHub-hosted Ubuntu runner and run `tdk up` from nothing, building every image:
 
 - [**Quickstart E2E**](.github/workflows/quickstart-e2e.yml): the commands from the top of this README, one scaffolded backend, until it answers `/health` through Traefik. About 4 minutes. Runs after each release and daily.
-- [**ERP scale E2E**](.github/workflows/erp-scale-e2e.yml): the 100-service example. [Run 36395860088](https://github.com/tdk-landscape/tdk-cli-core/actions/runs/36395860088) (CLI 1.3.72, 4 vCPU / 15 GB): **100 / 100 backends healthy through Traefik after 472 s**, 111 containers, 1.8 GiB used by all containers. Runs weekly.
+- [**ERP fixture scale E2E**](.github/workflows/erp-scale-e2e.yml): the 100-service generated-health fixture bench. [Run 36395860088](https://github.com/tdk-landscape/tdk-cli-core/actions/runs/36395860088) (CLI 1.3.72, 4 vCPU / 15 GB): **100 / 100 backends healthy through Traefik after 472 s**, 111 containers, 1.8 GiB used by all containers. Runs weekly.
 
-Both are the same kind of fixture: generated services answering `/health`, not a real business app. A green run means TDK can generate, build, route and health-check a landscape of that size on a machine that has never seen it. It doesn't cover Windows, Apple Silicon, or an existing repo you bring yourself.
+Both are Linux/Ubuntu CI fixtures: generated services answering `/health`, not a real business app. A green run means TDK can generate, build, route and health-check a landscape of that size on a clean Ubuntu runner. Windows now has a separate smoke workflow for CLI startup and unit tests, but it does not boot a full landscape on Windows. These CI runs also don't cover Apple Silicon or an existing repo you bring yourself.
 
 ## What is TDK?
 
@@ -166,7 +200,9 @@ TDK has no telemetry or analytics. The CLI only goes online when you ask it to:
 
 **How is this different from Skaffold, Garden, DevSpace or Tilt itself?** Skaffold, Garden and DevSpace are built around Kubernetes, and plain Tilt leaves the Tiltfile to you. TDK runs on plain Docker with no cluster, and generates both the services and the Tilt config from a `service.json` per service.
 
-**Do I need 100 microservices?** No. Two services work the same way. The 100-service example is a stress test to show the overhead stays flat.
+See the [honest comparison](docs/compare-honest.md) for tradeoffs and cases where TDK may not fit.
+
+**Do I need 100 microservices?** No. Two services work the same way. The 100-service fixture bench is a stress test to show the overhead stays flat; it is not an ERP product example.
 
 **Is TDK affiliated with Tilt or Docker?** No. TDK is an independent project built on top of [Tilt](https://tilt.dev), which is maintained by Docker, Inc.
 
@@ -179,22 +215,32 @@ make test-fast      # fast unit tests, no external deps
 make pre-commit-run # run pre-commit hooks on all files
 ```
 
-`npm run typecheck` / `npm run lint` / `npm run test` delegate to the `cli/` workspace. See [cli/AGENTS.md](cli/AGENTS.md) for coding conventions if you're contributing to the CLI, and [engine/AGENTS.md](engine/AGENTS.md) for the Starlark topology framework.
+`npm run typecheck` / `npm run lint` / `npm run test` delegate to the `cli/` workspace. If you're contributing, start with the [step-by-step contributor guide](docs/contributing/README.md) for subsystem-specific instructions.
 
 ## Environment check
 
+### Cold npx / first run
+
+```bash
+npx @tdk-landscape/tdk-cli-core
+npx @tdk-landscape/tdk-cli-core doctor
+```
+
+Ranked first failures: Node 22.12+, Docker Engine 25+, Compose 2.20.2+, Tilt 0.25+, Bun 1.2+, and ports 80/443/5432.
+Install Bun 1.2+ as a machine prerequisite. `tdk project` generates the stack configuration; Prisma and NATS are project-specific, and NATS is required only when the feature is enabled.
+
 ```bash
 tdk doctor
 ```
 
-Checks Docker, Compose and Tilt. Inside a project it also checks the generated configs, `.env`, service scripts and that the ingress ports are free, before you run `tdk up`.
+Checks Docker, Compose and Tilt. Inside a project it also checks the generated configs, `.env`, service scripts and that the ingress ports are free, before you run `tdk up`. It also catches wiring mistakes: a resource without `package.json`, a `params` URL that uses the wrong port for another service, a frontend calling a backend on `localhost:<port>`, the `nats` feature without a broker to start, duplicate Tilt processes, and Docker running out of network address space.
 
 ## Community
 
 - **Questions and ideas:** [open an issue](https://github.com/tdk-landscape/tdk-cli-core/issues/new/choose).
-- **Contributing:** see [CONTRIBUTING.md](CONTRIBUTING.md). Issues labeled [`good first issue`](https://github.com/tdk-landscape/tdk-cli-core/labels/good%20first%20issue) are a good place to start.
+- **Contributing:** see [CONTRIBUTING.md](CONTRIBUTING.md) and the [step-by-step guide](docs/contributing/README.md). Issues labeled [`good first issue`](https://github.com/tdk-landscape/tdk-cli-core/labels/good%20first%20issue) are a good place to start.
 - **Security:** see [SECURITY.md](SECURITY.md). Please don't report vulnerabilities in public issues.
-- **Examples:** [ERP system (100 services)](https://github.com/tdk-landscape/tdk-erp-system), [SaaS starter](https://github.com/tdk-landscape/tdk-saas-starter), [restaurant](https://github.com/tdk-landscape/tdk-restaurant-example).
+- **Examples:** bundled [TDK product example](examples/tdk-example), [ERP fixture bench (100 generated services)](https://github.com/tdk-landscape/tdk-erp-system), [SaaS starter](https://github.com/tdk-landscape/tdk-saas-starter), [restaurant](https://github.com/tdk-landscape/tdk-restaurant-example), [ecommerce (Vue + Hono)](https://github.com/tdk-landscape/tdk-ecommerce-example).
 
 ## License
 

package/cli/bin/tdk.js

@@ -1,14 +1,34 @@
 #!/usr/bin/env node
 
 import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+function nodeTooOld(version) {
+  const [major = 0, minor = 0] = String(version)
+    .split(".")
+    .map((part) => Number.parseInt(part, 10));
+  return (
+    !Number.isFinite(major) || !Number.isFinite(minor) || major < 22 || (major === 22 && minor < 12)
+  );
+}
+
+if (nodeTooOld(process.versions.node)) {
+  console.error(
+    "TDK CLI needs Node.js 22.12+ (current: " +
+      process.versions.node +
+      ").\n" +
+      "This is the first cold-npx failure. Bun/Prisma/NATS are not involved yet.\n" +
+      "Install Node 22.12+ and rerun.",
+  );
+  process.exit(1);
+}
+
 const cliPath = join(__dirname, "..", "dist", "cli.js");
 
-import(cliPath).catch((err) => {
+import(pathToFileURL(cliPath).href).catch((err) => {
   console.error("Failed to start TDK:", err);
   process.exit(1);
 });

package/cli/dist/cli.js

@@ -6,6 +6,7 @@ import { completionCommand } from "./commands/completion.js";
 import { configCommand } from "./commands/config.js";
 import { doctorCommand } from "./commands/doctor.js";
 import { downCommand } from "./commands/down.js";
+import { ejectCommand } from "./commands/eject.js";
 import { showHelp } from "./commands/help.js";
 import { networksCommand } from "./commands/networks.js";
 import { projectCommand } from "./commands/project.js";
@@ -19,6 +20,7 @@ import { uiCommand } from "./commands/ui.js";
 import { upCommand } from "./commands/up.js";
 import { upgradeCommand } from "./commands/upgrade.js";
 import { versionCommand } from "./commands/version.js";
+import { formatColdPreflight, runColdPreflight } from "./utils/cold-preflight.js";
 const program = new Command();
 program
     .name("tdk")
@@ -40,6 +42,7 @@ program.addCommand(resourcesCommand);
 program.addCommand(projectsCommand);
 program.addCommand(upCommand);
 program.addCommand(downCommand);
+program.addCommand(ejectCommand);
 program.addCommand(statusCommand);
 program.addCommand(stackCommand);
 program.addCommand(resourceCommand);
@@ -53,9 +56,13 @@ program.addCommand(upgradeCommand);
 program.addCommand(networksCommand);
 // Default: show help if no command provided
 if (process.argv.length === 2) {
-    showHelp();
-    process.exit(0);
+    const result = await runColdPreflight();
+    console.log(formatColdPreflight(result));
+    console.log("\nCommands: tdk doctor | tdk project --yes | tdk --help");
+    process.exit(result.ok ? 0 : 1);
 }
+if (process.argv[2] === "--doctor")
+    process.argv[2] = "doctor";
 if (process.argv.length === 3 && ["-h", "--help", "help"].includes(process.argv[2])) {
     showHelp();
     process.exit(0);

package/cli/dist/commands/completion.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import chalk from "chalk";
@@ -213,9 +213,16 @@ complete -c tdk -n '__fish_seen_subcommand_from doctor' -l fix -d 'Attempt to fi
 complete -c tdk -n '__fish_seen_subcommand_from upgrade' -l force -d 'Force upgrade even if on latest'
 complete -c tdk -n '__fish_seen_subcommand_from upgrade' -l dry-run -d 'Show what would be upgraded'
 `;
+const POWERSHELL_COMPLETION = `Register-ArgumentCompleter -Native -CommandName tdk -ScriptBlock {
+  param($wordToComplete)
+  $cmds = @('up','down','doctor','project','resource','stacks','status','networks','upgrade','version','ui','config')
+  $cmds | Where-Object { $_ -like "$wordToComplete*" }
+}`;
+const POWERSHELL_START = "# TDK-CLI-COMPLETION-START";
+const POWERSHELL_END = "# TDK-CLI-COMPLETION-END";
 export const completionCommand = new Command("completion")
     .description("Generate shell completion scripts")
-    .option("-s, --shell <shell>", "Target shell (bash, zsh, fish)", "bash")
+    .option("-s, --shell <shell>", "Target shell (bash, zsh, fish, powershell)", "bash")
     .option("-o, --output <path>", "Output file path (default: stdout)")
     .option("--install", "Install to shell config automatically")
     .action((options) => {
@@ -235,9 +242,13 @@ export const completionCommand = new Command("completion")
             completionScript = FISH_COMPLETION;
             filename = "tdk.fish";
             break;
+        case "powershell":
+            completionScript = `${POWERSHELL_START}\n${POWERSHELL_COMPLETION}\n${POWERSHELL_END}`;
+            filename = "Microsoft.PowerShell_profile.ps1";
+            break;
         default:
             console.error(chalk.red(`❌ Unsupported shell: ${shell}`));
-            console.log(chalk.gray("Supported shells: bash, zsh, fish"));
+            console.log(chalk.gray("Supported shells: bash, zsh, fish, powershell"));
             process.exit(1);
     }
     if (options.install) {
@@ -245,6 +256,22 @@ export const completionCommand = new Command("completion")
         let installPath;
         let installInstructions;
         switch (shell) {
+            case "powershell": {
+                const docs = join(home, "Documents");
+                const ps7 = process.env.PSModulePath?.includes(join("Documents", "PowerShell", "Modules"));
+                const profileDir = join(docs, ps7 ? "PowerShell" : "WindowsPowerShell");
+                installPath = join(profileDir, filename);
+                mkdirSync(profileDir, { recursive: true });
+                const existing = existsSync(installPath) ? readFileSync(installPath, "utf-8") : "";
+                const block = `${POWERSHELL_START}\n${POWERSHELL_COMPLETION}\n${POWERSHELL_END}`;
+                const markerPattern = new RegExp(`${POWERSHELL_START}[\\s\\S]*?${POWERSHELL_END}`, "m");
+                const updated = markerPattern.test(existing)
+                    ? existing.replace(markerPattern, block)
+                    : `${existing}${existing && !existing.endsWith("\n") ? "\n" : ""}${block}\n`;
+                writeFileSync(installPath, updated, "utf-8");
+                installInstructions = "\n# Close and reopen PowerShell to load the completion.";
+                break;
+            }
             case "bash": {
                 installPath = join(home, ".bash_completion.d", filename);
                 const bashDir = join(home, ".bash_completion.d");

package/cli/dist/commands/config.js

@@ -1,5 +1,5 @@
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import chalk from "chalk";
 import { Command } from "commander";
@@ -10,6 +10,8 @@ import { assertValid } from "../utils/command-helpers.js";
 import { MASTER_CONFIG_FILES } from "../utils/constants.js";
 import { requireProjectRoot, runCommand } from "../utils/errors.js";
 import { writeJsonFile } from "../utils/file-helpers.js";
+import { SERVICE_MANIFEST_SCHEMA_VERSION, validateServiceManifest, } from "../utils/service-manifest.js";
+import { discoverServiceManifestPaths } from "../utils/services.js";
 import { validateOptionalInfraService } from "../utils/validation.js";
 /**
  * Serialize ProjectConfig to JSON-safe value.
@@ -115,6 +117,59 @@ export const configCommand = new Command("config")
         await generateMasterConfigs(projectRoot);
         console.log(chalk.green("\n✅ Configuration regenerated!"));
     });
+}))
+    .addCommand(new Command("migrate")
+    .description("Migrate service.json files to the current schema version")
+    .action(async () => {
+    await runCommand(async () => {
+        const projectRoot = requireProjectRoot();
+        const failures = [];
+        const pendingMigrations = [];
+        for (const filePath of discoverServiceManifestPaths(projectRoot)) {
+            let manifest;
+            try {
+                manifest = JSON.parse(readFileSync(filePath, "utf-8"));
+            }
+            catch (error) {
+                failures.push(`${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+                continue;
+            }
+            if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
+                failures.push(`${filePath}: expected a JSON object`);
+                continue;
+            }
+            const record = manifest;
+            if (record.appType === undefined && typeof record.type === "string") {
+                record.appType = record.type;
+            }
+            if (record.schemaVersion === SERVICE_MANIFEST_SCHEMA_VERSION)
+                continue;
+            if (record.schemaVersion !== undefined) {
+                failures.push(`${filePath}.schemaVersion: cannot migrate unsupported version ${String(record.schemaVersion)} automatically`);
+                continue;
+            }
+            const validation = validateServiceManifest({ ...record, schemaVersion: SERVICE_MANIFEST_SCHEMA_VERSION }, filePath);
+            if (validation.errors.length > 0) {
+                failures.push(...validation.errors);
+                continue;
+            }
+            for (const warning of validation.warnings) {
+                console.warn(chalk.yellow(`⚠️  ${warning}`));
+            }
+            record.schemaVersion = SERVICE_MANIFEST_SCHEMA_VERSION;
+            pendingMigrations.push({ filePath, manifest: record });
+        }
+        for (const failure of failures)
+            console.error(chalk.red(`❌ ${failure}`));
+        if (failures.length > 0)
+            process.exit(1);
+        for (const migration of pendingMigrations) {
+            writeFileSync(migration.filePath, `${JSON.stringify(migration.manifest, null, 2)}\n`);
+        }
+        const migrated = pendingMigrations.length;
+        console.log(chalk.green(`✅ Migrated ${migrated} service.json file${migrated === 1 ? "" : "s"} to schema version ${SERVICE_MANIFEST_SCHEMA_VERSION}.`));
+        console.log(chalk.yellow("Review the diff; unknown fields were preserved."));
+    });
 }))
     .addCommand(new Command("verify")
     .description("Verify that generated files match .tdk/project.json")
@@ -123,6 +178,9 @@ export const configCommand = new Command("config")
         const projectRoot = requireProjectRoot();
         console.log(chalk.blue("🔍 Verifying configuration...\n"));
         const result = verifyMasterConfigs(projectRoot);
+        for (const warning of result.warnings) {
+            console.warn(chalk.yellow(`⚠️  ${warning}`));
+        }
         if (result.valid) {
             console.log(chalk.green("✅ All files are in sync!"));
             return;