@lumoai/cli 1.42.0 → 1.43.0

package/assets/skill/references/verify.md

@@ -117,6 +117,15 @@ what's unmet and why (the exact failure tails), and how many rounds are left.
   - A pass can carry a **`⚠ pre-edit version`** note (LUM-457): the criterion was changed after that verdict (reworded, or its checkpointer was swapped so the recorded evidence ran a different command). The pass still counts as met (a stale pass does not block DONE — render-only signal), but it vouches for an older version — **re-run `lumo verify` to re-confirm against the current criterion.** This is the habit whenever you edit a MACHINE criterion's checkpointer mid-task: change the check, then re-verify so the green is honest.
 - **History** — one line per recorded round: `rN · timestamp · X PASS / Y FAIL`.
 - **Last round failures** — the most recent round's FAIL verdicts with their rejection reasons (why the last round bounced).
+- **Struggle / rework / outstanding** (LUM-561) — the anti-mum-and-deaf block: **always printed when the contract exists, even on a clean 0-unmet task** so a passing task still shows its scars instead of wiping them to a single PASS count. Lists, when present:
+  - **rework rounds** — verify rounds that had a FAIL;
+  - **send-backs** — criteria sent back by a human/agent verdict (a MACHINE verify-loop FAIL is not a 打回), with their open/resolved lifecycle, preserved even for since-removed criteria;
+  - **leftover follow-ups** — criteria whose latest verdict is `PASS_WITH_FOLLOWUP`;
+  - **PR iterations** — when the task has >1 PR (the dominant rework signal when the verify loop ran once but the work churned across many follow-up PRs — e.g. LUM-557: ~10 PRs vs 1 verify round); a single PR is the happy path and is not flagged;
+  - **reopens** — backward `IN_REVIEW/DONE → IN_PROGRESS/TODO` transitions (from the `STATUS_CHANGED` log): the task reached review/done and got bounced, a rework that leaves no FAIL verdict.
+
+  When the trail is genuinely empty it states the **basis** (`None recorded — N rounds run, 0 FAIL, no send-backs, no reopens, no leftover follow-ups`); when nothing has been verified yet it says so (`No verification has run yet — cannot confirm there were no difficulties`) rather than rendering an implicitly-clean slate. Carried in `--json` as `struggleTrail` (incl. `pullRequests` + `reopens`).
+
 - **Next actions** — the unmet criteria (latest verdict is not a pass: failed or never verified, HUMAN ones included). This list IS the plan — recomputed from the event log on every read, never maintained separately. Empty + rounds recorded = awaiting human adjudication.
 - **Open boundary crossings** (LUM-448) — a trailing safety block when the task has ≥1 OPEN (undispositioned) forbidden-action crossing: a count, then one line per crossing `• [SEVERITY] CATEGORY — <clipped detail>` (highest-severity first), each followed by a read-only **attribution** line `↳ by model=<m> · agent=<type>[/branch] · session=<8-char prefix>` (LUM-469 — who/what crossed; any dimension that couldn't be resolved server-side prints `unknown`, never a fabricated value), then a pointer to the web acceptance panel. Silent when there are none, so it never overshadows the criteria.
   - **Read-only awareness** — this surfaces crossings detected elsewhere (LUM-426/435/442); there is no CLI path to disposition or clear one. Disposition stays web + human-only (LUM-426/435/422): an agent/CLI bearer cannot clear its own crossing from the terminal.

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

@@ -102,10 +102,14 @@ function formatLineageMarkdown(data) {
     lines.push(`**Status**: ${data.task.status}`);
     lines.push('');
     if (data.groups.length === 0) {
-        lines.push('_No lineage edges recorded yet. Lineage is captured when a ' +
-            "bound session consumes this task's context; once that happens " +
-            '(and a PR merges / the task closes), the causal trail and its cost ' +
-            'will appear here._');
+        // LUM-559: an empty report is fail-closed — it means no session ever bound
+        // to this task, so neither its cost nor its causal trail could be measured.
+        // Say "not measured" explicitly; never let the blank read as "zero cost".
+        lines.push('_Cost not measured — no session was ever bound to this task, so its ' +
+            'cost and causal trail could not be recorded. This is "not measured", ' +
+            'not "zero cost". Cost and lineage are captured once a session binds ' +
+            '(`lumo session attach <id>`) and consumes the context; bind before ' +
+            'working so future runs are recorded._');
         lines.push('');
         return lines.join('\n');
     }
@@ -146,6 +150,16 @@ function formatLineageMarkdown(data) {
         }
         const summary = outcomeSummary(fragmentOutcomeCounts(g.fragments));
         lines.push(`**Fragments** (${g.fragments.length}${summary ? `: ${summary}` : ''}):`);
+        // LUM-559: an edgeless cost group is a session that spent tokens but
+        // recorded no fragments (it bound after session-start). Its empty trail is
+        // "not captured", NOT "the session used nothing" — say so, and skip the
+        // per-fragment usage legend that has nothing to annotate.
+        if (g.fragments.length === 0) {
+            lines.push('_Causal fragments not captured — this session bound after start, so ' +
+                'its cost is recorded but its fragment trail is not._');
+            lines.push('');
+            continue;
+        }
         lines.push('_✓ used · · abstained · ✗ unused (manual)_');
         for (const f of g.fragments) {
             const tag = f.disclosure === 'INDEX'

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

@@ -134,6 +134,7 @@ function formatTaskStatus(data, extras = {}) {
             }
         }
     }
+    pushStruggleTrail(lines, data);
     lines.push('');
     if (data.nextActions.length === 0) {
         lines.push(data.currentRound > 0
@@ -165,6 +166,79 @@ function formatTaskStatus(data, extras = {}) {
     pushOpenCrossings(lines, extras);
     return lines.join('\n') + '\n';
 }
+/**
+ * Append the honest "Struggle / rework / outstanding" section (LUM-561) — the
+ * anti-mum-and-deaf block (kills a silent "Nothing outstanding"). It is ALWAYS
+ * rendered when the contract exists, even on a clean 0-unmet task: a passing
+ * task that bounced, was sent back, or left a follow-up behind still shows its
+ * scars. When the trail is genuinely empty the block states the *basis* for
+ * that ("none — N rounds run, 0 FAIL …"), or, when nothing has been verified,
+ * that absence cannot be confirmed — never a bare clean slate. Skipped only
+ * when the server didn't emit the field (older server).
+ */
+function pushStruggleTrail(lines, data) {
+    const trail = data.struggleTrail;
+    if (!trail)
+        return; // older server: can't fabricate, so don't claim "none".
+    lines.push('');
+    lines.push('Struggle / rework / outstanding:');
+    // A single PR is the happy path; >1 PR is the iteration signal. Reopens (a
+    // bounce after IN_REVIEW/DONE) always count. These two catch the rework that
+    // lives in PR cycles / status flips rather than in FAIL verdicts (LUM-561
+    // follow-up — without them a 10-PR task like LUM-557 reads as one hiccup).
+    const prIterated = trail.pullRequests.length > 1;
+    const empty = trail.reworkRounds.length === 0 &&
+        trail.sendBacks.length === 0 &&
+        trail.followUps.length === 0 &&
+        trail.reopens.length === 0 &&
+        !prIterated;
+    if (empty) {
+        if (data.currentRound === 0) {
+            // Honest fail-open: nothing was verified, so we cannot claim there were
+            // no difficulties — say so rather than render an implicitly-clean slate.
+            lines.push('  No verification has run yet — cannot confirm there were no difficulties. Run `lumo verify`.');
+        }
+        else {
+            const rounds = `${data.currentRound} verification round${data.currentRound === 1 ? '' : 's'}`;
+            lines.push(`  None recorded — ${rounds} run, 0 FAIL, no send-backs, no reopens, no leftover follow-ups.`);
+        }
+        return;
+    }
+    if (trail.reworkRounds.length > 0) {
+        const parts = trail.reworkRounds.map(r => `round ${r.round} (${r.failed} FAIL)`);
+        lines.push(`  Rework rounds: ${parts.join(', ')}`);
+    }
+    if (trail.sendBacks.length > 0) {
+        lines.push('  Send-backs:');
+        for (const s of trail.sendBacks) {
+            const lifecycle = s.status === 'resolved'
+                ? `resolved (sent back r${s.failedAtRound}${s.resolvedAtRound != null ? ` → r${s.resolvedAtRound}` : ''})`
+                : `open (sent back r${s.failedAtRound})`;
+            lines.push(`    • ${(0, sanitize_1.sanitizeField)(s.statement)} — ${lifecycle}`);
+        }
+    }
+    if (trail.followUps.length > 0) {
+        lines.push('  Follow-ups left behind:');
+        for (const f of trail.followUps) {
+            lines.push(`    • ${(0, sanitize_1.sanitizeField)(f.statement)} — flagged r${f.round}`);
+        }
+    }
+    // PR iteration — the dominant rework signal when the verify loop only ran
+    // once but the work churned across many PRs (LUM-557). Only when >1 PR.
+    if (prIterated) {
+        const PR_CAP = 12;
+        const nums = trail.pullRequests.map(p => `#${p.number}`);
+        const shown = nums.slice(0, PR_CAP).join(', ');
+        const overflow = nums.length > PR_CAP ? `, +${nums.length - PR_CAP} more` : '';
+        lines.push(`  PR iterations: ${trail.pullRequests.length} PRs (${shown}${overflow})`);
+    }
+    if (trail.reopens.length > 0) {
+        lines.push(`  Reopened ${trail.reopens.length}× (bounced back after review/done):`);
+        for (const r of trail.reopens) {
+            lines.push(`    • ${r.from} → ${r.to}`);
+        }
+    }
+}
 /**
  * Append the OPEN boundary-crossings safety block (LUM-448) — a count, one line
  * per crossing with its severity + category + clipped detail, and a pointer to

package/package.json

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