npm - @lumoai/cli - Versions diffs - 1.51.0 → 1.53.0 - Mend

@lumoai/cli 1.51.0 → 1.53.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/assets/skill/SKILL.md +5 -3
package/assets/skill/references/memory.md +5 -1
package/assets/skill/references/milestones.md +56 -0
package/assets/skill/references/sessions.md +1 -0
package/assets/skill/references/tasks.md +10 -4
package/dist/cli/src/commands/milestone-changelog.js +155 -0
package/dist/cli/src/commands/milestone-show.js +23 -0
package/dist/cli/src/commands/milestone-triage.js +123 -0
package/dist/cli/src/commands/next.js +41 -4
package/dist/cli/src/commands/session-attach.js +6 -0
package/dist/cli/src/commands/task-update.js +30 -4
package/dist/cli/src/index.js +19 -1
package/dist/cli/src/lib/claimable-filter.js +72 -0
package/dist/cli/src/lib/hook-runner.js +4 -0
package/package.json +1 -1

package/assets/skill/SKILL.md CHANGED Viewed

@@ -63,9 +63,9 @@ The command catalog below is a **map**: it lists every command grouped by domain
 **Tasks** — see [tasks.md](references/tasks.md)
 - `lumo task create <title> [flags]` — create a task. **Mid-task** (your session is bound to an in-flight task) it requires `--rework-of <id>` (redirects you to fix the existing task — creates nothing) or `--new-scope` (genuinely new, out-of-scope work). On a send-back, fix in place / amend the contract instead of spinning off a new task — see [verify.md](references/verify.md) and [criteria.md](references/criteria.md).
-- `lumo task update <id> [flags]` — patch status/title/priority/assignee/milestone/sprint/tags
+- `lumo task update <id> [flags]` — patch status/title/priority/assignee/milestone/sprint/tags; `--claimable`/`--not-claimable` set the agent-claimable marker (LUM-646)
 - `lumo task list [flags]` — list tasks assigned to you
-- `lumo next [--count N]` — recommend the next task to work on (read-only)
+- `lumo next [--count N] [--claimable]` — recommend the next task to work on (read-only). `--claimable` restricts to the autonomy boundary: only tasks that are claimable ∩ unblocked (F3 topology) ∩ within milestone budget (F2); old server degrades gracefully to the standard ranking (LUM-646)
 - `lumo task show <id>` — print one task's detail
 - `lumo task comment <id> <body>` — leave a comment
@@ -124,7 +124,9 @@ lumo fidelity show LUM-42 --json
 - `lumo milestone list/create/show/update/delete` — milestone CRUD (`show` includes a Sprint-coverage section)
 - `lumo milestone archive/unarchive` — soft-archive / restore
 - `lumo milestone add/remove <id> <task...>` — batch bind/unbind tasks
+- `lumo milestone triage <id> <task...> --claimable|--not-claimable` — steward batch agent-claimable triage (LUM-646): mark in-milestone tasks (not) claimable; tasks not in the milestone are skipped. Feeds `lumo next --claimable`
 - `lumo milestone summary [--retry]` — AI retro
+- `lumo milestone changelog <id> [--json]` — structured changelog from DONE tasks + merged PRs + frozen claimSnapshot (pure assembly, no LLM; runs on any status). Headline counts carry a baseline vs prior completed milestones (LUM-508); each claim shows provenance, no-PR/no-claim rendered explicitly (LUM-649)
 - `lumo milestone reorder/move` — manual ordering
 - `lumo milestone criteria set/list/verdict` — milestone-level **exit criteria** (LUM-643): the close contract, drafted & adjudicated (裁定) by the steward (LUM-640) or a human. Unresolved criteria (pending or NOT_MET) block `--status completed` **and** the LUM-624 auto-rollup with 409/fail-closed; human override is web-only (`?force=1`, stamped as a persistent trail). `verdict --met` on `EXTERNAL_FACT` requires `--evidence` (422); `PENDING_OUTCOME` can never be MET
@@ -158,7 +160,7 @@ lumo fidelity show LUM-42 --json
 **Sessions** — see [sessions.md](references/sessions.md)
 - `lumo session attach <id>` — bind this session to a task (then run `task context`). **Lifetime lock**: re-attaching to the same task is a no-op; attaching to a _different_ task is refused with 409 — start a new Claude Code session instead. No `--force`, no `session detach`.
-- `lumo session attach --steward <milestone>` — bind this session to a **milestone** as a **STEWARD (governance) session** (LUM-640): plan & accept only. Governance passes (task create/update, criteria set incl. `--human`, deps confirm/dismiss, `verdict --fail` with session provenance, milestone add/remove, all reads); implementation is gated (`lumo verify` → 409 **without burning a round**; moving a task to in_progress assigned to yourself → 409); commits/PRs produced anyway are recorded as milestone-scoped boundary crossings (fail-closed; disposition stays web+human-only, no CLI clear path). Same lifetime lock: same milestone idempotent, any other attach (a task, or a different milestone) → 409; multiple stewards per milestone are fine. See [sessions.md](references/sessions.md)
+- `lumo session attach --steward <milestone>` — bind this session to a **milestone** as a **STEWARD (governance) session** (LUM-640): plan & accept only. Governance passes (task create/update, criteria set incl. `--human`, deps confirm/dismiss, `verdict --fail` with session provenance, milestone add/remove, milestone triage (LUM-646 claimable), all reads); implementation is gated (`lumo verify` → 409 **without burning a round**; moving a task to in_progress assigned to yourself → 409); commits/PRs produced anyway are recorded as milestone-scoped boundary crossings (fail-closed; disposition stays web+human-only, no CLI clear path). Same lifetime lock: same milestone idempotent, any other attach (a task, or a different milestone) → 409; multiple stewards per milestone are fine. See [sessions.md](references/sessions.md)
 - `lumo session status` — show current binding (a task, or the milestone + STEWARD role)
 - End-of-session housekeeping is fully automatic (no command). On DONE the server runs three best-effort silent passes: Layer-1 memory curation, fragment-usage audit, and blocked-tag automation. See [sessions.md](references/sessions.md)
 - Git-suggest at session start (suggests `session attach`, never auto-binds) + Layer-2 project-memory review — see the reference

