@lumoai/cli 1.40.0 → 1.42.0

package/dist/cli/src/commands/session-attach.js

@@ -4,6 +4,8 @@ exports.sessionAttach = sessionAttach;
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const sanitize_1 = require("../lib/sanitize");
+const resolve_project_1 = require("../lib/resolve-project");
+const memory_auto_1 = require("../lib/memory-auto");
 /**
  * `lumo session attach <identifier>` — bind the currently-running
  * Claude Code session to a task.
@@ -109,4 +111,31 @@ async function sessionAttach(identifier) {
         console.log('');
         console.log((0, sanitize_1.sanitizeField)(body.memorySection));
     }
+    // LUM-551: attach-triggered best-effort downsync. Resolve the bound task's
+    // project and refresh team memory (throttle-gated inside autoDownsyncOnAttach).
+    // Wrapped + swallowed: a sync failure must never change the attach outcome.
+    try {
+        const base = (0, api_1.trimTrailingSlash)(apiUrl);
+        const proj = await (0, resolve_project_1.resolveBoundProjectId)(apiUrl, creds.token, body.taskIdentifier);
+        if (proj.ok) {
+            const sync = await (0, memory_auto_1.autoDownsyncOnAttach)({
+                cwd: process.cwd(),
+                base,
+                token: creds.token,
+                projectId: proj.id,
+                now: new Date(),
+            });
+            const touched = (sync.added ?? 0) + (sync.updated ?? 0) + (sync.removed ?? 0);
+            if (!sync.skipped && !sync.error && touched > 0) {
+                console.log('');
+                console.log((0, sanitize_1.sanitizeField)(`memory sync → +${sync.added} ~${sync.updated} -${sync.removed}` +
+                    (sync.anchorCandidates
+                        ? ` · ${sync.anchorCandidates} stale-anchor candidate(s)`
+                        : '')));
+            }
+        }
+    }
+    catch {
+        // best-effort — the bind already succeeded; never surface a sync error here
+    }
 }

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/dist/cli/src/lib/apply-sync.js

@@ -4,6 +4,7 @@ exports.applySync = applySync;
 const local_memory_store_1 = require("./local-memory-store");
 const memory_reconcile_1 = require("./memory-reconcile");
 const managed_block_1 = require("./managed-block");
+const sync_throttle_1 = require("./sync-throttle");
 /**
  * Apply a downsync bundle to the local memory dir. Owns only `root/team/*.md`
  * and the MEMORY.md managed block; dev-authored files and out-of-block index
@@ -17,6 +18,7 @@ function applySync(root, bundle, opts = {}) {
             for (const o of owned)
                 (0, local_memory_store_1.removeEntry)(root, o.id);
             (0, local_memory_store_1.writeIndex)(root, (0, managed_block_1.removeBlock)((0, local_memory_store_1.readIndex)(root)));
+            (0, sync_throttle_1.clearThrottleState)(root);
         }
         return {
             added: [],

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

@@ -13,6 +13,9 @@ const sanitize_1 = require("./sanitize");
 const agent_1 = require("./agent");
 const git_task_1 = require("./git-task");
 const transcript_usage_1 = require("./transcript-usage");
+const resolve_project_1 = require("./resolve-project");
+const resolve_bound_task_1 = require("./resolve-bound-task");
+const memory_auto_1 = require("./memory-auto");
 /**
  * Hard timeout for the hook POST. On timeout the request is aborted,
  * logged, and `runHook` exits 0 — Claude Code is never blocked beyond
@@ -329,6 +332,31 @@ async function runHookWithBody(path, body, agentToken) {
         finally {
             clearTimeout(timer);
         }
+        // LUM-551: upsync drain on session-wrap-equivalent hooks. The outbox-empty
+        // fast path inside autoUpsyncOnDrain means most `stop` events do zero
+        // network (and never resolve the project). Best-effort: a failure is
+        // logged, never thrown — the hook still exits 0.
+        if (path === 'session-end' ||
+            path === 'stop' ||
+            path === 'task-completed') {
+            try {
+                await (0, memory_auto_1.autoUpsyncOnDrain)({
+                    cwd: process.cwd(),
+                    base: (0, api_1.trimTrailingSlash)(apiUrl),
+                    token: creds.token,
+                    resolveProjectId: async () => {
+                        const bound = await (0, resolve_bound_task_1.resolveBoundTaskIdentifier)(apiUrl, creds.token);
+                        if (!bound)
+                            return null;
+                        const r = await (0, resolve_project_1.resolveBoundProjectId)(apiUrl, creds.token, bound);
+                        return r.ok ? r.id : null;
+                    },
+                });
+            }
+            catch (err) {
+                (0, hook_log_1.logHookError)(`[${path}] upsync`, err);
+            }
+        }
     }
     catch (err) {
         (0, hook_log_1.logHookError)(`[${path}] runner`, err);

package/dist/cli/src/lib/memory-auto.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoDownsyncOnAttach = autoDownsyncOnAttach;
+exports.autoUpsyncOnDrain = autoUpsyncOnDrain;
+const node_fs_1 = require("node:fs");
+const claude_memory_dir_1 = require("./claude-memory-dir");
+const apply_sync_1 = require("./apply-sync");
+const anchor_staleness_1 = require("./anchor-staleness");
+const upsync_1 = require("./upsync");
+const sync_throttle_1 = require("./sync-throttle");
+/**
+ * LUM-551 — best-effort auto-triggers for team-memory sync/push.
+ *
+ * Both orchestrators are CLI-local, total `try/catch` (never throw), and quiet.
+ * They reuse the existing sync/push/anchor primitives rather than adding a
+ * parallel path. `LUMO_DISABLE_MEMORY_AUTO` turns both off wholesale.
+ */
+function autoDisabled() {
+    return !!process.env.LUMO_DISABLE_MEMORY_AUTO;
+}
+/** Fetch the team-memory sync bundle for a project. Throws on a non-2xx. */
+async function fetchSyncBundle(base, token, projectId) {
+    const res = await fetch(`${base}/api/projects/${encodeURIComponent(projectId)}/memories/sync-bundle`, { headers: { Authorization: `Bearer ${token}` } });
+    if (!res.ok)
+        throw new Error(`sync-bundle HTTP ${res.status}`);
+    const { bundle } = (await res.json());
+    return bundle;
+}
+/**
+ * Attach-triggered best-effort downsync (LUM-551). Throttle-gated; swallows all
+ * errors into `{ error }`; NEVER throws. On a real sync it also runs the P4b
+ * anchor check (advisory) and records the throttle timestamp.
+ */
+async function autoDownsyncOnAttach(input) {
+    if (autoDisabled())
+        return { skipped: 'disabled' };
+    try {
+        const dir = (0, claude_memory_dir_1.resolveMemoryDir)(input.cwd, undefined, input.dir);
+        const state = (0, sync_throttle_1.readThrottleState)(dir);
+        if ((0, sync_throttle_1.isThrottled)(state, input.now, (0, sync_throttle_1.throttleHours)(), input.projectId)) {
+            return { skipped: 'throttled' };
+        }
+        const bundle = await fetchSyncBundle(input.base, input.token, input.projectId);
+        const summary = (0, apply_sync_1.applySync)(dir, bundle);
+        let anchorCandidates = 0;
+        try {
+            const { candidates, report } = await (0, anchor_staleness_1.runAnchorCheck)({
+                cwd: input.cwd,
+                base: input.base,
+                token: input.token,
+                projectId: input.projectId,
+                entries: bundle.entries,
+            });
+            if (report.ok)
+                anchorCandidates = candidates.length;
+        }
+        catch {
+            // anchor detection is advisory — never fail the sync over it
+        }
+        (0, sync_throttle_1.writeThrottleState)(dir, { lastSyncAt: input.now.toISOString(), projectId: input.projectId }, input.now);
+        return {
+            added: summary.added.length,
+            updated: summary.updated.length,
+            removed: summary.removed.length,
+            anchorCandidates,
+        };
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Lifecycle-hook upsync drain (LUM-551). Outbox-empty fast path FIRST (no
+ * network); only a non-empty outbox resolves the project and pushes. Reuses the
+ * `memory-push` semantics (POST → unlink on 2xx). NEVER throws.
+ */
+async function autoUpsyncOnDrain(input) {
+    if (autoDisabled())
+        return { skipped: 'disabled' };
+    try {
+        const dir = (0, claude_memory_dir_1.resolveMemoryDir)(input.cwd, undefined, input.dir);
+        const candidates = (0, upsync_1.collectUpsyncCandidates)(dir);
+        if (candidates.length === 0)
+            return { skipped: 'empty' };
+        const projectId = await input.resolveProjectId();
+        if (!projectId)
+            return { error: 'no resolvable project for upsync' };
+        const url = (0, upsync_1.projectMemoriesEndpoint)(input.base, projectId);
+        let pushed = 0;
+        for (const c of candidates) {
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${input.token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ category: c.category, content: c.content }),
+            });
+            if (!res.ok)
+                continue;
+            try {
+                (0, node_fs_1.unlinkSync)(c.file);
+            }
+            catch {
+                // best-effort cleanup; a re-push is idempotent via reconcile-on-write
+            }
+            pushed++;
+        }
+        return { pushed };
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}

