@lumoai/cli 1.11.0 → 1.17.0

package/dist/cli/src/commands/milestone-move.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.milestoneMove = milestoneMove;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const resolve_1 = require("../lib/resolve");
+const sanitize_1 = require("../lib/sanitize");
+const milestone_reorder_1 = require("../lib/milestone-reorder");
+async function milestoneMove(reference, opts) {
+    if (!reference) {
+        console.error('Error: usage: lumo milestone move <ref> --before <ref> | --after <ref>');
+        return 1;
+    }
+    const hasBefore = typeof opts.before === 'string' && opts.before.length > 0;
+    const hasAfter = typeof opts.after === 'string' && opts.after.length > 0;
+    if (hasBefore && hasAfter) {
+        console.error('Error: --before and --after are mutually exclusive');
+        return 1;
+    }
+    if (!hasBefore && !hasAfter) {
+        console.error('Error: specify --before <ref> or --after <ref>');
+        return 1;
+    }
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    const apiUrl = (0, api_1.resolveAuthedApiUrl)(creds.apiUrl);
+    const base = (0, api_1.trimTrailingSlash)(apiUrl);
+    let projectId;
+    try {
+        projectId = await (0, resolve_1.resolveProjectId)(base, creds.token, opts.project);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    const listRes = await fetch(`${base}/api/projects/${projectId}/milestones`, {
+        headers: { Authorization: `Bearer ${creds.token}` },
+    });
+    if (!listRes.ok) {
+        console.error(`Error: milestone list failed (HTTP ${listRes.status})`);
+        return 1;
+    }
+    const { milestones } = (await listRes.json());
+    const refRows = milestones.map(m => ({
+        id: m.id,
+        name: m.name,
+        sortOrder: m.sortOrder,
+    }));
+    const position = hasBefore ? 'before' : 'after';
+    const targetRef = (hasBefore ? opts.before : opts.after);
+    const resolved = (0, milestone_reorder_1.computeMoveOrder)(reference, targetRef, position, refRows);
+    if (!resolved.ok) {
+        console.error(`Error: ${resolved.error}`);
+        return 1;
+    }
+    const patchRes = await fetch(`${base}/api/projects/${projectId}/milestones/reorder`, {
+        method: 'PATCH',
+        headers: {
+            Authorization: `Bearer ${creds.token}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ orderedIds: resolved.orderedIds }),
+    });
+    if (!patchRes.ok) {
+        const text = await patchRes.text();
+        let msg = text;
+        try {
+            const json = JSON.parse(text);
+            if (json.error)
+                msg = json.error;
+        }
+        catch { }
+        console.error(`Error: ${patchRes.status} ${patchRes.statusText}: ${(0, sanitize_1.sanitizeField)(msg)}`);
+        return 1;
+    }
+    const byId = new Map(refRows.map(m => [m.id, m.name]));
+    console.log(`Moved "${(0, sanitize_1.sanitizeField)(reference)}" ${position} "${(0, sanitize_1.sanitizeField)(targetRef)}". New order:`);
+    resolved.orderedIds.forEach((id, i) => {
+        console.log(`  ${i + 1}. ${(0, sanitize_1.sanitizeField)(byId.get(id) ?? id)}`);
+    });
+}

package/dist/cli/src/commands/milestone-reorder.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.milestoneReorder = milestoneReorder;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const resolve_1 = require("../lib/resolve");
+const sanitize_1 = require("../lib/sanitize");
+const milestone_reorder_1 = require("../lib/milestone-reorder");
+async function milestoneReorder(refs, opts) {
+    if (!refs || refs.length === 0) {
+        console.error('Error: usage: lumo milestone reorder <ref...> [--project <ref>]');
+        return 1;
+    }
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    const apiUrl = (0, api_1.resolveAuthedApiUrl)(creds.apiUrl);
+    const base = (0, api_1.trimTrailingSlash)(apiUrl);
+    let projectId;
+    try {
+        projectId = await (0, resolve_1.resolveProjectId)(base, creds.token, opts.project);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    const listRes = await fetch(`${base}/api/projects/${projectId}/milestones`, {
+        headers: { Authorization: `Bearer ${creds.token}` },
+    });
+    if (!listRes.ok) {
+        console.error(`Error: milestone list failed (HTTP ${listRes.status})`);
+        return 1;
+    }
+    const { milestones } = (await listRes.json());
+    const refRows = milestones.map(m => ({
+        id: m.id,
+        name: m.name,
+        sortOrder: m.sortOrder,
+    }));
+    const resolved = (0, milestone_reorder_1.resolveOrderedIds)(refs, refRows);
+    if (!resolved.ok) {
+        console.error(`Error: ${resolved.error}`);
+        return 1;
+    }
+    const patchRes = await fetch(`${base}/api/projects/${projectId}/milestones/reorder`, {
+        method: 'PATCH',
+        headers: {
+            Authorization: `Bearer ${creds.token}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ orderedIds: resolved.orderedIds }),
+    });
+    if (!patchRes.ok) {
+        const text = await patchRes.text();
+        let msg = text;
+        try {
+            const json = JSON.parse(text);
+            if (json.error)
+                msg = json.error;
+        }
+        catch { }
+        console.error(`Error: ${patchRes.status} ${patchRes.statusText}: ${(0, sanitize_1.sanitizeField)(msg)}`);
+        return 1;
+    }
+    const byId = new Map(refRows.map(m => [m.id, m.name]));
+    console.log(`Reordered ${resolved.orderedIds.length} milestones:`);
+    resolved.orderedIds.forEach((id, i) => {
+        console.log(`  ${i + 1}. ${(0, sanitize_1.sanitizeField)(byId.get(id) ?? id)}`);
+    });
+}

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

