@lumoai/cli 1.15.0 → 1.18.0

package/dist/cli/src/commands/session-attach.js

@@ -4,6 +4,7 @@ exports.sessionAttach = sessionAttach;
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const sanitize_1 = require("../lib/sanitize");
+const line_prompt_1 = require("../lib/line-prompt");
 /**
  * `lumo session attach <identifier>` — bind the currently-running
  * Claude Code session to a task.
@@ -14,8 +15,15 @@ const sanitize_1 = require("../lib/sanitize");
  *
  * The binding lives entirely on the server (`Session.taskId`); subsequent
  * hooks read it back via the session row. The CLI keeps no local sentinel.
+ *
+ * Re-binding a session that's already attached to a *different* task no
+ * longer silently clobbers `Session.taskId` (LUM-266): the server returns
+ * the current binding and we confirm before overwriting —
+ *   - `--force` skips the prompt and overwrites directly;
+ *   - on a TTY we ask `已绑定 LUM-X，覆盖为 LUM-Y? [y/N]`;
+ *   - off a TTY (the usual agent case) we refuse and point at `--force`.
  */
-async function sessionAttach(identifier) {
+async function sessionAttach(identifier, options = {}) {
     if (!identifier) {
         console.error('Error: missing <identifier>. Usage: lumo session attach <LUM-42>');
         return 1;
@@ -33,48 +41,79 @@ async function sessionAttach(identifier) {
     }
     const apiUrl = (0, api_1.resolveAuthedApiUrl)(creds.apiUrl);
     const url = `${(0, api_1.trimTrailingSlash)(apiUrl)}/api/sessions/${encodeURIComponent(sessionId)}/bind-task`;
-    let res;
-    try {
-        res = await fetch(url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${creds.token}`,
-            },
-            body: JSON.stringify({ taskIdentifier: identifier }),
-        });
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
-        return 1;
-    }
-    if (res.status === 401) {
-        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
-        return 1;
-    }
-    if (res.status === 404) {
-        let message = 'Not found';
+    const bind = async (force) => {
+        let res;
         try {
-            const body = (await res.json());
-            if (body.error)
-                message = body.error;
+            res = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${creds.token}`,
+                },
+                body: JSON.stringify({ taskIdentifier: identifier, force }),
+            });
         }
-        catch {
-            // fall through
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+            return { ok: false, code: 1 };
         }
-        console.error(`Error: ${(0, sanitize_1.sanitizeField)(message)}`);
-        return 1;
+        if (res.status === 401) {
+            console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+            return { ok: false, code: 1 };
+        }
+        if (res.status === 404) {
+            let message = 'Not found';
+            try {
+                const data = (await res.json());
+                if (data.error)
+                    message = data.error;
+            }
+            catch {
+                // fall through
+            }
+            console.error(`Error: ${(0, sanitize_1.sanitizeField)(message)}`);
+            return { ok: false, code: 1 };
+        }
+        if (!res.ok) {
+            console.error(`Error: bind-task failed (HTTP ${res.status})`);
+            return { ok: false, code: 1 };
+        }
+        return { ok: true, body: (await res.json()) };
+    };
+    // First attempt. `--force` overwrites unconditionally; otherwise the server
+    // may answer `already-bound` so we can confirm before clobbering.
+    const first = await bind(options.force === true);
+    if (!first.ok)
+        return first.code;
+    let body = first.body;
+    if (body.status === 'already-bound') {
+        // Reached only when not forced (force=true would have overwritten).
+        if (!process.stdin.isTTY) {
+            console.error(`Session already bound to ${body.currentTaskIdentifier} "${(0, sanitize_1.sanitizeField)(body.currentTaskTitle)}". ` +
+                `Not overwriting. Re-run with --force to switch to ${identifier} ` +
+                '(or run `lumo session detach` first).');
+            return 0;
+        }
+        const answer = await (0, line_prompt_1.promptLine)(`已绑定 ${body.currentTaskIdentifier}，覆盖为 ${identifier}? [y/N] `);
+        if (!/^y(es)?$/i.test(answer)) {
+            console.log(`已取消，仍绑定 ${body.currentTaskIdentifier}。`);
+            return 0;
+        }
+        const second = await bind(true);
+        if (!second.ok)
+            return second.code;
+        body = second.body;
     }
