@lumoai/cli 1.39.0 → 1.40.0

package/dist/cli/src/lib/anchor-staleness.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRepoProbe = createRepoProbe;
+exports.detectStaleCandidates = detectStaleCandidates;
+exports.reportStaleCandidates = reportStaleCandidates;
+exports.shouldRunAnchorCheck = shouldRunAnchorCheck;
+exports.runAnchorCheck = runAnchorCheck;
+const node_child_process_1 = require("node:child_process");
+const code_anchor_1 = require("../../../shared/src/code-anchor");
+/**
+ * Build an existence probe over the repo at `cwd`. Resolves against git-tracked
+ * state, never the dirty working tree, so an uncommitted local rename/branch
+ * cannot false-flag a team memory. Fails OPEN: if git is unavailable or the
+ * lookup errors, anchors are treated as still-existing (宁可放过 — never
+ * false-flag a good memory off a broken probe).
+ */
+function createRepoProbe(cwd) {
+    const tracked = new Set();
+    try {
+        const out = (0, node_child_process_1.execFileSync)('git', ['ls-files'], {
+            cwd,
+            encoding: 'utf8',
+            maxBuffer: 256 * 1024 * 1024,
+        });
+        for (const line of out.split('\n')) {
+            const p = line.trim();
+            if (p)
+                tracked.add(p);
+        }
+    }
+    catch {
+        // not a git repo / git missing — leave `tracked` empty → fail open below.
+    }
+    const ready = tracked.size > 0;
+    return {
+        fileExists: p => (ready ? tracked.has(p) : true),
+        symbolExists: name => {
+            if (!ready)
+                return true;
+            try {
+                // exit 0 = found. `-w` word-boundary, `-q` quiet, `-F` fixed string,
+                // `-e` so a name starting with '-' is never read as a flag.
+                (0, node_child_process_1.execFileSync)('git', ['grep', '-wqF', '-e', name], {
+                    cwd,
+                    stdio: 'ignore',
+                });
+                return true;
+            }
+            catch (err) {
+                // exit 1 = clean "no match" → absent; any other exit = probe error →
+                // fail open (treat as present) so we never false-flag on a git hiccup.
+                const status = err.status;
+                return status === 1 ? false : true;
+            }
+        },
+    };
+}
+/**
+ * Classify each synced memory and keep only the stale candidates (every anchor
+ * dead). Pure given the probe — the heavy lifting lives in
+ * {@link classifyMemoryStaleness}.
+ */
+function detectStaleCandidates(entries, probe) {
+    const out = [];
+    for (const e of entries) {
+        const verdict = (0, code_anchor_1.classifyMemoryStaleness)(e.body, probe);
+        if (verdict.stale) {
+            out.push({ memoryId: e.id, deadAnchors: verdict.deadAnchors });
+        }
+    }
+    return out;
+}
+/**
+ * Report stale candidates to the server's stale-anchors endpoint (bearer auth).
+ * No candidates → no network call. This is the ONLY server write the detection
+ * path makes; it records candidacy, never archives.
+ */
+async function reportStaleCandidates(base, token, projectId, candidates) {
+    if (candidates.length === 0)
+        return { ok: true, recorded: 0 };
+    const res = await fetch(`${base}/api/projects/${encodeURIComponent(projectId)}/memories/stale-anchors`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ candidates }),
+    });
+    if (!res.ok)
+        return { ok: false, status: res.status };
+    const data = (await res.json().catch(() => ({})));
+    return { ok: true, recorded: data.recorded };
+}
+/**
+ * Whether `memory sync` should run the anchor check. Skipped for an explicit
+ * `--no-anchor-check`, and for `--dry-run` / `--clean` (a preview or rollback
+ * must not write candidates to the server).
+ */
+function shouldRunAnchorCheck(options) {
+    if (options.anchorCheck === false)
+        return false;
+    if (options.dryRun || options.clean)
+        return false;
+    return true;
+}
+/**
+ * Orchestrate the check: build the repo probe, detect candidates over the synced
+ * entries, and report them. Best-effort — returns the candidate count and the
+ * report result; callers log and move on (never fail the sync over detection).
+ */
+async function runAnchorCheck(input) {
+    const probe = createRepoProbe(input.cwd);
+    const candidates = detectStaleCandidates(input.entries, probe);
+    const report = await reportStaleCandidates(input.base, input.token, input.projectId, candidates);
+    return { candidates, report };
+}

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+/**
+ * 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
+ * content are never touched. `--clean` removes all owned files + the block;
+ * `--dry-run` computes the plan and writes nothing.
+ */
+function applySync(root, bundle, opts = {}) {
+    if (opts.clean) {
+        const owned = (0, local_memory_store_1.readOwned)(root);
+        if (!opts.dryRun) {
+            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)));
+        }
+        return {
+            added: [],
+            updated: [],
+            removed: owned.map(o => o.id),
+            skippedDrift: [],
+            noop: owned.length === 0,
+        };
+    }
+    const owned = (0, local_memory_store_1.readOwned)(root);
+    const plan = (0, memory_reconcile_1.diffSync)(owned, bundle.entries.map(e => ({ id: e.id, contentHash: e.contentHash })));
+    const byId = new Map(bundle.entries.map(e => [e.id, e]));
+    const summary = {
+        added: plan.add.map(a => a.id),
+        updated: plan.update.map(u => u.id),
+        removed: plan.remove,
+        skippedDrift: plan.skipDrift,
+        noop: plan.add.length === 0 &&
+            plan.update.length === 0 &&
+            plan.remove.length === 0,
+    };
+    if (opts.dryRun)
+        return summary;
+    for (const a of plan.add) {
+        const e = byId.get(a.id);
+        (0, local_memory_store_1.writeEntry)(root, e);
+    }
+    for (const u of plan.update) {
+        const e = byId.get(u.id);
+        (0, local_memory_store_1.writeEntry)(root, e);
+    }
+    for (const id of plan.remove)
+        (0, local_memory_store_1.removeEntry)(root, id);
+    // Index = every bundle entry's line (added/updated/unchanged/drift-skipped all
+    // still exist locally); removed ids are absent from the bundle so they drop out.
+    (0, local_memory_store_1.writeIndex)(root, (0, managed_block_1.upsertBlock)((0, local_memory_store_1.readIndex)(root), bundle.entries.map(e => e.indexLine)));
+    return summary;
+}

