lucid-mem 0.4.0 → 0.5.1

package/README.md

@@ -34,7 +34,7 @@ Memory lives in `~/agent-memory` — a real git repo you can read, diff, and poi
 
 ## Multi-repo memory
 
-One memory repo serves every project. `projects/<name>-<hash>.md` files key off the repo's origin remote, so clones share memory and same-named repos don't collide. `amr link` attaches related projects (transitively); `private` policy keeps a project out of transitive auto-attach; `noglobal` skips global memory for a repo.
+One memory repo serves every project. `projects/<name>-<hash>.md` files key off the repo's origin remote, so clones share memory and same-named repos don't collide. Inside a known repo, `amr context` is project-scoped — the project's latest 25 plus linked siblings (up to 8 projects). Outside one, it shows global bullets plus the latest 25 pooled across all projects. `private` and `noglobal` policies keep a project out of the pooled digest (links still reach private projects — your link graph is your own curation).
 
 ## MCP
 

package/lib/cli.mjs

@@ -26,7 +26,7 @@ const USAGE = `amr: agent memory CLI (lucid-mem)
 usage: amr <command> [args] [flags]
 
   ensure                        create/verify the memory repo ($AMR_HOME, default ~/agent-memory)
-  context [dir]                 print session memory digest (global + current project, capped; --full for all)
+  context [dir]                 session digest: project-scoped inside a known repo; global + pooled projects outside
   add "text"                    save a memory entry
   update "match" "text"         replace an existing entry in place
   search "term"                 grep all memory files

package/lib/commands.mjs

@@ -77,37 +77,42 @@ export function cmdContext(flags) {
         ];
   const cfg = loadConfig(home);
   const entry = proj ? projectEntry(cfg, proj) : null;
-  // noglobal: this repo's sessions omit the global section.
-  const globalLines = entry?.noglobal
-    ? []
-    : cap(bullets(idxSplit[0] || ''), 25);
+  // Two modes: inside a repo that has a memory file, the digest is
+  // project-scoped — this project plus its linked siblings only, no
+  // global bullets. Outside any known project (or a repo with no
+  // memory yet), it is global bullets plus a pooled digest of the
+  // latest entries across all projects.
+  const projHasFile =
+    !!proj &&
+    fs.existsSync(path.join(home, 'projects', `${proj.slug}.md`));
+  const inProject = projHasFile;
+  const globalLines = inProject ? [] : cap(bullets(idxSplit[0] || ''), 25);
   const indexLinks = cap(bullets(idxSplit[1] || ''), 12);
 
   // Attach list: the current project, then its config links
-  // (transitive, deduped, max 5 total) and any --also names.
-  // private blocks reachability from repos that never linked it:
-  // direct links (siblings) and explicit --also attach fine; it only
-  // refuses when reached transitively through another project's links.
+  // (transitive, deduped, max 8 total) and any --also names.
+  // Links are the owner's curation — private projects attach fine
+  // through them. `private` only keeps a project out of the pooled
+  // outside digest, the one unlinked exposure path.
   const bySlug = new Map(listProjects(home).map((p) => [p.slug, p]));
   const attach = [];
   const seen = new Set();
   const push = (slug, linked) => {
-    if (seen.has(slug) || attach.length >= 5) return;
+    if (seen.has(slug) || attach.length >= 8) return;
     seen.add(slug);
     attach.push({ slug, name: bySlug.get(slug)?.name || slug, linked });
   };
   if (proj) push(proj.slug, false);
-  const queue = (entry?.links || []).map((k) => ({ k, via: 'entry' }));
+  const queue = (entry?.links || []).map((k) => ({ k }));
   if (flags.also)
     queue.push(
       ...String(flags.also)
         .split(',')
-        .map((k) => ({ k, via: 'also' }))
+        .map((k) => ({ k }))
     );
-  const refused = [];
   const unknown = [];
-  while (queue.length && attach.length < 5) {
-    const { k: raw, via } = queue.shift();
+  while (queue.length && attach.length < 8) {
+    const { k: raw } = queue.shift();
     const key = String(raw).trim().toLowerCase();
     if (!key) continue;
     const slug = resolveProjectSlug(home, key);
@@ -117,13 +122,8 @@ export function cmdContext(flags) {
     }
     if (seen.has(slug)) continue;
     const e = projectEntry(cfg, { slug, name: key });
-    if (e?.private && via === 'transitive') {
-      refused.push(key);
-      continue;
-    }
     push(slug, true);
-    if (e?.links)
-      queue.push(...e.links.map((l) => ({ k: l, via: 'transitive' })));
+    if (e?.links) queue.push(...e.links.map((l) => ({ k: l })));
   }
 
   const lines = [`<agent-memory repo="${home}">`];
@@ -131,19 +131,34 @@ export function cmdContext(flags) {
   for (const a of attach) {
     const pf = path.join(home, 'projects', `${a.slug}.md`);
     if (!fs.existsSync(pf)) continue;
-    const body = cap(
-      bullets(fs.readFileSync(pf, 'utf8')),
-      a.linked ? 12 : 25
-    ).join('\n');
+    const body = cap(bullets(fs.readFileSync(pf, 'utf8')), 25).join('\n');
     lines.push('', `## Project: ${a.name}${a.linked ? ' (linked)' : ''}`);
     if (body) lines.push(body);
   }