package/assets/skill/references/memory.md CHANGED Viewed

@@ -5,7 +5,11 @@
 Record and curate the long-term Memory that Claude reads on future sessions.
 Memories are scoped **TASK** (useful only for one task) or **PROJECT** (useful
 across the whole project). Automated extraction (layer1) and promotion (layer2,
-on task→done) already run; these commands are the manual override.
+on task→done) already run; these commands are the manual override. A third,
+**MILESTONE** scope is written automatically only (no manual command): when a
+milestone closes and its retro is generated, the durable forward-looking
+learnings are distilled into MILESTONE-scope memories and injected at the next
+milestone's steward session start (LUM-647) — see [sessions.md](sessions.md).
 ### Commands

package/assets/skill/references/milestones.md CHANGED Viewed

@@ -91,6 +91,14 @@ Sprint coverage:
   Unscheduled             1 task
 ```
+**Cross-milestone learning (LUM-648):** when this milestone's STEWARD sessions were injected prior-milestone distilled learning (the LUM-647 learning unit), a **Cross-milestone learning** section reports how much of it was actually used — `Injected: N prior learnings (from K prior milestones)` and `Usage rate: Z% (judged-used X/Y)`. The rate reuses lineage's `used=true/false/null` usage voting (judged at the successor milestone's close): abstentions (un-audited / judge-abstained impressions) are **excluded from the denominator**, so it is a lower bound. Below 3 judged edges it reads `insufficient (judged Y, need ≥3)` rather than a fabricated percentage. The section is omitted entirely when nothing was injected (that's "nothing to migrate", not 0%).
+```
+Cross-milestone learning:
+  Injected: 8 prior learnings (from 2 prior milestones)
+  Usage rate: 62% (judged-used 5/8)
+```
 ```bash
 lumo milestone show "Q3 Launch"
 lumo milestone show 11111111-2222-3333-4444-555555555555
@@ -251,6 +259,29 @@ Q3 Launch: 1 removed, 1 skipped
 - `remove` only clears the binding for tasks actually in the named milestone, so it's safe to pass a broad list — anything not in it is reported as skipped, not clobbered.
 - For one-at-a-time sprint binding see `lumo sprint add / remove` (sprint batch is not yet supported).
+### `lumo milestone triage <identifier> <task...> --claimable | --not-claimable` — steward batch agent-claimable triage (LUM-646)
+The **steward's batch annotation** for the F4/自治边界 loop. Marks **one or more** in-milestone tasks agent-claimable (or not) in one call — the "可领范围" leg of the autonomy-boundary triad (契约 F1 / 预算 F2 / 可领范围 F4). Exactly one direction is required: `--claimable` or `--not-claimable` (mutually exclusive; the CLI errors before any network call if both or neither is given).
+Mirrors `milestone add/remove`: dedupes refs, and a task **not in this milestone is skipped** (triage is milestone-scoped, never touches tasks elsewhere). `<identifier>` accepts a name or UUID; each `<task>` accepts `LUM-N` or a task UUID. `--project <ref>` is required when the identifier is a name and the workspace has >1 project. Best-effort — partial failures do not roll back.
+Setting the marker is a **governance** action, so a STEWARD session (`lumo session attach --steward <milestone>`) passes the server-side binding guard. `claimable` is **fail-closed**: a task is not auto-claimable until triaged. Once tasks are triaged, an agent runs `lumo next --claimable` to get only claimable ∩ unblocked (F3) ∩ in-budget (F2) work. A single task can also be toggled with `lumo task update <id> --claimable | --not-claimable`.
+```bash
+lumo milestone triage "Agent-Native Milestones" LUM-1 LUM-2 --claimable
+lumo milestone triage "Agent-Native Milestones" LUM-9 --not-claimable
+```
+Output — `✓` marked, `-` skipped (not in milestone), `✗` failed:
+```
+Agent-Native Milestones: 1 marked claimable, 1 skipped
+  ✓ LUM-1
+  - LUM-9  not in this milestone
+```
+**When to suggest `milestone triage`**: the user (typically in a steward/governance session) wants to declare which of a milestone's tasks are safe for an agent to autonomously pick up ("mark these claimable", "open these up for agents", "triage the milestone for auto-dispatch"). For a single task, `task update --claimable` is equally fine.
 ### `lumo milestone summary <identifier> [--retry]` — fetch AI-generated milestone retro
 Prints the AI-generated retrospective summary for a milestone (mirrors `sprint summary`). `<identifier>` accepts a milestone name or UUID; `--project <ref>` is required when the identifier is a name and the workspace has more than one project. When no summary exists yet the command prints `(no summary generated yet)`.
@@ -270,6 +301,31 @@ lumo milestone summary 11111111-2222-3333-4444-555555555555
 When to suggest: user asks "summarize the milestone", "milestone retro", "give me a summary of the Q3 milestone".
