mixdog 1.2.6 → 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/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/tool-call-handler.mjs

@@ -58,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'],