@lumoai/cli 1.20.1 → 1.21.0

package/assets/skill/references/memory.md

@@ -34,6 +34,28 @@ When the session is bound (`lumo session attach <LUM-N>`), omit the identifier:
 `lumo task memory add --category trap --trigger ... --outcome ...` records onto
 the bound task; `lumo project memory add ...` records onto its project.
 
+### Reconcile-on-write & deduplication
+
+`memory add` does **not** unconditionally insert a new row. Before writing it:
+
+1. Retrieves the nearest existing memories in the store (embedding similarity).
+2. If a near-duplicate is found — including a **cross-language match** (e.g. you
+   supply content in Chinese but an equivalent English memory already exists) —
+   an LLM decides the outcome; otherwise the new memory is inserted directly.
+
+The command prints **one** of these outcome lines:
+
+| Output line | Meaning |
+|---|---|
+| `Added <CATEGORY> <SCOPE> memory …` | No near-duplicate found; stored as a new row. |
+| `Merged into existing memory <id> (near-duplicate) …` | Near-duplicate found; the existing row was refined/updated in-place (UPDATE). |
+| `Superseded an existing memory; new version <id> …` | New content contradicts an old memory; old row invalidated, new row created (SUPERSEDE). |
+| `Skipped — duplicate of existing memory <id>, nothing written …` | Exact or near-exact duplicate; no write performed (NOOP). |
+
+Content is **always normalized to English** before storing — the memory store has
+a single canonical language. If you supply text in another language the CLI
+translates it automatically; the stored memory will be in English.
+
 ### When to record a memory (worthiness)
 
 Record only knowledge that is **invisible in the codebase** — the _why_ behind a

package/dist/cli/src/commands/memory-project-add.js

@@ -82,5 +82,27 @@ async function memoryProjectAdd(refArg, options) {
         console.error(m ? `Error: ${(0, sanitize_1.sanitizeField)(m)}` : `Error: memory add failed (HTTP ${res.status})`);
         return 1;
     }
-    process.stdout.write(`Added ${built.category} PROJECT memory${echoSuffix}\n`);
+    let outcome = 'ADD';
+    let memId = '';
+    try {
+        const b = (await res.json());
+        if (typeof b.outcome === 'string')
+            outcome = b.outcome;
+        if (b.memory && typeof b.memory.id === 'string')
+            memId = b.memory.id;
+    }
+    catch { /* keep defaults */ }
+    switch (outcome) {
+        case 'NOOP':
+            process.stdout.write(`Skipped — duplicate of existing memory ${memId}, nothing written${echoSuffix}\n`);
+            break;
+        case 'UPDATE':
+            process.stdout.write(`Merged into existing memory ${memId} (near-duplicate)${echoSuffix}\n`);
+            break;
+        case 'SUPERSEDE':
+            process.stdout.write(`Superseded an existing memory; new version ${memId}${echoSuffix}\n`);
+            break;
+        default:
+            process.stdout.write(`Added ${built.category} PROJECT memory${echoSuffix}\n`);
+    }
 }

package/dist/cli/src/commands/memory-task-add.js

@@ -93,7 +93,29 @@ async function memoryTaskAdd(identifierArg, options) {
         console.error(m ? `Error: ${(0, sanitize_1.sanitizeField)(m)}` : `Error: memory add failed (HTTP ${res.status})`);
         return 1;
     }
-    process.stdout.write(`Added ${built.category} memory to ${identifier}` +
-        `${identifierArg ? '' : ' (from bound session)'}\n` +
-        'Tip: only useful for this task? If it generalizes, use `lumo project memory add` or `lumo memory promote` later.\n');
+    const boundSuffix = identifierArg ? '' : ' (from bound session)';
+    let outcome = 'ADD';
+    let memId = '';
+    try {
+        const b = (await res.json());
+        if (typeof b.outcome === 'string')
+            outcome = b.outcome;
+        if (b.memory && typeof b.memory.id === 'string')
+            memId = b.memory.id;
+    }
+    catch { /* keep defaults */ }
+    switch (outcome) {
+        case 'NOOP':
+            process.stdout.write(`Skipped — duplicate of existing memory ${memId}, nothing written${boundSuffix}\n`);
+            break;
+        case 'UPDATE':
+            process.stdout.write(`Merged into existing memory ${memId} (near-duplicate)${boundSuffix}\n`);
+            break;
+        case 'SUPERSEDE':
+            process.stdout.write(`Superseded an existing memory; new version ${memId}${boundSuffix}\n`);
+            break;
+        default:
+            process.stdout.write(`Added ${built.category} memory to ${identifier}${boundSuffix}\n` +
+                'Tip: only useful for this task? If it generalizes, use `lumo project memory add` or `lumo memory promote` later.\n');
+    }
 }

