@lumoai/cli 1.10.0 → 1.15.0

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/next.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextCommand = nextCommand;
+exports.formatNextOutput = formatNextOutput;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const sanitize_1 = require("../lib/sanitize");
+const rank_tasks_1 = require("../lib/rank-tasks");
+/**
+ * `lumo next [-n, --count <N>]` — recommend the next task(s) to work on.
+ *
+ * Chains two read-only endpoints: active sprint ids (for a ranking boost) and
+ * "my tasks". The active-sprints call is non-fatal — if it fails we warn and
+ * rank without the sprint boost rather than aborting.
+ */
+async function nextCommand(opts) {
+    const count = opts.count !== undefined ? parseInt(opts.count, 10) : 3;
+    if (Number.isNaN(count) || count < 1) {
+        console.error(`Error: invalid --count "${opts.count}" (expected a positive integer)`);
+        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);
+    const authHeaders = { Authorization: `Bearer ${creds.token}` };
+    // 1. Active sprint ids — non-fatal. Failure just drops the sprint boost.
+    let activeSprintIds = new Set();
+    try {
+        const res = await fetch(`${base}/api/me/active-sprints`, {
+            headers: authHeaders,
+        });
+        if (res.ok) {
+            const data = (await res.json());
+            activeSprintIds = new Set(data.sprintIds);
+        }
+        else {
+            console.error(`Warning: could not load active sprints (HTTP ${res.status}); ranking without sprint boost.`);
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Warning: could not load active sprints (${msg}); ranking without sprint boost.`);
+    }
+    // 2. My tasks — fatal on failure.
+    let res;
+    try {
+        res = await fetch(`${base}/api/tasks/me`, { headers: authHeaders });
+    }
+    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) {
+        console.error(`Error: task fetch failed (HTTP ${res.status})`);
+        return 1;
+    }
+    const data = (await res.json());
+    const open = data.tasks.filter(t => t.status !== 'DONE');
+    const ranked = (0, rank_tasks_1.rankTasks)(open, activeSprintIds, new Date()).slice(0, count);
+    process.stdout.write(formatNextOutput(ranked, open.length) + '\n');
+}
+/**
+ * Render the ranked recommendation block. `ranked` is already sliced to the
+ * requested count; `totalOpen` is the count of all non-DONE tasks (for the
+ * "(of N open)" header). Pure — no I/O.
+ */
+function formatNextOutput(ranked, totalOpen) {
+    const first = ranked[0];
+    if (!first)
+        return 'No open tasks assigned to you. 🎉';
+    const widths = {
+        identifier: Math.max(...ranked.map(r => r.identifier.length)),
+        status: Math.max(...ranked.map(r => r.task.status.length)),
+        priority: Math.max(...ranked.map(r => r.task.priority.length)),
+    };
+    const plural = ranked.length === 1 ? '' : 's';
+    const lines = [
+        `Top ${ranked.length} recommended task${plural} (of ${totalOpen} open):`,
+        '',
+    ];
+    ranked.forEach((r, i) => {
+        lines.push(`${i + 1}. ${r.identifier.padEnd(widths.identifier)}  ` +
+            `${r.task.status.padEnd(widths.status)}  ` +
+            `${r.task.priority.padEnd(widths.priority)}  ` +
+            (0, sanitize_1.sanitizeField)(r.task.title));
+        lines.push(`     ↳ ${r.reasons.join(' · ')}`);
+    });
+    lines.push('');
+    lines.push(`Next: lumo session attach ${first.identifier} && lumo task context ${first.identifier}`);
+    if (ranked.length > 1) {
+        lines.push('（也可换成列表里任意一个 LUM-N）');
+    }
+    return lines.join('\n');
+}

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

@@ -4,13 +4,17 @@ exports.sessionWrap = sessionWrap;
 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. v1 has a single section: draft a progress comment
- * from this session's unposted turnSummaries and post it (after y/e/s
- * confirmation) to the bound task. Designed as a multi-section panel so
- * LUM-152's memory-review section slots in without touching this command.
+ * 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; (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;
@@ -24,7 +28,11 @@ async function sessionWrap(options) {
         console.error('Error: not logged in. Run `lumo auth login` first.');
         return 1;
     }
-    const sections = [new progress_comment_section_1.ProgressCommentSection({ creds, sessionId })];
+    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,
         dryRun: options.dryRun === true,

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/commands/wrap/memory-review-section.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryReviewSection = void 0;
+exports.parseReviewInstruction = parseReviewInstruction;
+const sanitize_1 = require("../../lib/sanitize");
+const line_prompt_1 = require("../../lib/line-prompt");
+const memory_content_1 = require("../../lib/memory-content");
+const session_memory_api_1 = require("../../lib/session-memory-api");
+/** Parse a one-line review instruction into 0-based row indices. */
+function parseReviewInstruction(line) {
+    const result = { deleteIdx: [], promoteIdx: [] };
+    const re = /([dp])\s*([\d,\s]+)/gi;
+    let m;
+    while ((m = re.exec(line)) !== null) {
+        const nums = m[2]
+            .split(/[\s,]+/)
+            .map(s => s.trim())
+            .filter(Boolean)
+            .map(s => parseInt(s, 10) - 1)
+            .filter(n => Number.isInteger(n) && n >= 0);
+        if (m[1].toLowerCase() === 'd')
+            result.deleteIdx.push(...nums);
+        else
+            result.promoteIdx.push(...nums);
+    }
+    return result;
+}
+/**
+ * Wrap-panel section that lists the Layer1 memories this session sedimented and
+ * lets the user delete noise / promote keepers to project scope. Keeps its own
+ * draft state between prepare() and run(). Dedup is server-side via watermark.
+ */
+class MemoryReviewSection {
+    deps;
+    title = '记忆审阅';
+    draft = null;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async prepare() {
+        this.draft = await (0, session_memory_api_1.fetchMemoryDraft)(this.deps.creds, this.deps.sessionId);
+        return this.draft.memories.length > 0;
+    }
+    async run(opts) {
+        const draft = this.draft;
+        if (!draft || !draft.watermark || draft.memories.length === 0)
+            return;
+        process.stdout.write(`本次会话新增了这 ${draft.memories.length} 条 memory：\n`);
+        process.stdout.write(`${(0, sanitize_1.sanitizeField)((0, memory_content_1.formatMemoryReviewList)(draft.memories))}\n`);
+        if (opts.dryRun) {
+            process.stdout.write('(dry-run，未改动)\n');
+            return;
+        }
+        if (opts.yes) {
+            await this.apply(draft.watermark, [], []);
+            return;
+        }
+        const line = (await (0, line_prompt_1.promptLine)('[回车] 全部保留  [d 1,3] 删除  [p 2] 提升到项目级  [s] 跳过 > ')).trim();
+        if (line.toLowerCase() === 's') {
+            process.stdout.write('已跳过本节。\n');
+            return;
+        }
+        if (line === '') {
+            await this.apply(draft.watermark, [], []);
+            return;
+        }
+        const { deleteIdx, promoteIdx } = parseReviewInstruction(line);
+        const inRange = (n) => n >= 0 && n < draft.memories.length;
+        const deleteIds = deleteIdx.filter(inRange).map(i => draft.memories[i].id);
+        const promoteIds = promoteIdx
+            .filter(inRange)
+            .map(i => draft.memories[i].id)
+            .filter(id => !deleteIds.includes(id));
+        await this.apply(draft.watermark, deleteIds, promoteIds);
+    }
+    async apply(watermark, deleteIds, promoteIds) {
+        const { deleted, promoted } = await (0, session_memory_api_1.applyMemoryReview)(this.deps.creds, this.deps.sessionId, { watermark, deleteIds, promoteIds });
+        process.stdout.write(`已删除 ${deleted} 条，提升 ${promoted} 条到项目级。\n`);
+    }
+}
+exports.MemoryReviewSection = MemoryReviewSection;

package/dist/cli/src/index.js

@@ -46,6 +46,7 @@ const session_attach_1 = require("./commands/session-attach");
 const session_detach_1 = require("./commands/session-detach");
 const session_status_1 = require("./commands/session-status");
 const session_wrap_1 = require("./commands/session-wrap");
+const next_1 = require("./commands/next");
 const task_context_1 = require("./commands/task-context");
 const task_create_1 = require("./commands/task-create");
 const task_update_1 = require("./commands/task-update");
@@ -78,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");
@@ -184,6 +189,11 @@ program
     .option('--force', 'Overwrite an existing SKILL.md when its contents 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
+    .command('next')
+    .description('Recommend the next task(s) to work on, ranked by priority, active sprint, and due date. Prints top N (default 3); pick one and run `session attach` + `task context`.')
+    .option('-n, --count <N>', 'Number of tasks to recommend (default 3)')
+    .action(wrap(options => (0, next_1.nextCommand)(options)));
 const session = program
     .command('session')
     .description('Manage per-terminal coding-session context');
@@ -405,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>')
@@ -437,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.')
@@ -453,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');

package/dist/cli/src/lib/failure-summary-api.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchFailureSummary = fetchFailureSummary;
+exports.markTaskBlocked = markTaskBlocked;
+const api_1 = require("./api");
+function base(creds) {
+    return (0, api_1.trimTrailingSlash)((0, api_1.resolveAuthedApiUrl)(creds.apiUrl));
+}
+/** GET the blocked-tag prompt draft for the session. Throws on transport / non-200. */
+async function fetchFailureSummary(creds, sessionId) {
+    const url = `${base(creds)}/api/sessions/${encodeURIComponent(sessionId)}/failure-summary`;
+    const res = await fetch(url, {
+        headers: { Authorization: `Bearer ${creds.token}` },
+    });
+    if (res.status === 401)
+        throw new Error('API key invalid or revoked. Run `lumo auth login`.');
+    if (!res.ok)
+        throw new Error(`failure summary fetch failed (HTTP ${res.status})`);
+    return (await res.json());
+}
+/** POST to attach the `blocked` tag to the session's bound task. Throws the server message on non-201. */
+async function markTaskBlocked(creds, sessionId) {
+    const url = `${base(creds)}/api/sessions/${encodeURIComponent(sessionId)}/mark-blocked`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${creds.token}` },
+    });
+    if (res.status === 401)
+        throw new Error('API key invalid or revoked. Run `lumo auth login`.');
+    if (res.status !== 201) {
+        let serverMsg = null;
+        try {
+            const errBody = (await res.json());
+            if (typeof errBody.error === 'string')
+                serverMsg = errBody.error;
+        }
+        catch {
+            // body wasn't JSON
+        }
+        throw new Error(serverMsg ?? `mark blocked failed (HTTP ${res.status})`);
+    }
+    return (await res.json());
+}