+### `lumo milestone changelog <identifier> [--project <ref>] [--json]` — structured changelog (LUM-649)
+Assembles a **structured changelog** from the milestone's **DONE tasks + merged PRs + frozen claimSnapshot**. Pure deterministic assembly — **no LLM**, and (unlike `summary`) **no COMPLETED gate**: it runs on a milestone of any status, so an ACTIVE milestone reports "what has shipped so far". Only DONE tasks ever appear. `<identifier>` accepts a milestone name or UUID; `--project <ref>` is required when the identifier is a name and the workspace has >1 project.
+Honest-reporting contract (why this is more than a task list):
+- **Headline counts carry a baseline (LUM-508 reuse).** "Tasks shipped" and "PRs merged" are rendered as a current-vs-base stat against the reference class of **prior COMPLETED milestones in the same project** — e.g. `4 (base 3, +33% · above)`. With **fewer than 3** prior milestones the base is honestly suppressed to `4 (no baseline yet)` — never a naked number, never a thin fabricated baseline.
+- **Claim provenance.** Each DONE task shows its frozen `claimSnapshot` tagged with its source + session (`Claim [RUN_SUMMARY · sess-1]: …`). A synthesized-but-empty claim reads `(no claim recorded)` (fail-closed "no material"), distinct from a never-synthesized `(not synthesized)`.
+- **Nothing silently dropped.** A DONE task with no merged PR renders an explicit `PRs: (no merged PR)`. Entries are ordered newest-delivery-first (by task `updatedAt` — Task has no `completedAt` column, so this is a best-available proxy).
+`--json` emits the raw structured payload (milestone / headline baseline stats / entries) unchanged for programmatic use.
+| Flag              | Type    | Notes                                                                                      |
+| ----------------- | ------- | ------------------------------------------------------------------------------------------ |
+| `--project <ref>` | string  | Project name or slug. Required when identifier is a name and the workspace has >1 project. |
+| `--json`          | boolean | Emit the raw structured changelog payload instead of the human markdown.                   |
+```bash
+lumo milestone changelog "Agent-Native Milestones"
+lumo milestone changelog "Agent-Native Milestones" --json
+lumo milestone changelog 11111111-2222-3333-4444-555555555555
+```
+When to suggest: user asks for a "changelog", "release notes", "what shipped in this milestone", or wants a structured delivery list they can paste into a release note. For the AI narrative retro use `milestone summary`; for the honest delivery-count/cost rollup see `milestone show`.
 ### `lumo milestone reorder <ref...> [--project <ref>]` — set the full milestone order
 Reorders a project's milestones. Pass **every** milestone in the project (by name, case-insensitive, or its cuid) in the desired order — the command rewrites each milestone's `sortOrder` to match. An incomplete list (not every milestone named), an unknown ref, or a duplicate is rejected **before any network mutation**, with a message naming the offending / missing milestones.

package/assets/skill/references/sessions.md CHANGED Viewed

@@ -132,6 +132,7 @@ lumo session attach --steward cmxyz123...                 # by milestone id
 - **Resolution:** exact id → case-insensitive name/slug across the workspace's active milestones. An **ambiguous** name is refused with 400 listing the candidates (retry with the id); no match is 404.
 - **Lifetime lock, same semantics as the task form:** re-attach to the **same** milestone = idempotent no-op; attach a **task** after a steward bind → 409; attach a **different milestone** → 409; a task-bound session running `--steward` → 409. No `--force`, no detach — a different binding needs a new Claude Code session.
 - **Multiple stewards per milestone are allowed** (acceptance is multi-round by nature); sessions don't conflict.
+- **Prior-milestone learnings injected at attach (LUM-647):** the attach prints a `## Prior-milestone learnings (this project)` section — the **MILESTONE-scope** memories distilled from this project's earlier milestone-close retros (a cross-milestone learning unit), wrapped in the `<untrusted-team-memory>` boundary. Empty when the project has no prior distilled learnings; the current milestone's own rows are excluded. A resumed steward session re-gets it via the session-start hook. These memories are written automatically when a milestone closes and its retro is generated — there is no manual command to author them.
 **Allowed (governance — pass through unchanged, with the session recorded as provenance):** `task create` / `task update`, `task criteria set` (incl. `--human`), `task deps confirm/dismiss`, `verdict --fail` (the send-back rows carry `sourceSessionId`), `milestone add/remove`, and **all read operations**.

package/assets/skill/references/tasks.md CHANGED Viewed

@@ -59,6 +59,8 @@ Pure flag-driven update. Provide at least one of:
 | `-a, --assignee <ref>`   | string              | `me`, an email, or a member name. `--assignee ""` clears the field.                                                                                                                                                                                                   |
 | `--milestone <ref>`      | string              | Milestone name (case-insensitive) within the task's project. `--milestone ""` unbinds.                                                                                                                                                                                |
 | `--sprint <ref>`         | string              | Sprint number or UUID to bind the task to. `--sprint ""` clears the current sprint binding (idempotent when already unbound).                                                                                                                                         |
+| `--claimable`            | boolean             | LUM-646: mark the task agent-claimable (fail-closed default is false). Surfaces the task in `lumo next --claimable`. Mutually exclusive with `--not-claimable`.                                                                                                       |
+| `--not-claimable`        | boolean             | LUM-646: mark the task NOT agent-claimable. Mutually exclusive with `--claimable`.                                                                                                                                                                                    |
 | `--tag <name>`           | string (repeatable) | **Bulk replace** the tag set by name. Creates tag if missing. Max 20. Mutually exclusive with `--add-tag*` / `--remove-tag*`.                                                                                                                                         |
 | `--tag-id <cuid>`        | string (repeatable) | **Bulk replace** the tag set by id. Max 20. Mutually exclusive with `--add-tag*` / `--remove-tag*`.                                                                                                                                                                   |
 | `--add-tag <name>`       | string (repeatable) | Attach tag by name (find-or-create). Max 20.                                                                                                                                                                                                                          |
@@ -170,7 +172,7 @@ Filtering is currently client-side — the server returns the full "my tasks" se
 - The user asks "what am I working on", "what tasks do I have", "list my tasks", "show me my queue".
 - Before suggesting a status change ("mark something as done"), if no task ID is in context — run `task list` first to surface candidates.
