@lenne.tech/cli 1.26.1 → 1.28.0

package/build/commands/ticket/switch.js

@@ -0,0 +1,70 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const dev_project_1 = require("../../lib/dev-project");
+const dev_ticket_1 = require("../../lib/dev-ticket");
+/**
+ * `lt ticket switch <id>` — show a ticket worktree's path and open it in your
+ * editor (best-effort). A CLI cannot change the parent shell's directory, so it
+ * also prints the `cd` line to copy. `--no-open` only prints.
+ */
+const SwitchCommand = {
+    alias: ['sw', 'open'],
+    description: 'Show a ticket worktree path + open it in your editor',
+    name: 'switch',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const { filesystem, parameters, print: { colors, error, info, success }, } = toolbox;
+        const id = String((_a = parameters.first) !== null && _a !== void 0 ? _a : '').trim();
+        if (!id) {
+            error('Usage: lt ticket switch <id>');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket switch: missing id';
+        }
+        const layout = (0, dev_project_1.resolveLayout)(filesystem.cwd(), filesystem);
+        let mainRepoRoot;
+        try {
+            mainRepoRoot = (0, dev_ticket_1.gitMainRepoRoot)(layout.root);
+        }
+        catch (_b) {
+            error('Not inside a git repository.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket switch: not a git repo';
+        }
+        const wt = (0, dev_ticket_1.listWorktrees)(mainRepoRoot).find((w) => w.ticket === id);
+        if (!wt) {
+            error(`No ticket worktree "${id}" found. See \`lt ticket list\`.`);
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket switch: not found';
+        }
+        info('');
+        info(`Ticket "${id}"  →  ${wt.path}`);
+        info(colors.dim(`  cd ${wt.path}`));
+        if (parameters.options.open !== false) {
+            const editor = process.env.LT_EDITOR || 'code';
+            try {
+                (0, child_process_1.execFileSync)(editor, [wt.path], { stdio: 'ignore' });
+                success(`Opened in ${editor}.`);
+            }
+            catch (_c) {
+                info(colors.dim(`  (could not run \`${editor}\` — open the folder manually, or set LT_EDITOR)`));
+            }
+        }
+        if (!parameters.options.fromGluegunMenu)
+            process.exit();
+        return `ticket switch: ${id}`;
+    }),
+};
+module.exports = SwitchCommand;

package/build/commands/ticket/test.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dev_process_1 = require("../../lib/dev-process");
+const dev_project_1 = require("../../lib/dev-project");
+const dev_ticket_1 = require("../../lib/dev-ticket");
+/**
+ * `lt ticket test <id> [--shard N] [-- <args>]` — run the E2E suite for a ticket
+ * in ITS isolated stack + DB, by delegating to `lt dev test` inside the ticket
+ * worktree (which is ticket-aware via the marker → test DB `<base>-<id>-test`).
+ */
+const TestCommand = {
+    alias: ['t'],
+    description: 'Run the E2E suite for a ticket in its isolated stack',
+    name: 'test',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const { filesystem, parameters, print: { colors, error, info }, } = toolbox;
+        const id = String((_a = parameters.first) !== null && _a !== void 0 ? _a : '').trim();
+        if (!id) {
+            error('Usage: lt ticket test <id> [--shard N] [--keep] [-- <playwright args>]');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket test: missing id';
+        }
+        const layout = (0, dev_project_1.resolveLayout)(filesystem.cwd(), filesystem);
+        let mainRepoRoot;
+        try {
+            mainRepoRoot = (0, dev_ticket_1.gitMainRepoRoot)(layout.root);
+        }
+        catch (_b) {
+            error('Not inside a git repository.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket test: not a git repo';
+        }
+        const wt = (0, dev_ticket_1.listWorktrees)(mainRepoRoot).find((w) => w.ticket === id);
+        if (!wt) {
+            error(`No ticket worktree "${id}" found. See \`lt ticket list\`.`);
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket test: not found';
+        }
+        // Reconstruct `lt dev test` args: forward the common flags + the `--` array.
+        const devArgs = ['dev', 'test'];
+        if (parameters.options.shard !== undefined) {
+            const s = parameters.options.shard;
+            devArgs.push(s === true ? '--shard' : `--shard=${s}`);
+        }
+        if (parameters.options.keep === true)
+            devArgs.push('--keep');
+        if (parameters.options.debug === true)
+            devArgs.push('--debug');
+        // Playwright args after `--` (e.g. a spec path / `--grep`): read them from
+        // the RAW argv. gluegun's parsed `parameters.array` does not reliably carry
+        // post-`--` tokens through the `ticket <id>` positional, which silently ran
+        // the WHOLE suite instead of the requested spec.
+        const dashIdx = process.argv.indexOf('--');
+        const forwarded = dashIdx >= 0 ? process.argv.slice(dashIdx + 1) : [];
+        if (forwarded.length > 0)
+            devArgs.push('--', ...forwarded);
+        info(colors.dim(`(cd ${wt.path} && lt ${devArgs.join(' ')})`));
+        const code = yield (0, dev_process_1.runChildInherit)(process.execPath, [process.argv[1], ...devArgs], {
+            cwd: wt.path,
+            env: process.env,
+        });
+        if (!parameters.options.fromGluegunMenu)
+            process.exit(code !== null && code !== void 0 ? code : 1);
+        return `ticket test: ${id} exit=${code}`;
+    }),
+};
+module.exports = TestCommand;

