@lumoai/cli 1.35.0 → 1.37.0

package/assets/skill/SKILL.md

@@ -27,6 +27,7 @@ The command catalog below is a **map**: it lists every command grouped by domain
 | `task artifact*`, `task figma*`                                                         | [references/artifacts-figma.md](references/artifacts-figma.md) |
 | `task criteria set/list`, drafting the acceptance contract                              | [references/criteria.md](references/criteria.md)               |
 | `verify`, `task status` — machine verification loop, claim-done flow, self-check/resume | [references/verify.md](references/verify.md)                   |
+| `cost` — per-operation (per-tool) token cost read-out; `task lineage` Top-5             | [references/task-context.md](references/task-context.md)       |
 | `project list`, `milestone*`                                                            | [references/milestones.md](references/milestones.md)           |
 | `doc*`                                                                                  | [references/docs.md](references/docs.md)                       |
 | `sprint*`                                                                               | [references/sprints.md](references/sprints.md)                 |
@@ -51,11 +52,11 @@ The command catalog below is a **map**: it lists every command grouped by domain
 - `lumo task figma context <id> <linkId>` — Figma link metadata (v1)
 - `lumo task comments list <id>` — comment thread, capped to the output budget (`--full` prints every comment; read-only; ≠ `task comment`)
 - `lumo task pr show <id> <number>` — synced PR metadata (v1)
-- `lumo task lineage <id>` — show the causal trail: fragments that fed the task + each one's outcome + the run's token/loop cost (read-only audit view); `lumo task lineage <id> --signal` also appends workspace-level usage signal-health (used distribution, per-session variance, used-vs-base merge rate)
+- `lumo task lineage <id>` — show the causal trail: fragments that fed the task + each one's outcome (each fragment line shows its disclosure tag: `· INDEX pulled` / `· INDEX not-pulled` / `· FULL`) + the run's token/loop cost (read-only audit view); totals include a single-task disclosure-funnel summary (`- Disclosure funnel: N impressions · M INDEX (X%) · K pulled (Y% of INDEX) · J used (Z%)`) and a per-task **"Top operations by token cost"** Top-5 — the most expensive tools by attributed token cost, with a pointer to the full breakdown via `lumo cost --task <id>`; `lumo task lineage <id> --signal` also appends workspace-level usage signal-health (used distribution, per-session variance, used-vs-base merge rate via iteration-taint fold — tasks with a send-back/reopen/PR-close count as the negative class even if later merged; shows negative-class size per side; prints "metric cannot discriminate" when no failure outcomes exist yet; also prints a raw count of mid-flight `--new-scope` spinoffs (recorded, not yet judged — LUM-511 Phase 3)) and a workspace-wide disclosure funnel in the same shape as the single-task line
 
 **Tasks** — see [tasks.md](references/tasks.md)
 
-- `lumo task create <title> [flags]` — create a task
+- `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 list [flags]` — list tasks assigned to you
 - `lumo next [--count N]` — recommend the next task to work on (read-only)
@@ -79,8 +80,12 @@ The command catalog below is a **map**: it lists every command grouped by domain
 **Verification (machine acceptance loop)** — see [verify.md](references/verify.md)
 
 - `lumo verify [task] [--timeout <seconds>]` — run every MACHINE criterion's checkpointer locally, report one structured PASS/FAIL verdict per criterion to the server, print next actions. Defaults to the session-bound task. Round cap 3: an all-pass round moves the task to IN_REVIEW (agent stops there); a round-3 fail escalates to a human (stop retrying). **Run this before claiming a task is done.**
