@lumoai/cli 1.42.0 → 1.44.0

package/assets/skill/references/verify.md

@@ -117,6 +117,16 @@ 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).
+- **Cost** (LUM-560) — 规律 1: the costs a human should weigh, on the same report as the verdict instead of scattered across the web delivery card and `task lineage`. Three lines: **Tokens** (total input+output+cache across the task's sessions), **Active time** (non-idle agent seconds — Σ per-turn `STOP − prompt`, LUM-487), and **Rework rounds** (verify rounds that recorded a FAIL). Read from the **same** server-side source the web delivery card consumes (`retrospectiveRepository.loadActuals`), so the two reports cannot drift. Token cost is **fail-closed**: when no session usage was recorded it prints `Tokens: not recorded (no session usage captured)`, kept distinct from a measured `0` (没测到 vs 花了0, aligned with LUM-559). Carried in `--json` as `cost { tokenCost, activeTimeSec, reworkRounds }` (`tokenCost: null` = not measured). Omitted only against an older server that doesn't emit the field.
+- **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,8 @@ function formatTaskStatus(data, extras = {}) {
             }
         }
     }
+    pushCost(lines, data);
+    pushStruggleTrail(lines, data);
     lines.push('');
     if (data.nextActions.length === 0) {
         lines.push(data.currentRound > 0
@@ -165,6 +167,130 @@ function formatTaskStatus(data, extras = {}) {
     pushOpenCrossings(lines, extras);
     return lines.join('\n') + '\n';
 }
+/** Compact a token count for the terminal — 1_200_000 → "1.2M", 850_000 →
+ *  "850K", 0 → "0". Uses the SAME Intl compact formatter the web card's
+ *  fmtCompact uses (notation:'compact', maximumFractionDigits:1) so the same
+ *  number reads identically in both surfaces — no presentation drift (LUM-560). */
+const TOKEN_FMT = new Intl.NumberFormat('en-US', {
+    notation: 'compact',
+    maximumFractionDigits: 1,
+});
+function fmtTokens(n) {
+    return TOKEN_FMT.format(n);
+}
+/** Active (non-idle) seconds → a compact "2h 14m" / "3m 5s" / "12s". 0 → "0s". */
+function fmtDuration(totalSec) {
+    const sec = Math.max(0, Math.round(totalSec));
+    if (sec === 0)
+        return '0s';
+    const h = Math.floor(sec / 3600);
+    const m = Math.floor((sec % 3600) / 60);
+    const s = sec % 60;
+    const parts = [];
+    if (h > 0)
+        parts.push(`${h}h`);
+    if (m > 0)
+        parts.push(`${m}m`);
+    // Show seconds only when the duration is under an hour (keeps long runs tidy).
+    if (s > 0 && h === 0)
+        parts.push(`${s}s`);
+    return parts.join(' ');
+}
+/**
+ * Append the honest "Cost" section (LUM-560) — 规律 1: surface the costs a human
+ * should weigh (token spend, active time, machine rework) on the same report as
+ * the acceptance verdict, instead of leaving them scattered across the web
+ * delivery card and `task lineage`. Every number is the server's, read from the
+ * same loadActuals source as the web card (no drift). Token cost is fail-closed:
+ * a null reads as an explicit "not recorded" line, never a silent or fake 0, so
+ * 没测到 (no session usage) stays distinct from a measured 花了0. Skipped only
+ * when the server didn't emit the field (older server) — never fabricated.
+ */
+function pushCost(lines, data) {
+    const cost = data.cost;
+    if (!cost)
+        return; // older server: can't fabricate cost, so don't claim any.
+    lines.push('');
+    lines.push('Cost:');
+    lines.push(cost.tokenCost == null
+        ? '  Tokens: not recorded (no session usage captured)'
+        : `  Tokens: ${fmtTokens(cost.tokenCost)}`);
+    lines.push(`  Active time: ${fmtDuration(cost.activeTimeSec)} (non-idle)`);
+    lines.push(`  Rework rounds: ${cost.reworkRounds}${cost.reworkRounds === 0 ? ' (no machine rework)' : ''}`);
+}
+/**
+ * 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.44.0",
   "description": "Lumo CLI — manage tasks and sessions from the terminal",
   "license": "MIT",
   "author": "cli@uselumo.ai",