package/build/commands/ticket/ticket.js

@@ -0,0 +1,36 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Parallel ticket dev environments (`lt ticket <subcommand>`).
+ *
+ * Each ticket runs in its OWN git worktree (a fresh branch from `origin/dev`)
+ * with its OWN isolated `lt dev` stack — own URLs, ports, Caddy block and empty
+ * database — so several tickets can be developed, browser-tested and E2E-tested
+ * fully in parallel without ever influencing each other.
+ *
+ * Subcommands:
+ * - `start <name>`  — create the worktree + bring the isolated stack up
+ * - `list`          — dashboard of all ticket envs (URLs, branch, status, DB)
+ * - `switch <id>`   — show + open a ticket worktree in your editor
+ * - `test <id>`     — run the E2E suite in the ticket's isolated stack
+ * - `stop <id>`     — tear the env down + remove the worktree (branch kept)
+ */
+module.exports = {
+    alias: ['tk'],
+    description: 'Parallel ticket dev environments (worktree + isolated lt dev stack)',
+    hidden: false,
+    name: 'ticket',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        yield toolbox.helper.showMenu('ticket');
+        return 'ticket';
+    }),
+};

package/build/lib/dev-env-bridge.js

@@ -24,8 +24,8 @@ const os_1 = require("os");
 const path_1 = require("path");
 const HEADER = `# Managed by \`lt dev up\` — do NOT edit, will be overwritten.\n# Removed by \`lt dev down\`. Loaded by Playwright + other tools.\n`;
 /** Remove the ENV bridge file. No-op if missing. */
