@lenne.tech/cli 1.35.1 → 1.37.0

package/build/commands/dev/doctor.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 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) {
@@ -121,6 +154,28 @@ const DoctorCommand = {
             else if (gs.file && gs.hasDbReset) {
                 line('OK', colors.green, 'global-setup allow-list is ticket + shard safe');
             }
+            // 7.5 check.mjs drift: the root wrapper is canonical (bundled with the
+            //     CLI, synced by `lt fullstack update`). A diverged copy silently
+            //     misses fixes (idle-watchdog, install hoisting, summed test
+            //     metrics) — surface it instead of letting copies drift apart.
+            try {
+                const { readFileSync: read } = yield Promise.resolve().then(() => __importStar(require('fs')));
+                const { join: j } = yield Promise.resolve().then(() => __importStar(require('path')));
+                const projectCheck = j(layout.root, 'scripts', 'check.mjs');
+                const bundledCheck = j(__dirname, '..', '..', 'templates', 'check', 'check.mjs');
+                if (filesystem.exists(projectCheck) && filesystem.exists(bundledCheck)) {
+                    if (read(projectCheck, 'utf8') === read(bundledCheck, 'utf8')) {
+                        line('OK', colors.green, 'scripts/check.mjs matches the canonical CLI version');
+                    }
+                    else {
+                        line('WARN', colors.yellow, 'scripts/check.mjs differs from the canonical CLI version');
+                        line('WARN', colors.yellow, '  run `lt fullstack update` to sync it (skips uncommitted local edits)');
+                    }
+                }
+            }
+            catch (_a) {
+                /* best-effort diagnostics */
+            }
             // 8. Slug ↔ path: is this project's slug registered to a DIFFERENT checkout?
             //    Two clones of the same project (same package.json "name") share the
             //    slug → Caddy block / ports / DB and collide. Surface it proactively.

package/build/commands/dev/prune.js

@@ -0,0 +1,152 @@
+"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_prune_1 = require("../../lib/dev-prune");
+const dev_state_1 = require("../../lib/dev-state");
+const dev_ticket_1 = require("../../lib/dev-ticket");
+const workspace_integration_1 = require("../../lib/workspace-integration");
+/**
+ * `lt dev prune [--dry-run] [--noConfirm]` — collect the leftovers that accumulate
+ * around parallel ticket work:
+ *
+ *   1. ORPHANED TICKET DATABASES of this project: `<base>-<id>`(+`-test`/`-test-<n>`)
+ *      whose ticket has neither a live worktree nor a live registry entry. The id
+ *      set comes from this repo's own `feat/*` branches — never from name shapes,
+ *      so sibling projects sharing a name prefix are safe. DBs recorded via
+ *      `lt ticket stop --keep-db` are never touched.
+ *   2. STALE SHARD TEST DATABASES (`<base>-test-<n>` from `lt dev test --shard`)
+ *      when no test session is running — they are reset on every run anyway.
+ *   3. DEAD REGISTRY ENTRIES (all projects): path no longer exists → the entry and
+ *      its reserved ports are reclaimed. Databases of dead MAIN projects are NEVER
+ *      dropped (a deleted folder is not consent to destroy data).
+ *
+ * `lt dev up` runs the same collection automatically (opt out with --no-prune), so
+ * restarting an environment always cleans up after its predecessors.
+ */
+const PruneCommand = {
+    description: 'Remove orphaned ticket databases, stale shard test DBs and dead registry entries',
+    hidden: false,
+    name: 'prune',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        const { filesystem, parameters, print: { colors, error, info, success, warning }, prompt: { confirm }, } = toolbox;
+        const dryRun = parameters.options.dryRun === true || parameters.options['dry-run'] === true;
+        const layout = (0, dev_project_1.resolveLayout)(filesystem.cwd(), filesystem);
+        let mainRepoRoot = layout.root;
+        try {
+            mainRepoRoot = (0, dev_ticket_1.gitMainRepoRoot)(layout.root);
+        }
+        catch (_a) {
+            /* not a git repo — registry prune still works, ticket sweep will be empty */
+        }
+        const mainLayout = (0, dev_project_1.resolveLayout)(mainRepoRoot, filesystem);
+        const slug = (0, dev_identity_1.buildIdentity)(mainRepoRoot).slug;
+        const projectDevDb = (0, dev_project_1.deriveDbName)(mainLayout.apiDir, slug);
+        const observed = mainLayout.apiDir ? (0, dev_ticket_1.listDatabaseNames)(undefined, [mainLayout.apiDir, mainRepoRoot]) : null;
+        if (mainLayout.apiDir && observed === null) {
+            warning('Could not list databases (mongosh missing or MongoDB unreachable) — only the registry is pruned.');
+        }
+        const plan = (0, dev_prune_1.collectDevPrunePlan)({
+            loadRegistry: dev_state_1.loadRegistry,
+            mainRepoRoot,
+            observedDbNames: observed,
+            projectDevDb,
+            slug,
+        });
+        const dbTargets = [...new Set([...plan.orphan.targets, ...plan.shardTargets])];
+        if (dbTargets.length === 0 && plan.registryPrune.length === 0) {
+            success('Nothing to prune — no orphaned ticket DBs, no stale shard DBs, no dead registry entries.');
+            if (plan.orphan.protected.length > 0) {
+                info(colors.dim(`  kept (registry keptDbs / referenced): ${plan.orphan.protected.join(', ')}`));
+            }
+            if (!parameters.options.fromGluegunMenu)
+                process.exit();
+            return 'dev prune: nothing to do';
+        }
+        if (plan.orphan.targets.length > 0) {
+            info(colors.bold(`Orphaned ticket databases (tickets: ${plan.orphan.orphanIds.join(', ')}):`));
+            plan.orphan.targets.forEach((db) => info(colors.dim(`  • ${db}`)));
+        }
+        if (plan.shardTargets.length > 0) {
+            info(colors.bold('Stale shard test databases (no test session running):'));
+            plan.shardTargets.forEach((db) => info(colors.dim(`  • ${db}`)));
+        }
+        if (plan.orphan.protected.length > 0) {
+            info(colors.dim(`Kept (recorded via --keep-db or still referenced): ${plan.orphan.protected.join(', ')}`));
+        }
+        if (plan.registryPrune.length > 0) {
+            info(colors.bold('Dead registry entries (path gone — entry + ports reclaimed, databases untouched):'));
+            plan.registryPrune.forEach((key) => info(colors.dim(`  • ${key}`)));
+        }
+        if (dryRun) {
+            info('');
+            info(colors.dim('--dry-run → nothing was changed.'));
+            if (!parameters.options.fromGluegunMenu)
+                process.exit();
+            return 'dev prune: dry run';
+        }
+        // Dropping databases is irreversible — confirm interactively (documented default
+        // for non-interactive callers, mirroring `lt ticket stop`).
+        let confirmedDbTargets = dbTargets;
+        if (dbTargets.length > 0 && !(0, workspace_integration_1.isNonInteractive)(parameters.options.noConfirm === true)) {
+            info('');
+            warning('  These databases will be DROPPED (irreversible):');
+            dbTargets.forEach((db) => info(colors.dim(`    • ${db}`)));
+            if (!(yield confirm('Drop them?', true))) {
+                info(colors.dim('  keeping the databases.'));
+                confirmedDbTargets = [];
+            }
+        }
+        if (confirmedDbTargets.length > 0) {
+            const { dropped, reason } = (0, dev_ticket_1.dropDatabases)(confirmedDbTargets, undefined, [mainLayout.apiDir, mainRepoRoot]);
+            dropped.forEach((db) => info(colors.dim(`  dropped db ${db}`)));
+            if (reason === 'no-mongosh') {
+                warning('  mongosh is not installed — the databases were NOT dropped.');
+            }
+            else if (reason === 'unreachable') {
+                warning('  MongoDB is not reachable — the databases were NOT dropped.');
+            }
+        }
+        if (plan.registryPrune.length > 0) {
+            try {
+                // Locked read-modify-write: a parallel `lt dev up` may be registering a
+                // project right now — pruning without the lock clobbers its fresh entry.
+                const removed = yield (0, dev_state_1.withRegistryLock)(() => {
+                    const reg = (0, dev_state_1.loadRegistry)();
+                    const gone = [];
+                    for (const key of plan.registryPrune) {
+                        if (reg.projects[key] && !filesystem.exists(reg.projects[key].path)) {
+                            delete reg.projects[key];
+                            gone.push(key);
+                        }
+                    }
+                    if (gone.length > 0) {
+                        (0, dev_state_1.saveRegistry)(reg);
+                    }
+                    return gone;
+                });
+                if (removed.length > 0) {
+                    info(colors.dim(`  removed ${removed.length} dead registry entr${removed.length === 1 ? 'y' : 'ies'}: ${removed.join(', ')}`));
+                }
+            }
+            catch (e) {
+                error(`  registry update failed: ${e.message}`);
+            }
+        }
+        info('');
+        success('Prune complete.');
+        if (!parameters.options.fromGluegunMenu)
+            process.exit();
+        return 'dev prune: done';
+    }),
+};
+module.exports = PruneCommand;

