@lenne.tech/cli 1.27.0 → 1.29.0

package/build/commands/ticket/list.js

@@ -0,0 +1,78 @@
+"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_identity_1 = require("../../lib/dev-identity");
+const dev_project_1 = require("../../lib/dev-project");
+const dev_state_1 = require("../../lib/dev-state");
+const dev_ticket_1 = require("../../lib/dev-ticket");
+/**
+ * `lt ticket list` — the dashboard of all active ticket worktrees: id, folder,
+ * branch, URLs, DB and running state. The one place to re-view every ticket's
+ * URLs at any time.
+ */
+const ListCommand = {
+    alias: ['ls'],
+    description: 'List all ticket worktrees with their URLs + status',
+    name: 'list',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const { filesystem, parameters, print: { colors, info, warning }, } = toolbox;
+        const layout = (0, dev_project_1.resolveLayout)(filesystem.cwd(), filesystem);
+        let mainRepoRoot;
+        try {
+            mainRepoRoot = (0, dev_ticket_1.gitMainRepoRoot)(layout.root);
+        }
+        catch (_b) {
+            warning('Not inside a git repository.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket list: not a git repo';
+        }
+        const base = (0, dev_identity_1.buildIdentity)(mainRepoRoot);
+        const tickets = (0, dev_ticket_1.listWorktrees)(mainRepoRoot).filter((w) => w.ticket);
+        const reg = (0, dev_state_1.loadRegistry)();
+        info('');
+        info(colors.bold('Ticket environments'));
+        info(colors.dim('─'.repeat(64)));
+        if (tickets.length === 0) {
+            info(colors.dim('  none — start one with `lt ticket start <ticket-or-name>`'));
+            info('');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit();
+            return 'ticket list: empty';
+        }
+        for (const wt of tickets) {
+            const session = (0, dev_state_1.loadSession)(wt.path);
+            const apiAlive = (session === null || session === void 0 ? void 0 : session.pids.api) ? (0, dev_state_1.isPidAlive)(session.pids.api) : false;
+            const appAlive = (session === null || session === void 0 ? void 0 : session.pids.app) ? (0, dev_state_1.isPidAlive)(session.pids.app) : false;
+            const running = apiAlive || appAlive;
+            const dot = running ? colors.green('●') : colors.dim('○');
+            // The dev stack for this ticket is registered under `<base>-<id>`.
+            const entry = reg.projects[`${base.slug}-${wt.ticket}`];
+            info(`  ${dot} ${colors.bold(String(wt.ticket).padEnd(16))} ${colors.dim(`branch ${(_a = wt.branch) !== null && _a !== void 0 ? _a : '-'}`)}`);
+            if (entry) {
+                for (const [sub, host] of Object.entries(entry.subdomains))
+                    info(`       ${sub.padEnd(4)} https://${host}`);
+                if (entry.dbName)
+                    info(`       db   mongodb://127.0.0.1/${entry.dbName}`);
+            }
+            info(colors.dim(`       dir  ${wt.path}`));
+            info(colors.dim(`       ${running ? 'running' : 'stopped'}${entry ? '' : ' (not brought up yet)'}`));
+        }
+        info('');
+        info(colors.dim('Open: `code <dir>` / `lt ticket switch <id>` · Test: `lt ticket test <id>` · Stop: `lt ticket stop <id>`'));
+        info('');
+        if (!parameters.options.fromGluegunMenu)
+            process.exit();
+        return `ticket list: ${tickets.length}`;
+    }),
+};
+module.exports = ListCommand;

package/build/commands/ticket/start.js