-function clearEnvBridge(projectRoot) {
-    const file = envBridgePath(projectRoot);
+function clearEnvBridge(projectRoot, fileName = '.env') {
+    const file = envBridgePath(projectRoot, fileName);
     if (!(0, fs_1.existsSync)(file))
         return false;
     try {
@@ -61,16 +61,16 @@ function detectCaddyRootCa() {
     return null;
 }
 /** Resolve the path to the ENV bridge file for a project. */
-function envBridgePath(projectRoot) {
-    return (0, path_1.join)(projectRoot, '.lt-dev', '.env');
+function envBridgePath(projectRoot, fileName = '.env') {
+    return (0, path_1.join)(projectRoot, '.lt-dev', fileName);
 }
 /**
  * Write the ENV bridge file. Idempotent — same content = no rewrite.
  *
  * Returns the absolute path that was written.
  */
-function writeEnvBridge(projectRoot, devEnv, dbName) {
-    const file = envBridgePath(projectRoot);
+function writeEnvBridge(projectRoot, devEnv, dbName, fileName = '.env') {
+    const file = envBridgePath(projectRoot, fileName);
     const lines = [];
     // The App-side env is the more "external" one (Playwright, browser tools).
     // We expose every URL/storage/api key the App env carries.

package/build/lib/dev-identity.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildIdentity = buildIdentity;
+exports.buildTestIdentity = buildTestIdentity;
+exports.buildTicketIdentity = buildTicketIdentity;
 exports.projectSlug = projectSlug;
 exports.slugify = slugify;
 /**
@@ -67,6 +69,40 @@ function buildIdentity(root) {
     }
     return { root, slug, subdomains };
 }
+/**
+ * Derive an ephemeral "test" identity from a base identity (used by
+ * `lt dev test`). Suffixes the slug and every subdomain hostname with
+ * `-test`, so the test stack runs on its own URLs / ports / Caddy block,
+ * fully parallel to (and isolated from) the dev session.
+ *
+ *   svl.localhost      → svl-test.localhost
+ *   api.svl.localhost  → api.svl-test.localhost
+ */
+function buildTestIdentity(base, suffix = '-test') {
+    const slug = `${base.slug}${suffix}`;
+    const subdomains = {};
+    for (const [sub, value] of Object.entries(base.subdomains)) {
+        subdomains[sub] = Object.assign(Object.assign({}, value), { hostname: value.isPrimaryApp ? `${slug}.localhost` : `${sub}.${slug}.localhost` });
+    }
+    return { root: base.root, slug, subdomains };
+}
+/**
+ * Derive a per-TICKET identity from a base identity (used by `lt ticket` /
+ * `lt dev up --ticket`). Suffixes the slug + every subdomain hostname with the
+ * ticket id, so each ticket worktree runs on its OWN URLs / ports / Caddy block
+ * / DB — fully parallel to and isolated from every other ticket and the base
+ * dev session.
+ *
+ *   svl.localhost      → svl-2200.localhost
+ *   api.svl.localhost  → api.svl-2200.localhost
+ *
+ * Mechanically identical to {@link buildTestIdentity} (a named wrapper for
+ * readability + intent at the call sites). `id` is already a clean slug (see
+ * `deriveTicketId` in dev-ticket.ts).
+ */
+function buildTicketIdentity(base, id) {
+    return buildTestIdentity(base, `-${id}`);
+}
 /**
  * Read the bare project name from package.json (scope stripped).
  * Falls back to directory basename if no package.json or no `name`.

package/build/lib/dev-migrate-helper.js

@@ -78,15 +78,25 @@ function runMigrate(input) {
     });
     const identity = (0, dev_identity_1.buildIdentity)(layout.root);
     const dbName = (0, dev_project_1.deriveDbName)(layout.apiDir, identity.slug);
-    // 1. Code patches (config.env.ts, nuxt.config.ts, playwright.config.ts).
+    // 1. Code patches. Run `autoPatch` over EVERY existing config file (not just
+    //    the ones a port-detector flags): the patches are idempotent, and some —
+    //    e.g. the playwright.config `ignoreHTTPSErrors` + shard-aware
+    //    `LT_DEV_TEST_SHARDS` timeout block — apply to configs that are already
+    //    env-aware. So `lt dev init` makes any project fully `lt dev test --shard`
+    //    ready in one command; an up-to-date config is a no-op (`patched: false`).
     const filesToPatch = [];
     if (layout.apiDir) {
-        const f = (0, dev_project_1.apiNeedsPortPatch)(layout.apiDir);
-        if (f)
-            filesToPatch.push(f);
+        const apiCfg = (0, path_1.join)(layout.apiDir, 'src', 'config.env.ts');
+        if ((0, fs_1.existsSync)(apiCfg))
+            filesToPatch.push(apiCfg);
+    }
+    if (layout.appDir) {
+        for (const rel of ['nuxt.config.ts', 'playwright.config.ts']) {
+            const f = (0, path_1.join)(layout.appDir, rel);
+            if ((0, fs_1.existsSync)(f))
+                filesToPatch.push(f);
+        }
     }
-    if (layout.appDir)
-        filesToPatch.push(...(0, dev_project_1.appNeedsPortPatch)(layout.appDir));
     const codePatches = filesToPatch.map((f) => (0, dev_patches_1.autoPatch)(f));
     // 2. CLAUDE.md URL block (root + each subproject — only patches existing files).
     const claudeCandidates = [

package/build/lib/dev-patches.js

@@ -165,6 +165,16 @@ function patchNuxtConfig(file) {
  *      bracketed by `// >>> lt-dev:bridge >>>` markers.
  *   2. Hardcoded baseURL/host/url for `http://localhost:3001` →
  *      `process.env.NUXT_PUBLIC_SITE_URL || 'http://localhost:3001'`.
+ *   3. `webServer` wrapped in an `LT_DEV_ACTIVE` guard so Playwright reuses
+ *      the App already served by `lt dev` / `lt dev test` instead of spawning
+ *      its own (which would bind the wrong port and miss the isolated stack).
+ *   4. `ignoreHTTPSErrors: true` so Playwright's Chromium accepts the lt dev
+ *      Caddy self-signed cert (required for `lt dev test` over HTTPS).
+ *   5. Shard-aware timeouts gated on `LT_DEV_TEST_SHARDS` — a `SHARDED` const
+ *      plus relaxed `timeout` / `expect` / `navigationTimeout` / `actionTimeout`
+ *      under sharded load only, so serial + CI keep their tight, fast-failing
+ *      defaults. Each sub-patch is a graceful no-op on a non-standard config.
+ *   6. `slowMo: 10` → `0` (pointless per-action delay, multiplied across shards).
  */
 function patchPlaywrightConfig(file) {
     if (!(0, fs_1.existsSync)(file))
@@ -225,6 +235,67 @@ function patchPlaywrightConfig(file) {
             count++;
         }
     }
+    // 3. Wrap `webServer` in an `LT_DEV_ACTIVE` guard so Playwright does NOT
+    //    start/manage its own server when the App is already served by
+    //    `lt dev` / `lt dev test` (both export LT_DEV_ACTIVE + the App URL).
+    //    The original array/object's closing `]`/`}` becomes the ternary's
+    //    false branch, so no bracket-matching is needed. Idempotent.
+    if (!/webServer:\s*process\.env\.LT_DEV_ACTIVE/.test(after)) {
+        after = after.replace(/webServer:\s*([[{])/, (_match, open) => {
+            count++;
+            return `webServer: process.env.LT_DEV_ACTIVE ? undefined : ${open}`;
+        });
+    }
+    // 4. ignoreHTTPSErrors — accept the `lt dev` Caddy self-signed cert on
+    //    `https://*.localhost` (Playwright's bundled Chromium uses its own trust
+    //    store, so NODE_EXTRA_CA_CERTS alone is not enough). No-op in CI (http).
+    //    Without this, `lt dev test` fails with ERR_CERT_AUTHORITY_INVALID.
+    if (!/ignoreHTTPSErrors/.test(after)) {
+        after = after.replace(/(\n(\s*)use:\s*\{)/, (_m, whole, indent) => {
+            count++;
+            return `${whole}\n${indent}  ignoreHTTPSErrors: true,`;
+        });
+    }
+    // 5. Shard-aware timeouts — `lt dev test --shard N` runs N built stacks +
+    //    N Chromium concurrently; the CPU saturates and SSR slows 2-3x. Relax
+    //    timeouts ONLY under that load (the CLI exports LT_DEV_TEST_SHARDS), so
+    //    serial + CI keep their tight values and fast-failure feedback. Each
+    //    sub-patch is idempotent + a graceful no-op on non-standard configs.
+    if (!/const SHARDED\b/.test(after) && /export default defineConfig/.test(after)) {
+        const shardConst = '// `lt dev test --shard N` saturates the CPU (N built SSR servers + N Chromium),\n' +
+            '// slowing every navigation. Relax timeouts ONLY under that load — the CLI sets\n' +
+            '// LT_DEV_TEST_SHARDS — so serial + CI keep their tight, fast-failing defaults.\n' +
+            "const SHARDED = Number(process.env.LT_DEV_TEST_SHARDS || '0') > 1;\n\n";
+        after = after.replace(/(export default defineConfig)/, `${shardConst}$1`);
+        count++;
+    }
+    // 5a. per-test timeout (`isWindows ? A : B` form) → add the sharded branch.
+    if (/timeout:\s*isWindows\s*\?/.test(after) && !/timeout:\s*isWindows\s*\?[^,\n]*SHARDED/.test(after)) {
+        after = after.replace(/timeout:\s*isWindows\s*\?\s*([0-9_]+)\s*:\s*([0-9_]+|undefined)/, (_m, a, b) => {
+            count++;
+            return `timeout: isWindows ? ${a} : SHARDED ? 180_000 : ${b}`;
+        });
+    }
+    // 5b. expect.timeout (only when an `expect: { timeout: N }` already exists).
+    if (/expect:\s*\{\s*timeout:\s*[0-9_]+\s*\}/.test(after) && !/expect:\s*\{\s*timeout:\s*SHARDED/.test(after)) {
+        after = after.replace(/expect:\s*\{\s*timeout:\s*([0-9_]+)\s*\}/, (_m, t) => {
+            count++;
+            return `expect: { timeout: SHARDED ? 30_000 : ${t} }`;
+        });
+    }
+    // 5c. navigation/action ceilings under shard (inject into `use` if absent).
+    if (!/navigationTimeout/.test(after)) {
+        after = after.replace(/(\n(\s*)use:\s*\{)/, (_m, whole, indent) => {
+            count++;
+            return `${whole}\n${indent}  actionTimeout: SHARDED ? 30_000 : undefined,\n${indent}  navigationTimeout: SHARDED ? 60_000 : undefined,`;
+        });
+    }
+    // 6. slowMo: 10 → 0 — an artificial per-action delay, pointless and multiplied
+    //    across N concurrent sharded browsers.
+    after = after.replace(/slowMo:\s*10\b/, () => {
+        count++;
+        return 'slowMo: 0';
+    });
     if (count === 0)
         return { file, patched: false, replacements: 0 };
     (0, fs_1.writeFileSync)(file, after, 'utf8');

package/build/lib/dev-process.js

@@ -13,7 +13,11 @@ exports.checkPortInUse = checkPortInUse;
 exports.killProcessGroup = killProcessGroup;
 exports.listenSnapshot = listenSnapshot;
 exports.rotateLogFile = rotateLogFile;
+exports.runChildInherit = runChildInherit;
+exports.runChildToFile = runChildToFile;
 exports.spawnDetached = spawnDetached;
+exports.terminateProcessGroup = terminateProcessGroup;
+exports.waitForHttp = waitForHttp;
 /**
  * Process + port helpers for `lt dev`.
  *
@@ -145,6 +149,60 @@ function rotateLogFile(logFile) {
     }
     return { archivePath, previousSize, rotated: true };
 }
+/**
+ * Run a child to completion with inherited stdio. Resolves with the exit code.
+ *
+ * Counterpart of `spawnDetached`: foreground, synchronous-feeling, used for
+ * commands the user must see live output from (build, test runners).
+ * Errors during spawn resolve as exit code `1` so callers can branch on a
+ * single integer instead of try/catch.
+ */
+function runChildInherit(cmd, args, opts) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)(cmd, args, { cwd: opts.cwd, env: opts.env, stdio: 'inherit' });
+        child.on('error', () => resolve(1));
+        child.on('close', (code) => resolve(code));
+    });
+}
+/**
+ * Run a child to completion with stdout+stderr redirected to a log file.
+ * Resolves with the exit code (`1` on spawn error). Like `runChildInherit` but
+ * non-interleaving — used to run several children CONCURRENTLY (e.g. parallel
+ * Playwright shards) without their console output clobbering each other.
+ */
+function runChildToFile(cmd, args, opts) {
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(opts.logFile), { recursive: true });
+    // Rotate so each run starts with a fresh log (one prior generation kept as
+    // `<logFile>.1`) instead of appending run-on-run.
+    rotateLogFile(opts.logFile);
+    const out = (0, fs_1.openSync)(opts.logFile, 'a');
+    const close = () => {
+        try {
+            (0, fs_1.closeSync)(out);
+        }
+        catch (_a) {
+            /* already closed */
+        }
+    };
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = (0, child_process_1.spawn)(cmd, args, { cwd: opts.cwd, env: opts.env, stdio: ['ignore', out, out] });
+        }
+        catch (_a) {
+            close();
+            return resolve(1);
+        }
+        child.on('error', () => {
+            close();
+            resolve(1);
+        });
+        child.on('close', (code) => {
+            close();
+            resolve(code);
+        });
+    });
+}
 /**
  * Spawn a detached child whose stdio is redirected to a log file.
  *
@@ -188,3 +246,99 @@ function spawnDetached(cmd, args, opts) {
         }
     }
 }
+/**
+ * Terminate a detached process group RELIABLY: SIGTERM the group, wait up to
+ * `graceMs` for it to exit, then SIGKILL anything still alive.
+ *
+ * Needed because a compiled NestJS API (`node dist`) installs shutdown hooks
+ * that catch SIGTERM and can hang on open Mongo connections — a single
+ * SIGTERM then "succeeds" (the call returns) while the process keeps
+ * listening on its port and holding DB connections. `lt dev test`'s
+ * residue-free teardown promise depends on the process actually being gone,
+ * so we escalate to SIGKILL after a grace period.
+ *
+ * Polls every 150ms so a process that exits cleanly returns near-instantly
+ * (only a hung process waits the full `graceMs`). Returns true if the process
+ * is gone by the end, false if it somehow survived even SIGKILL.
+ */
+function terminateProcessGroup(pid_1) {
+    return __awaiter(this, arguments, void 0, function* (pid, graceMs = 4000) {
+        if (!(0, dev_state_1.isValidPid)(pid))
+            return false;
+        if (!(0, dev_state_1.isPidAlive)(pid))
+            return true;
+        // Phase 1 — graceful: SIGTERM the group (single-PID fallback inside).
+        killProcessGroup(pid);
+        const deadline = Date.now() + Math.max(0, graceMs);
+        while (Date.now() < deadline) {
+            if (!(0, dev_state_1.isPidAlive)(pid))
+                return true;
+            yield delay(150);
+        }
+        // Phase 2 — forced: SIGKILL the group, then the single PID.
+        if (!(0, dev_state_1.isPidAlive)(pid))
+            return true;
+        try {
+            process.kill(-pid, 'SIGKILL');
+        }
+        catch (_a) {
+            /* group already gone or pid is not a group leader */
+        }
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch (_b) {
+            /* already dead */
+        }
+        yield delay(150);
+        return !(0, dev_state_1.isPidAlive)(pid);
+    });
+}
+/**
+ * Poll an HTTPS/HTTP URL until a matching response is observed or `timeoutMs`
+ * elapses.
+ *
+ * Used to wait for dev servers to become reachable before the next step
+ * (typically running a test suite). By default treats ANY HTTP status (1xx-5xx)
+ * as "up" — a 404 means the server is bound and answering, which is usually
+ * what we want to know. Pass `ready` to require a stricter status: an API
+ * readiness probe wants a real 2xx on `/meta`, because Caddy answers 502 while
+ * its upstream is still booting and the default predicate would accept that
+ * prematurely (the cause of the test-suite API-readiness race). Uses `curl`
+ * because it is universally available and handles HTTPS-with-self-signed-cert
+ * (Caddy) via `-k` for free.
+ *
+ * Resolves `true` on the first matching response, `false` on timeout. Never rejects.
+ */
+function waitForHttp(url, timeoutMs, ready = (status) => status >= 100 && status < 600) {
+    const start = Date.now();
+    return new Promise((resolve) => {
+        const tick = () => {
+            var _a;
+            const child = (0, child_process_1.spawn)('curl', ['-sk', '-o', '/dev/null', '-w', '%{http_code}', '--max-time', '2', url], {
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            let status = '';
+            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (b) => (status += String(b)));
+            child.on('close', () => {
+                const code = Number(status.trim());
+                // `000` (curl could not connect) parses to 0 → never "ready".
+                if (Number.isFinite(code) && code > 0 && ready(code))
+                    return resolve(true);
+                if (Date.now() - start > timeoutMs)
+                    return resolve(false);
+                setTimeout(tick, 500);
+            });
+            child.on('error', () => {
+                if (Date.now() - start > timeoutMs)
+                    return resolve(false);
+                setTimeout(tick, 500);
+            });
+        };
+        tick();
+    });
+}
+/** Promise-based delay used by the graceful→forced termination escalation. */
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/build/lib/dev-project.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.apiNeedsPortPatch = apiNeedsPortPatch;
 exports.appNeedsPortPatch = appNeedsPortPatch;
 exports.deriveDbName = deriveDbName;
+exports.deriveTestDbName = deriveTestDbName;
+exports.deriveTicketDbName = deriveTicketDbName;
 exports.resolveLayout = resolveLayout;
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -33,7 +35,10 @@ function appNeedsPortPatch(appDir) {
             /target:\s*'http:\/\/localhost:3000'/.test(c) ||
             /baseURL:\s*'http:\/\/localhost:3001'/.test(c) ||
             /url:\s*'http:\/\/localhost:3001'/.test(c) ||
-            /host:\s*'http:\/\/localhost:3001'/.test(c));
+            /host:\s*'http:\/\/localhost:3001'/.test(c) ||
+            // Unguarded Playwright `webServer` (no LT_DEV_ACTIVE guard) — patch it so
+            // `lt dev test`'s isolated stack is reused instead of a stray server.
+            (/webServer:\s*[[{]/.test(c) && !/webServer:\s*process\.env\.LT_DEV_ACTIVE/.test(c)));
     });
 }
 /** Read `dbName` from the API config (defaults to `<slug>-local`). */
@@ -49,6 +54,34 @@ function deriveDbName(apiDir, slug) {
     }
     return `${slug}-local`;
 }
+/**
+ * Derive the dedicated database name for the `lt dev test` stack from the
+ * project's dev DB name. Distinct from both `<…>-local` (developer DB) and
+ * the API unit-test DB (`<…>-e2e`), so Playwright E2E never touches developer
+ * or API-test data.
+ *
+ *   svl-sports-system-local → svl-sports-system-test
+ *
+ * Uses the `-test` suffix so it passes test-helper guards that only permit
+ * local/test databases (name ending in `-local` | `-ci` | `-e2e` | `-test`).
+ */
+function deriveTestDbName(devDbName) {
+    const base = devDbName.replace(/-(local|dev)$/i, '');
+    return `${base}-test`;
+}
+/**
+ * Derive the per-TICKET database name from the project's dev DB name, so each
+ * ticket worktree reads/writes its OWN database and tickets never collide.
+ *
+ *   svl-sports-system-local + "2200" → svl-sports-system-2200
+ *
+ * The ticket's isolated `lt dev test` stack then derives its test DB from this
+ * via {@link deriveTestDbName} → `svl-sports-system-2200-test`.
+ */
+function deriveTicketDbName(devDbName, ticketId) {
+    const base = devDbName.replace(/-(local|dev)$/i, '');
+    return `${base}-${ticketId}`;
+}
 /**
  * Resolve layout starting from `cwd`. Walks up to find a workspace if
  * cwd is inside `projects/api/` or `projects/app/`.