package/dist/cli/src/lib/claude-memory-dir.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveMemoryDir = resolveMemoryDir;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+/**
+ * Resolve the local Claude Code memory directory for a project working dir.
+ * Claude Code stores per-project memory under
+ * `~/.claude/projects/<encoded-cwd>/memory/`, where the cwd is encoded by
+ * replacing path separators with `-` (e.g. `/Users/x/lumo` →
+ * `-Users-x-lumo`). The encoding lives ONLY here so a Claude Code change is a
+ * one-line fix; `lumo memory sync --dry-run` prints the resolved path so the
+ * dev can sanity-check it, and `--dir` overrides entirely.
+ */
+function resolveMemoryDir(cwd, home = (0, node_os_1.homedir)(), override) {
+    if (override)
+        return override;
+    const encoded = cwd.replace(/\//g, '-');
+    return (0, node_path_1.join)(home, '.claude', 'projects', encoded, 'memory');
+}

package/dist/cli/src/lib/local-memory-store.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashBody = hashBody;
+exports.readOwned = readOwned;
+exports.writeEntry = writeEntry;
+exports.removeEntry = removeEntry;
+exports.readIndex = readIndex;
+exports.writeIndex = writeIndex;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+const TEAM_DIR = 'team';
+const INDEX_FILE = 'MEMORY.md';
+function teamPath(root) {
+    return (0, node_path_1.join)(root, TEAM_DIR);
+}
+function hashBody(body) {
+    return (0, node_crypto_1.createHash)('sha256').update(body).digest('hex');
+}
+/**
+ * Parse the `lumo: { ... }` ownership marker. Returns null unless the file
+ * carries `source: team` — dev-authored files (no marker) are NOT owned and
+ * must never be touched by sync.
+ */
+function parseMarker(text) {
+    const m = text.match(/lumo:\s*\{([^}]*)\}/);
+    if (!m || !m[1])
+        return null;
+    const inner = m[1];
+    if (!/\bsource:\s*team\b/.test(inner))
+        return null;
+    const id = inner.match(/\bid:\s*([^,}\s]+)/)?.[1];
+    const contentHash = inner.match(/\bcontentHash:\s*([^,}\s]+)/)?.[1];
+    if (!id || !contentHash)
+        return null;
+    return { id, contentHash };
+}
+/** Body = everything after the closing frontmatter fence, minus the single
+ * trailing newline {@link writeEntry} appends (keeps write/read hashing symmetric). */
+function bodyOf(text) {
+    const end = text.indexOf('\n---\n');
+    const raw = end === -1 ? text : text.slice(end + 5);
+    return raw.replace(/\n$/, '');
+}
+/** Read every owned team file under `root/team/`, newest-id order. */
+function readOwned(root) {
+    const dir = teamPath(root);
+    if (!(0, node_fs_1.existsSync)(dir))
+        return [];
+    const out = [];
+    for (const f of (0, node_fs_1.readdirSync)(dir)) {
+        if (!f.endsWith('.md'))
+            continue;
+        const text = (0, node_fs_1.readFileSync)((0, node_path_1.join)(dir, f), 'utf8');
+        const marker = parseMarker(text);
+        if (!marker)
+            continue; // dev-authored → not owned
+        out.push({
+            id: marker.id,
+            contentHash: marker.contentHash,
+            diskHash: hashBody(bodyOf(text)),
+        });
+    }
+    return out.sort((a, b) => a.id.localeCompare(b.id));
+}
+function writeEntry(root, entry) {
+    const dir = teamPath(root);
+    if (!(0, node_fs_1.existsSync)(dir))
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, `${entry.id}.md`), `${entry.frontmatter}\n${entry.body}\n`);
+}
+function removeEntry(root, id) {
+    const p = (0, node_path_1.join)(teamPath(root), `${id}.md`);
+    if ((0, node_fs_1.existsSync)(p))
+        (0, node_fs_1.rmSync)(p);
+}
+function readIndex(root) {
+    const p = (0, node_path_1.join)(root, INDEX_FILE);
+    return (0, node_fs_1.existsSync)(p) ? (0, node_fs_1.readFileSync)(p, 'utf8') : '';
+}
+function writeIndex(root, text) {
+    if (!(0, node_fs_1.existsSync)(root))
+        (0, node_fs_1.mkdirSync)(root, { recursive: true });
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(root, INDEX_FILE), text);
+}