@@ -7,9 +7,38 @@ const api_1 = require("../lib/api");
 const resolve_1 = require("../lib/resolve");
 const format_1 = require("../lib/format");
 const sanitize_1 = require("../lib/sanitize");
+const HEALTH_LABEL = {
+    'on-track': 'ON-TRACK',
+    'at-risk': 'AT-RISK',
+    overdue: 'OVERDUE',
+};
 function fmtDate(iso) {
     return iso ? iso.slice(0, 10) : '-';
 }
+function fmtHealth(health) {
+    return health ? HEALTH_LABEL[health] : '-';
+}
+function sprintCoverageLines(coverage) {
+    if (!coverage)
+        return [];
+    if (coverage.sprints.length === 0) {
+        return ['', 'Sprint coverage: (no sprint coverage)'];
+    }
+    const numW = Math.max(...coverage.sprints.map(s => `#${s.number}`.length));
+    const statusW = Math.max(...coverage.sprints.map(s => s.status.length));
+    const nameW = Math.max(...coverage.sprints.map(s => (0, sanitize_1.sanitizeField)(s.name).length));
+    const rows = coverage.sprints.map(s => {
+        const num = `#${s.number}`.padEnd(numW);
+        const status = s.status.padEnd(statusW);
+        const name = (0, sanitize_1.sanitizeField)(s.name).padEnd(nameW);
+        return `  ${num}  ${status}  ${name}   ${s.doneCount}/${s.taskCount} done`;
+    });
+    if (coverage.unsprinted > 0) {
+        const label = '未排期'.padEnd(numW + 2 + statusW + 2 + nameW);
+        rows.push(`  ${label}   ${coverage.unsprinted} task${coverage.unsprinted === 1 ? '' : 's'}`);
+    }
+    return ['', 'Sprint coverage:', ...rows];
+}
 function formatMilestoneShow(m, tasks) {
     const total = m.taskCounts.TODO +
         m.taskCounts.IN_PROGRESS +
@@ -18,6 +47,8 @@ function formatMilestoneShow(m, tasks) {
     const lines = [
         `Milestone:    ${(0, sanitize_1.sanitizeField)(m.name)}`,
         `Status:       ${m.status}`,
+        `Archived:     ${m.archivedAt ? m.archivedAt.slice(0, 10) : 'no'}`,
+        `Health:       ${fmtHealth(m.health)}`,
         `Start:        ${fmtDate(m.startDate)}`,
         `Target:       ${fmtDate(m.targetDate)}`,
         `Project:      ${(0, sanitize_1.sanitizeField)(m.projectName)}`,
@@ -26,6 +57,7 @@ function formatMilestoneShow(m, tasks) {
         ``,
         `Tasks:        ${total} total (TODO ${m.taskCounts.TODO} / IN_PROGRESS ${m.taskCounts.IN_PROGRESS} / IN_REVIEW ${m.taskCounts.IN_REVIEW} / DONE ${m.taskCounts.DONE})`,
     ];
+    lines.push(...sprintCoverageLines(m.sprintCoverage));
     if (tasks.length > 0) {
         lines.push('', (0, format_1.formatTaskListTable)(tasks));
     }
@@ -99,8 +131,11 @@ async function milestoneShow(identifier, opts) {
         status: milestone.status,
         startDate: milestone.startDate,
         targetDate: milestone.targetDate,
+        archivedAt: milestone.archivedAt,
         description: milestone.description,
         projectName,
         taskCounts: milestone.taskCounts,
+        health: milestone.health,
+        sprintCoverage: milestone.sprintCoverage,
     }, tasks) + '\n');
 }