@@ -0,0 +1,141 @@
+"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 fs_1 = require("fs");
+const dev_identity_1 = require("../../lib/dev-identity");
+const dev_process_1 = require("../../lib/dev-process");
+const dev_project_1 = require("../../lib/dev-project");
+const dev_state_1 = require("../../lib/dev-state");
+const dev_ticket_1 = require("../../lib/dev-ticket");
+/**
+ * `lt ticket start <name>` — spin up a fully-isolated parallel dev environment
+ * for a ticket or feature, in seconds:
+ *
+ *   1. `git fetch` + create a git WORKTREE on a fresh branch from `origin/dev`
+ *      (so every ticket starts independent from the latest dev) at a sibling
+ *      folder `<parent>/<slug>-<id>`,
+ *   2. tag it with a `.lt-dev/ticket` marker (makes every `lt dev *` in it
+ *      ticket-aware),
+ *   3. `pnpm install` (hard-links from the shared store → fast),
+ *   4. `lt dev up` → own URLs (`<slug>-<id>.localhost` / `api.<slug>-<id>…`),
+ *      own ports, own Caddy block, own EMPTY DB (`<base>-<id>`).
+ *
+ *   lt ticket start DEV-2200            → svl-2200.localhost      (branch feat/DEV-2200)
+ *   lt ticket start checkout-refactor   → svl-checkout-refactor.localhost
+ *   lt ticket start DEV-2200 --as cof   → svl-cof.localhost
+ */
+const StartCommand = {
+    description: 'Start an isolated parallel dev env for a ticket/feature (worktree + lt dev up)',
+    name: 'start',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const { filesystem, parameters, print: { colors, error, info, success, warning }, } = toolbox;
+        // `String(...)` — a purely-numeric arg (e.g. a ticket "9991") is parsed as a
+        // JS number by the option parser, on which `.trim()` would throw.
+        const name = String((_a = parameters.first) !== null && _a !== void 0 ? _a : '').trim();
+        if (!name) {
+            error('Usage: lt ticket start <ticket-or-name> [--as <id>] [--branch <branch>] [--base <ref>]');
+            info(colors.dim('  e.g. lt ticket start DEV-2200    |    lt ticket start checkout-refactor'));
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket start: missing name';
+        }
+        // Anchor to the MAIN repo (works even when invoked from inside a worktree).
+        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 — `lt ticket` needs a git project.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket start: not a git repo';
+        }
+        const base = (0, dev_identity_1.buildIdentity)(mainRepoRoot);
+        const id = (0, dev_ticket_1.deriveTicketId)(name, parameters.options.as != null ? String(parameters.options.as) : undefined);
+        const branch = typeof parameters.options.branch === 'string' ? parameters.options.branch : (0, dev_ticket_1.defaultTicketBranch)(name);
+        const baseRef = typeof parameters.options.base === 'string' ? parameters.options.base : 'origin/dev';
+        const ticketIdentity = (0, dev_identity_1.buildTicketIdentity)(base, id);
+        const dbName = (0, dev_project_1.deriveTicketDbName)((0, dev_project_1.deriveDbName)(layout.apiDir, base.slug), id);
+        const worktreePath = (0, dev_ticket_1.worktreePathFor)(mainRepoRoot, base.slug, id);
+        // Pre-flight: nothing already there + slug free.
+        if ((0, fs_1.existsSync)(worktreePath)) {
+            error(`Target folder already exists: ${worktreePath}`);
+            info(colors.dim('  Use a different id (`--as <id>`) or remove it with `lt ticket stop`.'));
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket start: path exists';
+        }
+        if ((0, dev_state_1.loadRegistry)().projects[ticketIdentity.slug]) {
+            warning(`An env named "${ticketIdentity.slug}" is already registered — choose another id with --as.`);
+        }
+        info('');
+        info(colors.bold(`Starting ticket "${id}"  →  ${ticketIdentity.slug}`));
+        info(colors.dim(`  branch:   ${branch}  (from ${baseRef})`));
+        info(colors.dim(`  worktree: ${worktreePath}`));
+        info('');
+        // 1. fetch + worktree (fresh branch from origin/dev → independent).
+        try {
+            info(colors.dim(`Fetching + creating worktree from ${baseRef} …`));
+            (0, dev_ticket_1.gitFetch)(mainRepoRoot);
+            (0, dev_ticket_1.worktreeAdd)(mainRepoRoot, worktreePath, branch, baseRef);
+        }
+        catch (e) {
+            error(`git worktree setup failed: ${e.message}`);
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket start: worktree failed';
+        }
+        // 2. tag the worktree with its ticket id (makes lt dev * ticket-aware).
+        (0, dev_ticket_1.writeTicketMarker)(worktreePath, id);
+        // 3. install deps (pnpm hard-links from the shared store → fast).
+        if (parameters.options.install !== false) {
+            info(colors.dim('Installing dependencies (pnpm) …'));
+            try {
+                (0, dev_ticket_1.pnpmInstall)(worktreePath);
+            }
+            catch (e) {
+                warning(`pnpm install failed (${e.message}) — continuing; run it manually in the worktree.`);
+            }
+        }
+        // 4. bring the isolated stack up (re-invokes THIS lt build so the marker is
+        //    honoured even before a global recompile). `--no-up` just scaffolds.
+        if (parameters.options.up !== false) {
+            info('');
+            info(colors.dim('Bringing up the isolated stack (lt dev up) …'));
+            const code = yield (0, dev_process_1.runChildInherit)(process.execPath, [process.argv[1], 'dev', 'up'], {
+                cwd: worktreePath,
+                env: process.env,
+            });
+            if (code !== 0)
+                warning(`lt dev up exited ${code} — inspect with \`cd ${worktreePath} && lt dev status\`.`);
+        }
+        // Summary — the URLs the user works with (always re-viewable via `lt ticket list`).
+        info('');
+        success(`Ticket "${id}" ready.`);
+        if (ticketIdentity.subdomains.app)
+            info(`  app: https://${ticketIdentity.subdomains.app.hostname}`);
+        if (ticketIdentity.subdomains.api)
+            info(`  api: https://${ticketIdentity.subdomains.api.hostname}`);
+        info(`  db:  mongodb://127.0.0.1/${dbName}  (empty)`);
+        info(`  dir: ${worktreePath}`);
+        info('');
+        info(colors.dim(`Open it:   code ${worktreePath}    (or: lt ticket switch ${id})`));
+        info(colors.dim(`Test it:   cd ${worktreePath} && lt dev test    (or: lt ticket test ${id})`));
+        info(colors.dim('All envs:  lt ticket list'));
+        info(colors.dim(`Stop it:   lt ticket stop ${id}`));
+        if (!parameters.options.fromGluegunMenu)
+            process.exit();
+        return `ticket start: ${id}`;
+    }),
+};
+module.exports = StartCommand;