package/dist/cli/src/lib/managed-block.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BLOCK_END = exports.BLOCK_START = void 0;
+exports.upsertBlock = upsertBlock;
+exports.removeBlock = removeBlock;
+exports.BLOCK_START = '<!-- lumo:team-memory:start (managed by `lumo memory sync` — do not edit inside) -->';
+exports.BLOCK_END = '<!-- lumo:team-memory:end -->';
+/**
+ * Replace the managed team-memory block in MEMORY.md with `lines`, leaving
+ * every byte OUTSIDE the markers untouched. If no block exists, append a fresh
+ * one at EOF (original content preserved verbatim as the prefix). This is the
+ * only writer allowed to touch MEMORY.md, and it never edits dev-authored
+ * index lines outside the markers.
+ */
+function upsertBlock(md, lines) {
+    const block = `${exports.BLOCK_START}\n${lines.join('\n')}\n${exports.BLOCK_END}`;
+    const s = md.indexOf(exports.BLOCK_START);
+    const e = md.indexOf(exports.BLOCK_END);
+    if (s !== -1 && e !== -1 && e > s) {
+        return md.slice(0, s) + block + md.slice(e + exports.BLOCK_END.length);
+    }
+    const sep = md.length === 0 ? '' : md.endsWith('\n') ? '\n' : '\n\n';
+    return `${md}${sep}${block}\n`;
+}
+/** Remove the managed block entirely (used by `--clean`). Bytes outside the
+ * markers are preserved. No-op if no block is present. */
+function removeBlock(md) {
+    const s = md.indexOf(exports.BLOCK_START);
+    const e = md.indexOf(exports.BLOCK_END);
+    if (s === -1 || e === -1 || e < s)
+        return md;
+    return md.slice(0, s) + md.slice(e + exports.BLOCK_END.length);
+}

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildMemoryContent = buildMemoryContent;
 exports.formatMemoryList = formatMemoryList;
