@lumoai/cli 1.43.0 → 1.44.0

package/assets/skill/references/verify.md

@@ -117,6 +117,7 @@ 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;

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

@@ -134,6 +134,7 @@ function formatTaskStatus(data, extras = {}) {
             }
         }
     }
+    pushCost(lines, data);
     pushStruggleTrail(lines, data);
     lines.push('');
     if (data.nextActions.length === 0) {
@@ -166,6 +167,57 @@ 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

package/package.json

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