package/dist/cli/src/lib/hook-runner.js

@@ -115,6 +115,7 @@ function formatHookStdoutLines(path, responseBody, now = new Date()) {
         body.memorySection,
         body.linkedResourcesSection,
         body.reviewTodosSection,
+        body.layer2ReviewSection,
     ]);
     if (envelope)
         lines.push(envelope);

package/dist/cli/src/lib/memory-content.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildMemoryContent = buildMemoryContent;
 exports.formatMemoryList = formatMemoryList;
+exports.formatMemoryReviewList = formatMemoryReviewList;
 // Category/field metadata + builders for the `lumo memory` commands.
 // Mirrors the four content shapes validated server-side by parseMemoryContent.
 const sanitize_1 = require("./sanitize");
@@ -86,3 +87,9 @@ function formatMemoryList(rows) {
     })
         .join('\n');
 }
+/** Numbered review list: `  N. [SCOPE] CATEGORY  headline`. 1-indexed. */
+function formatMemoryReviewList(rows) {
+    return rows
+        .map((r, i) => `  ${i + 1}. [${r.scope}] ${r.category}  ${headline(r.category, r.content)}`)
+        .join('\n');
+}

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOrderedIds = resolveOrderedIds;
+exports.computeMoveOrder = computeMoveOrder;
+function findRef(ref, milestones) {
+    // Try by id first (exact match — milestone ids are cuids, unique).
+    const byId = milestones.find(m => m.id === ref);
+    if (byId)
+        return { kind: 'found', ref: byId };
+    // Then by name (case-insensitive). Names are NOT unique within a project
+    // (only slug is), so a name can match more than one milestone.
+    const needle = ref.trim().toLowerCase();
+    const hits = milestones.filter(m => m.name.toLowerCase() === needle);
+    if (hits.length === 0)
+        return { kind: 'not-found' };
+    if (hits.length === 1)
+        return { kind: 'found', ref: hits[0] };
+    return { kind: 'ambiguous', candidates: hits };
+}
+function ambiguousError(ref, candidates) {
+    const ids = candidates.map(c => c.id).join(', ');
+    return `ambiguous milestone name "${ref}" matches ${candidates.length} milestones; re-run with the id: ${ids}`;
+}
+/** Milestones in current display order (sortOrder asc, stable). */
+function sorted(milestones) {
+    return [...milestones].sort((a, b) => a.sortOrder - b.sortOrder);
+}
+/**
+ * Resolve a full list of milestone refs (name or UUID) to ids in the given
+ * order. The list must name EVERY milestone in the project exactly once.
+ */
+function resolveOrderedIds(refs, milestones) {
+    const ids = [];
+    const seen = new Set();
+    for (const ref of refs) {
+        const found = findRef(ref, milestones);
+        if (found.kind === 'not-found') {
+            return { ok: false, error: `unknown milestone: "${ref}"` };
+        }
+        if (found.kind === 'ambiguous') {
+            return { ok: false, error: ambiguousError(ref, found.candidates) };
+        }
+        const match = found.ref;
+        if (seen.has(match.id)) {
+            return { ok: false, error: `duplicate milestone: "${ref}"` };
+        }
+        seen.add(match.id);
+        ids.push(match.id);
+    }
+    if (ids.length !== milestones.length) {
+        const missing = milestones
+            .filter(m => !seen.has(m.id))
+            .map(m => m.name);
+        return {
+            ok: false,
+            error: `incomplete order: list every milestone. Missing: ${missing.join(', ')}`,
+        };
+    }
+    return { ok: true, orderedIds: ids };
+}
+/**
+ * Compute the full orderedIds after moving `moveRef` immediately before/after
+ * `targetRef` in the project's current order.
+ */
+function computeMoveOrder(moveRef, targetRef, position, milestones) {
+    const moveFound = findRef(moveRef, milestones);
+    if (moveFound.kind === 'not-found') {
+        return { ok: false, error: `unknown milestone: "${moveRef}"` };
+    }
+    if (moveFound.kind === 'ambiguous') {
+        return { ok: false, error: ambiguousError(moveRef, moveFound.candidates) };
+    }
+    const targetFound = findRef(targetRef, milestones);
+    if (targetFound.kind === 'not-found') {
+        return { ok: false, error: `unknown milestone: "${targetRef}"` };
+    }
+    if (targetFound.kind === 'ambiguous') {
+        return { ok: false, error: ambiguousError(targetRef, targetFound.candidates) };
+    }
+    const move = moveFound.ref;
+    const target = targetFound.ref;
+    if (move.id === target.id) {
+        return { ok: false, error: 'cannot move a milestone relative to itself' };
+    }
+    const order = sorted(milestones)
+        .map(m => m.id)
+        .filter(id => id !== move.id);
+    const targetIndex = order.indexOf(target.id);
+    const insertAt = position === 'before' ? targetIndex : targetIndex + 1;
+    order.splice(insertAt, 0, move.id);
+    return { ok: true, orderedIds: order };
+}