-exports.formatMemoryReviewList = formatMemoryReviewList;
 // Category/field metadata + builders for the `lumo memory` commands.
 // Mirrors the four content shapes validated server-side by parseMemoryContent.
 const sanitize_1 = require("./sanitize");
@@ -24,7 +23,11 @@ function buildMemoryContent(category, flags) {
                 return { ok: false, error: '--trigger is required for category trap.' };
             if (!outcome)
                 return { ok: false, error: '--outcome is required for category trap.' };
-            return { ok: true, category: 'TRAP', content: { trigger, outcome, ...(workaround ? { workaround } : {}) } };
+            return {
+                ok: true,
+                category: 'TRAP',
+                content: { trigger, outcome, ...(workaround ? { workaround } : {}) },
+            };
         }
         case 'decision': {
             const what = trimmed(flags.what);
@@ -38,40 +41,73 @@ function buildMemoryContent(category, flags) {
             return {
                 ok: true,
                 category: 'DECISION',
-                content: { what, why, ...(alternatives ? { alternatives } : {}), ...(implications ? { implications } : {}) },
+                content: {
+                    what,
+                    why,
+                    ...(alternatives ? { alternatives } : {}),
+                    ...(implications ? { implications } : {}),
+                },
             };
         }
         case 'convention': {
             const rule = trimmed(flags.rule);
             const applies = trimmed(flags.applies);
             if (!rule)
-                return { ok: false, error: '--rule is required for category convention.' };
+                return {
+                    ok: false,
+                    error: '--rule is required for category convention.',
+                };
             if (!applies)
-                return { ok: false, error: '--applies is required for category convention (where the rule applies).' };
-            return { ok: true, category: 'CONVENTION', content: { rule, scope: applies } };
+                return {
+                    ok: false,
+                    error: '--applies is required for category convention (where the rule applies).',
+                };
+            return {
+                ok: true,
+                category: 'CONVENTION',
+                content: { rule, scope: applies },
+            };
         }
         case 'procedural': {
             const workflow = trimmed(flags.workflow);
             const trigger = trimmed(flags.trigger);
             const steps = (flags.step ?? []).map(s => s.trim()).filter(Boolean);
             if (!workflow)
-                return { ok: false, error: '--workflow is required for category procedural.' };
+                return {
+                    ok: false,
+                    error: '--workflow is required for category procedural.',
+                };
             if (!trigger)
-                return { ok: false, error: '--trigger is required for category procedural.' };
-            return { ok: true, category: 'PROCEDURAL', content: { workflow, trigger, ...(steps.length ? { steps } : {}) } };
+                return {
+                    ok: false,
+                    error: '--trigger is required for category procedural.',
+                };
+            return {
+                ok: true,
+                category: 'PROCEDURAL',
+                content: { workflow, trigger, ...(steps.length ? { steps } : {}) },
+            };
         }
         default:
-            return { ok: false, error: `Unknown --category "${category}". Use trap | decision | convention | procedural.` };
+            return {
+                ok: false,
+                error: `Unknown --category "${category}". Use trap | decision | convention | procedural.`,
+            };
     }
 }
 function headline(category, content) {
     const c = (content ?? {});
-    const key = category === 'TRAP' ? 'trigger'
-        : category === 'DECISION' ? 'what'
-            : category === 'CONVENTION' ? 'rule'
+    const key = category === 'TRAP'
+        ? 'trigger'
+        : category === 'DECISION'
+            ? 'what'
+            : category === 'CONVENTION'
+                ? 'rule'
                 : 'workflow';
     const v = c[key];
-    return typeof v === 'string' && v.length > 0 ? (0, sanitize_1.sanitizeField)(v) : '(unparseable)';
+    return typeof v === 'string' && v.length > 0
+        ? (0, sanitize_1.sanitizeField)(v)
+        : '(unparseable)';
 }
 /** Fixed-width rows: id  SCOPE  CATEGORY  headline  source(auto|manual). */
 function formatMemoryList(rows) {
@@ -87,9 +123,3 @@ function formatMemoryList(rows) {
     })
         .join('\n');
 }