-    if (!res.ok) {
-        console.error(`Error: bind-task failed (HTTP ${res.status})`);
+    if (body.status === 'already-bound') {
+        // Defensive: a forced bind should never report already-bound.
+        console.error(`Error: bind did not take effect (still bound to ${body.currentTaskIdentifier}).`);
         return 1;
     }
-    const result = (await res.json());
-    console.log(`Attached session ${sessionId} to ${result.taskIdentifier} "${(0, sanitize_1.sanitizeField)(result.taskTitle)}"`);
-    console.log(`Re-tagged ${result.retaggedEventCount} previously-untagged event${result.retaggedEventCount === 1 ? '' : 's'} in this session.`);
-    if (result.memorySection !== '') {
+    console.log(`Attached session ${sessionId} to ${body.taskIdentifier} "${(0, sanitize_1.sanitizeField)(body.taskTitle)}"`);
+    console.log(`Re-tagged ${body.retaggedEventCount} previously-untagged event${body.retaggedEventCount === 1 ? '' : 's'} in this session.`);
+    if (body.memorySection !== '') {
         console.log('');
-        console.log((0, sanitize_1.sanitizeField)(result.memorySection));
+        console.log((0, sanitize_1.sanitizeField)(body.memorySection));
     }
 }

package/dist/cli/src/commands/setup.js

@@ -103,33 +103,57 @@ async function resolveScope(options) {
     process.stderr.write(`Unrecognized choice "${answer}". Aborting.\n`);
     return null;
 }
+// Recursively list files under `dir` as paths relative to `base`.
+function listSkillFiles(dir, base = dir) {
+    const out = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            out.push(...listSkillFiles(full, base));
+        else if (entry.isFile())
+            out.push(path.relative(base, full));
+    }
+    return out;
+}
+function filesEqual(src, dst) {
+    if (!fs.existsSync(dst))
+        return false;
+    if (fs.statSync(src).size !== fs.statSync(dst).size)
+        return false;
+    return fs.readFileSync(src).equals(fs.readFileSync(dst));
+}
 function installSkill(claudeDir, force) {
     const skillDir = path.join(claudeDir, 'skills', 'lumo');
-    const skillDst = path.join(skillDir, 'SKILL.md');
-    // Asset bundled in cli/assets/skill.md, shipped via package.json "files".
-    // From dist/cli/src/commands/setup.js → ../../../../assets/skill.md
-    const skillSrc = path.resolve(__dirname, '../../../..', 'assets', 'skill.md');
-    if (!fs.existsSync(skillSrc)) {
-        throw new Error(`Bundled skill asset missing at ${skillSrc} — reinstall @lumoai/cli.`);
-    }
-    fs.mkdirSync(skillDir, { recursive: true });
-    if (fs.existsSync(skillDst) && !force) {
-        const srcStat = fs.statSync(skillSrc);
-        const dstStat = fs.statSync(skillDst);
-        if (srcStat.size === dstStat.size) {
-            const a = fs.readFileSync(skillSrc, 'utf8');
-            const b = fs.readFileSync(skillDst, 'utf8');
-            if (a === b) {
-                process.stdout.write(`✓ skill already up to date: ${skillDst}\n`);
-                return;
-            }
+    const skillDstMain = path.join(skillDir, 'SKILL.md');
+    // The skill is a directory (SKILL.md + references/*.md) bundled in
+    // cli/assets/skill/, shipped via package.json "files".
+    // From dist/cli/src/commands/setup.js → ../../../../assets/skill
+    const skillSrcDir = path.resolve(__dirname, '../../../..', 'assets', 'skill');
+    if (!fs.existsSync(path.join(skillSrcDir, 'SKILL.md'))) {
+        throw new Error(`Bundled skill asset missing at ${skillSrcDir} — reinstall @lumoai/cli.`);
+    }
+    const relFiles = listSkillFiles(skillSrcDir);
+    // Non-force, install already present: only overwrite when something differs,
+    // and then only with --force.
+    if (fs.existsSync(skillDstMain) && !force) {
+        const allMatch = relFiles.every(rel => filesEqual(path.join(skillSrcDir, rel), path.join(skillDir, rel)));
+        if (allMatch) {
+            process.stdout.write(`✓ skill already up to date: ${skillDir}\n`);
+            return;
         }
-        process.stdout.write(`⚠ ${skillDst} exists and differs from the bundled version.\n` +
+        process.stdout.write(`⚠ ${skillDir} exists and differs from the bundled version.\n` +
             `  Re-run with --force to overwrite.\n`);
         return;
     }
-    fs.copyFileSync(skillSrc, skillDst);
-    process.stdout.write(`✓ wrote skill: ${skillDst}\n`);
+    // Fresh install or --force: replace the managed references/ dir wholesale so
+    // stale reference files don't linger, then copy every bundled file.
+    fs.rmSync(path.join(skillDir, 'references'), { recursive: true, force: true });
+    for (const rel of relFiles) {
+        const dst = path.join(skillDir, rel);
+        fs.mkdirSync(path.dirname(dst), { recursive: true });
+        fs.copyFileSync(path.join(skillSrcDir, rel), dst);
+    }
+    process.stdout.write(`✓ wrote skill (${relFiles.length} files): ${skillDir}\n`);
 }
 function mergeSettings(claudeDir, agentToken) {
     const settingsPath = path.join(claudeDir, 'settings.json');
@@ -172,7 +196,11 @@ function installGitHook(projectRoot) {
         printGitHookManualInstructions(coreHooksPath);
         return;
     }
-    const hooksDirRaw = gitCapture(projectRoot, ['rev-parse', '--git-path', 'hooks']);
+    const hooksDirRaw = gitCapture(projectRoot, [
+        'rev-parse',
+        '--git-path',
+        'hooks',
+    ]);
     if (!hooksDirRaw) {
         process.stdout.write('⚠ could not resolve git hooks dir — skipped prepare-commit-msg hook.\n');
         return;

package/dist/cli/src/commands/sprint-show.js

@@ -10,7 +10,15 @@ const sanitize_1 = require("../lib/sanitize");
 function fmtDate(iso) {
     return iso ? iso.slice(0, 10) : '-';
 }
-function formatSprintShow(s, progress, tasks) {
+function blockerLine(label, items) {
+    if (items.length === 0)
+        return null;
+    const rendered = items
+        .map(i => `${i.identifier} ${(0, sanitize_1.sanitizeField)(i.title)}`)
+        .join(', ');
+    return `  ${label.padEnd(11)}${rendered}`;
+}
+function formatSprintShow(s, progress, tasks, risk, topBlockers) {
     const lines = [
         `Sprint:    #${s.number} ${(0, sanitize_1.sanitizeField)(s.name)}`,
         `Status:    ${s.status}`,
@@ -22,6 +30,27 @@ function formatSprintShow(s, progress, tasks) {
         ``,
         `Progress:  ${progress.done} / ${progress.total}`,
     ];
+    if (risk) {
+        lines.push(`Health:    ${risk.level.toUpperCase()}`);
+        for (const r of risk.reasons) {
+            lines.push(`  - ${(0, sanitize_1.sanitizeField)(r.detail)}`);
+        }
+    }
+    if (topBlockers) {
+        const blockerLines = [
+            blockerLine('Overdue:', topBlockers.overdueTaskIds),
+            blockerLine('Stalled:', topBlockers.stalledTaskIds),
+            blockerLine('Agent fail:', topBlockers.failingAgentTaskIds),
+            topBlockers.staleOpenPrNumbers.length > 0
+                ? `  ${'Stale PRs:'.padEnd(11)}${topBlockers.staleOpenPrNumbers
+                    .map(n => `#${n}`)
+                    .join(', ')}`
+                : null,
+        ].filter((l) => l !== null);
+        if (blockerLines.length > 0) {
+            lines.push('Blockers:', ...blockerLines);
+        }
+    }
     if (tasks.length > 0) {
         lines.push('', (0, format_1.formatTaskListTable)(tasks));
     }
@@ -75,7 +104,7 @@ async function sprintShow(identifier, opts) {
         console.error(`Error: sprint tasks failed (HTTP ${tasksRes.status})`);
         return 1;
     }
-    const { sprint, progress } = (await sprintRes.json());
+    const { sprint, progress, risk, topBlockers } = (await sprintRes.json());
     const { tasks } = (await tasksRes.json());
-    process.stdout.write(formatSprintShow(sprint, progress, tasks) + '\n');
+    process.stdout.write(formatSprintShow(sprint, progress, tasks, risk, topBlockers) + '\n');
 }

package/dist/cli/src/commands/worktree-add.js

@@ -0,0 +1,108 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.worktreeAdd = worktreeAdd;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const worktree_1 = require("../lib/worktree");
+function printGuidance(dir, branch) {
+    console.log('');
+    console.log(`✓ Worktree ready: ${dir}`);
+    console.log(`  branch:        ${branch}`);
+    console.log(`  node_modules:  symlinked to main checkout`);
+    console.log('');
+    console.log('Next:');
+    console.log(`  cd ${dir}`);
+    console.log('');
+    console.log('Gotchas baked into this worktree:');
+    console.log('  • prisma: the generated client is SHARED via the node_modules symlink.');
+    console.log("          Don't run `prisma generate` mid-work across parallel worktrees;");
+    console.log('          verify with jest, and do generate+tsc atomically once at the end.');
+    console.log('  • jest:   always run it from INSIDE this worktree (cd first), or the');
+    console.log('          cli/package.json haste collision silently runs the wrong tests.');
+}
+async function worktreeAdd(rawId, slug, opts) {
+    const taskId = (0, worktree_1.normalizeTaskId)(rawId);
+    if (!taskId) {
+        console.error(`Error: "${rawId}" is not a task id (expected LUM-N or N)`);
+        return 1;
+    }
+    if (!(0, worktree_1.isMainCheckout)()) {
+        console.error('Error: run `lumo worktree add` from the main checkout, not inside a worktree');
+        return 1;
+    }
+    const root = (0, worktree_1.getRepoRoot)();
+    const branch = (0, worktree_1.deriveBranchName)(taskId, slug);
+    const dir = path.join(root, '.worktrees', (0, worktree_1.deriveWorktreeDirName)(taskId, slug));
+    if (fs.existsSync(dir)) {
+        console.error(`Error: ${dir} already exists — remove it first or pick a different slug`);
+        return 1;
+    }
+    fs.mkdirSync(path.dirname(dir), { recursive: true });
+    const base = opts.base ?? 'origin/main';
+    if (!opts.noFetch && !opts.base) {
+        console.log('Fetching origin/main …');
+        if ((0, worktree_1.runGit)(['fetch', 'origin', 'main'], root).status !== 0) {
+            console.error(`Warning: git fetch failed; branching off the existing local ${base} (may be stale)`);
+        }
+    }
+    const branchExists = (0, worktree_1.runGit)(['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`], root)
+        .status === 0;
+    const addArgs = branchExists
+        ? ['worktree', 'add', dir, branch]
+        : ['worktree', 'add', dir, '-b', branch, base];
+    const added = (0, worktree_1.runGit)(addArgs, root);
+    if (added.status !== 0) {
+        console.error(`Error: ${(added.stderr || '').trim() || 'git worktree add failed'}`);
+        return 1;
+    }
+    const srcModules = path.join(root, 'node_modules');
+    if (fs.existsSync(srcModules)) {
+        fs.symlinkSync(srcModules, path.join(dir, 'node_modules'));
+    }
+    else {
+        console.log('Warning: main checkout has no node_modules; run `npm install` there, then symlink manually');
+    }
+    printGuidance(dir, branch);
+    if (opts.verify) {
+        console.log('Running baseline jest …');
+        const j = (0, child_process_1.spawnSync)('npx', ['jest'], { cwd: dir, stdio: 'inherit' });
+        if (j.status !== 0) {
+            console.error('Warning: baseline jest did not pass cleanly');
+        }
+    }
+    return 0;
+}

package/dist/cli/src/commands/worktree-list.js

@@ -0,0 +1,73 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.worktreeList = worktreeList;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const worktree_1 = require("../lib/worktree");
+const git_task_1 = require("../lib/git-task");
+function nodeModulesLinked(dir) {
+    try {
+        return fs.lstatSync(path.join(dir, 'node_modules')).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+/** Pull a LUM-N from a worktree dir basename or its branch, else '—'. */
+function taskIdOf(dirBase, branch) {
+    return ((0, git_task_1.matchTaskIdentifier)(dirBase) ??
+        (branch ? (0, git_task_1.matchTaskIdentifier)(branch) : null) ??
+        '—');
+}
+async function worktreeList() {
+    const mainRoot = path.dirname((0, worktree_1.getGitCommonDir)());
+    const worktreesDir = path.join(mainRoot, '.worktrees');
+    const entries = (0, worktree_1.parseWorktreePorcelain)((0, worktree_1.gitOutput)(['worktree', 'list', '--porcelain'], mainRoot)).filter(e => e.path.startsWith(worktreesDir + path.sep));
+    if (entries.length === 0) {
+        console.log('(no worktrees under .worktrees/)');
+        return 0;
+    }
+    for (const e of entries) {
+        const base = path.basename(e.path);
+        const id = taskIdOf(base, e.branch);
+        const dirty = (0, worktree_1.gitOutput)(['status', '--porcelain'], e.path).length > 0
+            ? 'dirty'
+            : 'clean';
+        const nm = nodeModulesLinked(e.path) ? 'linked' : 'MISSING';
+        console.log(`${id}\t${e.branch ?? '(detached)'}\t${dirty}\tnode_modules:${nm}\t${e.path}`);
+    }
+    return 0;
+}

package/dist/cli/src/commands/worktree-rm.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.worktreeRm = worktreeRm;
+const worktree_1 = require("../lib/worktree");
+async function worktreeRm(rawId, opts) {
+    const taskId = (0, worktree_1.normalizeTaskId)(rawId);
+    if (!taskId) {
+        console.error(`Error: "${rawId}" is not a task id (expected LUM-N or N)`);
+        return 1;
+    }
+    if (!(0, worktree_1.isMainCheckout)()) {
+        console.error('Error: run `lumo worktree rm` from the main checkout, not inside a worktree');
+        return 1;
+    }
+    const root = (0, worktree_1.getRepoRoot)();
+    const entries = (0, worktree_1.parseWorktreePorcelain)((0, worktree_1.gitOutput)(['worktree', 'list', '--porcelain'], root));
+    const target = (0, worktree_1.findWorktreeByTaskId)(entries, taskId);
+    if (!target) {
+        console.error(`Error: no worktree found for ${taskId}`);
+        return 1;
+    }
+    if (!opts.yes) {
+        console.error(`Error: refusing to remove ${target.path} without --yes (destructive)`);
+        return 1;
+    }
+    const dirty = (0, worktree_1.gitOutput)(['status', '--porcelain'], target.path).length > 0;
+    if (dirty && !opts.force) {
+        console.error(`Error: ${target.path} has uncommitted changes — pass --force to remove anyway`);
+        return 1;
+    }
+    const removeArgs = dirty && opts.force
+        ? ['worktree', 'remove', '--force', target.path]
+        : ['worktree', 'remove', target.path];
+    const removed = (0, worktree_1.runGit)(removeArgs, root);
+    if (removed.status !== 0) {
+        console.error(`Error: ${(removed.stderr || '').trim() || 'git worktree remove failed'}`);
+        return 1;
+    }
+    console.log(`✓ Removed worktree ${target.path}`);
+    if (opts.deleteBranch && target.branch) {
+        const del = (0, worktree_1.runGit)(['branch', '-d', target.branch], root);
+        if (del.status !== 0) {
+            console.error(`Warning: could not delete branch ${target.branch}: ${(del.stderr || '').trim()}`);
+        }
+        else {
+            console.log(`✓ Deleted branch ${target.branch}`);
+        }
+    }
+    else if (target.branch) {
+        console.log(`  branch ${target.branch} kept (use --delete-branch to remove)`);
+    }
+    return 0;
+}

package/dist/cli/src/index.js

@@ -111,6 +111,9 @@ const doc_share_list_1 = require("./commands/doc-share-list");
 const doc_move_1 = require("./commands/doc-move");
 const update_1 = require("./commands/update");
 const setup_1 = require("./commands/setup");
+const worktree_add_1 = require("./commands/worktree-add");
+const worktree_rm_1 = require("./commands/worktree-rm");
+const worktree_list_1 = require("./commands/worktree-list");
 const update_check_1 = require("./lib/update-check");
 const sanitize_1 = require("./lib/sanitize");
 // Resolve package.json relative to __dirname so this works regardless of how
@@ -186,7 +189,7 @@ program
     .description('Install the Lumo Claude Code skill and wire hook handlers into .claude/settings.json. Run via `npx @lumoai/cli setup` for first-time onboarding.')
     .option('--user', 'Install into ~/.claude (applies across all projects for this user)')
     .option('--project', 'Install into ./.claude (applies to the current project only)')
-    .option('--force', 'Overwrite an existing SKILL.md when its contents differ from the bundled version')
+    .option('--force', 'Overwrite existing skill files (SKILL.md + references/) when they differ from the bundled version')
     .option('--agent <token>', 'Coding agent these hooks run under (claude-code, codex, cursor, gemini-cli, github-copilot, windsurf). Baked into every hook command. Defaults to claude-code.')
     .action(wrap(options => (0, setup_1.setup)(options)));
 program
@@ -199,8 +202,9 @@ const session = program
     .description('Manage per-terminal coding-session context');
 session
     .command('attach <identifier>')
-    .description('Attach the currently-running Claude Code session (CLAUDE_CODE_SESSION_ID) to a task. Sets Session.taskId server-side and re-tags untagged hook events.')
-    .action(wrap(identifier => (0, session_attach_1.sessionAttach)(identifier)));
+    .description('Attach the currently-running Claude Code session (CLAUDE_CODE_SESSION_ID) to a task. Sets Session.taskId server-side and re-tags untagged hook events. If the session is already bound to a different task, confirms before overwriting (use --force to skip).')
+    .option('--force', 'Overwrite an existing binding to a different task without confirmation (skips the [y/N] prompt).')
+    .action(wrap((identifier, options) => (0, session_attach_1.sessionAttach)(identifier, options)));
 session
     .command('status')
     .description('Show the task currently bound to this Claude Code session (or "no task" if none).')
@@ -654,6 +658,34 @@ task
     .option('--remove-tag <name>', 'Remove tag by name (repeatable). Unknown names are find-or-create, so prefer --remove-tag-id to avoid orphan rows.', collect, [])
     .option('--remove-tag-id <cuid>', 'Remove tag by id (repeatable). Unknown ids are a no-op.', collect, [])
     .action(wrap((identifier, options) => (0, task_update_1.taskUpdate)(identifier, options)));
+const worktree = program
+    .command('worktree')
+    .description('Scaffold, remove, and list parallel git worktrees under .worktrees/ (node_modules symlink + prisma/jest gotcha guidance). Local dev tooling; run from the main checkout.');
+worktree
+    .command('add <identifier> [slug]')
+    .description('Create a worktree at .worktrees/<LUM-N>[-slug] on branch lumo/<LUM-N>[-slug] off origin/main, symlink node_modules to the main checkout, and print prisma/jest guidance. Run from the main checkout.')
+    .option('--base <ref>', 'Branch off this ref instead of origin/main (skips fetch)')
+    .option('--no-fetch', 'Do not `git fetch origin main` before branching')
+    .option('--verify', 'Run `npx jest` in the new worktree to confirm a clean baseline')
+    .action(wrap((identifier, slug, options) => {
+    const o = options;
+    return (0, worktree_add_1.worktreeAdd)(identifier, slug, {
+        base: o.base,
+        noFetch: o.fetch === false,
+        verify: o.verify,
+    });
+}));
+worktree
+    .command('rm <identifier>')
+    .description('Remove the worktree for a task (git worktree remove). Requires --yes. Refuses a dirty worktree unless --force. Keeps the branch unless --delete-branch.')
+    .option('--yes', 'Confirm removal (required, no interactive prompt)')
+    .option('--force', 'Remove even with uncommitted changes')
+    .option('--delete-branch', 'Also delete the branch (git branch -d; refuses if unmerged)')
+    .action(wrap((identifier, options) => (0, worktree_rm_1.worktreeRm)(identifier, options)));
+worktree
+    .command('list')
+    .description('List worktrees under .worktrees/: task id, branch, dirty state, and whether node_modules is symlinked.')
+    .action(wrap(() => (0, worktree_list_1.worktreeList)()));
 // Claude Code invokes `lumo hook <type>` per tool call, so these handlers
 // must never crash the caller. Two invariants keep us safe:
 //   1. `hookCommand` is stderr-silent and never throws (it catches internally