-- `lumo task status [task] [--json]` — read-only acceptance self-check (no LLM, milliseconds): the contract with each criterion's latest verdict (REVIEW_ADDED provenance visible), verification history, current round, last round's failure reasons, `nextActions` = the unmet criteria (the declarative "what's next" — no separate plan), and any OPEN (undispositioned) boundary crossings (count + per crossing category/severity/detail + a read-only attribution line `↳ by model=…·agent=…·session=…` naming who/what crossed, `unknown` when unresolved — LUM-469; `--json` adds an `openCrossings` field, each entry carrying an `attribution` object) — read-only awareness, disposition stays web + human-only (LUM-448). The crossings check fails closed (LUM-480): if the read errors, the block prints `⚠ Boundary-crossing check failed` instead of staying silent, and `--json` sets `openCrossings: null` (distinct from `[]` = a successful read with zero open — treat `null` as "could not confirm", not "safe"). Defaults to the session-bound task; `--json` emits a versioned payload (`version` field). **Run it first when resuming a task in a new session or after a verification round was rejected.**
-- `lumo verdict [task] --pass | --pass-with-followup | --fail` — acceptance verdicts (LUM-422). `--pass` / `--pass-with-followup` open the browser to the human verdict bar focused on the passing action (a deep link — **records nothing**; a passing data row is only ever a human's own click). `--fail --reason <enum> [--note <text>] [--criterion <id>…]` records an **AGENT send-back** (verifierType=AGENT, verdict hard-coded FAIL) and bounces the task to IN_PROGRESS. Defaults to the session-bound task. **An unresolved send-back (machine/AGENT/human FAIL) blocks the agent/CLI DONE transition with 409** — clear it (re-verify) before `task update --status done`.
+- `lumo task status [task] [--json]` — read-only acceptance self-check (no LLM, milliseconds): the contract with each criterion's latest verdict (REVIEW_ADDED provenance visible), verification history, current round, last round's failure reasons, a per-criterion **send-back lifecycle** line when applicable (`↳ send-back (rN) resolved in rM · PR #K` / `… open` — LUM-511 Phase 5), `nextActions` = the unmet criteria (the declarative "what's next" — no separate plan), and any OPEN (undispositioned) boundary crossings (count + per crossing category/severity/detail + a read-only attribution line `↳ by model=…·agent=…·session=…` naming who/what crossed, `unknown` when unresolved — LUM-469; `--json` adds an `openCrossings` field, each entry carrying an `attribution` object) — read-only awareness, disposition stays web + human-only (LUM-448). The crossings check fails closed (LUM-480): if the read errors, the block prints `⚠ Boundary-crossing check failed` instead of staying silent, and `--json` sets `openCrossings: null` (distinct from `[]` = a successful read with zero open — treat `null` as "could not confirm", not "safe"). Defaults to the session-bound task; `--json` emits a versioned payload (`version` field). **Run it first when resuming a task in a new session or after a verification round was rejected.**
+- `lumo verdict [task] --pass | --fail` — acceptance verdicts (LUM-422). `--pass` opens the browser to the human verdict bar focused on Pass (a deep link — **records nothing**; a passing data row is only ever a human's own click). `--fail --reason <enum> [--note <text>] [--criterion <id>…]` records an **AGENT send-back** (verifierType=AGENT, verdict hard-coded FAIL) and bounces the task to IN_PROGRESS. Defaults to the session-bound task. **An unresolved send-back (machine/AGENT/human FAIL) blocks the agent/CLI DONE transition with 409** — clear it (re-verify) before `task update --status done`.
+
+**Cost (per-operation token read-out)** — see [task-context.md](references/task-context.md)
+
+- `lumo cost [--task <id>|--session <id>|--since <date>] [--by tool|model|member|session] [--json]` — per-operation (per-tool) token cost read-out. Attributes each model step's token delta to the tool(s) it ran (per-step where POST_TOOL_BATCH data exists, per-turn fallback otherwise), output vs cache_read shown separately, plus a per-step coverage line and a "heuristic" note (parallel tools split a step's tokens evenly). Scope is mutually exclusive: `--task` (one task) / `--session` (one Claude Code session) / `--since` (workspace window); default = workspace last-30-days. `--by` only changes which grouping is the headline (the others are still printed when non-trivial). For the per-task Top-5 inline, see `lumo task lineage`.
 
 **Artifacts & Figma** — see [artifacts-figma.md](references/artifacts-figma.md)
 
@@ -120,13 +125,14 @@ The command catalog below is a **map**: it lists every command grouped by domain
 **Memory** — see [memory.md](references/memory.md)
 
 - `lumo task memory add/list` · `lumo project memory add/list` — record/curate Memory (TASK vs PROJECT)
+- `lumo memory show <id>` — show one memory's full card (category + content) by id (progressive disclosure from a one-line index entry)
 - `lumo memory promote <id>` / `lumo memory rm <id> --yes` — TASK→PROJECT / delete
 
 **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 status` — show current binding
-- `lumo session wrap [--yes] [--dry-run] [--used <indices>]` — end-of-session panel: progress comment + memory review + fragment-usage vote (`--used`, LUM-300) + blocked-tag prompt, then a read-only reminder when the bound task has ≥1 OPEN boundary crossing still undispositioned (silent only on a genuine empty read — no wrap-up noise; a crossings-check failure prints a "could not confirm" warning instead of staying silent, LUM-480; pointer is web + human-only, LUM-448). Usage is now also audited automatically when a task reaches DONE (evidence-gated, true-only — confident fragments marked used, the rest left NULL); `session wrap --used` remains the manual override and takes precedence for a session.
+- `lumo session wrap [--yes] [--dry-run] [--used <indices>]` — end-of-session panel: memory review + fragment-usage vote (`--used`, LUM-300) + blocked-tag prompt, then a read-only reminder when the bound task has ≥1 OPEN boundary crossing still undispositioned (silent only on a genuine empty read — no wrap-up noise; a crossings-check failure prints a "could not confirm" warning instead of staying silent, LUM-480; pointer is web + human-only, LUM-448). Usage is now also audited automatically when a task reaches DONE (evidence-gated, true-only — confident fragments marked used, the rest left NULL); `session wrap --used` remains the manual override and takes precedence for a session.
 - Git-suggest at session start (suggests `session attach`, never auto-binds) + Layer-2 project-memory review — see the reference
 
 **Worktrees (local dev tooling)** — see [worktree.md](references/worktree.md)

package/assets/skill/references/criteria.md

@@ -49,6 +49,19 @@ across all stages: a criterion that already has verification runs is
 run-free criterion is hard-deleted. Either way, reword rather than delete when
 possible.
 
+### A send-back may mean the contract was wrong — amend it, don't spin off
+
+If a send-back reveals the **contract itself** was wrong or incomplete, the right
+move is to **amend the criteria on this task** (`lumo task criteria set <id>`,
+and with `--human` annotate the reason via `--cause NEW_INFO | SCOPE_CHANGE |
+DRAFT_BLIND_SPOT`) and re-verify — **not** to open a new task. Sharpening the
+contract as understanding grows is expected; that's what the drift trail is
+_for_, not something to avoid. **The line:** amending to reflect reality is
+legitimate; **weakening a criterion you were just FAILed on, purely to make it
+pass, is tampering** — it's audited and counts as a failure either way. Deleting
+a failed criterion doesn't help: the DONE gate still blocks on its standing FAIL
+(the run is soft-deleted, the verdict survives).
+
 ## Scale the contract to the task size
 
 The 3–7 range is calibrated for typical multi-file tasks. The criterion count

package/assets/skill/references/docs.md

@@ -82,7 +82,7 @@ The `Tags:` line is omitted when no tags were attached.
 | `--title <text>`         | string              | New title (cannot be empty).                                                                                                                                                                                                                                          |
 | `--content <text>`       | string              | Replace content (inline).                                                                                                                                                                                                                                             |
 | `--file <path>`          | string              | Replace content from file.                                                                                                                                                                                                                                            |
-| (stdin)                  | —                   | Pipe to replace content.                                                                                                                                                                                                                                              |
+| (stdin)                  | —                   | Pipe to replace content. Empty / whitespace-only stdin (a non-TTY shell with nothing piped — the common agent case) is treated as **no content channel**, not a body clear (LUM-505).                                                                                 |
 | `--scope <scope>`        | enum                | `personal` / `workspace`.                                                                                                                                                                                                                                             |
 | `--project <ref>`        | string              | Project name/slug. `--project ""` clears the filing.                                                                                                                                                                                                                  |
 | `--tag <name>`           | string (repeatable) | **Bulk replace** the tag set by name. Creates tag if missing. Max 20. Mutually exclusive with `--add-tag*` / `--remove-tag*`.                                                                                                                                         |
@@ -93,6 +93,8 @@ The `Tags:` line is omitted when no tags were attached.
 | `--remove-tag-id <cuid>` | string (repeatable) | Detach tag by id. Unknown ids are a no-op (no side effects). Max 20.                                                                                                                                                                                                  |
 | `--allow-shrink`         | boolean             | Let a body update through even when it drops tables/rows/headings versus the stored body (see structure guard below).                                                                                                                                                 |
 
+A **metadata-only update leaves the body untouched** (LUM-505): when no content channel is supplied (`--title`/`--scope`/`--project`/tag flags only), the body is omitted from the PATCH — it does not get blanked and the structure guard cannot fire. To deliberately clear or replace the body you must supply a content channel explicitly (`--content ""` to clear, which then hits the structure guard as a shrink → pair with `--allow-shrink`).
+
 Optimistic concurrency (LUM-409): `--if-revision <n>` only applies the update if the doc body is still at revision `n` (from `doc show`). Mismatch → 409 conflict, nothing written — re-read, rebase, retry. `--if-revision` alone is not an update (still errors "no fields to update"); same for `--allow-shrink`.
 
 **Structure guard (LUM-410), built into the server:** a body update whose new render has **fewer `table` / `tr` / heading elements than the stored body** is rejected with **422** before anything is written — the error names each shrunk category with old→new counts (e.g. `table 1→0, tr 4→0`). This is the `verify-live-doc.ts` reconciliation moved into the write path, so table flattening (LUM-349) and stale-base section loss (#460) fail loudly even when nobody remembers to run the script. When the deletion is intentional (you really are removing a section/table), re-run with `--allow-shrink`. On a 422: don't reach for `--allow-shrink` reflexively — first check whether your edit base is stale (`doc show <doc> --raw`) and rebase. Only markdown-path writes are guarded; web-editor edits and `doc sync` (Google authority) are not.

package/assets/skill/references/memory.md

@@ -26,6 +26,7 @@ lumo project memory add [<project>] --category convention --rule "..." --applies
 # Omitting --agent records the memory as produced by Claude Code.
 
 # Single-memory ops (memoryId from `... memory list` column 1)
+lumo memory show <memoryId>        # show one memory's full card by id
 lumo memory promote <memoryId>     # TASK → PROJECT
 lumo memory rm <memoryId> --yes    # hard delete
 ```
@@ -47,10 +48,29 @@ lumo task memory add LUM-42 --category decision --what "Store doc content as Tip
 lumo project memory add lumo --category procedural --workflow "Regenerate the CLI grammar snapshot" --trigger "any cli/src/commands change" --step "npx tsx scripts/analysis/lum392-cli-friction/emit-grammar.ts" --step "npx jest scripts/analysis/lum392-cli-friction" --agent claude-code
 
 # Curate
+lumo memory show cmpi19iqabc123
 lumo memory promote cmpi19iqabc123
 lumo memory rm cmpi19iqabc123 --yes
 ```
 
+### `lumo memory show <id>` (progressive disclosure)
+
+Fetches one memory's full card by id from the server and prints its category tag
+(`[TRAP]`, `[DECISION]`, `[CONVENTION]`, `[WORKFLOW]`, …) followed by the
+structured `content` body (pretty-printed JSON).
+
+- **Arg**: `<memoryId>` (required) — the id you saw in `... memory list` column 1
+  or as a one-line index entry at session start. Without it the command errors
+  with a usage line and exits 1.
+- **Errors**: not-logged-in (run `lumo auth login`), `401` invalid/revoked key,
+  `404` memory not found in your workspace (cross-workspace ids 404 too), other
+  non-2xx → generic HTTP error; all exit 1.
+
+**When to suggest**: at session start memories arrive as one-line index entries.
+When a specific entry looks relevant to the task at hand, run
+`lumo memory show <id>` to pull its full body before acting on it — read the
+detail on demand instead of carrying every memory's content in context.
+
 ### Reconcile-on-write & deduplication
 
 `memory add` does **not** unconditionally insert a new row. Before writing it:

package/assets/skill/references/sessions.md

@@ -125,18 +125,11 @@ lumo session status
 
 When to suggest: the user asks "which task am I on", "what's this session bound to", or you need to decide whether to suggest `session attach` for a mentioned task ID.
 
-### `lumo session wrap [--yes] [--dry-run] [--used <indices>]` — wrap-up panel: progress comment + memory review + fragment-usage vote + blocked-tag prompt
+### `lumo session wrap [--yes] [--dry-run] [--used <indices>]` — wrap-up panel: memory review + fragment-usage vote + blocked-tag prompt
 
-Session-end wrap-up panel with **four sections, run in order**:
+Session-end wrap-up panel with **three sections, run in order**:
 
-**1. Progress comment** — reads back the current Claude Code session's per-turn
-`turnSummary` rows (the one-line summaries written each STOP), aggregates
-every turn **since the last progress comment** into one bulleted body, and — after
-a `[y] post / [e] edit / [s] skip` confirmation — posts it as a comment on the
-session's bound task. A server-side watermark (`Session.lastProgressCommentAt`)
-means re-running never re-posts the same turns.
-
-**2. Memory review** — lists the Layer1 memories this session sedimented since the
+**1. Memory review** — lists the Layer1 memories this session sedimented since the
 last review (deduped by a per-session watermark `Session.lastMemoryReviewAt`).
 Each new memory is shown as `[SCOPE] CATEGORY  headline`, numbered from 1. You
 curate with a single line: `d 1,3` deletes rows 1 and 3, `p 2` promotes row 2 to
@@ -147,7 +140,7 @@ Out-of-range indices are ignored. Deletes/promotes run server-side, scoped to
 memories this session created (you can't touch other sessions' memories through
 this panel). With no new memories the section prints "(no content)" and does nothing.
 
-**3. Fragment-usage vote (LUM-300)** — lists the context
+**2. Fragment-usage vote (LUM-300)** — lists the context
 fragments this session **consumed** (its lineage edges: memory / slack / web /
 figma / PR / review-todo / session), numbered from 1 with a content snippet
 label. The agent records which it **actually used** via
@@ -161,7 +154,7 @@ upgrades the flywheel signal from "co-loaded" (constant, no information) to
 fragment's usage-based merge rate, falling back to the weaker presence rate when
 usage samples are thin. With no consumed fragments the section prints "(no content)".
 
-**4. Blocked check (blocked-tag prompt, LUM-153)** — if the **same kind of failure
+**3. Blocked check (blocked-tag prompt, LUM-153)** — if the **same kind of failure
 recurred ≥ 3 times** in this session (server-aggregated from
 `POST_TOOL_USE_FAILURE` events grouped by tool name, plus `STOP_FAILURE`
 turn-level failures), the section surfaces the dominant failure (`This session looks repeatedly stuck on <tool> (N failures).` + last error summary) and prompts `[y] tag / [s] skip` whether to
@@ -177,7 +170,7 @@ shared board requires an interactive `y`, so `--yes` (and non-TTY) prints the
 suggestion and moves on rather than silently flipping board state. When there's
 nothing to prompt, the section prints "(no content)".
 
-**After the panel — open-crossings reminder (LUM-448).** Once the four sections
+**After the panel — open-crossings reminder (LUM-448).** Once the three sections
 finish, `session wrap` prints a one-shot read-only reminder **if** the bound
 task has ≥1 OPEN (undispositioned) boundary crossing: `⚠ N open boundary
 crossing(s) on LUM-N still undispositioned:` then a line per crossing `• [SEVERITY]
@@ -194,31 +187,27 @@ clear its own crossing from the terminal.
 
 ```bash
 lumo session wrap                  # interactive: preview each section, choose per-section
-lumo session wrap --yes            # progress posted + memories kept; blocked tag NOT auto-applied (needs interactive y)
+lumo session wrap --yes            # memories kept; blocked tag NOT auto-applied (needs interactive y)
 lumo session wrap --yes --used 1,3 # also record fragments 1 & 3 as used (the rest used=false)
 lumo session wrap --used none      # record that none of the injected fragments were used
-lumo session wrap --dry-run        # print all drafts only; never posts, never mutates, never advances watermarks
+lumo session wrap --dry-run        # print all drafts only; never mutates, never advances watermarks
 ```
 
 The usage vote is a two-step flow for agents: run `lumo session wrap` once to
 see the numbered fragment list, decide which you actually used, then re-run with
 `--used <indices>`. Re-running is safe — the other sections are watermark-guarded
-(progress won't double-post, reviewed memories won't re-list).
+(reviewed memories won't re-list).
 
 - Requires `$CLAUDE_CODE_SESSION_ID` (must run inside Claude Code) and a bound
-  task (`lumo session attach <LUM-N>` first). With no bound task or no new turn
-  summaries, the Progress comment section prints "(no content)" and posts nothing.
-- `[e] edit` (Progress comment) opens `$EDITOR` (fallback vi/nano) on the drafted body;
-  the edited text is posted and the watermark still advances to the turns the
-  draft covered.
-- `--yes` posts the progress comment AND keeps all memories (no
-  deletes/promotes) while advancing the memory-review watermark; for the
-  blocked-tag section it prints the suggestion but does **not** apply the tag.
-- `--dry-run` prints all drafts; never posts, never mutates memories/tags, never
-  advances either watermark.
-- Non-TTY without `--yes`: prints the drafts and does **not** post, mutate, or
-  tag (safe default).
-
-When to suggest: at the end of a working session on a bound task, to record what
-was done as a progress comment — offer `lumo session wrap` rather than composing
-a `task comment` by hand.
+  task (`lumo session attach <LUM-N>` first).
+- `--yes` keeps all memories (no deletes/promotes) while advancing the
+  memory-review watermark; for the blocked-tag section it prints the suggestion
+  but does **not** apply the tag.
+- `--dry-run` prints all drafts; never mutates memories/tags, never advances the
+  memory-review watermark.
+- Non-TTY without `--yes`: prints the drafts and does **not** mutate or tag (safe
+  default).
+
+When to suggest: at the end of a working session on a bound task, to review the
+memories it sedimented, vote which injected fragments were actually used, and
+flag the task `blocked` if it got repeatedly stuck — offer `lumo session wrap`.

package/assets/skill/references/task-context.md

@@ -132,20 +132,38 @@ identifier (`LUM-N`), prints the causal trail:
 
 ```bash
 lumo task lineage LUM-42            # per-session causal trail + cost
-lumo task lineage LUM-42 --signal   # append workspace-level usage signal-health
+lumo task lineage LUM-42 --signal   # append workspace-level usage signal-health; used-vs-base merge rate uses iteration-taint fold (send-back/reopen/PR-close = negative class even if later merged); shows negative-class size per side; prints "metric cannot discriminate" when no failure outcomes exist yet
 ```
 
 - **Totals banner** — distinct sessions, fragment count, edge count,
   total tokens (input/output/cache split) and loops, and the outcome
-  distribution.
+  distribution. After the outcome summary, one funnel line is appended:
+  `- Disclosure funnel: N impressions · M INDEX (X%) · K pulled (Y% of INDEX) · J used (Z%)`
+  where impressions = edge count, INDEX% and used% are over impressions,
+  pull% is over INDEX only (FULL fragments have no pull opportunity).
+  Divide-by-zero is guarded (zero impressions or zero INDEX renders `0%`).
+  When per-fragment token weights have been collected (LUM-522), the line also
+  appends `· ~T tokens saved` = Σ(fullTokens − indexTokens) over un-pulled INDEX
+  edges (the token cost the index-only injection avoided); the suffix is omitted
+  cleanly when no edge carries token data yet (older edges predate the columns).
 - **One block per session** — the group's cost shown **once** (token/loop),
   the date it consumed context, then each context fragment as
-  `[OUTCOME] TYPE — <source label>`, plus a per-group outcome summary.
+  `[OUTCOME] TYPE — <source label>`, plus a disclosure annotation suffix:
+  `· INDEX pulled` (INDEX fragment, `pulledAt` is set) /
+  `· INDEX not-pulled` (INDEX fragment, never pulled) /
+  `· FULL` (injected in full at session-start).
+  Per-group outcome summary follows.
 
 Cost is attributed once per session (a session that injected many fragments is
 not double-counted). Fragment ids are canonical — MEMORY fragments survive
 consolidation drift.
 
+**`--signal` workspace funnel:** the workspace-level usage signal-health block
+appended by `--signal` ends with a workspace-wide disclosure funnel in the
+same format: `- Disclosure funnel: N impressions · M INDEX (X%) · K pulled (Y% of INDEX) · J used (Z%)`
+aggregated over all edges in the workspace (not just this task) — including the
+same `· ~T tokens saved` suffix when token data exists (LUM-522).
+
 **Cold start:** a task with no edges prints a friendly note (lineage is captured
 when a session-bound run consumes the task's context), not an error.
 
@@ -154,3 +172,48 @@ use, and what did it cost" for a task / merged PR — CFO / compliance / trust
 narratives.
 
 Entry point is the task identifier only; PR-number lookup is a future addition.
+
+**Top operations by token cost (LUM-523):** the lineage totals also append a
+per-task **"Top operations by token cost"** Top-5 — the most expensive tools by
+attributed token cost (`<tool> — N tokens`), ending with the pointer
+`(full breakdown: lumo cost --task <id>)`. The block is omitted when no
+per-operation cost has been attributed yet.
+
+## `lumo cost`
+
+Per-operation (per-tool) token cost read-out. Where `task lineage` answers
+"what context fed this task and what did the run cost," `lumo cost` answers
+"which _operations_ (tools) burned the tokens." It attributes each model step's
+token delta to the tool(s) that ran in it — **per-step** where the
+`POST_TOOL_BATCH` hook captured the tool list, **per-turn fallback** otherwise
+(a parallel-tool step splits its tokens evenly across the tools, hence the
+"heuristic" note). `output` (generation) and `cache_read` (~95%, structural —
+turns × context) are shown in separate columns.
+
+```bash
+lumo cost --task LUM-42
+lumo cost --session <session-id> --by model
+lumo cost --since 2026-06-01 --by member --json
+```
+
+- **Scope (mutually exclusive)** — `--task <id>` scopes to one task,
+  `--session <id>` to one Claude Code session, `--since <ISO-date>` to a
+  workspace window from that date. With none given, the default is a
+  **workspace last-30-days** window. (If more than one is passed, the CLI
+  picks task > session > since.)
+- **`--by tool|model|member|session`** (default `tool`) — only changes which
+  grouping is the **headline** table; the other groupings are still printed
+  below when non-trivial (member/session tables appear only when there is more
+  than one). Case-insensitive.
+- **`--json`** — emit the versioned payload (`version: 1`, scope, grandTotal,
+  coverage, and `byTool` / `byModel` / `byMember` / `bySession` row arrays)
+  instead of the rendered tables.
+- **Coverage line** — `Per-step attribution: X% of N tool-using turns` tells
+  you how much of the report is precise per-step attribution vs the per-turn
+  fallback. `n/a` when there were no tool-using turns.
+
+**When to suggest:** the user asks where their tokens went _by operation_ —
+"which tools are most expensive," cost attribution by model / teammate /
+session, or a workspace cost window. For the quick per-task Top-5 inline, point
+them at `lumo task lineage <id>` instead; reach for `lumo cost` for the full
+breakdown or any non-task scope.

package/assets/skill/references/verify.md

@@ -63,6 +63,18 @@ only).
   them; the server rejects partial rounds.
 - Criteria added during review (`REVIEW_ADDED`) appear in the contract and
   are picked up automatically by the next round.
+- **Session bound to a different task (LUM-459)** → the server returns 409,
+  which the command surfaces as an error. No advisory is printed; the verify
+  round is rejected outright.
+- **Provably-unbound session** → the server includes `bindingAdvisory: 'unbound'`
+  in the round response, and the command prints:
+  `⚠ Working unbound — this verify ran from a Claude Code session not attached to the task.`
+  The run is recorded as a `SESSION_BINDING_MISSING` boundary crossing visible in
+  `lumo task status` open crossings. Run `lumo session attach <LUM-N>` before the
+  next verify to bind the session.
+- **Unconfirmed session binding** → `bindingAdvisory: 'unconfirmed'` causes a
+  softer advisory: `⚠ Could not confirm this session is attached to the task.`
+  Same remediation: `lumo session attach <LUM-N>`.
 
 ## Round discipline
 
@@ -205,17 +217,17 @@ is ever agent-produced.**
 
 ```
 lumo verdict --pass
-lumo verdict LUM-42 --pass-with-followup
+lumo verdict LUM-42 --pass
 lumo verdict --fail --reason CRITERION_UNMET --note "the retry path is still missing"
 lumo verdict LUM-42 --fail --reason scope_mismatch --criterion c-abc123
 ```
 
-### --pass / --pass-with-followup — a deep link, never a write
+### --pass — a deep link, never a write
 
-These resolve the task, then open the browser to its verdict bar focused on the
-passing action. **The CLI writes nothing** — PASS / PASS_WITH_FOLLOWUP only ever
-land from a human's own click (Clerk session). Use this to hand a finished task
-to a human for the final pass; it carries them one click from recording it.
+This resolves the task, then opens the browser to its verdict bar focused on
+Pass. **The CLI writes nothing** — PASS only ever lands from a human's own click
+(Clerk session). Use this to hand a finished task to a human for the final pass;
+it carries them one click from recording it.
 
 ### --fail — the AGENT send-back
 
@@ -244,3 +256,42 @@ criteria were never adjudicated, transitions freely — the gate only blocks an
 actual send-back, never an un-adjudicated criterion. When the machine loop has
 left a task IN_REVIEW with no send-back standing, the agent may move it to DONE
 directly; a human-PASS row is a provable manual override, not a required ticket.
+
+## When a defect appears — fix in place, don't spin off a new task
+
+On a send-back **or** a self-review finding: if the issue falls under any
+existing acceptance criterion of **this** task, fix it in place and re-run
+`lumo verify`. **Do not** `lumo task create` for it. New tasks are only for work
+genuinely _outside_ this task's acceptance contract. Creating a task (and PR)
+for in-scope rework launders a first-attempt failure — it bypasses the DONE
+gate's send-back protection and corrupts the flywheel signal.
+
+This is now enforced: when you're mid-task, `lumo task create` refuses the bare
+form and makes you declare intent — `--rework-of <id>` (it redirects you back to
+fix the existing task and creates nothing) or `--new-scope` (genuinely new,
+separate work). If the send-back reveals the **contract itself** was wrong,
+amend it on this task (`lumo task criteria set`) rather than opening a new
+task — see criteria.md.
+
+**Hard rule:** while THIS task has an unresolved send-back (any criterion's
+latest verdict is FAIL — the same condition that blocks DONE), `lumo task create`
+is refused with 409 **even with `--new-scope`**. A standing send-back means the
+task can't be completed yet; resolve it (fix + `lumo verify`, or amend the
+contract) before opening any new work. `--rework-of` still redirects you to it.
+
+## Human-reported defects, once a task is submitted
+
+When someone reports a defect in conversation, your action depends on whether the
+task has **ever entered IN_REVIEW**:
+
+- **Not yet** (still your first working pass) → just fix it and continue. No
+  verdict needed — nothing was claimed complete, so there's nothing to contradict.
+- **Already submitted** (entered IN*REVIEW / DONE / merged) → **do not silently
+  fix and re-pass.** Either record your own send-back (`lumo verdict --fail`,
+  noting it was human-reported — this is \_your* honest concurrence, not a forged
+  human verdict), or ask the reporter to record a human FAIL via the web UI /
+  Slack (the only channel that can attribute it to a human). If the defect is a
+  **new requirement** not covered by any criterion, first transcribe it with
+  `lumo task criteria set --human`, then proceed. You can never write a human
+  _verdict_ — the terminal can't prove a human is behind the command
+  (attribution integrity, not anti-forgery).

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatOperationCost = formatOperationCost;
+exports.cost = cost;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+/** Deterministic thousands separator (no locale dependency, test-stable). */
+function groupThousands(value) {
+    return Math.round(value)
+        .toString()
+        .replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+function rankTable(title, rows) {
+    if (rows.length === 0)
+        return '';
+    const lines = [
+        title,
+        '  operation              output      cache_read       total',
+    ];
+    for (const r of rows.slice(0, 20)) {
+        lines.push(`  ${r.label.slice(0, 20).padEnd(20)}  ${groupThousands(r.output).padStart(10)}  ${groupThousands(r.cacheRead).padStart(12)}  ${groupThousands(r.total).padStart(12)}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Render an OperationCostResponse as the per-operation cost report. Pure
+ * function (no clock / env / network) so it is deterministic and unit-testable.
+ */
+function formatOperationCost(data, by) {
+    const primary = by === 'model'
+        ? data.byModel
+        : by === 'member'
+            ? data.byMember
+            : by === 'session'
+                ? data.bySession
+                : data.byTool;
+    const pct = data.coverage.perStepPct == null
+        ? 'n/a'
+        : `${Math.round(data.coverage.perStepPct * 100)}%`;
+    const out = [];
+    out.push(`Per-operation cost — ${data.scope.kind} ${data.scope.label}`);
+    out.push(`Total: output ${groupThousands(data.grandTotal.output)} · cache_read ${groupThousands(data.grandTotal.cacheRead)} · all ${groupThousands(data.grandTotal.total)} tokens`);
+    out.push(`Per-step attribution: ${pct} of ${data.coverage.toolTurns} tool-using turns (rest fall back to per-turn split)`);
+    out.push('');
+    out.push(rankTable(`By ${by}:`, primary));
+    if (by !== 'tool')
+        out.push('\n' + rankTable('By tool:', data.byTool));
+    if (by !== 'model')
+        out.push('\n' + rankTable('By model:', data.byModel));
+    if (by !== 'member' && data.byMember.length > 1)
+        out.push('\n' + rankTable('By member:', data.byMember));
+    if (by !== 'session' && data.bySession.length > 1)
+        out.push('\n' + rankTable('By session:', data.bySession));
+    out.push('');
+    out.push('Note: token→tool attribution is heuristic — a model step that fires several tools in parallel splits its tokens evenly across them; cache_read (~95%) is structural (turns × context), shown alongside output (generation).');
+    return out.join('\n');
+}
+async function cost(opts) {
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    const byArg = opts.by?.toLowerCase();
+    const by = byArg === 'model' || byArg === 'member' || byArg === 'session'
+        ? byArg
+        : 'tool';
+    const params = new URLSearchParams();
+    if (opts.task)
+        params.set('task', opts.task);
+    else if (opts.session)
+        params.set('session', opts.session);
+    else if (opts.since)
+        params.set('since', opts.since);
+    const apiUrl = (0, api_1.resolveAuthedApiUrl)(creds.apiUrl);
+    const qs = params.toString();
+    const url = `${(0, api_1.trimTrailingSlash)(apiUrl)}/api/cost${qs ? `?${qs}` : ''}`;
+    let res;
+    try {
+        res = await fetch(url, {
+            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.status === 404) {
+        console.error(`Error: task ${opts.task ?? ''} not found in workspace ${creds.workspaceSlug}`);
+        return 1;
+    }
+    if (!res.ok) {
+        console.error(`Error: server returned HTTP ${res.status}`);
+        return 1;
+    }
+    const data = (await res.json());
+    if (opts.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    console.log(formatOperationCost(data, by));
+}

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryShow = memoryShow;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const sanitize_1 = require("../lib/sanitize");
+const report_pull_1 = require("../lib/report-pull");
+/**
+ * `lumo memory show <memory-id>`
+ *
+ * Progressive disclosure: fetch one memory's full card by id from
+ * `/api/memories/:id`. The agent sees memories as one-line index entries at
+ * session start; this pulls the body of a specific one on demand. Prints the
+ * category tag and the structured content.
+ */
+async function memoryShow(id) {
+    if (!id) {
+        console.error('Error: usage: lumo memory show <memory-id>');
+        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 res;
+    try {
+        res = await fetch(`${base}/api/memories/${encodeURIComponent(id)}`, {
+            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.status === 404) {
+        console.error(`Error: memory ${id} not found in workspace ${creds.workspaceSlug}`);
+        return 1;
+    }
+    if (!res.ok) {
+        console.error(`Error: memory show failed (HTTP ${res.status})`);
+        return 1;
+    }
+    const { memory } = (await res.json());
+    console.log((0, sanitize_1.sanitizeField)(`[${memory.category}]`));
+    console.log((0, sanitize_1.sanitizeField)(JSON.stringify(memory.content, null, 2)));
+    // LUM-500: stamp the disclosure funnel. The arg id == lineage MEMORY
+    // fragmentId. Fire-and-forget — never blocks output, swallows failures.
+    await (0, report_pull_1.reportPull)({ fragmentType: 'MEMORY', fragmentId: id });
+}

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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 fragment_usage_section_1 = require("./wrap/fragment-usage-section");
 const blocked_prompt_section_1 = require("./wrap/blocked-prompt-section");
@@ -11,13 +10,12 @@ const crossings_reminder_1 = require("./wrap/crossings-reminder");
 /**
  * `lumo session wrap [--yes] [--dry-run]`
  *
- * Session-end wrap-up panel with four 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) vote which injected context fragments were actually used
- * (LUM-300, via `--used`); (4) if the session repeatedly hit the same failure,
- * prompt whether to flag the bound task with a `blocked` tag (LUM-153).
+ * Session-end wrap-up panel with three sections, run in order: (1) review the
+ * Layer1 memories this session sedimented — keep/delete/promote, deduped by a
+ * per-session watermark; (2) vote which injected context fragments were
+ * actually used (LUM-300, via `--used`); (3) if the session repeatedly hit the
+ * same failure, prompt whether to flag the bound task with a `blocked` tag
+ * (LUM-153).
  */
 async function sessionWrap(options) {
     const sessionId = process.env.CLAUDE_CODE_SESSION_ID;
@@ -32,7 +30,6 @@ async function sessionWrap(options) {
         return 1;
     }
     const sections = [
-        new progress_comment_section_1.ProgressCommentSection({ creds, sessionId }),
         new memory_review_section_1.MemoryReviewSection({ creds, sessionId }),
         new fragment_usage_section_1.FragmentUsageSection({ creds, sessionId, used: options.used }),
         new blocked_prompt_section_1.BlockedPromptSection({ creds, sessionId }),