package/dist/cli/src/lib/sync-throttle.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readThrottleState = readThrottleState;
+exports.writeThrottleState = writeThrottleState;
+exports.clearThrottleState = clearThrottleState;
+exports.throttleHours = throttleHours;
+exports.isThrottled = isThrottled;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const STATE_FILE = '.lumo-sync.json';
+const DEFAULT_HOURS = 12;
+function statePath(dir) {
+    return (0, node_path_1.join)(dir, STATE_FILE);
+}
+/** Read the throttle state; null on missing / unreadable / malformed file. */
+function readThrottleState(dir) {
+    const p = statePath(dir);
+    if (!(0, node_fs_1.existsSync)(p))
+        return null;
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(p, 'utf8'));
+        if (typeof parsed.lastSyncAt === 'string' &&
+            typeof parsed.projectId === 'string') {
+            return { lastSyncAt: parsed.lastSyncAt, projectId: parsed.projectId };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Best-effort write of the throttle state. Never throws. */
+function writeThrottleState(dir, state, 
+// accepted for signature symmetry with the caller; not otherwise needed.
+_now = new Date()) {
+    try {
+        (0, node_fs_1.writeFileSync)(statePath(dir), JSON.stringify(state) + '\n');
+    }
+    catch {
+        // best-effort — a missing dir or read-only fs just means no throttle next time
+    }
+}
+/** Remove the throttle state file (used by `memory sync --clean`). Never throws. */
+function clearThrottleState(dir) {
+    try {
+        (0, node_fs_1.rmSync)(statePath(dir), { force: true });
+    }
+    catch {
+        // best-effort
+    }
+}
+/** The throttle window in hours: LUMO_SYNC_THROTTLE_HOURS or the 12h default. */
+function throttleHours() {
+    const raw = process.env.LUMO_SYNC_THROTTLE_HOURS;
+    if (!raw)
+        return DEFAULT_HOURS;
+    const n = Number(raw);
+    return Number.isFinite(n) && n > 0 ? n : DEFAULT_HOURS;
+}
+/**
+ * True when a fresh sync for `projectId` exists within `hours` of `now`. A null
+ * state, a different project, or a stale timestamp all return false (sync runs).
+ */
+function isThrottled(state, now, hours, projectId) {
+    if (!state || state.projectId !== projectId)
+        return false;
+    const last = Date.parse(state.lastSyncAt);
+    if (!Number.isFinite(last))
+        return false;
+    return now.getTime() - last < hours * 3600_000;
+}

package/package.json

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