-### `lumo next [--count <N>]` — recommend the next task to work on
+### `lumo next [--count <N>] [--claimable]` — recommend the next task to work on
 Ranks the tasks assigned to you and prints the top N (default 3), each with a
 one-line reason. Read-only — it does **not** bind or load context. Pick one from
@@ -186,15 +188,19 @@ command still recommends, just without the sprint boost. The topology counts
 come from the server (`/api/tasks/me`); against an older server without them
 the order is simply the pre-topology ranking.
-| Flag              | Type    | Notes                                                                   |
-| ----------------- | ------- | ----------------------------------------------------------------------- |
-| `-n, --count <N>` | integer | How many tasks to recommend. Defaults to 3. Must be a positive integer. |
+| Flag              | Type    | Notes                                                                                                                                                                                                                                                                                                  |
+| ----------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `-n, --count <N>` | integer | How many tasks to recommend. Defaults to 3. Must be a positive integer.                                                                                                                                                                                                                                |
+| `--claimable`     | boolean | LUM-646 (F4/自治边界): restrict to the autonomy boundary — recommend **only** tasks that are agent-claimable (steward-triaged) **and** unblocked (no open CONFIRMED blocker, F3) **and** within milestone budget (not measured over the LUM-644 token budget, F2). Off by default (unchanged ranking). |
 ```bash
 lumo next
 lumo next --count 1
+lumo next --claimable        # autonomy-scoped: only claimable ∩ unblocked ∩ in-budget
 ```