-/** Numbered review list: `  N. [SCOPE] CATEGORY  headline`. 1-indexed. */
-function formatMemoryReviewList(rows) {
-    return rows
-        .map((r, i) => `  ${i + 1}. [${r.scope}] ${r.category}  ${headline(r.category, r.content)}`)
-        .join('\n');
-}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffSync = diffSync;
+/**
+ * Pure reconcile: given the owned local files and the server bundle, classify
+ * each into add / update / remove / skipDrift. Idempotent — identical state
+ * yields empty add/update/remove. A locally-edited owned file (drift) is never
+ * an update or remove; it is reported as skipDrift so the dev's edit survives
+ * (and becomes a P3 upsync candidate).
+ */
+function diffSync(owned, bundle) {
+    const ownedById = new Map(owned.map(o => [o.id, o]));
+    const bundleById = new Map(bundle.map(b => [b.id, b]));
+    const add = bundle.filter(b => !ownedById.has(b.id));
+    const remove = [];
+    const update = [];
+    const skipDrift = [];
+    for (const o of owned) {
+        const b = bundleById.get(o.id);
+        if (o.diskHash !== o.contentHash) {
+            // locally edited → protect it regardless of whether the server changed
+            skipDrift.push(o.id);
+            continue;
+        }
+        if (!b) {
+            remove.push(o.id);
+            continue;
+        }
+        if (b.contentHash !== o.contentHash)
+            update.push(b);
+    }
+    return { add, update, remove, skipDrift };
+}

package/dist/cli/src/lib/upsync.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectUpsyncCandidates = collectUpsyncCandidates;
+exports.projectMemoriesEndpoint = projectMemoriesEndpoint;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const OUTBOX_DIR = 'outbox';
+/**
+ * Collect upsync candidates from `<root>/outbox/*.json` — each a structured
+ * `{ category, content }` the dev authored locally and wants promoted to the
+ * team. JSON (not the rendered team/*.md files) keeps the content lossless and
+ * already category-shaped; a rendered team file cannot be reversed back to
+ * structured content, so edited team files (P1 drift candidates) are reported by
+ * `lumo memory sync`, not auto-converted here. Malformed/non-JSON files are
+ * skipped, not fatal.
+ */
+function collectUpsyncCandidates(root) {
+    const dir = (0, node_path_1.join)(root, OUTBOX_DIR);
+    if (!(0, node_fs_1.existsSync)(dir))
+        return [];
+    const out = [];
+    for (const f of (0, node_fs_1.readdirSync)(dir).sort()) {
+        if (!f.endsWith('.json'))
+            continue;
+        const p = (0, node_path_1.join)(dir, f);
+        try {
+            const parsed = JSON.parse((0, node_fs_1.readFileSync)(p, 'utf8'));
+            if (typeof parsed.category === 'string' && parsed.content !== undefined) {
+                out.push({
+                    file: p,
+                    category: parsed.category,
+                    content: parsed.content,
+                });
+            }
+        }
+        catch {
+            // skip malformed JSON
+        }
+    }
+    return out;
+}
+/**
+ * The endpoint upsync POSTs to. Deliberately the SAME create-project-memory
+ * route the web/CLI already use (`createForProject`: canonicalize → dedup →
+ * reconcile-on-write, LUM-538) — upsync reuses that pipeline rather than adding
+ * a parallel one.
+ */
+function projectMemoriesEndpoint(base, projectId) {
+    return `${base}/api/projects/${encodeURIComponent(projectId)}/memories`;
+}