package/build/commands/dev/test.js

@@ -236,6 +236,9 @@ const TestCommand = {
             info(colors.dim(`  app: ${ctx.appUrl}   db: ${ctx.dbName}`));
             info('');
             const appPm = (0, dev_package_manager_1.pickPackageManager)(layout.appDir);
+            // Self-heal: install the app's Playwright browser build if missing —
+            // idempotent (~1s when cached); a fresh project otherwise fails every spec.
+            (0, dev_test_session_1.ensurePlaywrightBrowsers)(layout.appDir, appPm, (m) => info(colors.dim(m)));
             exitCode = yield (0, dev_process_1.runChildInherit)(appPm.bin, appPm.runScript('test:e2e', forwarded), {
                 cwd: layout.appDir,
                 env,

package/build/commands/dev/up.js

@@ -14,10 +14,12 @@ const path_1 = require("path");
 const caddy_1 = require("../../lib/caddy");
 const dev_env_1 = require("../../lib/dev-env");
 const dev_env_bridge_1 = require("../../lib/dev-env-bridge");
+const dev_identity_1 = require("../../lib/dev-identity");
 const dev_package_manager_1 = require("../../lib/dev-package-manager");
 const dev_patches_1 = require("../../lib/dev-patches");
 const dev_process_1 = require("../../lib/dev-process");
 const dev_project_1 = require("../../lib/dev-project");
+const dev_prune_1 = require("../../lib/dev-prune");
 const dev_state_1 = require("../../lib/dev-state");
 const dev_ticket_1 = require("../../lib/dev-ticket");
 /**
@@ -432,6 +434,67 @@ const UpCommand = {
             if (pids.app)
                 (0, dev_process_1.killProcessGroup)(pids.app);
         }
+        // AUTO-PRUNE — restarting an environment is the moment to clean up after its
+        // predecessors: orphaned ticket DBs (ids from this repo's own feat/* branches,
+        // no live worktree/registry entry, `--keep-db` records excluded), stale shard
+        // test DBs, and dead-path registry entries. Same guards as `lt dev prune`;
+        // best-effort and non-blocking — a failure here must never affect `up` itself.
+        // Opt out with `--no-prune`.
+        if (parameters.options.prune !== false) {
+            try {
+                let mainRepoRoot = layout.root;
+                try {
+                    mainRepoRoot = (0, dev_ticket_1.gitMainRepoRoot)(layout.root);
+                }
+                catch (_m) {
+                    /* not a git repo — registry prune still applies */
+                }
+                const mainLayout = (0, dev_project_1.resolveLayout)(mainRepoRoot, filesystem);
+                const baseSlug = (0, dev_identity_1.buildIdentity)(mainRepoRoot).slug;
+                const plan = (0, dev_prune_1.collectDevPrunePlan)({
+                    loadRegistry: dev_state_1.loadRegistry,
+                    mainRepoRoot,
+                    observedDbNames: mainLayout.apiDir ? (0, dev_ticket_1.listDatabaseNames)(undefined, [mainLayout.apiDir, mainRepoRoot]) : null,
+                    projectDevDb: (0, dev_project_1.deriveDbName)(mainLayout.apiDir, baseSlug),
+                    slug: baseSlug,
+                });
+                const dbTargets = [...new Set([...plan.orphan.targets, ...plan.shardTargets])];
+                if (dbTargets.length > 0) {
+                    const { dropped, reason } = (0, dev_ticket_1.dropDatabases)(dbTargets, undefined, [mainLayout.apiDir, mainRepoRoot]);
+                    if (dropped.length > 0) {
+                        info(colors.dim(`Pruned ${dropped.length} orphaned test/ticket database(s): ${dropped.join(', ')}`));
+                    }
+                    if (reason) {
+                        info(colors.dim(`(prune incomplete — ${reason === 'no-mongosh' ? 'mongosh missing' : 'MongoDB unreachable'}; run \`lt dev prune\` later)`));
+                    }
+                }
+                if (plan.registryPrune.length > 0) {
+                    // Under the registry lock: a parallel `lt dev up` (another project) may be
+                    // REGISTERING right now — an unlocked read-modify-write here would clobber
+                    // its fresh entry (classic lost update; observed with two simultaneous ups).
+                    const removed = yield (0, dev_state_1.withRegistryLock)(() => {
+                        const reg = (0, dev_state_1.loadRegistry)();
+                        const gone = [];
+                        for (const key of plan.registryPrune) {
+                            if (reg.projects[key] && !(0, fs_1.existsSync)(reg.projects[key].path)) {
+                                delete reg.projects[key];
+                                gone.push(key);
+                            }
+                        }
+                        if (gone.length > 0) {
+                            (0, dev_state_1.saveRegistry)(reg);
+                        }
+                        return gone;
+                    });
+                    if (removed.length > 0) {
+                        info(colors.dim(`Pruned ${removed.length} dead registry entr${removed.length === 1 ? 'y' : 'ies'}: ${removed.join(', ')} (ports reclaimed)`));
+                    }
+                }
+            }
+            catch (_o) {
+                /* never block `up` on cleanup */
+            }
+        }
         if (!parameters.options.fromGluegunMenu)
             process.exit();
         return `dev up: api=${pids.api}, app=${pids.app}`;