package/dist/cli/src/lib/hook-runner.js

@@ -216,14 +216,17 @@ function resolveSessionStartStdout(responseBody, deps, now = new Date()) {
     return [formatSuggestLine(sessionId, match)];
 }
 /**
- * For stop/stop-failure hooks, read the transcript named in the payload and
- * fold cumulative token totals into the body under `_lumo_usage` so the server
- * can persist them on the Session. Best-effort: returns the body unchanged on
- * any failure (no transcript_path, unreadable, unparseable, no usage). The
- * hook is never blocked or failed by this.
+ * For stop/stop-failure/post-tool-batch hooks, read the transcript named in
+ * the payload and fold cumulative token totals into the body under
+ * `_lumo_usage` so the server can persist them on the Session. post-tool-batch
+ * carries usage so long single turns surface live burn before the first STOP
+ * (LUM-345); the server treats it as a flat-columns-only overwrite. Best-
+ * effort: returns the body unchanged on any failure (no transcript_path,
+ * unreadable, unparseable, no usage). The hook is never blocked or failed by
+ * this.
  */
 function augmentBodyWithUsage(path, body) {
-    if (path !== 'stop' && path !== 'stop-failure')
+    if (path !== 'stop' && path !== 'stop-failure' && path !== 'post-tool-batch')
         return body;
     let parsed;
     try {

package/dist/cli/src/lib/transcript-usage.js

@@ -2,31 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sumTranscriptUsage = sumTranscriptUsage;
 const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 function asNumber(v) {
     return typeof v === 'number' && Number.isFinite(v) ? v : 0;
 }
 /**
- * Read a Claude Code transcript JSONL and sum `message.usage` across all
- * assistant entries, grouped by `message.model` -> cumulative session totals.
- * `<synthetic>` entries (local injections with no API cost) are skipped.
- * Entries with no model string bucket under "unknown". Best-effort: returns
- * null if the file can't be read or has no real assistant usage. Never throws.
+ * Sum `message.usage` across all (non-synthetic) assistant entries of one
+ * transcript JSONL file into the shared accumulators. Returns true if at
+ * least one real usage entry was seen. Never throws.
  */
-function sumTranscriptUsage(transcriptPath) {
+function accumulateFileUsage(path, total, byModel) {
     let text;
     try {
-        text = (0, node_fs_1.readFileSync)(transcriptPath, 'utf8');
+        text = (0, node_fs_1.readFileSync)(path, 'utf8');
     }
     catch {
-        return null;
+        return false;
     }
-    const byModel = {};
-    const total = {
-        inputTokens: 0,
-        outputTokens: 0,
-        cacheReadTokens: 0,
-        cacheCreationTokens: 0,
-    };
     let seen = false;
     for (const raw of text.split('\n')) {
         const line = raw.trim();
@@ -73,5 +65,46 @@ function sumTranscriptUsage(transcriptPath) {
         m.cacheCreation += cacheCreation;
         byModel[model] = m;
     }
+    return seen;
+}
+/**
+ * Subagent (Task tool) turns are NOT in the main transcript — Claude Code
+ * writes them to sibling files at `<dir>/<sessionId>/subagents/agent-*.jsonl`.
+ * Resolve those for a main transcript path. Best-effort: returns [] when the
+ * directory is missing or unreadable. Never throws.
+ */
+function listSubagentTranscripts(transcriptPath) {
+    if (!transcriptPath.endsWith('.jsonl'))
+        return [];
+    const subagentsDir = (0, node_path_1.join)(transcriptPath.slice(0, -'.jsonl'.length), 'subagents');
+    try {
+        return (0, node_fs_1.readdirSync)(subagentsDir)
+            .filter(name => name.startsWith('agent-') && name.endsWith('.jsonl'))
+            .map(name => (0, node_path_1.join)(subagentsDir, name));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Read a Claude Code transcript JSONL — plus any subagent transcripts under
+ * `<dir>/<sessionId>/subagents/agent-*.jsonl` — and sum `message.usage`
+ * across all (non-synthetic) assistant entries, grouped by `message.model`
+ * -> cumulative session totals. Entries with no model string bucket under
+ * "unknown". Best-effort: returns null if nothing readable has real
+ * assistant usage. Never throws.
+ */
+function sumTranscriptUsage(transcriptPath) {
+    const byModel = {};
+    const total = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+    };
+    let seen = accumulateFileUsage(transcriptPath, total, byModel);
+    for (const path of listSubagentTranscripts(transcriptPath)) {
+        seen = accumulateFileUsage(path, total, byModel) || seen;
+    }
     return seen ? { total, byModel } : null;
 }

package/package.json

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