@lumoai/cli 1.54.0 → 1.56.0

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

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPlanDeepLink = formatPlanDeepLink;
+exports.stageLabel = stageLabel;
+exports.plan = plan;
+exports.planStatus = planStatus;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const sanitize_1 = require("../lib/sanitize");
+const browser_1 = require("../lib/browser");
+/**
+ * Web deep-link to a run's converter page: `/workspace/<slug>/plan/<runId>`.
+ * The page routes to whichever gate is open on the run — so the same link is
+ * "gate A" at start (run in CLUSTERING) and "the next gate" mid-run. Editing
+ * and gate confirmation happen in the web UI; the CLI only carries the human
+ * there.
+ */
+function formatPlanDeepLink(base, workspaceSlug, runId) {
+    return `${(0, api_1.trimTrailingSlash)(base)}/workspace/${workspaceSlug}/plan/${runId}`;
+}
+/**
+ * Human label for a run stage. The gates (`*_READY`) name the decision waiting
+ * on the human; the working stages name the LLM segment in flight. Unknown /
+ * future stages fall back to the raw enum so nothing is silently swallowed.
+ */
+function stageLabel(stage) {
+    const LABELS = {
+        CLUSTERING: '聚类中 (clustering)',
+        CLUSTERS_READY: '闸门 A · 聚类待确认 (gate A — confirm clusters)',
+        ALIGNING: '对齐中 (aligning)',
+        ALIGNMENT_READY: '闸门 B · 对齐待确认 (gate B — confirm alignment)',
+        GENERATING: '成计划中 (generating)',
+        DRAFT_READY: '闸门 C · 草案待确认 (gate C — confirm draft)',
+        FAILED: '失败 · 可重试 (failed — retryable)',
+    };
+    return LABELS[stage] ?? stage;
+}
+/**
+ * `lumo plan [--abandon-active]` — start a design-thinking 转换器 run.
+ *
+ * Starts a run and prints (and opens) the gate-A web deep-link. When a run is
+ * already active the server refuses (409) — we point the user at
+ * `lumo plan status` or `--abandon-active`. `--abandon-active` first abandons
+ * the prior run, then starts a fresh one. All editing/confirmation is in web;
+ * the CLI only triggers and hands off the deep-link.
+ */
+async function plan(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);
+    const body = {};
+    if (opts.abandonActive)
+        body.abandonActive = true;
+    let res;
+    try {
+        res = await fetch(`${base}/api/plan-runs`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${creds.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+    }
+    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 === 409) {
+        console.error('Error: a plan run is already active for your team.\n' +
+            '  Check it with `lumo plan status`, or start over with ' +
+            '`lumo plan --abandon-active`.');
+        return 1;
+    }
+    if (res.status === 201) {
+        const { run } = (await res.json());
+        const deepLink = formatPlanDeepLink(base, creds.workspaceSlug, run.id);
+        process.stdout.write(`✓ 计划转换 run 已启动 (${run.id}) — 聚类进行中。\n` +
+            '到闸门 A 在 web 端确认聚类结果:\n' +
+            `  ${(0, sanitize_1.sanitizeField)(deepLink)}\n`);
+        (0, browser_1.openBrowser)(deepLink);
+        return;
+    }
+    return reportServerError(res);
+}
+/**
+ * `lumo plan status` — where the active run stands.
+ *
+ * Prints the active run's current stage and the deep-link to act on its next
+ * gate. With no active run, prompts the user to run `lumo plan`.
+ */
+async function planStatus() {
+    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 res;
+    try {
+        res = await fetch(`${base}/api/plan-runs/active`, {
+            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) {
+        return reportServerError(res);
+    }
+    const { run } = (await res.json());
+    if (!run) {
+        process.stdout.write('没有进行中的计划转换 run。运行 `lumo plan` 启动一个。\n');
+        return;
+    }
+    const deepLink = formatPlanDeepLink(base, creds.workspaceSlug, run.id);
+    process.stdout.write(`计划转换 run ${run.id}\n` +
+        `  当前 stage: ${stageLabel(run.stage)}\n` +
+        '  下一个闸门在 web 端处理:\n' +
+        `  ${(0, sanitize_1.sanitizeField)(deepLink)}\n`);
+    return;
+}
+/** Print a server error body (or status-only fallback) to stderr; returns 1. */
+async function reportServerError(res) {
+    let serverMsg = null;
+    try {
+        const errBody = (await res.json());
+        if (typeof errBody.error === 'string')
+            serverMsg = errBody.error;
+    }
+    catch {
+        // Body wasn't JSON; fall through to a status-only message.
+    }
+    if (serverMsg) {
+        console.error(`Error: ${(0, sanitize_1.sanitizeField)(serverMsg)}`);
+    }
+    else {
+        console.error(`Error: plan command failed (HTTP ${res.status})`);
+    }
+    return 1;
+}

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 next_steps_1 = require("../lib/next-steps");
 const resolve_project_1 = require("../lib/resolve-project");
 const memory_auto_1 = require("../lib/memory-auto");
 /**
@@ -166,6 +167,9 @@ async function sessionAttach(identifier, options) {
     catch {
         // best-effort — the bind already succeeded; never surface a sync error here
     }
+    // Last, after the contract/memory/sync sections — the block reads as the
+    // closing "so do this now" line rather than interrupting them (LUM-686).
+    (0, next_steps_1.emitNextSteps)(body.nextSteps ?? [], options ?? {});
 }
 /**
  * LUM-640: the `--steward` form — bind this session to a MILESTONE as a

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

@@ -41,6 +41,7 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const hooks_template_1 = require("../lib/hooks-template");
+const next_steps_1 = require("../lib/next-steps");
 const git_hook_template_1 = require("../lib/git-hook-template");
 const line_prompt_1 = require("../lib/line-prompt");
 const agent_1 = require("../lib/agent");
@@ -246,20 +247,28 @@ function printPostInstall() {
     const onPath = isLumoOnPath();
     const credsPath = path.join((0, config_1.configDir)(), 'credentials.json');
     const authed = fs.existsSync(credsPath);
-    process.stdout.write('\nNext steps:\n');
+    // LUM-686: same conditional advice, now assembled as NextStep[] and handed
+    // to the shared renderer. Locally static — setup has no task state to judge.
+    const steps = [];
     if (!onPath || isRunningUnderNpx()) {
-        process.stdout.write('  • Install the CLI globally so Claude Code hooks can find it:\n' +
-            '      npm install -g @lumoai/cli\n');
+        steps.push({
+            command: 'npm install -g @lumoai/cli',
+            why: 'install the CLI globally so Claude Code hooks can find it',
+        });
     }
     if (!authed) {
-        process.stdout.write('  • Authenticate so the CLI can sync with the Lumo server:\n' +
-            '      lumo auth login\n');
+        steps.push({
+            command: 'lumo auth login',
+            why: 'authenticate so the CLI can sync with the Lumo server',
+        });
     }
     if (onPath && authed && !isRunningUnderNpx()) {
-        process.stdout.write('  • All set. Open Claude Code in this directory — the SKILL.md and\n' +
-            '    hooks are wired in.\n');
+        steps.push({
+            command: null,
+            why: 'All set. Open Claude Code in this directory — the SKILL.md and hooks are wired in.',
+        });
     }
-    process.stdout.write('\n');
+    process.stdout.write(`\n${(0, next_steps_1.formatNextSteps)(steps)}\n\n`);
 }
 function isLumoOnPath() {
     try {

package/dist/cli/src/commands/task-comment-list.js

@@ -54,11 +54,12 @@ function formatCommentThread(comments, opts = {}) {
     if (opts.full)
         return blocks.join('\n\n');
     const id = opts.identifier ?? '<LUM-N>';
+    const fetchCommand = opts.fetchCommand ?? 'task comments list';
     return (0, output_budget_1.truncateUnitsToBudget)({
         units: blocks,
         maxTokens: opts.maxTokens,
         unitNoun: 'comments',
-        fetchHint: `read the whole thread with: lumo task comments list ${id} --full`,
+        fetchHint: `read the whole thread with: lumo ${fetchCommand} ${id} --full`,
         separator: '\n\n',
     }).text;
 }

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

@@ -5,9 +5,10 @@ exports.formatTaskContextMarkdown = formatTaskContextMarkdown;
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const sanitize_1 = require("../lib/sanitize");
+const next_steps_1 = require("../lib/next-steps");
 const format_1 = require("../lib/format");
 const output_budget_1 = require("../../../shared/src/output-budget");
-async function taskContext(identifier) {
+async function taskContext(identifier, options) {
     if (!identifier) {
         console.error('Error: missing <identifier>. Usage: lumo task context <LUM-42>');
         return 1;
@@ -45,6 +46,9 @@ async function taskContext(identifier) {
     const data = (await res.json());
     const now = new Date();
     process.stdout.write(formatTaskContextMarkdown(data, now));
+    // Emitted outside the rendered markdown so the output budget can never drop
+    // it — the closing "so do this now" line is the cheapest section here.
+    (0, next_steps_1.emitNextSteps)(data.nextSteps ?? [], options ?? {});
 }
 /**
  * Render a TaskContextResponse as the agent-facing markdown handoff. Pure

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertSameTeam = assertSameTeam;
 exports.normalizePriority = normalizePriority;
+exports.formatCreateOutput = formatCreateOutput;
 exports.formatCreatedTaskLine = formatCreatedTaskLine;
 exports.taskCreate = taskCreate;
 const config_1 = require("../lib/config");
@@ -9,6 +10,7 @@ const api_1 = require("../lib/api");
 const tag_resolver_1 = require("../lib/tag-resolver");
 const resolve_1 = require("../lib/resolve");
 const sanitize_1 = require("../lib/sanitize");
+const next_steps_1 = require("../lib/next-steps");
 const ALLOWED_PRIORITIES = ['LOW', 'MEDIUM', 'HIGH', 'URGENT'];
 /**
  * Assert that the sprint belongs to the same team as the newly created task.
@@ -80,6 +82,21 @@ function normalizePriority(value) {
         ? upper
         : null;
 }
+/**
+ * Compose the full `task create` output: the result line first, then the
+ * server-computed next-step block (LUM-686). Exported so the render test
+ * exercises the real composition rather than re-assembling the parts itself.
+ *
+ * The result line stays byte-identical and first — a reader taking line 1 is
+ * unaffected by the block below it.
+ */
+function formatCreateOutput(task, steps = [], opts = {}, env = process.env) {
+    const head = formatCreatedTaskLine(task);
+    if ((0, next_steps_1.nextStepsSilenced)(env, opts))
+        return head;
+    const block = (0, next_steps_1.formatNextSteps)(steps);
+    return block === '' ? head : `${head}\n\n${block}`;
+}
 /**
  * Format the single-line success output. Title is double-quoted; embedded
  * double-quotes are backslash-escaped so the output stays parseable as one
@@ -173,7 +190,7 @@ async function taskCreate(title, opts) {
     if (res.status === 201) {
         const data = (await res.json());
         const responseTagNames = (data.task.taskTags ?? []).map(t => t.name);
-        process.stdout.write(formatCreatedTaskLine({ ...data.task, tags: responseTagNames }) + '\n');
+        process.stdout.write(formatCreateOutput({ ...data.task, tags: responseTagNames }, data.nextSteps ?? [], opts) + '\n');
         // Sprint binding (optional): if --sprint was passed, bind the new task.
         if (opts.sprint) {
             const workspaceSlug = creds.workspaceSlug ?? '';

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

@@ -11,6 +11,7 @@ const task_create_1 = require("./task-create");
 const tag_resolver_1 = require("../lib/tag-resolver");
 const resolve_1 = require("../lib/resolve");
 const sanitize_1 = require("../lib/sanitize");
+const next_steps_1 = require("../lib/next-steps");
 const ALLOWED_STATUSES = ['TODO', 'IN_PROGRESS', 'IN_REVIEW', 'DONE'];
 /**
  * Pure function: given the task's current sprint binding and the resolved
@@ -101,7 +102,21 @@ function formatUpdatedTaskLine(task) {
     }
     return head;
 }
+/**
+ * Thin wrapper so the next-step block always lands last (LUM-686). The update
+ * flow has several success exits — a plain PATCH, plus the sprint bind/unbind
+ * branches — and hints belong after whatever the command printed, not wedged
+ * before the Sprint line. Only the wrapper emits; the inner run just collects.
+ */
 async function taskUpdate(identifier, opts) {
+    const collected = { steps: [] };
+    const code = await runTaskUpdate(identifier, opts, collected);
+    // Success only — a failed update's advice would be noise on top of an error.
+    if (code === undefined)
+        (0, next_steps_1.emitNextSteps)(collected.steps, opts);
+    return code;
+}
+async function runTaskUpdate(identifier, opts, collected) {
     if (!identifier || identifier.trim().length === 0) {
         console.error('Error: missing <identifier>. Usage: lumo task update <LUM-42> [options]');
         return 1;
@@ -249,6 +264,7 @@ async function taskUpdate(identifier, opts) {
             if (responseTagNames !== undefined)
                 taskLine.tags = responseTagNames;
             process.stdout.write(formatUpdatedTaskLine(taskLine) + '\n');
+            collected.steps = data.nextSteps ?? [];
         }
         else {
             let serverMsg = null;

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

@@ -37,6 +37,7 @@ exports.worktreeAdd = worktreeAdd;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
+const next_steps_1 = require("../lib/next-steps");
 const worktree_1 = require("../lib/worktree");
 function printGuidance(dir, branch) {
     console.log('');
@@ -44,8 +45,11 @@ function printGuidance(dir, branch) {
     console.log(`  branch:        ${branch}`);
     console.log(`  node_modules:  symlinked to main checkout`);
     console.log('');
-    console.log('Next:');
-    console.log(`  cd ${dir}`);
+    // Locally-static source: no server round-trip to carry steps, but the same
+    // renderer so the block looks identical everywhere (LUM-686).
+    console.log((0, next_steps_1.formatNextSteps)([
+        { command: `cd ${dir}`, why: 'work from the isolated checkout' },
+    ]));
     console.log('');
     console.log('Gotchas baked into this worktree:');
     console.log('  • prisma: the generated client is SHARED via the node_modules symlink.');

package/dist/cli/src/index.js

@@ -47,6 +47,20 @@ const session_attach_1 = require("./commands/session-attach");
 const session_status_1 = require("./commands/session-status");
 const next_1 = require("./commands/next");
 const idea_1 = require("./commands/idea");
+const idea_slack_add_1 = require("./commands/idea-slack-add");
+const idea_slack_show_1 = require("./commands/idea-slack-show");
+const idea_slack_rm_1 = require("./commands/idea-slack-rm");
+const idea_web_add_1 = require("./commands/idea-web-add");
+const idea_web_show_1 = require("./commands/idea-web-show");
+const idea_web_rm_1 = require("./commands/idea-web-rm");
+const idea_figma_add_1 = require("./commands/idea-figma-add");
+const idea_figma_list_1 = require("./commands/idea-figma-list");
+const idea_figma_rm_1 = require("./commands/idea-figma-rm");
+const idea_figma_refresh_1 = require("./commands/idea-figma-refresh");
+const idea_figma_context_1 = require("./commands/idea-figma-context");
+const idea_comment_1 = require("./commands/idea-comment");
+const initiative_1 = require("./commands/initiative");
+const plan_1 = require("./commands/plan");
 const cost_1 = require("./commands/cost");
 const priority_1 = require("./commands/priority");
 const criteria_audit_1 = require("./commands/criteria-audit");
@@ -202,8 +216,18 @@ const program = new commander_1.Command()
     // point at --help instead of dead-ending on "unknown option". Subcommands
     // created via .command() inherit these settings.
     .showSuggestionAfterError(true)
-    .showHelpAfterError('(run the command with --help to list its valid flags and arguments)');
+    .showHelpAfterError('(run the command with --help to list its valid flags and arguments)')
+    // LUM-686: global mute for the trailing next-step block. `LUMO_NO_HINTS=1`
+    // does the same for a whole shell.
+    .option('--no-hints', 'suppress the trailing next-step suggestions');
 exports.program = program;
+// Commander does not merge program-level options into a subcommand's own
+// opts(), so the global `--no-hints` is folded into the env channel before any
+// action runs. One silencing path (`nextStepsSilenced`) instead of two.
+program.hook('preAction', thisCommand => {
+    if (thisCommand.opts().hints === false)
+        process.env.LUMO_NO_HINTS = '1';
+});
 const auth = program.command('auth').description('Manage Lumo authentication');
 auth
     .command('login')
@@ -278,11 +302,112 @@ program
     .option('-n, --count <N>', 'Number of tasks to recommend (default 3)')
     .option('--claimable', 'Only recommend agent-claimable tasks that are unblocked (F3) and within milestone budget (F2)')
     .action(wrap(options => (0, next_1.nextCommand)(options)));
-program
-    .command('idea <statement>')
+const ideaCmd = program
+    .command('idea [statement]')
     .description('Capture a team-level idea into the pool (<10s, no friction). Grabs the current Claude Code session id and its bound task as provenance; prints an I-prefixed id (e.g. LUM-I42). The transformer (Spec 2) consumes the pool.')
     .option('-c, --context <text>', 'Free-text origin context for the idea')
     .action(wrap((statement, options) => (0, idea_1.ideaCapture)(statement, options)));
+ideaCmd
+    .command('list')
+    .description('List the team idea pool newest-first — each line shows the LUM-I<n> id, status (CAPTURED|DEVELOPING|PLANNED|DROPPED) and statement.')
+    .action(wrap(() => (0, idea_1.ideaList)()));
+ideaCmd
+    .command('update <id>')
+    .description('Move an idea through its lifecycle (LUM-679). Allowed: CAPTURED↔DEVELOPING→PLANNED and any state→DROPPED (DROPPED is terminal). <id> is the LUM-I<n> id (a bare number also resolves).')
+    .option('-s, --status <value>', 'New status: captured | developing | planned | dropped (case-insensitive)')
+    .action(wrap((id, options) => (0, idea_1.ideaUpdate)(id, options)));
+// Idea evidence commands (LUM-681): mirrors `task slack/web/figma`, hitting
+// `/api/ideas/:id/...` instead of `/api/tasks/:id/...`. Lets an agent attach
+// Slack threads, web links, and Figma design links to an idea before it goes
+// through the plan-run converter.
+const ideaSlack = ideaCmd
+    .command('slack')
+    .description('Attach & inspect Slack context on an idea');
+ideaSlack
+    .command('add <idea> <permalink>')
+    .description('Attach a Slack thread to an idea')
+    .action(wrap((id, p) => (0, idea_slack_add_1.ideaSlackAdd)(id, p)));
+ideaSlack
+    .command('show <idea> <contextId>')
+    .description('Show the full stored Slack thread snapshot')
+    .action(wrap((id, ctx) => (0, idea_slack_show_1.ideaSlackShow)(id, ctx)));
+ideaSlack
+    .command('rm <idea> <contextId>')
+    .description('Remove a Slack context from an idea')
+    .action(wrap((id, ctx) => (0, idea_slack_rm_1.ideaSlackRm)(id, ctx)));
+const ideaWeb = ideaCmd
+    .command('web')
+    .description('Attach & inspect web links on an idea');
+ideaWeb
+    .command('add <idea> <url>')
+    .description('Attach a web link to an idea')
+    .action(wrap((id, u) => (0, idea_web_add_1.ideaWebAdd)(id, u)));
+ideaWeb
+    .command('show <idea> <linkId>')
+    .description('Show the fetched web link body as plain text')
+    .action(wrap((id, l) => (0, idea_web_show_1.ideaWebShow)(id, l)));
+ideaWeb
+    .command('rm <idea> <linkId>')
+    .description('Remove a web link from an idea')
+    .action(wrap((id, l) => (0, idea_web_rm_1.ideaWebRm)(id, l)));
+const ideaFigma = ideaCmd
+    .command('figma')
+    .description('Attach Figma links to an idea');
+ideaFigma
+    .command('add <idea> <url>')
+    .description('Attach a Figma file/frame URL to an idea')
+    .action(wrap((id, u) => (0, idea_figma_add_1.ideaFigmaAdd)({ identifier: id, url: u })));
+ideaFigma
+    .command('list <idea>')
+    .description('List Figma links on an idea')
+    .action(wrap(id => (0, idea_figma_list_1.ideaFigmaList)({ identifier: id })));
+ideaFigma
+    .command('rm <idea> <link-id-or-url>')
+    .description('Remove a Figma link from an idea (idempotent)')
+    .action(wrap((id, l) => (0, idea_figma_rm_1.ideaFigmaRm)({ identifier: id, linkIdOrUrl: l })));
+ideaFigma
+    .command('refresh <idea>')
+    .description('Re-fetch Figma metadata for every link on an idea')
+    .action(wrap(id => (0, idea_figma_refresh_1.ideaFigmaRefresh)({ identifier: id })));
+ideaFigma
+    .command('context <idea> <linkId>')
+    .description('Show cached Figma design context')
+    .action(wrap((id, l) => (0, idea_figma_context_1.ideaFigmaContext)(id, l)));
+ideaCmd
+    .command('comment <id> <body>')
+    .description('Comment on an idea (LUM-680). <id> is the LUM-I<n> id (a bare number also resolves). Body is plain text — quote it to pass spaces or newlines.')
+    .action(wrap((id, body) => (0, idea_comment_1.ideaComment)(id, body)));
+// Plural `comments` parent (mirrors `task comments`): `idea comment <id> <body>`
+// already exists for posting, and commander disallows a duplicate name.
+const ideaComments = ideaCmd
+    .command('comments')
+    .description('Inspect an idea comment thread');
+ideaComments
+    .command('list <id>')
+    .description('List an idea comment thread (capped to the output budget; --full prints every comment).')
+    .option('--full', 'Print every comment, bypassing the output-token cap')
+    .action(wrap((id, opts) => (0, idea_comment_1.ideaCommentList)(id, opts)));
+const initiativeCmd = program
+    .command('initiative')
+    .description('Team-level Initiatives (LUM-INIT-<n>): create one directly (no plan run required) or list them. Converter-materialised initiatives show here too.');
+initiativeCmd
+    .command('create <goal>')
+    .description('Create a team-level initiative directly from a goal statement — no plan run required. Prints the LUM-INIT-<n> id; --assumption records the bet behind it.')
+    .option('--assumption <text>', 'The bet/assumption behind the initiative (赌注旁注)')
+    .action(wrap((goal, options) => (0, initiative_1.initiativeCreate)(goal, options)));
+initiativeCmd
+    .command('list')
+    .description('List the team initiatives newest-first — each line shows the LUM-INIT-<n> id, status (ACTIVE|DONE|DROPPED) and goal.')
+    .action(wrap(() => (0, initiative_1.initiativeList)()));
+const planCmd = program
+    .command('plan')
+    .description('Start a design-thinking 转换器 run (聚类→对齐→成计划) and print the gate-A web deep-link. Refuses when a run is already active (see `lumo plan status`); --abandon-active abandons the prior run first. Editing/confirmation happen in web.')
+    .option('--abandon-active', 'Abandon the team’s existing active run before starting a fresh one')
+    .action(wrap(options => (0, plan_1.plan)(options)));
+planCmd
+    .command('status')
+    .description('Print the active plan run’s current stage and the deep-link to its next gate; with no active run, prompts to run `lumo plan`.')
+    .action(wrap(() => (0, plan_1.planStatus)()));
 program
     .command('cost')
     .description('Show per-operation (per-tool) token cost. Defaults to a workspace 30-day window; scope with --task / --session')

package/dist/cli/src/lib/idea-figma-api.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addIdeaFigmaLink = addIdeaFigmaLink;
+exports.listIdeaFigmaLinks = listIdeaFigmaLinks;
+exports.removeIdeaFigmaLink = removeIdeaFigmaLink;
+exports.refreshIdeaFigmaLinks = refreshIdeaFigmaLinks;
+const api_1 = require("./api");
+const config_1 = require("./config");
+function buildErr(status, body) {
+    const err = Object.assign(new Error(body.error ?? `HTTP ${status}`), {
+        status,
+    });
+    if (body.code !== undefined)
+        err.code = body.code;
+    return err;
+}
+async function call(path, init) {
+    const creds = (0, config_1.readCredentials)();
+    if (!creds)
+        throw new Error('Not logged in. Run: lumo auth login');
+    const apiUrl = (0, api_1.resolveAuthedApiUrl)(creds.apiUrl);
+    const res = await fetch(`${(0, api_1.trimTrailingSlash)(apiUrl)}${path}`, {
+        ...init,
+        headers: {
+            Authorization: `Bearer ${creds.token}`,
+            'Content-Type': 'application/json',
+            ...(init.headers ?? {}),
+        },
+    });
+    if (!res.ok) {
+        let parsed = {};
+        try {
+            parsed = (await res.json());
+        }
+        catch {
+            /* non-JSON body */
+        }
+        throw buildErr(res.status, parsed);
+    }
+    return (await res.json());
+}
+/**
+ * Idea-side counterpart to `cli/src/lib/figma-api.ts` (LUM-681). Same shape,
+ * same error codes (`figma_not_connected` / `figma_needs_reauth`), only the
+ * URL prefix differs: `/api/ideas/:id/...` instead of `/api/tasks/:id/...`.
+ */
+async function addIdeaFigmaLink(identifier, url) {
+    return call(`/api/ideas/${encodeURIComponent(identifier)}/figma`, {
+        method: 'POST',
+        body: JSON.stringify({ url }),
+    });
+}
+async function listIdeaFigmaLinks(identifier) {
+    return call(`/api/ideas/${encodeURIComponent(identifier)}/figma`, {
+        method: 'GET',
+    });
+}
+async function removeIdeaFigmaLink(identifier, linkId) {
+    return call(`/api/ideas/${encodeURIComponent(identifier)}/figma/${encodeURIComponent(linkId)}`, { method: 'DELETE' });
+}
+async function refreshIdeaFigmaLinks(identifier) {
+    return call(`/api/ideas/${encodeURIComponent(identifier)}/figma/refresh`, {
+        method: 'POST',
+    });
+}

package/dist/cli/src/lib/next-steps.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEXT_STEPS_MAX = void 0;
+exports.nextStepsSilenced = nextStepsSilenced;
+exports.formatNextSteps = formatNextSteps;
+exports.emitNextSteps = emitNextSteps;
+const sanitize_1 = require("./sanitize");
+/** Mirrors NEXT_STEPS_MAX server-side; a defence in depth, not the only cap. */
+exports.NEXT_STEPS_MAX = 3;
+const HEADING = 'Next:';
+/**
+ * True when the user has muted suggestions. Hints cost tokens on every command;
+ * anyone who finds them noise must be able to turn them off for good.
+ */
+function nextStepsSilenced(env = process.env, opts = {}) {
+    // Commander maps `--no-hints` to `opts.hints === false`.
+    if (opts.hints === false)
+        return true;
+    const flag = env.LUMO_NO_HINTS;
+    return flag !== undefined && flag !== '' && flag !== '0';
+}
+/**
+ * Render the trailing suggestion block. Returns "" when there is nothing to
+ * say, so callers can append unconditionally without emitting a bare heading.
+ */
+function formatNextSteps(steps) {
+    const capped = steps.slice(0, exports.NEXT_STEPS_MAX);
+    if (capped.length === 0)
+        return '';
+    const lines = [HEADING];
+    for (const step of capped) {
+        const why = (0, sanitize_1.sanitizeField)(step.why);
+        lines.push(step.command === null
+            ? `  ${why}`
+            : `  ${(0, sanitize_1.sanitizeField)(step.command)}\n      ${why}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Write the block to **stdout**, after the command's own result line.
+ *
+ * Deliberately not stderr: suggestions are not errors, `2>/dev/null` would
+ * swallow them, some harnesses read any stderr output as failure, and with
+ * both streams redirected to one file the block can surface *above* the result
+ * it follows. Machine consumers are served by `--json` instead, where the
+ * steps ride as a field rather than as text.
+ */
+function emitNextSteps(steps, opts = {}, out = process.stdout, env = process.env) {
+    if (nextStepsSilenced(env, opts))
+        return;
+    const block = formatNextSteps(steps);
+    if (block === '')
+        return;
+    out.write(`\n${block}\n`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumoai/cli",
-  "version": "1.54.0",
+  "version": "1.56.0",
   "description": "Lumo CLI — manage tasks and sessions from the terminal",
   "license": "MIT",
   "author": "cli@uselumo.ai",