package/build/commands/fullstack/update.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
+const dev_patches_1 = require("../../lib/dev-patches");
 const framework_detection_1 = require("../../lib/framework-detection");
 const frontend_framework_detection_1 = require("../../lib/frontend-framework-detection");
 const heal_check_wrapper_1 = require("../../lib/heal-check-wrapper");
@@ -198,6 +199,15 @@ const NewCommand = {
             info('');
             success(`  Installed/updated the check wrapper: ${changedCheck.join(', ')}`);
         }
+        // ── Self-heal: keep `.lt-dev/` out of git ──────────────────────────────
+        //
+        // Newer templates ship the entry, but pre-existing projects predate it —
+        // `lt dev up` then dirties `.gitignore` in every ticket worktree, which
+        // used to block every `lt ticket stop` at its safety gate. Idempotent.
+        if ((0, dev_patches_1.addToGitignore)(cwd, '.lt-dev/')) {
+            info('');
+            success('  Added `.lt-dev/` to .gitignore');
+        }
         info('');
         info(colors.bold('For a comprehensive update of everything, use:'));
         info('');

package/build/commands/ticket/start.js

@@ -15,13 +15,16 @@ 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");
+const workspace_integration_1 = require("../../lib/workspace-integration");
 /**
  * `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>`,
+ *   1. `git fetch` + create a git WORKTREE on a fresh branch from the repo's base
+ *      branch (`origin/dev` → `origin/develop` → remote HEAD → …, or `--base`;
+ *      the user is asked when none of them exists) so every ticket starts
+ *      independent from the latest integration state, 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),
@@ -62,8 +65,18 @@ const StartCommand = {
         }
         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);
+        // `local`/`dev`/`test`/… would derive a ticket DB that collides with the PROJECT's own
+        // dev or test database (both derivations strip a trailing `-(local|dev)` before adding
+        // their suffix, so the name round-trips). `lt ticket stop` would then be aimed at the
+        // developer's own data. Refuse the id instead of creating that trap.
+        if ((0, dev_ticket_1.isReservedTicketId)(id)) {
+            error(`Ticket id "${id}" is reserved — its database would collide with the project's own.`);
+            info(colors.dim(`  Pick a different name, or map it to a distinct id: lt ticket start ${name} --as ${id}-fix`));
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'ticket start: reserved id';
+        }
         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);
@@ -80,14 +93,55 @@ const StartCommand = {
         }
         info('');
         info(colors.bold(`Starting ticket "${id}"  →  ${ticketIdentity.slug}`));
-        info(colors.dim(`  branch:   ${branch}  (from ${baseRef})`));
+        info(colors.dim(`  branch:   ${branch}`));
         info(colors.dim(`  worktree: ${worktreePath}`));
         info('');
-        // 1. fetch + worktree (fresh branch from origin/dev → independent).
+        // 1. fetch, so the base ref below is resolved against the freshest remote
+        //    state. Best-effort: offline / auth-less repos still get their worktree
+        //    from whatever refs exist locally.
+        info(colors.dim('Fetching …'));
         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) {
+            warning(`git fetch failed (${e.message.split('\n')[0]}) — continuing with the local refs.`);
+        }
+        // 2. resolve the ref the fresh branch starts from. Only needed for a NEW
+        //    branch — an existing one is simply checked out into the worktree.
+        let baseRef = null;
+        if (!(0, dev_ticket_1.gitBranchExists)(mainRepoRoot, branch)) {
+            const explicit = typeof parameters.options.base === 'string' ? parameters.options.base : undefined;
+            const resolution = (0, dev_ticket_1.resolveBaseRef)(mainRepoRoot, explicit);
+            baseRef = resolution.ref;
+            if (!baseRef) {
+                // No base branch found (repos differ: `dev`, `develop`, `main`, …) — ask
+                // the user rather than failing on a guess. Non-interactive callers (CI /
+                // AI agents) must pass `--base` instead.
+                if (resolution.explicit) {
+                    error(`Base ref "${explicit}" does not exist in this repository.`);
+                }
+                else {
+                    error(`No base branch found — tried: ${resolution.candidates.join(', ')}`);
+                }
+                if ((0, workspace_integration_1.isNonInteractive)(Boolean(parameters.options.noConfirm))) {
+                    info(colors.dim(`  Pass one explicitly:  lt ticket start ${name} --base <ref>`));
+                    if (!parameters.options.fromGluegunMenu)
+                        process.exit(1);
+                    return 'ticket start: no base ref';
+                }
+                baseRef = yield askForBaseRef(toolbox, mainRepoRoot);
+                if (!baseRef) {
+                    if (!parameters.options.fromGluegunMenu)
+                        process.exit(1);
+                    return 'ticket start: no base ref';
+                }
+            }
+            info(colors.dim(`  base:     ${baseRef}`));
+        }
+        // 3. worktree (fresh branch from the base ref → independent).
+        try {
+            info(colors.dim(`Creating worktree${baseRef ? ` from ${baseRef}` : ` on existing branch ${branch}`} …`));
+            (0, dev_ticket_1.worktreeAdd)(mainRepoRoot, worktreePath, branch, baseRef !== null && baseRef !== void 0 ? baseRef : '');
         }
         catch (e) {
             error(`git worktree setup failed: ${e.message}`);
@@ -95,9 +149,9 @@ const StartCommand = {
                 process.exit(1);
             return 'ticket start: worktree failed';
         }
-        // 2. tag the worktree with its ticket id (makes lt dev * ticket-aware).
+        // 4. tag the worktree with its ticket id (makes lt dev * ticket-aware).
         (0, dev_ticket_1.writeTicketMarker)(worktreePath, id);
-        // 3. install deps. Auto-detects pnpm/yarn/npm from the worktree's
+        // 5. install deps. Auto-detects pnpm/yarn/npm from the worktree's
         // lockfile so an npm-only repo doesn't get a foreign pnpm-lock
         // injected on every ticket start.
         if (parameters.options.install !== false) {
@@ -109,7 +163,7 @@ const StartCommand = {
                 warning(`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
+        // 6. 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('');
@@ -140,4 +194,47 @@ const StartCommand = {
         return `ticket start: ${id}`;
     }),
 };
+/**
+ * Ask which ref the ticket branch should start from — the last resort when no
+ * base branch was found (repos name theirs differently: `dev`, `develop`,
+ * `main`, …). Offers the repo's branches (most recently committed first) plus a
+ * free-text escape hatch, and re-asks until the ref actually resolves, so a typo
+ * fails here instead of inside `git worktree add`.
+ */
+function askForBaseRef(toolbox, repoDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { print: { colors, info, warning }, prompt, } = toolbox;
+        const MANUAL = 'Other — type a ref …';
+        const choices = (0, dev_ticket_1.listBaseRefChoices)(repoDir);
+        for (let attempt = 0; attempt < 3; attempt++) {
+            let ref;
+            if (choices.length) {
+                const answer = yield prompt.ask({
+                    choices: [...choices, MANUAL],
+                    message: 'Which branch should this ticket start from?',
+                    name: 'ref',
+                    type: 'select',
+                });
+                ref = answer.ref;
+            }
+            // No branches at all (fresh repo), or the user picked the escape hatch.
+            if (!choices.length || ref === MANUAL) {
+                const answer = yield prompt.ask({
+                    message: 'Base ref (branch, tag or commit):',
+                    name: 'ref',
+                    type: 'input',
+                });
+                ref = (_a = answer.ref) === null || _a === void 0 ? void 0 : _a.trim();
+            }
+            if (!ref)
+                return null; // aborted / empty
+            if ((0, dev_ticket_1.gitRefExists)(repoDir, ref))
+                return ref;
+            warning(`"${ref}" does not resolve to a commit — pick another one.`);
+        }
+        info(colors.dim('  No usable base ref — aborting.'));
+        return null;
+    });
+}
 module.exports = StartCommand;