package/build/commands/ticket/stop.js

@@ -0,0 +1,166 @@
+"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 fs_1 = require("fs");
+const dev_identity_1 = require("../../lib/dev-identity");
+const dev_process_1 = require("../../lib/dev-process");
+const dev_project_1 = require("../../lib/dev-project");
+const dev_state_1 = require("../../lib/dev-state");
+const dev_ticket_1 = require("../../lib/dev-ticket");
+/**
+ * `lt ticket stop [<id>]` — tear a ticket env down + remove its worktree.
+ *
+ *   1. `lt dev down` inside the worktree (stops the ticket stack + any test
+ *      stacks, removes the Caddy block — residue-free),
+ *   2. `git worktree remove` (the BRANCH is kept, so nothing is lost),
+ *   3. `--drop-db` also drops the ticket's empty dev + test databases.
+ *
+ * Run with NO id from INSIDE a ticket worktree to clean up THIS environment
+ * (the current folder is removed; the process steps out to the main repo first).
+ */
+const StopCommand = {
+    alias: ['rm'],
+    description: 'Stop a ticket env + remove its worktree (branch kept); no id = the current worktree',
+    name: 'stop',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        const { filesystem, parameters, print: { colors, error, info, success, warning }, } = toolbox;
+        const layout = (0, dev_project_1.resolveLayout)(filesystem.cwd(), filesystem);
+        let mainRepoRoot;
+        try {
+            mainRepoRoot = (0, dev_ticket_1.gitMainRepoRoot)(layout.root);
+        }
+        catch (_f) {
+            error('Not inside a git repository.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket stop: not a git repo';
+        }
+        // Id from the argument — or, when invoked with NO id from INSIDE a ticket
+        // worktree, the current worktree's own ticket (so a bare `lt ticket stop`
+        // cleans up "this" environment and removes this very folder).
+        const fromMarker = parameters.first == null ? (0, dev_ticket_1.readTicketMarker)(layout.root) : null;
+        const id = String((_b = (_a = parameters.first) !== null && _a !== void 0 ? _a : fromMarker) !== null && _b !== void 0 ? _b : '').trim();
+        if (!id) {
+            error('Usage: lt ticket stop <id> [--drop-db] [--force]  — or run with no id from INSIDE a ticket worktree.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket stop: missing id';
+        }
+        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 stop: not found';
+        }
+        // SAFETY: never silently delete unsaved work. Warn + REFUSE (unless --force)
+        // when the worktree has uncommitted changes OR unpushed commits, so the user
+        // commits + pushes first. (`--force` removes anyway; the branch is kept, so
+        // committed history survives regardless.)
+        const safety = (0, dev_ticket_1.worktreeSafetyReport)(wt.path);
+        if ((safety.dirtySource.length > 0 || safety.unpushed > 0) && parameters.options.force !== true) {
+            warning('');
+            warning(`Refusing to remove ticket "${id}" — work is not fully committed + pushed:`);
+            if (safety.dirtySource.length > 0) {
+                warning(`  • ${safety.dirtySource.length} uncommitted change(s) — would be LOST on removal:`);
+                safety.dirtySource.slice(0, 12).forEach((l) => info(colors.dim(`      ${l}`)));
+                if (safety.dirtySource.length > 12)
+                    info(colors.dim(`      … and ${safety.dirtySource.length - 12} more`));
+            }
+            if (safety.unpushed > 0) {
+                warning(`  • ${safety.unpushed} commit(s) on "${(_c = wt.branch) !== null && _c !== void 0 ? _c : '-'}" not pushed to any remote`);
+            }
+            info('');
+            info(colors.dim('  Commit + push first (the branch is kept), or re-run with --force to remove anyway.'));
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket stop: unsaved work (use --force)';
+        }
+        // If we are removing the worktree we are standing in, step the process out
+        // to the main repo first so git can remove the folder cleanly.
+        const removingCwd = fromMarker !== null || samePath(wt.path, layout.root);
+        if (removingCwd) {
+            try {
+                process.chdir(mainRepoRoot);
+            }
+            catch (_g) {
+                /* best-effort */
+            }
+        }
+        info('');
+        info(colors.bold(`Stopping ticket "${id}"`));
+        // 1. Tear the isolated stack down from inside the worktree (marker-aware).
+        info(colors.dim('  lt dev down …'));
+        yield (0, dev_process_1.runChildInherit)(process.execPath, [process.argv[1], 'dev', 'down'], { cwd: wt.path, env: process.env });
+        // 2. Optionally drop the ticket databases (they are otherwise just left empty).
+        if (parameters.options.dropDb === true || parameters.options['drop-db'] === true) {
+            const base = (0, dev_identity_1.buildIdentity)(mainRepoRoot);
+            const entry = (0, dev_state_1.loadRegistry)().projects[`${base.slug}-${id}`];
+            const mainLayout = (0, dev_project_1.resolveLayout)(mainRepoRoot, filesystem);
+            const devDb = (_d = entry === null || entry === void 0 ? void 0 : entry.dbName) !== null && _d !== void 0 ? _d : (0, dev_project_1.deriveTicketDbName)((0, dev_project_1.deriveDbName)(mainLayout.apiDir, base.slug), id);
+            const testDb = (0, dev_project_1.deriveTestDbName)(devDb);
+            for (const db of [devDb, testDb]) {
+                if ((0, dev_ticket_1.dropDatabase)(db))
+                    info(colors.dim(`  dropped db ${db}`));
+                else
+                    warning(`  could not drop db ${db} (mongosh missing or DB not reachable) — drop it manually if needed.`);
+            }
+        }
+        // 3. Remove the worktree (branch is kept). Auto-force when the ONLY dirty
+        //    files are framework-generated (e.g. `nuxt dev` rewrites the tracked
+        //    `.nuxtrc` on boot), which would otherwise block the remove — but NEVER
+        //    discard real source edits (those keep the non-forced remove, which
+        //    errors with a hint so unsaved work is never lost).
+        const force = parameters.options.force === true || (0, dev_ticket_1.worktreeDirtyOnlyGenerated)(wt.path);
+        if (force && parameters.options.force !== true) {
+            info(colors.dim('  (worktree had only generated files dirty, e.g. .nuxtrc — removing)'));
+        }
+        try {
+            (0, dev_ticket_1.worktreeRemove)(mainRepoRoot, wt.path, force);
+        }
+        catch (e) {
+            error(`git worktree remove failed: ${e.message}`);
+            info(colors.dim('  The worktree has uncommitted SOURCE changes — commit/stash them, or pass --force to discard.'));
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket stop: worktree remove failed';
+        }
+        // The whole env is gone now — drop the ticket's registry entry so its slug +
+        // reserved ports are reclaimed (`lt dev down` only ends the session, keeping
+        // the entry for a restart; `lt ticket stop` removes the env entirely).
+        {
+            const reg = (0, dev_state_1.loadRegistry)();
+            const ticketSlug = `${(0, dev_identity_1.buildIdentity)(mainRepoRoot).slug}-${id}`;
+            if (reg.projects[ticketSlug]) {
+                delete reg.projects[ticketSlug];
+                (0, dev_state_1.saveRegistry)(reg);
+            }
+        }
+        info('');
+        success(`Ticket "${id}" stopped — worktree removed, branch "${(_e = wt.branch) !== null && _e !== void 0 ? _e : '-'}" kept.`);
+        if (removingCwd)
+            info(colors.dim(`  This folder is gone — your shell is still in it. Run: cd ${mainRepoRoot}`));
+        if (!parameters.options.fromGluegunMenu)
+            process.exit();
+        return `ticket stop: ${id}`;
+    }),
+};
+/** True if two paths point at the same location (resolving symlinks, e.g. /tmp → /private/tmp). */
+function samePath(a, b) {
+    try {
+        return (0, fs_1.realpathSync)(a) === (0, fs_1.realpathSync)(b);
+    }
+    catch (_a) {
+        return a === b;
+    }
+}
+module.exports = StopCommand;

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';
+    }),
+};