+**`--claimable` semantics (LUM-646):** the three-part gate is a hard filter, not just a re-ranking (default `next` still soft-deprioritizes blocked tasks per LUM-645). `claimable` is **fail-closed** — a task is not claimable until a steward (`lumo milestone triage`) or `lumo task update --claimable` marks it, so the default field value excludes it. Budget is **fail-open on the unknown** — only a _measured_ overrun excludes; no budget set / unmeasured burn never gates. When the gate empties the list, the output states the honest breakdown (e.g. `No claimable, unblocked, in-budget tasks right now. (excluded: 3 not triaged claimable, 1 blocked by open deps)`). Against a server that predates F4 (no `claimable` field), `--claimable` prints a one-line notice and **degrades to the standard ranking** rather than returning nothing.
 Output:
 ```

package/dist/cli/src/commands/milestone-changelog.js ADDED Viewed

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBaselineStat = formatBaselineStat;
+exports.formatMilestoneChangelog = formatMilestoneChangelog;
+exports.renderChangelogOutput = renderChangelogOutput;
+exports.milestoneChangelog = milestoneChangelog;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const resolve_1 = require("../lib/resolve");
+const sanitize_1 = require("../lib/sanitize");
+// Mirror of lib/baseline/types.MIN_BASELINE_SAMPLE — the honest floor below
+// which a baseline is suppressed. The server fold already nulls `base` under
+// this threshold; the check here is defensive so a thin baseline can never leak.
+const MIN_BASELINE_SAMPLE = 3;
+/**
+ * Render one BaselineStat as an honest inline string:
+ * - real base → `4 (base 3, +33% · above)`
+ * - no base / thin sample → `2 (no baseline yet)`
+ * - current unmeasured → `— (no baseline yet)`
+ */
+function formatBaselineStat(stat) {
+    const current = stat.current === null ? '—' : String(stat.current);
+    const grounded = stat.base !== null &&
+        stat.current !== null &&
+        stat.sampleSize >= MIN_BASELINE_SAMPLE;
+    if (!grounded) {
+        return `${current} (no baseline yet)`;
+    }
+    const unit = stat.deltaKind === 'rate' ? 'pt' : '%';
+    const parts = [`base ${stat.base}`];
+    if (stat.deltaPct !== null) {
+        const sign = stat.deltaPct > 0 ? '+' : '';
+        parts.push(`${sign}${stat.deltaPct}${unit}`);
+    }
+    if (stat.band !== null) {
+        parts.push(`· ${stat.band}`);
+    }
+    return `${current} (${parts.join(' ')})`;
+}
+function formatWindow(startDate, targetDate) {
+    const fmt = (iso) => iso.slice(0, 10);
+    if (startDate && targetDate)
+        return `${fmt(startDate)} → ${fmt(targetDate)}`;
+    if (startDate)
+        return `from ${fmt(startDate)}`;
+    if (targetDate)
+        return `target ${fmt(targetDate)}`;
+    return null;
+}
+function formatClaim(claim) {
+    switch (claim.status) {
+        case 'present': {
+            const tag = [claim.source, claim.sessionId].filter(Boolean).join(' · ');
+            const label = tag ? `Claim [${(0, sanitize_1.sanitizeField)(tag)}]` : 'Claim';
+            return `  ${label}: ${(0, sanitize_1.sanitizeField)(claim.text)}`;
+        }
+        case 'empty':
+            return '  Claim: (no claim recorded)';
+        case 'unsynthesized':
+            return '  Claim: (not synthesized)';
+    }
+}
+function formatEntry(entry) {
+    const lines = [
+        `### ${entry.identifier} — ${(0, sanitize_1.sanitizeField)(entry.title)}`,
+    ];
+    if (entry.prs.length === 0) {
+        lines.push('  PRs: (no merged PR)');
+    }
+    else {
+        const prs = entry.prs
+            .map(pr => {
+            const sha = pr.mergeCommitSha
+                ? ` (${pr.mergeCommitSha.slice(0, 7)})`
+                : '';
+            return `${pr.repo}#${pr.number} "${(0, sanitize_1.sanitizeField)(pr.title)}"${sha}`;
+        })
+            .join(', ');
+        lines.push(`  PRs: ${prs}`);
+    }
+    lines.push(formatClaim(entry.claim));
+    return lines.join('\n');
+}
+function formatMilestoneChangelog(cl) {
+    const lines = [
+        `# Changelog — ${(0, sanitize_1.sanitizeField)(cl.milestone.name)} (${cl.milestone.status})`,
+    ];
+    const window = formatWindow(cl.milestone.startDate, cl.milestone.targetDate);
+    if (window)
+        lines.push(window);
+    lines.push('', '## Summary');
+    lines.push(`- Tasks shipped: ${formatBaselineStat(cl.headline.tasksShipped)}`);
+    lines.push(`- PRs merged: ${formatBaselineStat(cl.headline.prsMerged)}`);
+    lines.push('', '## Shipped');
+    if (cl.entries.length === 0) {
+        lines.push('(no tasks delivered yet)');
+    }
+    else {
+        for (const entry of cl.entries) {
+            lines.push('', formatEntry(entry));
+        }
+    }
+    return lines.join('\n');
+}
+/** The exact string the command prints — markdown, or raw JSON with --json. */
+function renderChangelogOutput(cl, opts) {
+    return opts.json ? JSON.stringify(cl, null, 2) : formatMilestoneChangelog(cl);
+}
+async function milestoneChangelog(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 resolved;
+    try {
+        resolved = await (0, resolve_1.resolveMilestoneId)(base, creds.token, identifier, opts.project);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    let res;
+    try {
+        res = await fetch(`${base}/api/milestones/${resolved.id}/changelog`, {
+            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 changelog failed (HTTP ${res.status})`;
+        try {
+            const errBody = (await res.json());
+            if (errBody.error)
+                errMsg = errBody.error;
+        }
+        catch {
+            // ignore
+        }
+        console.error(`Error: ${(0, sanitize_1.sanitizeField)(errMsg)}`);
+        return 1;
+    }
+    const cl = (await res.json());
+    process.stdout.write(renderChangelogOutput(cl, { json: !!opts.json }) + '\n');
+}

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

@@ -39,6 +39,27 @@ function sprintCoverageLines(coverage) {
     }
     return ['', 'Sprint coverage:', ...rows];
 }
+/**
+ * LUM-648: the cross-milestone learning-migration read-out. Omitted entirely
+ * when this milestone's stewards were injected no prior learning (injected=0) —
+ * that's "nothing to migrate", not a 0% usage rate. When judged samples are too
+ * thin the rate reads `insufficient` rather than a fabricated percentage.
+ */
+function crossMilestoneLearningLines(learning) {
+    if (!learning || learning.injected === 0)
+        return [];
+    const { injected, judged, judgedUsed, sourceMilestones, rate } = learning;
+    const srcLabel = `${sourceMilestones} prior milestone${sourceMilestones === 1 ? '' : 's'}`;
+    const rateLabel = rate === null
+        ? `insufficient (judged ${judged}, need ≥3)`
+        : `${Math.round(rate * 100)}% (judged-used ${judgedUsed}/${judged})`;
+    return [
+        '',
+        'Cross-milestone learning:',
+        `  Injected: ${injected} prior learning${injected === 1 ? '' : 's'} (from ${srcLabel})`,
+        `  Usage rate: ${rateLabel}`,
+    ];
+}
 function formatMilestoneShow(m, tasks) {
     const total = m.taskCounts.TODO +
         m.taskCounts.IN_PROGRESS +
@@ -64,6 +85,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));
+    lines.push(...crossMilestoneLearningLines(m.crossMilestoneLearning));
     if (tasks.length > 0) {
         lines.push('', (0, format_1.formatTaskListTable)(tasks));
     }
@@ -144,5 +166,6 @@ async function milestoneShow(identifier, opts) {
         health: milestone.health,
         staleness: milestone.staleness,
         sprintCoverage: milestone.sprintCoverage,
+        crossMilestoneLearning: milestone.crossMilestoneLearning,
     }, tasks) + '\n');
 }

package/dist/cli/src/commands/milestone-triage.js ADDED Viewed

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.milestoneTriage = milestoneTriage;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const resolve_1 = require("../lib/resolve");
+const milestone_batch_1 = require("../lib/milestone-batch");
+/** GET the milestone's canonical name; needed only when a UUID was passed. */
+async function resolveMilestoneName(base, token, id, knownName) {
+    if (knownName)
+        return knownName;
+    const res = await fetch(`${base}/api/milestones/${id}`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok) {
+        throw new Error(`milestone ${id} not found (HTTP ${res.status})`);
+    }
+    const { milestone } = (await res.json());
+    return milestone.name;
+}
+/**
+ * `lumo milestone triage <milestone> <task...> --claimable|--not-claimable` —
+ * the steward's batch agent-claimable annotation (LUM-646, F4/自治边界).
+ *
+ * Mirrors `milestone add/remove`: dedupe refs, partition against the
+ * milestone's task set, PATCH each in-milestone task with the chosen claimable
+ * direction, and skip anything not in the milestone (triage is milestone-
+ * scoped). Best-effort — partial failures don't roll back. Setting the marker
+ * is a governance action, so a STEWARD session passes the server-side binding
+ * guard (task update is `allow-governance`).
+ */
+async function milestoneTriage(identifier, tasks, opts) {
+    // Exactly one direction must be chosen.
+    if (opts.claimable && opts.notClaimable) {
+        console.error('Error: --claimable and --not-claimable are mutually exclusive.');
+        return 1;
+    }
+    if (!opts.claimable && !opts.notClaimable) {
+        console.error('Error: choose a direction — pass --claimable or --not-claimable.');
+        return 1;
+    }
+    const claimable = Boolean(opts.claimable);
+    const refs = (0, milestone_batch_1.dedupeTaskRefs)(tasks);
+    if (refs.length === 0) {
+        console.error('Error: provide at least one task (e.g. `LUM-1 LUM-2`).');
+        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 milestoneId;
+    let milestoneName;
+    let milestoneTasks;
+    try {
+        const resolved = await (0, resolve_1.resolveMilestoneId)(base, creds.token, identifier, opts.project);
+        milestoneId = resolved.id;
+        milestoneName = await resolveMilestoneName(base, creds.token, resolved.id, resolved.name);
+        const tasksRes = await fetch(`${base}/api/milestones/${milestoneId}/tasks`, { headers: { Authorization: `Bearer ${creds.token}` } });
+        if (!tasksRes.ok) {
+            throw new Error(`milestone tasks fetch failed (HTTP ${tasksRes.status})`);
+        }
+        const body = (await tasksRes.json());
+        milestoneTasks = body.tasks;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    const { present, absent } = (0, milestone_batch_1.partitionMembership)(refs, milestoneTasks);
+    const sessionId = process.env.CLAUDE_CODE_SESSION_ID;
+    const outcomes = [];
+    for (const ref of present) {
+        try {
+            const headers = {
+                Authorization: `Bearer ${creds.token}`,
+                'Content-Type': 'application/json',
+            };
+            if (sessionId)
+                headers['X-Lumo-Session-Id'] = sessionId;
+            const res = await fetch(`${base}/api/tasks/by-identifier/${encodeURIComponent(ref)}`, {
+                method: 'PATCH',
+                headers,
+                body: JSON.stringify({ claimable }),
+            });
+            if (res.ok) {
+                outcomes.push({ task: ref, status: 'ok' });
+            }
+            else {
+                let msg = `triage failed (HTTP ${res.status})`;
+                try {
+                    const errBody = (await res.json());
+                    if (errBody.error)
+                        msg = errBody.error;
+                }
+                catch {
+                    // non-JSON body; keep the status-only message
+                }
+                outcomes.push({ task: ref, status: 'fail', detail: msg });
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            outcomes.push({ task: ref, status: 'fail', detail: msg });
+        }
+    }
+    for (const ref of absent) {
+        outcomes.push({
+            task: ref,
+            status: 'skip',
+            detail: 'not in this milestone',
+        });
+    }
+    process.stdout.write((0, milestone_batch_1.formatBatchSummary)({
+        milestoneName,
+        verb: claimable ? 'marked claimable' : 'marked not-claimable',
+        outcomes,
+    }) + '\n');
+    return outcomes.some(o => o.status === 'fail') ? 1 : undefined;
+}

package/dist/cli/src/commands/next.js CHANGED Viewed

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nextCommand = nextCommand;
+exports.formatClaimableOutput = formatClaimableOutput;
 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");
+const claimable_filter_1 = require("../lib/claimable-filter");
 /**
  * `lumo next [-n, --count <N>]` — recommend the next task(s) to work on.
  *
@@ -45,10 +47,14 @@ async function nextCommand(opts) {
         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.
+    // 2. My tasks — fatal on failure. `?claimable=1` asks the server to also
+    //    compute the per-milestone F2 budget signal (only needed for the gate).
+    const tasksUrl = opts.claimable
+        ? `${base}/api/tasks/me?claimable=1`
+        : `${base}/api/tasks/me`;
     let res;
     try {
-        res = await fetch(`${base}/api/tasks/me`, { headers: authHeaders });
+        res = await fetch(tasksUrl, { headers: authHeaders });
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -65,15 +71,46 @@ async function nextCommand(opts) {
     }
     const data = (await res.json());
     const open = data.tasks.filter(t => t.status !== 'DONE');
+    // LUM-646: the autonomy gate. Only when --claimable is passed; otherwise the
+    // standard LUM-645 ranking is untouched.
+    if (opts.claimable) {
+        const gate = (0, claimable_filter_1.filterClaimable)(open);
+        if (!gate.supported) {
+            // Older server predating F4 — degrade to the standard ranking with a
+            // one-line notice rather than silently returning nothing.
+            console.error('Note: `--claimable` needs an updated Lumo server; showing the standard ranking instead.');
+        }
+        else {
+            const ranked = (0, rank_tasks_1.rankTasks)(gate.kept, activeSprintIds, new Date()).slice(0, count);
+            process.stdout.write(formatClaimableOutput(ranked, gate.kept.length, gate.excluded) + '\n');
+            return;
+        }
+    }
     const ranked = (0, rank_tasks_1.rankTasks)(open, activeSprintIds, new Date()).slice(0, count);
     process.stdout.write(formatNextOutput(ranked, open.length) + '\n');
 }
+/**
+ * Render the `--claimable` recommendation block. Like `formatNextOutput` but
+ * scoped to the autonomy boundary: the header names the claimable count, and
+ * an empty result reports the honest exclusion breakdown (why nothing is
+ * claimable-and-workable) instead of the generic "no open tasks".
+ */
+function formatClaimableOutput(ranked, totalClaimable, excluded) {
+    if (ranked.length === 0) {
+        const breakdown = (0, claimable_filter_1.formatClaimableExclusions)(excluded);
+        const base = 'No claimable, unblocked, in-budget tasks right now.';
+        return breakdown ? `${base} (excluded: ${breakdown})` : base;
+    }
+    return formatNextOutput(ranked, totalClaimable, 'claimable');
+}
 /**
  * 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) {
+function formatNextOutput(ranked, totalOpen,
+/** Noun for the "(of N <noun>)" header — 'claimable' for the gated view. */
+poolNoun = 'open') {
     const first = ranked[0];
     if (!first)
         return 'No open tasks assigned to you. 🎉';
@@ -84,7 +121,7 @@ function formatNextOutput(ranked, totalOpen) {
     };
     const plural = ranked.length === 1 ? '' : 's';
     const lines = [
-        `Top ${ranked.length} recommended task${plural} (of ${totalOpen} open):`,
+        `Top ${ranked.length} recommended task${plural} (of ${totalOpen} ${poolNoun}):`,
         '',
     ];
     ranked.forEach((r, i) => {

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

@@ -238,4 +238,10 @@ async function stewardAttach(args) {
     console.log('  allowed: task create/update · criteria set (incl. --human) · deps confirm/dismiss · verdict --fail · milestone add/remove · all reads');
     console.log('  blocked: lumo verify (409, no round burned) · moving a task to in_progress assigned to yourself · attaching a task');
     console.log('  note:    commits/PRs produced in this session are recorded as boundary crossings (human-reviewed on the web)');
+    // LUM-647: prior-milestone learnings distilled from this project's earlier
+    // milestone-close retros, injected so the steward carries them into planning.
+    if (body.stewardMemorySection && body.stewardMemorySection.trim() !== '') {
+        console.log('');
+        console.log((0, sanitize_1.sanitizeField)(body.stewardMemorySection));
+    }
 }

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

@@ -80,6 +80,12 @@ function buildUpdatePayload(opts) {
         payload.milestoneRef = opts.milestone === '' ? null : opts.milestone;
         flagsGiven.push('--milestone');
     }
+    // LUM-646: resolved agent-claimable marker (true/false). The caller collapses
+    // --claimable / --not-claimable into this single tri-state before building.
+    if (opts.claimable !== undefined) {
+        payload.claimable = opts.claimable;
+        flagsGiven.push(opts.claimable ? '--claimable' : '--not-claimable');
+    }
     return { payload, flagsGiven };
 }
 /**
@@ -111,6 +117,17 @@ async function taskUpdate(identifier, opts) {
         console.error('Error: --tag/--tag-id are mutually exclusive with --add-tag/--add-tag-id/--remove-tag/--remove-tag-id');
         return 1;
     }
+    // LUM-646: collapse --claimable / --not-claimable into one tri-state
+    // (undefined = don't touch). The two flags cannot both be set.
+    if (opts.claimable && opts.notClaimable) {
+        console.error('Error: --claimable and --not-claimable are mutually exclusive');
+        return 1;
+    }
+    let claimable;
+    if (opts.claimable)
+        claimable = true;
+    else if (opts.notClaimable)
+        claimable = false;
     // Normalize status / priority before payload build.
     let status;
     if (opts.status !== undefined) {
@@ -134,6 +151,7 @@ async function taskUpdate(identifier, opts) {
         ...opts,
         ...(status !== undefined ? { status } : {}),
         ...(priority !== undefined ? { priority } : {}),
+        ...(claimable !== undefined ? { claimable } : {}),
     });
     // Tag fields count as "something to update" even when no other flags given
     const hasTagFields = hasBulk || hasIncremental;
@@ -372,7 +390,9 @@ async function taskUpdate(identifier, opts) {
                     if (b.error)
                         errMsg = b.error;
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
                 console.error(`Error: ${(0, sanitize_1.sanitizeField)(errMsg)}`);
                 return 1;
             }
@@ -404,12 +424,16 @@ async function taskUpdate(identifier, opts) {
                     if (b.error)
                         errMsg = b.error;
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
                 console.error(`Error: ${(0, sanitize_1.sanitizeField)(errMsg)}`);
                 return 1;
             }
             // resolvedSprintNumber is set from the resolveSprintId call above
-            const newLabel = resolvedSprintNumber !== null ? `#${resolvedSprintNumber}` : action.newSprintId;
+            const newLabel = resolvedSprintNumber !== null
+                ? `#${resolvedSprintNumber}`
+                : action.newSprintId;
             process.stdout.write(`Sprint: - → ${newLabel}\n`);
             return;
         }
@@ -464,7 +488,9 @@ async function taskUpdate(identifier, opts) {
             }
             const oldLabel = oldNumber !== null ? `#${oldNumber}` : '-';
             // resolvedSprintNumber is set from the resolveSprintId call above
-            const newLabel = resolvedSprintNumber !== null ? `#${resolvedSprintNumber}` : action.newSprintId;
+            const newLabel = resolvedSprintNumber !== null
+                ? `#${resolvedSprintNumber}`
+                : action.newSprintId;
             process.stdout.write(`Sprint: ${oldLabel} → ${newLabel}\n`);
             return;
         }

package/dist/cli/src/index.js CHANGED Viewed

@@ -98,7 +98,9 @@ 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_triage_1 = require("./commands/milestone-triage");
 const milestone_summary_1 = require("./commands/milestone-summary");
+const milestone_changelog_1 = require("./commands/milestone-changelog");
 const milestone_reorder_1 = require("./commands/milestone-reorder");
 const milestone_move_1 = require("./commands/milestone-move");
 const milestone_criteria_set_1 = require("./commands/milestone-criteria-set");
@@ -270,8 +272,9 @@ outcome
     .action(wrap(options => (0, outcome_1.outcomeRate)(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`.')
+    .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`. Use --claimable to restrict to the autonomy boundary (claimable ∩ unblocked ∩ in-budget).')
     .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('cost')
@@ -643,12 +646,25 @@ milestoneCmd
     .description('Unbind one or more tasks from a milestone in one call. Tasks not currently in the milestone are skipped (idempotent), never reassigned. <identifier> accepts a name or UUID; each <task> accepts LUM-N or UUID.')
     .option('--project <ref>', 'Project name or slug (when identifier is a name)')
     .action(wrap((identifier, tasks, options) => (0, milestone_remove_1.milestoneRemove)(identifier, tasks, options)));
+milestoneCmd
+    .command('triage <identifier> <tasks...>')
+    .description('Batch-mark tasks agent-claimable within a milestone (steward triage, LUM-646). Choose a direction: --claimable or --not-claimable. Tasks not in the milestone are skipped. <identifier> accepts a name or UUID; each <task> accepts LUM-N or UUID. `lumo next --claimable` then surfaces only claimable ∩ unblocked ∩ in-budget tasks.')
+    .option('--project <ref>', 'Project name or slug (when identifier is a name)')
+    .option('--claimable', 'Mark the listed tasks agent-claimable')
+    .option('--not-claimable', 'Mark the listed tasks NOT agent-claimable')
+    .action(wrap((identifier, tasks, options) => (0, milestone_triage_1.milestoneTriage)(identifier, tasks, options)));
 milestoneCmd
     .command('summary <identifier>')
     .description('Show the AI-generated summary for a milestone. Identifier accepts a milestone name or UUID. Prints "(no summary generated yet)" when none exists. Use --retry to queue regeneration before fetching.')
     .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('changelog <identifier>')
+    .description("Assemble a structured changelog from the milestone's DONE tasks + merged PRs + frozen claimSnapshot (pure assembly, no LLM; runs on any status). Headline counts carry a baseline vs prior completed milestones; every claim shows provenance. Identifier accepts a milestone name or UUID. --json emits the raw structured payload.")
+    .option('--project <ref>', 'Project name or slug (when identifier is a name)')
+    .option('--json', 'Emit the raw structured changelog payload')
+    .action(wrap((identifier, options) => (0, milestone_changelog_1.milestoneChangelog)(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.")
@@ -877,6 +893,8 @@ task
     .option('-a, --assignee <ref>', 'New assignee: email, name, or "me" (empty string to clear)')
     .option('--milestone <ref>', 'Milestone name (case-insensitive); empty string to unbind')
     .option('--sprint <ref>', 'Sprint number or UUID to bind the task to; empty string to unbind from current sprint')
+    .option('--claimable', 'Mark the task agent-claimable (surfaces in `lumo next --claimable`)')
+    .option('--not-claimable', 'Mark the task NOT agent-claimable (mutually exclusive with --claimable)')
     .option('--tag <name>', 'Set tags by name (bulk replace, repeatable)', collect, [])
     .option('--tag-id <cuid>', 'Set tags by id (bulk replace, repeatable)', collect, [])
     .option('--add-tag <name>', 'Add tag by name (repeatable)', collect, [])

package/dist/cli/src/lib/claimable-filter.js ADDED Viewed

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * LUM-646 (F4/自治边界): the agent-claimable autonomy gate for
+ * `lumo next --claimable`. Pure — no network/IO — so it can be unit-tested
+ * directly and kept out of the ranking comparator.
+ *
+ * A task is inside the autonomy boundary only when ALL THREE hold:
+ *   1. claimable === true         — a steward/human triaged it (fail-closed)
+ *   2. no open blockers            — F3 topology (blockedByOpenCount === 0)
+ *   3. milestone not over budget   — F2 advisory budget (milestoneBudgetExceeded !== true)
+ *
+ * Budget is advisory and fail-open on the unknown: only a MEASURED overrun
+ * (`milestoneBudgetExceeded === true`) excludes a task. `false` / `null` /
+ * absent (no budget set, or unmeasured burn) never excludes — mirroring the
+ * LUM-644 rule that the budget never fabricates an all-clear OR a false alert.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterClaimable = filterClaimable;
+exports.formatClaimableExclusions = formatClaimableExclusions;
+/** A new server always sends a boolean claimable; an old one omits it. */
+function serverSupportsClaimable(tasks) {
+    return tasks.some(t => typeof t.claimable === 'boolean');
+}
+/**
+ * Apply the three-part autonomy gate. Each excluded task is counted under its
+ * FIRST failing reason (claimable → blocked → budget), so the buckets sum to
+ * `tasks.length - kept.length` exactly.
+ */
+function filterClaimable(tasks) {
+    const excluded = {
+        notClaimable: 0,
+        blocked: 0,
+        overBudget: 0,
+    };
+    if (!serverSupportsClaimable(tasks)) {
+        return { supported: false, kept: [], excluded };
+    }
+    const kept = [];
+    for (const t of tasks) {
+        if (t.claimable !== true) {
+            excluded.notClaimable++;
+            continue;
+        }
+        if ((t.blockedByOpenCount ?? 0) > 0) {
+            excluded.blocked++;
+            continue;
+        }
+        if (t.milestoneBudgetExceeded === true) {
+            excluded.overBudget++;
+            continue;
+        }
+        kept.push(t);
+    }
+    return { supported: true, kept, excluded };
+}
+/**
+ * Render the exclusion tally as a one-line, human-readable clause (omitting
+ * zero buckets). Returns '' when nothing was excluded. Pure.
+ */
+function formatClaimableExclusions(excluded) {
+    const parts = [];
+    if (excluded.notClaimable > 0) {
+        parts.push(`${excluded.notClaimable} not triaged claimable`);
+    }
+    if (excluded.blocked > 0) {
+        parts.push(`${excluded.blocked} blocked by open deps`);
+    }
+    if (excluded.overBudget > 0) {
+        parts.push(`${excluded.overBudget} over milestone budget`);
+    }
+    return parts.join(', ');
+}

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

@@ -146,6 +146,10 @@ _now = new Date()) {
         body.linkedResourcesSection,
         body.reviewTodosSection,
         body.layer2ReviewSection,
+        // LUM-647: prior-milestone learnings for a resumed STEWARD session. Only the
+        // steward branch of the session-start hook populates this; task-bound
+        // sessions leave it empty.
+        body.stewardMemorySection,
     ]);
     if (envelope)
         lines.push(envelope);

package/package.json CHANGED Viewed

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