mixdog 1.2.5 → 1.3.0

package/src/runtime/memory/lib/core-memory-management.mjs

@@ -2,6 +2,7 @@
 // through recall, not through a second instruction-management namespace.
 import { indexedCoreRecord, syncCoreMemoryIndexes } from './core-memory-index.mjs';
 import { resolveProjectScope } from './project-id-resolver.mjs';
+import { corePoolLabel } from './core-memory-access.mjs';
 
 export async function listManagedMemories(db, scope, options = {}) {
   const includeInactive = options.include_inactive ?? false;
@@ -27,20 +28,24 @@ export async function listManagedMemories(db, scope, options = {}) {
     state.recordIds.map((id, index) => `WHEN ${Number(id)} THEN ${index + 1}`)
   );
   const publicOrder = indexCases.length ? `CASE id ${indexCases.join(' ')} ELSE id END` : 'id';
+  // `agent_id` lists that agent's own pool alone; otherwise agent pools are
+  // never part of a common/project listing.
+  const agentId = typeof options.agent_id === 'string' && options.agent_id ? options.agent_id : null;
   const result = await db.query(
     `
     SELECT * FROM (
-      SELECT 'curated'::text AS source, c.id, c.project_id, c.element, c.summary,
+      SELECT 'curated'::text AS source, c.id, c.project_id, c.agent_id, c.element, c.summary,
              COALESCE(c.status, 'active')::text AS status,
              (c.status IS NULL OR c.status = 'active') AS injection_enabled
       FROM core_entries c
     ) memories
-    WHERE ($1::text = '*' OR project_id = $1 OR (project_id IS NULL AND (NOT $5::boolean OR $1::text IS NULL)))
+    WHERE (agent_id = $6::text OR ($6::text IS NULL AND agent_id IS NULL
+        AND ($1::text = '*' OR project_id = $1 OR (project_id IS NULL AND (NOT $5::boolean OR $1::text IS NULL)))))
       AND ($4::boolean OR injection_enabled)
     ORDER BY project_id NULLS FIRST, ${publicOrder} ASC, id ASC
     LIMIT $2 OFFSET $3
   `,
-    [scope, limit + 1, offset, includeInactive, options.scope_only === true]
+    [scope, limit + 1, offset, includeInactive, options.scope_only === true, agentId]
   );
   const hasMore = result.rows.length > limit;
   const entries = result.rows.slice(0, limit).map((row) => indexedCoreRecord(row, directory));
@@ -54,7 +59,8 @@ export function formatManagedMemories(page) {
   const lines = page.entries.map((row) => {
     const id = row.id ? `id=${row.id}` : `archived_id=${row.record_id}`;
     const version = row.index_revision ? ` index_revision=${row.index_revision}` : '';
-    return `${id} source=curated project=${row.project_id ?? 'COMMON'} status=${row.status} injection=${row.injection_enabled ? 'enabled' : 'disabled'}${version} ${row.element ?? ''} — ${row.summary ?? ''}`;
+    const pool = corePoolLabel({ projectId: row.project_id, agentId: row.agent_id });
+    return `${id} source=curated ${pool} status=${row.status} injection=${row.injection_enabled ? 'enabled' : 'disabled'}${version} ${row.element ?? ''} — ${row.summary ?? ''}`;
   });
   if (page.nextOffset !== null)
     lines.push(`More memories: call list with offset=${page.nextOffset} and the same project scope/include_inactive.`);

package/src/runtime/memory/lib/core-memory-store.mjs

@@ -1,6 +1,7 @@
-
 // User-curated core memory store — native PG-backed via core_entries table.
-// Per-project entries distinguished by project_id column (NULL = COMMON).
+// Per-project entries distinguished by project_id column (NULL = COMMON); an
+// agent's own pool by agent_id (its project_id stays NULL). Every mutation
+// checks its caller against the pool (core-memory-access.mjs).
 // Explicit add/edit/delete operations affect only the requested entry.
 // Generated conversation history never enters this store automatically.
 
@@ -10,6 +11,11 @@ import { getDatabase } from './memory.mjs';
 import { VALID_CATEGORY } from './memory-categories.mjs';
 import { checkedConnect } from './pg/adapter.mjs';
 import { findCoreKeyRows } from './core-memory-uniqueness.mjs';
+import { assertCoreWrite, corePoolLabel, normalizeMemoryCaller } from './core-memory-access.mjs';
+
+// The advisory-lock key of one pool.
+const poolLockKey = (projectId, agentId) =>
+  agentId ? `core:agent:${agentId}` : `core:${projectId == null ? 'COMMON' : projectId}`;
 
 const CORE_ELEMENT_DERIVE_LENGTH = 40;
 
@@ -74,7 +80,6 @@ function _getDb(dataDir) {
   return db;
 }
 
-
 // NOTE: boot-time core id compaction was REMOVED. Resequencing core_entries.id
 // to 1..N rewrote primary keys that are handed out as stable `core:N`
 // references, so after a restart a retained reference pointed at a different
@@ -83,7 +88,7 @@ function _getDb(dataDir) {
 
 export async function listCore(dataDir, projectId = null) {
   const db = _getDb(dataDir);
-  const cols = `id, element, summary, category, project_id, created_at, updated_at`;
+  const cols = `id, element, summary, category, project_id, agent_id, created_at, updated_at`;
   // Only live cores enter recall/review — archived (superseded) rows are
   // retired but retained for audit. Legacy NULL status = active.
   const live = `(status IS NULL OR status = 'active')`;
@@ -92,7 +97,9 @@ export async function listCore(dataDir, projectId = null) {
     return r.rows;
   }
   if (projectId === null) {
-    const r = await db.query(`SELECT ${cols} FROM core_entries WHERE project_id IS NULL AND ${live} ORDER BY id ASC`);
+    const r = await db.query(
+      `SELECT ${cols} FROM core_entries WHERE project_id IS NULL AND agent_id IS NULL AND ${live} ORDER BY id ASC`
+    );
     return r.rows;
   }
   const r = await db.query(`SELECT ${cols} FROM core_entries WHERE project_id = $1 AND ${live} ORDER BY id ASC`, [
@@ -110,8 +117,10 @@ function serializeCoreMutation(fn) {
   return run;
 }
 
-export function addCore(dataDir, input, projectId) {
-  return serializeCoreMutation(() => _addCoreImpl(dataDir, input, projectId));
+/** `options`: `agentId` selects that agent's pool (projectId must be null);
+ *  `caller` is the normalized-or-raw memory caller (absent: the host). */
+export function addCore(dataDir, input, projectId, options = {}) {
+  return serializeCoreMutation(() => _addCoreImpl(dataDir, input, projectId, options));
 }
 export function editCore(dataDir, id, patch) {
   return serializeCoreMutation(() => _editCoreImpl(dataDir, id, patch));
@@ -120,9 +129,12 @@ export function deleteCore(dataDir, id, options = {}) {
   return serializeCoreMutation(() => _deleteCoreImpl(dataDir, id, options));
 }
 
-async function _addCoreImpl(dataDir, input, projectId) {
+async function _addCoreImpl(dataDir, input, projectId, { agentId = null, caller } = {}) {
   if (projectId === undefined)
     throw new Error('addCore: projectId required — pass null for COMMON pool, or slug string for scoped pool');
+  if (agentId && projectId !== null) throw new Error('agent memory has no project scope');
+  const pool = { projectId, agentId: agentId || null };
+  assertCoreWrite(normalizeMemoryCaller(caller), 'add', pool);
   const {
     element: el,
     summary: sm,
@@ -141,30 +153,29 @@ async function _addCoreImpl(dataDir, input, projectId) {
   try {
     await client.query('BEGIN');
     await client.query(`SET LOCAL lock_timeout = '5s'`);
-    const poolKey = `core:${projectId == null ? 'COMMON' : projectId}`;
-    await client.query(`SELECT pg_advisory_xact_lock(hashtext($1))`, [poolKey]);
-    const collisions = await findCoreKeyRows(client, projectId, el);
+    await client.query(`SELECT pg_advisory_xact_lock(hashtext($1))`, [poolLockKey(projectId, pool.agentId)]);
+    const collisions = await findCoreKeyRows(client, projectId, el, null, pool.agentId);
     if (collisions.length) {
       if (collisions.length !== 1 || collisions[0].status !== 'archived') {
         throw new Error(
-          `core entry already exists: project=${projectId ?? 'COMMON'} element=${JSON.stringify(el.slice(0, 200))}; use an explicit edit/delete`
+          `core entry already exists: ${corePoolLabel(pool)} element=${JSON.stringify(el.slice(0, 200))}; use an explicit edit/delete`
         );
       }
       const revived = await client.query(
         `UPDATE core_entries SET summary = $1, category = $2,
            status = 'active', archived_at = NULL, updated_at = $3
          WHERE id = $4
-         RETURNING id, element, summary, category, project_id, created_at, updated_at`,
+         RETURNING id, element, summary, category, project_id, agent_id, created_at, updated_at`,
         [sm, cat, now, collisions[0].id]
       );
       await client.query('COMMIT');
       return { ...revived.rows[0], revived_from_archived: true };
     }
     const r = await client.query(
-      `INSERT INTO core_entries(element, summary, category, project_id, created_at, updated_at)
-       VALUES ($1, $2, $3, $4, $5, $6)
-       RETURNING id, element, summary, category, project_id, created_at, updated_at`,
-      [el, sm, cat, projectId, now, now]
+      `INSERT INTO core_entries(element, summary, category, project_id, agent_id, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)
+       RETURNING id, element, summary, category, project_id, agent_id, created_at, updated_at`,
+      [el, sm, cat, projectId, pool.agentId, now, now]
     );
     await client.query('COMMIT');
     return r.rows[0];
@@ -187,6 +198,10 @@ async function _editCoreImpl(dataDir, id, patch) {
   if (Object.hasOwn(patch, 'expectedProjectId') && (patch.expectedProjectId ?? null) !== (cur.project_id ?? null)) {
     throw new Error(`entry id=${numId} is not in project ${patch.expectedProjectId ?? 'COMMON'}`);
   }
+  if (Object.hasOwn(patch, 'expectedAgentId') && (patch.expectedAgentId ?? null) !== (cur.agent_id ?? null)) {
+    throw new Error(`entry id=${numId} is not in ${corePoolLabel({ agentId: patch.expectedAgentId })}`);
+  }
+  const agentId = cur.agent_id ?? null;
   const incoming = normalizeCoreInput(patch);
   const newElement = incoming.element ?? cur.element;
   const newSummary = incoming.summary ?? cur.summary;
@@ -194,6 +209,10 @@ async function _editCoreImpl(dataDir, id, patch) {
   const newProjectId = Object.hasOwn(patch, 'targetProjectId')
     ? (patch.targetProjectId ?? null)
     : (cur.project_id ?? null);
+  if (agentId && newProjectId !== null) throw new Error('agent memory has no project scope');
+  const caller = normalizeMemoryCaller(patch.caller);
+  assertCoreWrite(caller, 'edit', { projectId: cur.project_id ?? null, agentId });
+  if (newProjectId !== (cur.project_id ?? null)) assertCoreWrite(caller, 'edit', { projectId: newProjectId, agentId });
   const { errors } = normalizeCoreInput(
     {
       element: newElement,
@@ -237,10 +256,7 @@ async function _editCoreImpl(dataDir, id, patch) {
   try {
     await client.query('BEGIN');
     await client.query(`SET LOCAL lock_timeout = '5s'`);
-    const poolKeys = [
-      `core:${cur.project_id == null ? 'COMMON' : cur.project_id}`,
-      `core:${newProjectId == null ? 'COMMON' : newProjectId}`,
-    ].sort();
+    const poolKeys = [poolLockKey(cur.project_id, agentId), poolLockKey(newProjectId, agentId)].sort();
     for (const poolKey of new Set(poolKeys)) {
       await client.query(`SELECT pg_advisory_xact_lock(hashtext($1))`, [poolKey]);
     }
@@ -254,14 +270,15 @@ async function _editCoreImpl(dataDir, id, patch) {
       fresh.summary !== cur.summary ||
       fresh.category !== cur.category ||
       (fresh.project_id ?? null) !== (cur.project_id ?? null) ||
+      (fresh.agent_id ?? null) !== agentId ||
       Number(fresh.updated_at ?? 0) !== Number(cur.updated_at ?? 0)
     ) {
       throw new Error(`core entry id=${numId} changed concurrently — re-read and retry`);
     }
     if (newElement !== cur.element || projectChanged) {
-      if ((await findCoreKeyRows(client, newProjectId, newElement, numId)).length) {
+      if ((await findCoreKeyRows(client, newProjectId, newElement, numId, agentId)).length) {
         throw new Error(
-          `core entry already exists: project=${newProjectId ?? 'COMMON'} element=${JSON.stringify(newElement.slice(0, 200))}`
+          `core entry already exists: ${corePoolLabel({ projectId: newProjectId, agentId })} element=${JSON.stringify(newElement.slice(0, 200))}`
         );
       }
     }
@@ -294,13 +311,19 @@ async function _deleteCoreImpl(dataDir, id, options = {}) {
   const numId = Number(id);
   if (!Number.isInteger(numId) || numId <= 0) throw new Error('integer id > 0 required');
   const db = _getDb(dataDir);
-  const scoped = Object.hasOwn(options, 'expectedProjectId');
-  const r = scoped
-    ? await db.query(`DELETE FROM core_entries WHERE id = $1 AND project_id IS NOT DISTINCT FROM $2 RETURNING *`, [
-        numId,
-        options.expectedProjectId,
-      ])
-    : await db.query(`DELETE FROM core_entries WHERE id = $1 RETURNING *`, [numId]);
+  const cur = (await db.query(`SELECT project_id, agent_id FROM core_entries WHERE id = $1`, [numId])).rows[0];
+  const pool = { projectId: cur?.project_id ?? null, agentId: cur?.agent_id ?? null };
+  const expected = (key, value) => !Object.hasOwn(options, key) || (options[key] ?? null) === value;
+  if (!cur || !expected('expectedProjectId', pool.projectId) || !expected('expectedAgentId', pool.agentId)) {
+    throw new Error(`no entry with id=${numId}`);
+  }
+  assertCoreWrite(normalizeMemoryCaller(options.caller), 'delete', pool);
+  // The pool just authorized: a concurrent move out of it deletes nothing.
+  const r = await db.query(
+    `DELETE FROM core_entries WHERE id = $1
+       AND project_id IS NOT DISTINCT FROM $2 AND agent_id IS NOT DISTINCT FROM $3 RETURNING *`,
+    [numId, pool.projectId, pool.agentId]
+  );
   if (r.rows.length === 0) throw new Error(`no entry with id=${numId}`);
   return r.rows[0];
 }

package/src/runtime/memory/lib/core-memory-uniqueness.mjs

@@ -2,10 +2,13 @@ import { __mixdogMemoryLog } from './memory-log.mjs';
 
 // Legacy conflicting keys remain visible and editable. Never choose a winner
 // or delete user-curated content just to install a constraint during startup.
+// The key is the pool (project_id, agent_id) plus element: an agent may keep
+// the same element as common memory. It replaced the (project_id, element)
+// index, which is dropped once the pool key is in place.
 export async function ensureCoreKeyIndex(db) {
   const conflicts = await db.query(`
-    SELECT project_id, element, COUNT(*) AS count
-    FROM core_entries GROUP BY project_id, element HAVING COUNT(*) > 1
+    SELECT project_id, agent_id, element, COUNT(*) AS count
+    FROM core_entries GROUP BY project_id, agent_id, element HAVING COUNT(*) > 1
     LIMIT 1
   `);
   if (conflicts.rows.length) {
@@ -16,8 +19,9 @@ export async function ensureCoreKeyIndex(db) {
   }
   try {
     await db.exec(
-      `CREATE UNIQUE INDEX IF NOT EXISTS core_entries_unique_proj_elem ON core_entries (project_id, element) NULLS NOT DISTINCT`
+      `CREATE UNIQUE INDEX IF NOT EXISTS core_entries_unique_pool_elem ON core_entries (project_id, agent_id, element) NULLS NOT DISTINCT`
     );
+    await db.exec(`DROP INDEX IF EXISTS core_entries_unique_proj_elem`);
     return true;
   } catch (error) {
     if (error.code !== '23505') throw error;
@@ -30,15 +34,15 @@ export async function ensureCoreKeyIndex(db) {
 
 // Called under the store's per-pool advisory lock. This also protects writes
 // while a legacy database still has conflicts and cannot install the index.
-export async function findCoreKeyRows(db, projectId, element, exceptId = null) {
+export async function findCoreKeyRows(db, projectId, element, exceptId = null, agentId = null) {
   const result = await db.query(
     `
     SELECT id, status FROM core_entries
-    WHERE project_id IS NOT DISTINCT FROM $1 AND element = $2
+    WHERE project_id IS NOT DISTINCT FROM $1 AND agent_id IS NOT DISTINCT FROM $4 AND element = $2
       AND ($3::bigint IS NULL OR id <> $3)
     ORDER BY id LIMIT 2 FOR UPDATE
   `,
-    [projectId, element, exceptId]
+    [projectId, element, exceptId, agentId]
   );
   return result.rows;
 }

package/src/runtime/memory/lib/embedding-tokenizer.mjs

@@ -15,7 +15,10 @@ const META = '\u2581';
 // The library's stand-in for SentencePiece's precompiled charsmap.
 function precompiledNormalize(text) {
   text = text.replace(/[\u0001-\u0008\u000B\u000E-\u001F\u007F\u008F\u009F]/gm, '');
-  text = text.replace(/[\u0009\u000A\u000C\u000D\u00A0\u1680\u2000-\u200F\u2028\u2029\u202F\u205F\u2581\u3000\uFEFF\uFFFD]/gm, ' ');
+  text = text.replace(
+    /[\u0009\u000A\u000C\u000D\u00A0\u1680\u2000-\u200F\u2028\u2029\u202F\u205F\u2581\u3000\uFEFF\uFFFD]/gm,
+    ' '
+  );
   return text.includes('\uFF5E')
     ? text
         .split('\uFF5E')
@@ -30,9 +33,10 @@ function buildNormalizer(spec) {
     if (step.type === 'Precompiled') return precompiledNormalize;
     if (step.type === 'Replace' && step.pattern?.Regex != null) {
       const re = new RegExp(step.pattern.Regex, 'gu');
-      return (text) => text.replace(re, step.content);
+      return (text) => text.replace(re, () => step.content);
     }
-    if (step.type === 'Replace' && step.pattern?.String != null) return (text) => text.replaceAll(step.pattern.String, step.content);
+    if (step.type === 'Replace' && step.pattern?.String != null)
+      return (text) => text.replaceAll(step.pattern.String, () => step.content);
     throw new UnsupportedTokenizerError(`unsupported normalizer ${step.type}`);
   });
   return (text) => fns.reduce((acc, fn) => fn(acc), text);
@@ -58,18 +62,10 @@ function splitOn(words, text) {
   return out;
 }
 
-/** Loads tokenizer.json; throws UnsupportedTokenizerError for any other layout. */
-export function loadUnigramTokenizer(tokenizerJsonPath, { maxLength = 512 } = {}) {
-  const json = JSON.parse(readFileSync(tokenizerJsonPath, 'utf8'));
-  const model = json.model;
-  const pre = json.pre_tokenizer;
-  const template = json.post_processor;
-  if (model?.type !== 'Unigram') throw new UnsupportedTokenizerError(`unsupported model ${model?.type}`);
-  if (pre?.type !== 'Metaspace') throw new UnsupportedTokenizerError(`unsupported pre-tokenizer ${pre?.type}`);
-  if (template?.type !== 'TemplateProcessing') throw new UnsupportedTokenizerError(`unsupported post-processor ${template?.type}`);
-  const normalize = buildNormalizer(json.normalizer);
-
-  const n = model.vocab.length;
+// Packs the vocabulary into one string pool with typed-array scores and an
+// open-addressing index; `lookup(str, a, b)` returns the id of str[a, b) or -1.
+function buildVocabIndex(vocab) {
+  const n = vocab.length;
   const scores = new Float64Array(n);
   const offsets = new Int32Array(n + 1);
   const pieces = [];
@@ -77,7 +73,7 @@ export function loadUnigramTokenizer(tokenizerJsonPath, { maxLength = 512 } = {}
   let maxChars = 1;
   let minScore = Infinity;
   for (let i = 0; i < n; i++) {
-    const [piece, score] = model.vocab[i];
+    const [piece, score] = vocab[i];
     scores[i] = score;
     if (score < minScore) minScore = score;
     offsets[i] = length;
@@ -119,6 +115,21 @@ export function loadUnigramTokenizer(tokenizerJsonPath, { maxLength = 512 } = {}
       slot = (slot + 1) & mask;
     }
   };
+  return { scores, minScore, maxChars, lookup };
+}
+
+/** Loads tokenizer.json; throws UnsupportedTokenizerError for any other layout. */
+export function loadUnigramTokenizer(tokenizerJsonPath, { maxLength = 512 } = {}) {
+  const json = JSON.parse(readFileSync(tokenizerJsonPath, 'utf8'));
+  const model = json.model;
+  const pre = json.pre_tokenizer;
+  const template = json.post_processor;
+  if (model?.type !== 'Unigram') throw new UnsupportedTokenizerError(`unsupported model ${model?.type}`);
+  if (pre?.type !== 'Metaspace') throw new UnsupportedTokenizerError(`unsupported pre-tokenizer ${pre?.type}`);
+  if (template?.type !== 'TemplateProcessing')
+    throw new UnsupportedTokenizerError(`unsupported post-processor ${template?.type}`);
+  const normalize = buildNormalizer(json.normalizer);
+  const { scores, minScore, maxChars, lookup } = buildVocabIndex(model.vocab);
   const unkId = model.unk_id;
   const unkScore = minScore - 10;
   scores[unkId] = unkScore;
@@ -229,8 +240,11 @@ export function loadUnigramTokenizer(tokenizerJsonPath, { maxLength = 512 } = {}
       return stripAround(splitOn(normalizedAdded, normalized)).flatMap((sub) => {
         if (sub.length === 0) return [];
         if (added.has(sub)) return [sub];
-        let piece = sub.replaceAll(' ', strRep);
-        if (!piece.startsWith(replacement) && (prependScheme === 'always' || (prependScheme === 'first' && sectionIndex === 0))) {
+        let piece = sub.replaceAll(' ', () => strRep);
+        if (
+          !piece.startsWith(replacement) &&
+          (prependScheme === 'always' || (prependScheme === 'first' && sectionIndex === 0))
+        ) {
           piece = strRep + piece;
         }
         return fuseUnk(viterbi(piece));

package/src/runtime/memory/lib/http-router/session-routes.mjs

@@ -29,8 +29,9 @@ function prewarmRecallEmbedding(log, reason = 'session-start') {
   }
 }
 
-const ACTIVE_CORE_ROWS = `SELECT id, summary FROM core_entries WHERE project_id IS NULL AND (status IS NULL OR status = 'active') ORDER BY id ASC`;
-const SCOPED_CORE_ROWS = `SELECT id, summary FROM core_entries WHERE project_id = $1 AND (status IS NULL OR status = 'active') ORDER BY id ASC`;
+// Agent pools never ride this payload (core-memory-access.mjs).
+const ACTIVE_CORE_ROWS = `SELECT id, summary FROM core_entries WHERE project_id IS NULL AND agent_id IS NULL AND (status IS NULL OR status = 'active') ORDER BY id ASC`;
+const SCOPED_CORE_ROWS = `SELECT id, summary FROM core_entries WHERE project_id = $1 AND agent_id IS NULL AND (status IS NULL OR status = 'active') ORDER BY id ASC`;
 
 export function createSessionRoutes({ getDb, log }) {
   async function buildSessionCoreMemoryPayload(cwd) {

package/src/runtime/memory/lib/memory-action-handlers/core-actions.mjs

@@ -1,13 +1,16 @@
 /**
  * memory-action-handlers/core-actions.mjs — `core`: user-curated core memory
  * add / edit / delete / list against the core store, with the
- * session-injection snapshot republished after every mutation.
+ * session-injection snapshot republished after every mutation. The caller
+ * (`memory_caller`) decides which pools it may read and write
+ * (core-memory-access.mjs); the store enforces the writes again.
  */
 import { addCore, editCore, deleteCore, normalizeCoreInput, normalizeCoreOp } from '../core-memory-store.mjs';
 import { resolveProjectScope } from '../project-id-resolver.mjs';
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { listManagedMemories, formatManagedMemories } from '../core-memory-management.mjs';
 import { publicCoreMemoryIdentity, resolveCoreMemoryIndex } from '../core-memory-index.mjs';
+import { assertCoreRead, corePoolLabel, normalizeMemoryCaller, validAgentId } from '../core-memory-access.mjs';
 
 const CORE_OPS = ['add', 'edit', 'delete', 'list'];
 
@@ -47,6 +50,20 @@ function normalizedWriteArgs(args, op, projectId) {
   };
 }
 
+// `agent_id` selects an agent's own pool instead of a project: "self" is the
+// caller's, another id the pool Mixy or the host manages.
+function coreAgentId(args, caller) {
+  const raw = typeof args.agent_id === 'string' ? args.agent_id.trim() : '';
+  if (!raw) return null;
+  if (raw.toLowerCase() === 'self') {
+    if (!caller.agentId) throw new Error('this session has no agent memory');
+    return caller.agentId;
+  }
+  const agentId = validAgentId(raw);
+  if (!agentId) throw new Error(`agent_id "${raw}" is not an agent id`);
+  return agentId;
+}
+
 function editTargetProjectId(args, projectId) {
   if (Object.hasOwn(args, 'target_project_id')) {
     const value = String(args.target_project_id ?? '').trim();
@@ -67,33 +84,44 @@ export function createCoreActions({
   const describe = async (entry) =>
     `(${await publicCoreMemoryIdentity(getDb(), entry)}): ${entry.element} — ${entry.summary.slice(0, 200)}`;
 
+  // `pool` is `{ projectId, agentId }`; an agent pool's projectId is null.
   const ops = {
-    async list(_coreDataDir, args, projectId) {
-      const page = await listManagedMemories(getDb(), projectId, args);
+    async list(_coreDataDir, args, { projectId, agentId }, caller) {
+      assertCoreRead(caller, agentId);
+      const page = await listManagedMemories(getDb(), projectId, { ...args, agent_id: agentId });
       return { text: args.format === 'json' ? JSON.stringify(page) : formatManagedMemories(page), ...page };
     },
-    async add(coreDataDir, args, projectId) {
-      const entry = await addCoreImpl(coreDataDir, args, projectId);
+    async add(coreDataDir, args, { projectId, agentId }, caller) {
+      const entry = await addCoreImpl(coreDataDir, args, projectId, { agentId, caller });
       await refreshCoreMemoryFile('core-add');
       return { text: `core added ${await describe(entry)}` };
     },
-    async edit(coreDataDir, args, projectId) {
-      const targetProjectId = editTargetProjectId(args, projectId);
-      const recordId = await resolveCoreMemoryIndex(getDb(), projectId, args.id, args.index_revision);
+    async edit(coreDataDir, args, { projectId, agentId }, caller) {
+      if (agentId && (Object.hasOwn(args, 'target_project_id') || args.target_cwd)) {
+        throw new Error('agent memory has no project scope');
+      }
+      const targetProjectId = agentId ? null : editTargetProjectId(args, projectId);
+      const recordId = await resolveCoreMemoryIndex(getDb(), projectId, args.id, args.index_revision, agentId);
       const entry = await editCoreImpl(coreDataDir, recordId, {
         ...args,
         expectedProjectId: projectId,
+        expectedAgentId: agentId,
         targetProjectId,
+        caller,
       });
       await refreshCoreMemoryFile('core-edit');
       return { text: `core edited ${await describe(entry)}` };
     },
-    async delete(coreDataDir, args, projectId) {
-      const recordId = await resolveCoreMemoryIndex(getDb(), projectId, args.id, args.index_revision);
-      const removed = await deleteCoreImpl(coreDataDir, recordId, { expectedProjectId: projectId });
+    async delete(coreDataDir, args, { projectId, agentId }, caller) {
+      const recordId = await resolveCoreMemoryIndex(getDb(), projectId, args.id, args.index_revision, agentId);
+      const removed = await deleteCoreImpl(coreDataDir, recordId, {
+        expectedProjectId: projectId,
+        expectedAgentId: agentId,
+        caller,
+      });
       await refreshCoreMemoryFile('core-delete');
       return {
-        text: `core deleted (project=${projectId ?? 'COMMON'} id=${args.id}): ${removed.element}. Remaining indices were compacted; list memories before the next write.`,
+        text: `core deleted (${corePoolLabel({ projectId, agentId })} id=${args.id}): ${removed.element}. Remaining indices were compacted; list memories before the next write.`,
       };
     },
   };
@@ -106,8 +134,10 @@ export function createCoreActions({
     }
     const coreDataDir = typeof dataDir === 'string' ? dataDir : resolvePluginData();
     if (!coreDataDir) return { text: 'core: memory data dir is not initialized', isError: true };
-    const projectId = coreProjectId(args);
+    const caller = normalizeMemoryCaller(args.memory_caller);
     try {
+      const agentId = coreAgentId(args, caller);
+      const projectId = agentId ? null : coreProjectId(args);
       if (args.source && args.source !== 'curated') {
         return { text: 'memory manages user-curated entries only; use recall for generated history.', isError: true };
       }
@@ -119,7 +149,7 @@ export function createCoreActions({
       if (projectId === '*' && op !== 'list') {
         return { text: `core ${op}: project_id "*" only valid for op="list"`, isError: true };
       }
-      return await ops[op](coreDataDir, args, projectId);
+      return await ops[op](coreDataDir, args, { projectId, agentId }, caller);
     } catch (e) {
       return { text: `core ${op} failed: ${e.message}`, isError: true };
     }

package/src/runtime/memory/lib/memory-schema/core-and-meta.mjs

@@ -21,9 +21,20 @@ export async function ensureCoreEntriesSchema(db) {
     )
   `);
   await db.exec(`CREATE INDEX IF NOT EXISTS core_entries_project_idx ON core_entries(project_id)`);
+  await ensureCoreAgentColumn(db);
   await ensureCoreKeyIndex(db);
 }
 
+// An agent's own pool (core-memory-access.mjs): agent_id names it and its
+// project_id stays NULL. Existing rows keep NULL, i.e. common/project memory.
+// Idempotent; runs on every boot before the pool key index.
+export async function ensureCoreAgentColumn(db) {
+  await db.exec(`ALTER TABLE core_entries ADD COLUMN IF NOT EXISTS agent_id TEXT`);
+  await db.exec(
+    `CREATE INDEX IF NOT EXISTS core_entries_agent_idx ON core_entries(agent_id) WHERE agent_id IS NOT NULL`
+  );
+}
+
 export async function ensureMetaSchema(db) {
   await db.exec(`
     CREATE TABLE IF NOT EXISTS meta (

package/src/runtime/memory/lib/memory.mjs

@@ -15,7 +15,12 @@ import { ensureCoreKeyIndex } from './core-memory-uniqueness.mjs';
 import { ensureScoreSchema } from './memory-schema/score-params.mjs';
 import { ensureEntriesSchema } from './memory-schema/entries.mjs';
 import { ensureEntryTriggers } from './memory-schema/entry-triggers.mjs';
-import { ensureCoreEntriesSchema, ensureMetaSchema, stampBootstrapMeta } from './memory-schema/core-and-meta.mjs';
+import {
+  ensureCoreAgentColumn,
+  ensureCoreEntriesSchema,
+  ensureMetaSchema,
+  stampBootstrapMeta,
+} from './memory-schema/core-and-meta.mjs';
 import { VALID_CATEGORY } from './memory-categories.mjs';
 
 const dbs = new Map();
@@ -366,6 +371,7 @@ export async function ensureCurrentSchemaExtensions(db, dims, embeddingIdentity
   // Legacy NULL status remains active; obsolete generated metadata is untouched.
   await db.exec(`ALTER TABLE core_entries ADD COLUMN IF NOT EXISTS status text`);
   await db.exec(`ALTER TABLE core_entries ADD COLUMN IF NOT EXISTS archived_at bigint`);
+  await ensureCoreAgentColumn(db);
 
   await ensureCoreKeyIndex(db);
 

package/src/runtime/memory/lib/query-core-recall.mjs

@@ -35,12 +35,20 @@ function appendTimeWindow(where, params, tsFrom, tsTo) {
   }
 }
 
-export async function recallCoreRows(db, query, { projectScope, category, limit, tsFrom, tsTo } = {}) {
+/** `agentId`: the caller's own agent pool joins the result; no other agent's
+ *  pool ever does (core-memory-access.mjs). */
+export async function recallCoreRows(db, query, { projectScope, category, limit, tsFrom, tsTo, agentId = '' } = {}) {
   const terms = coreRecallTerms(query);
   if (terms.length === 0) return [];
 
   const params = [];
   const where = [];
+  if (agentId) {
+    params.push(agentId);
+    where.push(`(agent_id IS NULL OR agent_id = $${params.length})`);
+  } else {
+    where.push('agent_id IS NULL');
+  }
   const scope = normalizeRecallProjectScope(projectScope);
   let scopeClause = scope;
   if (scope === null) scopeClause = 'common';

package/src/runtime/memory/lib/query-hybrid-search.mjs

@@ -14,6 +14,7 @@ import { compareRecallByScore, compareRecallNewestFirst } from './recall-order.m
 import { throwIfAborted } from './memory-cycle-shared.mjs';
 import { expandRecallEventContext } from './recall-event-context.mjs';
 import { insertTraceEvents } from './trace-store.mjs';
+import { normalizeMemoryCaller } from './core-memory-access.mjs';
 import {
   annotateRecallRootContext,
   boundRecallRowsToTemporal,
@@ -305,6 +306,7 @@ export async function searchByQuery({
     : await recallCoreRows(retrievalQuery, {
         projectScope,
         category,
+        agentId: normalizeMemoryCaller(args.memory_caller).agentId,
         limit: retrievalLimit,
         tsFrom: temporal?.startMs,
         tsTo: temporal?.endMs,

package/src/runtime/memory/lib/runtime-fetcher.mjs

@@ -188,7 +188,7 @@ function runtimeAssetUrlCandidates(url) {
     .map((repo) => repo.trim())
     .filter(Boolean);
   for (const repo of overrides) {
-    if (repo && repo !== releaseRepo) add(value.replace(`/github.com/${releaseRepo}/`, `/github.com/${repo}/`));
+    if (repo && repo !== releaseRepo) add(value.replace(`/github.com/${releaseRepo}/`, () => `/github.com/${repo}/`));
   }
   return out;
 }

package/src/runtime/memory/lib/tool-call-handler.mjs

@@ -1,5 +1,6 @@
 import {
   capLineOrientedToolOutput,
+  capMarker,
   RECALL_OUTPUT_MAX_BYTES,
 } from '../../agent/orchestrator/tools/builtin/tool-output-limit.mjs';
 
@@ -8,11 +9,12 @@ import {
 // footer, so a huge multi-query/grouped browse cannot flood the caller's
 // context (42KB single-call observed before the cap).
 function capRecallText(text) {
-  return capLineOrientedToolOutput(
-    text,
-    RECALL_OUTPUT_MAX_BYTES,
-    (kept, lines) =>
-      `... [recall output capped at ${Math.round(RECALL_OUTPUT_MAX_BYTES / 1024)}KB after ${kept.length} of ${lines.length} lines; narrow query[]/category/period or page with the returned cursor]`
+  return capLineOrientedToolOutput(text, RECALL_OUTPUT_MAX_BYTES, (kept, lines) =>
+    capMarker({
+      limit: RECALL_OUTPUT_MAX_BYTES,
+      shown: `${kept.length} of ${lines.length} lines shown`,
+      narrow: 'narrow query[]/category/period, lower limit, or page with the cursor/offset shown in the results',
+    })
   );
 }
 
@@ -56,6 +58,8 @@ export function createToolCallHandler({ handleSearch, handleMemoryAction }) {
           // Hint only — never a filter. Marks the caller's own session as
           // "(current)" in the multi-session grouped browse output.
           ...(a.currentSessionId ? { currentSessionId: a.currentSessionId } : {}),
+          // The calling session's scope: its own agent pool joins the core leg.
+          ...(a.memory_caller ? { memory_caller: a.memory_caller } : {}),
         };
         const result = await handleSearch(searchArgs, signal);
         const cappedText = capRecallText(result.text);

package/src/runtime/memory/tool-defs.mjs

@@ -59,6 +59,11 @@ export const TOOL_DEFS = [
           description:
             'Pool: omit for the current Project, "common" for common memory, or a Project slug; "*" is list only.',
         },
+        agent_id: {
+          type: 'string',
+          description:
+            'Agent memory instead of project_id: "self" is your own pool, read and injected only for you; an unattended run writes only there. The representative agent (lead) may list or delete another agent\'s by its id.',
+        },
       },
       additionalProperties: false,
       required: ['op'],