@lumoai/cli 1.41.0 → 1.43.0

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/dist/cli/src/index.js

@@ -70,6 +70,7 @@ const memory_rm_1 = require("./commands/memory-rm");
 const memory_show_1 = require("./commands/memory-show");
 const memory_sync_1 = require("./commands/memory-sync");
 const memory_push_1 = require("./commands/memory-push");
+const memory_fold_1 = require("./commands/memory-fold");
 const task_artifact_add_1 = require("./commands/task-artifact-add");
 const task_criteria_set_1 = require("./commands/task-criteria-set");
 const task_criteria_list_1 = require("./commands/task-criteria-list");
@@ -533,6 +534,11 @@ memoryCmd
     .option('--dir <path>', 'Memory dir (default: ~/.claude/projects/<cwd>/memory)')
     .option('--dry-run', 'List what would be pushed without sending')
     .action(wrap((opts) => (0, memory_push_1.memoryPush)(opts)));
+memoryCmd
+    .command('fold [project-ref]')
+    .description('Preview the autonomous topic-fold pass (folding itself runs daily, automatically). Requires --dry-run.')
+    .option('--dry-run', 'preview proposed subsystem cards + which fine cards they fold; writes nothing')
+    .action(wrap((ref, opts) => (0, memory_fold_1.memoryFold)(ref, opts)));
 const milestoneCmd = program
     .command('milestone')
     .description('Inspect milestones from the terminal');

package/package.json

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