@lumoai/cli 1.40.0 → 1.41.0

package/assets/skill/references/memory.md

@@ -97,13 +97,18 @@ during the transition both paths are active and overlap is expected, not a bug.
 - **Only touches what it owns**: a file is owned only if its frontmatter carries
   `metadata.lumo.source: team`. Your own hand-written memory files and any
   `MEMORY.md` lines outside the managed block are **never** read or written.
-- **Selection**: judge-used 履历 (LUM-539) ranks first, with relevance/cold-start
-  grace as backfill, capped to the resident-index budget — so the local index
-  stays compact.
-- **Routing (per recipient)**: the bundle is scoped to the calling dev — memories
-  are filtered by relevance to that dev's active (assigned, not-DONE) tasks in the
-  project, so different devs get differentiated sets rather than the whole corpus.
-  A dev with no active tasks falls back to the full budget-capped set.
+- **Mirrors the whole project (LUM-552)**: the bundle is the project's **full
+  ACTIVE memory set** — every dev in the project gets the same corpus, regardless
+  of how many active tasks they hold. There is **no** task-level routing/relevance
+  filter and **no** token-budget cap on the corpus at sync time: sync only writes
+  local files (no tokens, no conversation), so "which memory is relevant" is left
+  to Claude Code's native recall, not decided at sync. judge-used 履历 (LUM-539)
+  still orders the resident index (so the most-proven memories list first) but
+  never drops anything. Relevance/budget gating remains only on the **injection**
+  path (`lumo task context` / session-start), which does spend tokens.
+- **Project-level routing only**: you still don't sync a project you're not a
+  member of — that's the API route's workspace authorization. Within a project,
+  everyone gets the full set.
 - **Reconcile / drift**: re-running is idempotent. A team file you edited locally
   is detected (its on-disk hash diverged from the recorded `contentHash`) and
   **skipped, never overwritten** — your edit is preserved and flagged as an
@@ -149,6 +154,22 @@ successful push removes the file from the outbox.
 shared with the team — drop a `{category, content}` JSON in the memory `outbox/`
 and run `lumo memory push` (or just use `lumo project memory add` for a one-off).
 
+### Automatic sync/push triggers (LUM-551)
+
+Both directions also fire automatically, best-effort — a failure never blocks the
+session or command:
+
+- **Downsync** runs on `lumo session attach` (throttle-gated, default 12h; see
+  [sessions.md](sessions.md)). Manual `lumo memory sync` stays unthrottled.
+- **Upsync** runs on the `session-end` / `stop` / `task-completed` lifecycle hooks:
+  a non-empty `<memory-dir>/outbox/*.json` is drained via the same
+  create-project-memory pipeline as `lumo memory push`. An **empty outbox does zero
+  network** (the fast path checked first), so the high-frequency `stop` hook stays
+  cheap. This fills the gap left by the deleted `lumo session wrap` (LUM-544).
+- **Env vars**: `LUMO_SYNC_THROTTLE_HOURS` (downsync throttle window, default 12),
+  `LUMO_DISABLE_MEMORY_AUTO=1` (disable **both** auto-paths). The `--no-anchor-check`
+  flag on `lumo memory sync` is unchanged.
+
 ### Reconcile-on-write & deduplication
 
 `memory add` does **not** unconditionally insert a new row. Before writing it:

package/assets/skill/references/sessions.md

@@ -99,6 +99,10 @@ What it does:
 
 **After attaching, always run `lumo task context <identifier>` to load the task background.**
 
+#### Auto-downsync on attach (LUM-551)
+
+A successful `session attach` also runs a **best-effort team-memory downsync** for the bound task's project — the same work as `lumo memory sync` (including the P4b code-anchor staleness check), so the team's memory lands in your local Claude Code memory store without a separate command. It is **throttle-gated**: the network is skipped entirely if this repo already synced within `LUMO_SYNC_THROTTLE_HOURS` (default **12h**), so re-attaches and same-day sessions are cheap. A sync failure is swallowed — it **never** changes the bind outcome. On a non-trivial sync the CLI prints one extra line (`memory sync → +N ~M -K`). Manual `lumo memory sync` stays unthrottled. Set `LUMO_DISABLE_MEMORY_AUTO=1` to turn the auto-downsync (and the hook auto-upsync — see [memory.md](memory.md)) off entirely; `--no-anchor-check` on `lumo memory sync` is unchanged.
+
 #### Lifetime lock (LUM-459)
 
 `Session.taskId` is **write-once**. Re-attaching to the **same** task is always a no-op re-bind (idempotent, re-emits context). Attaching to a **different** task is refused with HTTP 409 — the server returns `{ error, currentTaskIdentifier, currentTaskTitle }` and the CLI prints:

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/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.41.0",
   "description": "Lumo CLI — manage tasks and sessions from the terminal",
   "license": "MIT",
   "author": "cli@uselumo.ai",