package/dist/shared/src/code-anchor.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * LUM-547 (P4b) — code-anchor staleness detection.
+ *
+ * Pure logic: parse a memory's flattened text for high-confidence references to
+ * code "anchors" (file paths, symbols, flag/constant names), then — given an
+ * injected existence probe — decide whether the whole memory is stale (every
+ * anchor it names is gone from the repo).
+ *
+ * 高精度优先 / 宁缺毋滥: anchor extraction errs toward under-extraction
+ * (symbols & flags must be backtick-guarded; paths must be path-shaped with a
+ * known extension), and the staleness verdict errs toward keeping a memory (any
+ * single surviving anchor spares the whole memory). Detection only proposes a
+ * candidate; a human confirms before anything is archived (see retire.service).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAnchors = extractAnchors;
+exports.classifyMemoryStaleness = classifyMemoryStaleness;
+const KNOWN_EXT = 'ts|tsx|js|jsx|mjs|cjs|json|prisma|md|mdx|css|scss|sass|sql|sh|yml|yaml|html|toml';
+// A repo-relative path: one or more "dir/" segments then a filename.ext.
+const PATH_RE = new RegExp(String.raw `(?<![\w@/.])((?:[\w.-]+/)+[\w.-]+\.(?:${KNOWN_EXT}))\b`, 'g');
+const IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const SCREAMING_SNAKE_RE = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+$/;
+// "Compound" identifier: camelCase, snake_case, or PascalCase-with-transition.
+const COMPOUND_RE = /[a-z][A-Z]|_|^[A-Z][a-z0-9]+[A-Z]/;
+function isExternalPath(p) {
+    return (p.startsWith('@') ||
+        p.startsWith('node_modules/') ||
+        p.includes('/node_modules/'));
+}
+/**
+ * Extract high-confidence code anchors from flattened memory text.
+ * - File paths: path-shaped tokens with a known extension (bare or backticked),
+ *   excluding URLs and external packages.
+ * - Symbols: backtick-wrapped compound identifiers (camel/snake/Pascal), with
+ *   single plain words and stop-words excluded.
+ * - Flags: backtick-wrapped SCREAMING_SNAKE constants.
+ * Result is de-duplicated, first-seen order.
+ */
+function extractAnchors(text) {
+    const out = [];
+    const seen = new Set();
+    const push = (kind, value) => {
+        const key = `${kind}::${value}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        out.push({ kind, value });
+    };
+    // Strip URLs so their path-looking tails are never mistaken for repo paths.
+    const deUrled = text.replace(/https?:\/\/\S+/g, ' ');
+    // File paths (from anywhere in the text).
+    PATH_RE.lastIndex = 0;
+    for (let m = PATH_RE.exec(deUrled); m != null; m = PATH_RE.exec(deUrled)) {
+        const p = m[1];
+        if (p && !isExternalPath(p))
+            push('file', p);
+    }
+    // Symbols & flags (backtick-guarded only).
+    const backtickRe = /`([^`]+)`/g;
+    for (let m = backtickRe.exec(text); m != null; m = backtickRe.exec(text)) {
+        const inner = (m[1] ?? '').trim();
+        if (!IDENT_RE.test(inner))
+            continue; // has spaces / slashes / dots → not a bare identifier
+        if (SCREAMING_SNAKE_RE.test(inner)) {
+            push('flag', inner);
+            continue;
+        }
+        if (inner.length >= 3 && COMPOUND_RE.test(inner)) {
+            push('symbol', inner);
+        }
+    }
+    return out;
+}
+function anchorExists(a, probe) {
+    return a.kind === 'file'
+        ? probe.fileExists(a.value)
+        : probe.symbolExists(a.value);
+}
+/**
+ * Decide whether a memory's text is code-anchor stale. A memory is a stale
+ * candidate only when it names at least one anchor and EVERY anchor it names is
+ * absent from the repo (any single survivor spares it — the mis-kill guard). An
+ * anchor-free memory is never a candidate. `deadAnchors` always reports the
+ * absent anchors found (useful as evidence even when the memory is not stale).
+ */
+function classifyMemoryStaleness(text, probe) {
+    const anchors = extractAnchors(text);
+    const deadAnchors = anchors.filter(a => !anchorExists(a, probe));
+    const stale = anchors.length > 0 && deadAnchors.length === anchors.length;
+    return { stale, deadAnchors, anchorsFound: anchors.length };
+}

package/dist/shared/src/index.js

@@ -1,7 +1,7 @@
 "use strict";
 // ── Agent Error types ────────────────────────────────────────────────────────
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.capRenderedOutput = exports.truncateUnitsToBudget = exports.OUTPUT_TOKEN_BUDGET = exports.estimateTokens = exports.buildCmdEvidencePointer = exports.isValidEvidencePointer = exports.EVIDENCE_POINTER_MAX = exports.EVIDENCE_POINTER_FORMAT_HINT = exports.EVIDENCE_POINTER_PATTERNS = exports.sanitizeField = exports.parseStreamJsonUsage = exports.tiptapToMarkdown = exports.markdownToTiptap = exports.AgentError = void 0;
+exports.classifyMemoryStaleness = exports.extractAnchors = exports.capRenderedOutput = exports.truncateUnitsToBudget = exports.OUTPUT_TOKEN_BUDGET = exports.estimateTokens = exports.buildCmdEvidencePointer = exports.isValidEvidencePointer = exports.EVIDENCE_POINTER_MAX = exports.EVIDENCE_POINTER_FORMAT_HINT = exports.EVIDENCE_POINTER_PATTERNS = exports.sanitizeField = exports.parseStreamJsonUsage = exports.tiptapToMarkdown = exports.markdownToTiptap = exports.AgentError = void 0;
 exports.userFriendlyError = userFriendlyError;
 class AgentError extends Error {
     code;
@@ -52,3 +52,7 @@ Object.defineProperty(exports, "estimateTokens", { enumerable: true, get: functi
 Object.defineProperty(exports, "OUTPUT_TOKEN_BUDGET", { enumerable: true, get: function () { return output_budget_1.OUTPUT_TOKEN_BUDGET; } });
 Object.defineProperty(exports, "truncateUnitsToBudget", { enumerable: true, get: function () { return output_budget_1.truncateUnitsToBudget; } });
 Object.defineProperty(exports, "capRenderedOutput", { enumerable: true, get: function () { return output_budget_1.capRenderedOutput; } });
+// ── Memory code-anchor staleness detection (LUM-547) ─────────────────────────
+var code_anchor_1 = require("./code-anchor");
+Object.defineProperty(exports, "extractAnchors", { enumerable: true, get: function () { return code_anchor_1.extractAnchors; } });
+Object.defineProperty(exports, "classifyMemoryStaleness", { enumerable: true, get: function () { return code_anchor_1.classifyMemoryStaleness; } });

package/package.json

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