+  // Outside-mode digest: the latest 25 project entries pooled across
+  // every project file, newest first by added: date. private projects
+  // never contribute (must not leak into foreign sessions); noglobal
+  // projects opt out of the pooled view the same way.
+  if (!inProject) {
+    const pool = [];
+    for (const p of listProjects(home)) {
+      const e = projectEntry(cfg, p);
+      if (e?.private || e?.noglobal) continue;
+      const pf = path.join(home, 'projects', `${p.slug}.md`);
+      for (const b of bullets(fs.readFileSync(pf, 'utf8'))) {
+        const d = (b.match(/added: (\d{4}-\d{2}-\d{2})/) || [])[1] || '';
+        pool.push({
+          d,
+          b: /project:/.test(b) ? b : b.replace(/^- /, `- (${p.name}) `),
+        });
+      }
+    }
+    pool.sort((a, b) => b.d.localeCompare(a.d));
+    const recent = cap(pool.map((x) => x.b), 25);
+    if (recent.length)
+      lines.push('', '## Recent project memory', recent.join('\n'));
+  }
   if (indexLinks.length) lines.push('', '## Index', indexLinks.join('\n'));
-  if (refused.length)
-    lines.push(
-      '',
-      `<!-- ${refused.length} linked project(s) omitted by private policy: ${refused.join(', ')} -->`
-    );
   if (unknown.length)
     lines.push(
       '',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lucid-mem",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "lucid-mem (amr) - autonomous git-backed agent memory (Agent Memory Repo spec)",
   "type": "module",
   "bin": {

package/test/context.test.mjs

@@ -28,7 +28,7 @@ test('context in a repo shows its project memory', () => {
   assert.match(r.stdout, /app uses redis cache/);
 });
 
-test('link attaches a sibling project transitively; private blocks transitive only', () => {
+test('link attaches siblings and private transitively (links are owner curation)', () => {
   const home = tmpdir();
   const base = tmpdir();
   const repoA = initRepo(path.join(base, 'a'), 'https://github.com/acme/a.git');
@@ -45,13 +45,13 @@ test('link attaches a sibling project transitively; private blocks transitive on
   const inB = run(['context'], { amrHome: home, cwd: repoB });
   assert.match(inB.stdout, /a uses sqlite/);
 
-  // c links to b; a is private -> transitive refusal in c
+  // c links to b; a is private -> still attaches transitively, since
+  // the link chain is the owner's own curation
   run(['link', 'b'], { amrHome: home, cwd: repoC });
   run(['policy', 'a', 'private', 'true'], { amrHome: home, cwd: repoA });
   const inC = run(['context'], { amrHome: home, cwd: repoC });
   assert.match(inC.stdout, /b uses kafka/);
-  assert.match(inC.stdout, /omitted by private policy/);
-  assert.ok(!inC.stdout.includes('a uses sqlite'));
+  assert.match(inC.stdout, /a uses sqlite/);
 
   // explicit --also still attaches the private project
   const explicit = run(['context', '--also', 'a'], { amrHome: home, cwd: repoC });
@@ -82,16 +82,38 @@ test('unlink removes the auto-attach', () => {
   assert.ok(!run(['context'], { amrHome: home, cwd: repoB }).stdout.includes('x1 fact'));
 });
 
-test('noglobal policy suppresses global memory for that repo', () => {
+test('context in a known project is project-scoped (no global section)', () => {
   const home = tmpdir();
   const repo = initRepo(path.join(tmpdir(), 'iso'), 'https://github.com/acme/iso.git');
   run(['ensure'], { amrHome: home });
   run(['add', 'global pref'], { amrHome: home });
   seed(home, repo, 'iso fact');
-  const before = run(['context'], { amrHome: home, cwd: repo });
-  assert.match(before.stdout, /global pref/);
-  run(['policy', 'iso', 'noglobal', 'true'], { amrHome: home, cwd: repo });
-  const after = run(['context'], { amrHome: home, cwd: repo });
-  assert.match(after.stdout, /iso fact/);
-  assert.ok(!after.stdout.includes('global pref'));
+  const r = run(['context'], { amrHome: home, cwd: repo });
+  assert.match(r.stdout, /iso fact/);
+  assert.ok(!r.stdout.includes('global pref'));
+  assert.ok(!r.stdout.includes('## Global'));
+  assert.ok(!r.stdout.includes('## Recent project memory'));
+});
+
+test('outside context pools latest project entries; private and noglobal excluded', () => {
+  const home = tmpdir();
+  const base = tmpdir();
+  const repoA = initRepo(path.join(base, 'pa'), 'https://github.com/acme/pa.git');
+  const repoB = initRepo(path.join(base, 'pb'), 'https://github.com/acme/pb.git');
+  const repoC = initRepo(path.join(base, 'pc'), 'https://github.com/acme/pc.git');
+  const repoD = initRepo(path.join(base, 'pd'), 'https://github.com/acme/pd.git');
+  run(['ensure'], { amrHome: home });
+  seed(home, repoA, 'pa pooled fact');
+  seed(home, repoB, 'pb pooled fact');
+  seed(home, repoC, 'pc secret fact');
+  seed(home, repoD, 'pd quiet fact');
+  run(['policy', 'pc', 'private', 'true'], { amrHome: home, cwd: repoC });
+  run(['policy', 'pd', 'noglobal', 'true'], { amrHome: home, cwd: repoD });
+  const r = run(['context'], { amrHome: home, cwd: tmpdir() });
+  assert.equal(r.status, 0, r.stderr);
+  assert.match(r.stdout, /## Recent project memory/);
+  assert.match(r.stdout, /pa pooled fact/);
+  assert.match(r.stdout, /pb pooled fact/);
+  assert.ok(!r.stdout.includes('pc secret fact'));
+  assert.ok(!r.stdout.includes('pd quiet fact'));
 });