package/dist/cli/src/commands/milestone-unarchive.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatUnarchiveResult = formatUnarchiveResult;
+exports.milestoneUnarchive = milestoneUnarchive;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const resolve_1 = require("../lib/resolve");
+const sanitize_1 = require("../lib/sanitize");
+function formatUnarchiveResult(name) {
+    return `Unarchived "${(0, sanitize_1.sanitizeField)(name)}"`;
+}
+async function milestoneUnarchive(identifier, opts) {
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    const apiUrl = (0, api_1.resolveAuthedApiUrl)(creds.apiUrl);
+    const base = (0, api_1.trimTrailingSlash)(apiUrl);
+    let milestoneId;
+    try {
+        const resolved = await (0, resolve_1.resolveMilestoneId)(base, creds.token, identifier, opts.project);
+        milestoneId = resolved.id;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    let res;
+    try {
+        res = await fetch(`${base}/api/milestones/${milestoneId}/unarchive`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${creds.token}` },
+        });
+    }
+    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.ok) {
+        let errMsg = `milestone unarchive failed (HTTP ${res.status})`;
+        try {
+            const body = (await res.json());
+            if (body.error)
+                errMsg = body.error;
+        }
+        catch {
+            // non-JSON body; keep the status-only message
+        }
+        console.error(`Error: ${(0, sanitize_1.sanitizeField)(errMsg)}`);
+        return 1;
+    }
+    const { milestone } = (await res.json());
+    process.stdout.write(formatUnarchiveResult(milestone.name) + '\n');
+}

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

@@ -5,14 +5,16 @@ const config_1 = require("../lib/config");
 const wrap_panel_1 = require("../lib/wrap-panel");
 const progress_comment_section_1 = require("./wrap/progress-comment-section");
 const memory_review_section_1 = require("./wrap/memory-review-section");
+const blocked_prompt_section_1 = require("./wrap/blocked-prompt-section");
 /**
  * `lumo session wrap [--yes] [--dry-run]`
  *
- * Session-end wrap-up panel with two sections, run in order: (1) draft a
+ * Session-end wrap-up panel with three sections, run in order: (1) draft a
  * progress comment from this session's unposted turnSummaries and post it
  * (after y/e/s confirmation) to the bound task; (2) review the Layer1 memories
  * this session sedimented — keep/delete/promote, deduped by a per-session
- * watermark.
+ * watermark; (3) if the session repeatedly hit the same failure, prompt whether
+ * to flag the bound task with a `blocked` tag (LUM-153, prompt-only).
  */
 async function sessionWrap(options) {
     const sessionId = process.env.CLAUDE_CODE_SESSION_ID;
@@ -29,6 +31,7 @@ async function sessionWrap(options) {
     const sections = [
         new progress_comment_section_1.ProgressCommentSection({ creds, sessionId }),
         new memory_review_section_1.MemoryReviewSection({ creds, sessionId }),
+        new blocked_prompt_section_1.BlockedPromptSection({ creds, sessionId }),
     ];
     await (0, wrap_panel_1.runWrapPanel)(sections, {
         yes: options.yes === true,

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/task-context.js

@@ -60,6 +60,10 @@ function formatTaskContextMarkdown(data, now) {
             ? `, target ${data.task.milestone.targetDate.slice(0, 10)}`
             : '';
         lines.push(`**Milestone**: ${(0, sanitize_1.sanitizeField)(data.task.milestone.name)} (${data.task.milestone.status}${target})`);
+        const milestoneGoal = data.task.milestone.description;
+        if (milestoneGoal && milestoneGoal.trim().length > 0) {
+            lines.push(`**Milestone goal**: ${(0, sanitize_1.sanitizeField)(milestoneGoal)}`);
+        }
     }
     const body = data.task.descriptionMarkdown ?? data.task.description;
     if (body && body.trim().length > 0) {

package/dist/cli/src/commands/task-update.js

@@ -186,14 +186,22 @@ async function taskUpdate(identifier, opts) {
     const hasPatchFields = flagsGiven.length > 0 || hasTagFields;
     if (hasPatchFields) {
         const patchUrl = `${base}/api/tasks/by-identifier/${encodeURIComponent(identifier)}`;
+        // When run inside a Claude Code session, pass its id so a status→DONE
+        // update attributes the resulting Layer 2 PROJECT memories to this
+        // session — the next session-start surfaces them for review (LUM-165).
+        // Absent outside Claude Code; the server treats the header as optional.
+        const headers = {
+            Authorization: `Bearer ${creds.token}`,
+            'Content-Type': 'application/json',
+        };
+        const sessionId = process.env.CLAUDE_CODE_SESSION_ID;
+        if (sessionId)
+            headers['X-Lumo-Session-Id'] = sessionId;
         let res;
         try {
             res = await fetch(patchUrl, {
                 method: 'PATCH',
-                headers: {
-                    Authorization: `Bearer ${creds.token}`,
-                    'Content-Type': 'application/json',
-                },
+                headers,
                 body: JSON.stringify(payload),
             });
         }

package/dist/cli/src/commands/wrap/blocked-prompt-section.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockedPromptSection = void 0;
+const sanitize_1 = require("../../lib/sanitize");
+const line_prompt_1 = require("../../lib/line-prompt");
+const failure_summary_api_1 = require("../../lib/failure-summary-api");
+/**
+ * Wrap-panel section (LUM-153) that detects repeated same-type failures in this
+ * session and *prompts* whether to flag the bound task with a `blocked` tag.
+ * Prompt-only by design — it never flips status automatically, and it only
+ * shows up when the server says `shouldPrompt` (≥ threshold failures, bound
+ * task, not already blocked). Confirming attaches the tag; the empty/`s`
+ * default does nothing, so a stray Enter never tags the task.
+ */
+class BlockedPromptSection {
+    deps;
+    title = '卡住检测';
+    draft = null;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async prepare() {
+        this.draft = await (0, failure_summary_api_1.fetchFailureSummary)(this.deps.creds, this.deps.sessionId);
+        return this.draft.shouldPrompt;
+    }
+    async run(opts) {
+        const draft = this.draft;
+        if (!draft || !draft.shouldPrompt || !draft.taskIdentifier)
+            return;
+        const top = draft.topFailure;
+        const where = top ? (0, sanitize_1.sanitizeField)(top.label) : '某个操作';
+        const count = top ? top.count : 0;
+        process.stdout.write(`看起来本次会话反复卡在 ${where}(${count} 次失败)。\n`);
+        if (top?.lastErrorSummary) {
+            process.stdout.write(`最后错误：${(0, sanitize_1.sanitizeField)(top.lastErrorSummary)}\n`);
+        }
+        if (opts.dryRun) {
+            process.stdout.write(`(dry-run，未改动；确认后会给 ${draft.taskIdentifier} 标 blocked)\n`);
+            return;
+        }
+        // Tagging the shared board is opt-in: it requires an explicit interactive
+        // `y`. `--yes` (and non-TTY, where promptLine returns empty) deliberately
+        // does NOT auto-tag — silently flipping shared board state is exactly what
+        // LUM-153 set out to avoid. We surface the suggestion and move on.
+        if (opts.yes) {
+            process.stdout.write(`(--yes 不自动标记；如确认请交互式回答 y，或手动 \`lumo task update ${draft.taskIdentifier} --add-tag blocked\`)\n`);
+            return;
+        }
+        const choice = (await (0, line_prompt_1.promptLine)(`要在 ${draft.taskIdentifier} 标 blocked 吗？[y] 标记  [s] 跳过 > `))
+            .trim()
+            .toLowerCase();
+        if (choice === 'y') {
+            await this.mark();
+            return;
+        }
+        // Empty / 's' / anything else → do nothing. Tagging is opt-in.
+        process.stdout.write('已跳过，未标记。\n');
+    }
+    async mark() {
+        const { taskIdentifier, tag } = await (0, failure_summary_api_1.markTaskBlocked)(this.deps.creds, this.deps.sessionId);
+        process.stdout.write(`已给 ${taskIdentifier} 标 ${tag}。\n`);
+    }
+}
+exports.BlockedPromptSection = BlockedPromptSection;

package/dist/cli/src/index.js

@@ -79,9 +79,13 @@ const milestone_create_1 = require("./commands/milestone-create");
 const milestone_show_1 = require("./commands/milestone-show");
 const milestone_update_1 = require("./commands/milestone-update");
 const milestone_delete_1 = require("./commands/milestone-delete");
+const milestone_archive_1 = require("./commands/milestone-archive");
+const milestone_unarchive_1 = require("./commands/milestone-unarchive");
 const milestone_add_1 = require("./commands/milestone-add");
 const milestone_remove_1 = require("./commands/milestone-remove");
 const milestone_summary_1 = require("./commands/milestone-summary");
+const milestone_reorder_1 = require("./commands/milestone-reorder");
+const milestone_move_1 = require("./commands/milestone-move");
 const sprint_create_1 = require("./commands/sprint-create");
 const sprint_list_1 = require("./commands/sprint-list");
 const sprint_show_1 = require("./commands/sprint-show");
@@ -182,7 +186,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
@@ -411,8 +415,11 @@ const milestoneCmd = program
     .description('Inspect milestones from the terminal');
 milestoneCmd
     .command('list')
-    .description('List milestones for a project. --project required when workspace has >1 project.')
+    .description('List milestones for a project. --project required when workspace has >1 project. By default only non-archived milestones are shown.')
     .option('--project <ref>', 'Project name or slug')
+    .option('--archived', 'Show only archived milestones')
+    .option('--all', 'Show both archived and non-archived milestones')
+    .option('--search <text>', 'Filter by name/description substring (case-insensitive)')
     .action(wrap(options => (0, milestone_list_1.milestoneList)(options)));
 milestoneCmd
     .command('create <name>')
@@ -443,6 +450,16 @@ milestoneCmd
     .option('--project <ref>', 'Project name or slug (when identifier is a name)')
     .option('--yes', 'Required: confirm deletion without TTY prompt')
     .action(wrap((identifier, options) => (0, milestone_delete_1.milestoneDelete)(identifier, options)));
+milestoneCmd
+    .command('archive <identifier>')
+    .description('Archive a milestone: hidden from `milestone list` by default, history and task links preserved, reversible with `milestone unarchive`. Identifier accepts UUID or name.')
+    .option('--project <ref>', 'Project name or slug (when identifier is a name)')
+    .action(wrap((identifier, options) => (0, milestone_archive_1.milestoneArchive)(identifier, options)));
+milestoneCmd
+    .command('unarchive <identifier>')
+    .description('Restore an archived milestone so it shows in `milestone list` again. Identifier accepts UUID or name.')
+    .option('--project <ref>', 'Project name or slug (when identifier is a name)')
+    .action(wrap((identifier, options) => (0, milestone_unarchive_1.milestoneUnarchive)(identifier, options)));
 milestoneCmd
     .command('add <identifier> <tasks...>')
     .description('Bind one or more tasks to a milestone in one call. <identifier> accepts a name or UUID; each <task> accepts LUM-N or UUID. Per-task result with a tally; partial failures do not roll back.')
@@ -459,6 +476,18 @@ milestoneCmd
     .option('--project <ref>', 'Project name or slug (when identifier is a name)')
     .option('--retry', 'Trigger summary regeneration before fetching')
     .action(wrap((identifier, options) => (0, milestone_summary_1.milestoneSummary)(identifier, options)));
+milestoneCmd
+    .command('reorder <refs...>')
+    .description("Reorder a project's milestones. Pass every milestone (name or UUID) in the desired order. --project required when workspace has >1 project.")
+    .option('--project <ref>', 'Project name or slug')
+    .action(wrap((refs, options) => (0, milestone_reorder_1.milestoneReorder)(refs, options)));
+milestoneCmd
+    .command('move <ref>')
+    .description('Move one milestone before or after another. --before and --after are mutually exclusive; exactly one is required. --project required when workspace has >1 project.')
+    .option('--project <ref>', 'Project name or slug')
+    .option('--before <ref>', 'Place <ref> immediately before this milestone')
+    .option('--after <ref>', 'Place <ref> immediately after this milestone')
+    .action(wrap((ref, options) => (0, milestone_move_1.milestoneMove)(ref, options)));
 const sprintCmd = program
     .command('sprint')
     .description('Inspect sprints from the terminal');