@agentprojectcontext/apx 1.68.0 → 1.70.0

package/src/core/integrations/plugins/obsidian.js

@@ -0,0 +1,299 @@
+// Obsidian integration plugin — the "credential" is a local Vault (a directory
+// of Markdown notes), not a remote API token. Unlike Asana/GitHub there is no
+// provider to call: the plugin's config is a filesystem `vault_path` plus a
+// couple of toggles. This same module doubles as a pure vault client that the
+// agent tools (obsidian-*.js) call to read/search/write notes directly on disk
+// — no external process, works offline, fully under APX's control.
+//
+// Two extra hooks beyond the standard lifecycle contract:
+//   - mcpServer(record): the generic MCP-reconcile hook the daemon uses to
+//     auto-register (opt-in) a community Obsidian MCP pointing at the vault.
+//   - actions.sync_memory(record, ctx): mirrors APX memory into the vault.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+// ─── path helpers ───────────────────────────────────────────────────────────
+
+// Expand a leading `~` to the user's home dir (Obsidian users type paths by hand).
+export function expandHome(p) {
+  const s = String(p || "");
+  if (s === "~") return os.homedir();
+  if (s.startsWith("~/") || s.startsWith("~\\")) return path.join(os.homedir(), s.slice(2));
+  return s;
+}
+
+// Turn a user-supplied vault path into a resolved absolute path.
+export function resolveVaultPath(raw) {
+  const expanded = expandHome(String(raw || "").trim());
+  if (!expanded) throw new Error("Vault path is empty");
+  return path.resolve(expanded);
+}
+
+// A directory is a "real" Obsidian vault when it holds a `.obsidian` config
+// folder. We don't require it — a plain folder of markdown works too — but we
+// report it so the UI can confirm the pick.
+export function isObsidianVault(vaultPath) {
+  try {
+    return fs.statSync(path.join(vaultPath, ".obsidian")).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// Throw unless `vaultPath` points at an existing directory.
+export function assertVaultDir(vaultPath) {
+  let st;
+  try {
+    st = fs.statSync(vaultPath);
+  } catch {
+    throw new Error(`Vault path does not exist: ${vaultPath}`);
+  }
+  if (!st.isDirectory()) throw new Error(`Vault path is not a directory: ${vaultPath}`);
+  return true;
+}
+
+// Normalize a user-supplied note reference to an absolute `.md` path inside the
+// vault, refusing anything that escapes the vault root (path-traversal guard).
+function noteAbs(vaultPath, note) {
+  let rel = String(note || "").trim();
+  if (!rel) throw new Error("Note path is required");
+  rel = rel.replace(/\\/g, "/").replace(/^\/+/, "");
+  if (!/\.md$/i.test(rel)) rel += ".md";
+  const root = path.resolve(vaultPath);
+  const abs = path.resolve(root, rel);
+  if (abs !== root && !abs.startsWith(root + path.sep)) {
+    throw new Error(`Note path escapes the vault: ${note}`);
+  }
+  return abs;
+}
+
+// ─── vault client (used by the agent tools) ─────────────────────────────────
+
+// Recursively list markdown notes as vault-relative POSIX paths. Skips dotfiles
+// and dot-dirs (`.obsidian`, `.trash`, …).
+export function listNotes(vaultPath, { limit = 1000 } = {}) {
+  assertVaultDir(vaultPath);
+  const root = path.resolve(vaultPath);
+  const out = [];
+  const walk = (dir) => {
+    if (out.length >= limit) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (out.length >= limit) return;
+      if (e.name.startsWith(".")) continue;
+      const abs = path.join(dir, e.name);
+      if (e.isDirectory()) walk(abs);
+      else if (/\.md$/i.test(e.name)) out.push(path.relative(root, abs).split(path.sep).join("/"));
+    }
+  };
+  walk(root);
+  out.sort();
+  return out;
+}
+
+export function readNote(vaultPath, note) {
+  assertVaultDir(vaultPath);
+  const abs = noteAbs(vaultPath, note);
+  if (!fs.existsSync(abs)) throw new Error(`Note not found: ${note}`);
+  return fs.readFileSync(abs, "utf8");
+}
+
+// Create or update a note. `mode`: "overwrite" (default) | "append".
+export function writeNote(vaultPath, note, content, { mode = "overwrite" } = {}) {
+  assertVaultDir(vaultPath);
+  const abs = noteAbs(vaultPath, note);
+  const body = String(content ?? "");
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  if (mode === "append" && fs.existsSync(abs)) {
+    const prev = fs.readFileSync(abs, "utf8");
+    fs.writeFileSync(abs, prev + (prev.endsWith("\n") ? "" : "\n") + body);
+  } else {
+    fs.writeFileSync(abs, body);
+  }
+  const root = path.resolve(vaultPath);
+  return {
+    note: path.relative(root, abs).split(path.sep).join("/"),
+    bytes: Buffer.byteLength(body),
+    mode,
+  };
+}
+
+// Dependency-free substring search across note bodies + filenames. Returns a
+// short context snippet per hit.
+export function searchNotes(vaultPath, query, { limit = 50, caseSensitive = false } = {}) {
+  assertVaultDir(vaultPath);
+  const q = String(query || "").trim();
+  if (!q) throw new Error("Search query is required");
+  const needle = caseSensitive ? q : q.toLowerCase();
+  const notes = listNotes(vaultPath, { limit: 10000 });
+  const results = [];
+  for (const rel of notes) {
+    if (results.length >= limit) break;
+    let body;
+    try {
+      body = fs.readFileSync(path.join(vaultPath, rel), "utf8");
+    } catch {
+      continue;
+    }
+    const hay = caseSensitive ? body : body.toLowerCase();
+    const nameHit = (caseSensitive ? rel : rel.toLowerCase()).includes(needle);
+    const idx = hay.indexOf(needle);
+    if (idx === -1 && !nameHit) continue;
+    let snippet = "";
+    if (idx !== -1) {
+      const start = Math.max(0, idx - 40);
+      const end = Math.min(body.length, idx + needle.length + 40);
+      snippet =
+        (start > 0 ? "…" : "") +
+        body.slice(start, end).replace(/\s+/g, " ").trim() +
+        (end < body.length ? "…" : "");
+    }
+    results.push({ note: rel, snippet, title_match: nameHit });
+  }
+  return results;
+}
+
+// ─── plugin descriptor + lifecycle ──────────────────────────────────────────
+
+function asBool(v, fallback) {
+  if (v === undefined || v === null) return fallback;
+  return v === true || v === "true" || v === "on" || v === 1 || v === "1";
+}
+
+export const obsidianPlugin = {
+  slug: "obsidian",
+  name: "Obsidian",
+  type: "knowledge",
+  description:
+    "Conectá un Vault de Obsidian para que los agentes lean, busquen y escriban notas",
+  auth: "path",
+  tools: [
+    { slug: "obsidian_search_notes", desc: "Buscar notas en el Vault" },
+    { slug: "obsidian_read_note", desc: "Leer una nota" },
+    { slug: "obsidian_write_note", desc: "Crear o actualizar una nota" },
+    { slug: "obsidian_list_notes", desc: "Listar notas del Vault" },
+  ],
+  // Structure only — display text lives in web i18n (integrations.obsidian.*).
+  ui: {
+    accent: "purple",
+    configFields: [
+      { key: "vault_path", type: "path", placeholder: "/Users/tu-usuario/Obsidian/MiVault" },
+      { key: "auto_mcp", type: "toggle", default: false },
+      { key: "memory_sync", type: "toggle", default: false },
+    ],
+    connectedFields: ["vault_path", "vault_name", "note_count"],
+    // Buttons shown in the connected view (label from i18n).
+    actions: [{ action: "sync_memory" }],
+  },
+
+  configure(record, body = {}) {
+    const rawPath = String(body.vault_path ?? record?.config?.vault_path ?? "").trim();
+    if (!rawPath) throw new Error("Provide the path to your Obsidian vault");
+    const config = {
+      vault_path: rawPath,
+      auto_mcp: asBool(body.auto_mcp, record?.config?.auto_mcp ?? false),
+      memory_sync: asBool(body.memory_sync, record?.config?.memory_sync ?? false),
+    };
+    return {
+      patch: {
+        name: this.name,
+        type: this.type,
+        description: this.description,
+        status: "pending_validation",
+        config,
+      },
+    };
+  },
+
+  async validate(record) {
+    const config = record?.config || {};
+    let vaultPath;
+    try {
+      vaultPath = resolveVaultPath(config.vault_path);
+      assertVaultDir(vaultPath);
+    } catch (e) {
+      return {
+        patch: { status: "error", is_enabled: false, config: { last_error: String(e.message || e) } },
+        result: { ok: false, error: String(e.message || e) },
+      };
+    }
+    const isVault = isObsidianVault(vaultPath);
+    const noteCount = listNotes(vaultPath, { limit: 10000 }).length;
+    const vaultName = path.basename(vaultPath);
+    // Persist the resolved absolute path so downstream consumers (tools, MCP,
+    // sync) never re-expand `~`.
+    return {
+      patch: {
+        status: "active",
+        is_enabled: true,
+        config: {
+          vault_path: vaultPath,
+          vault_name: vaultName,
+          is_vault: isVault,
+          note_count: noteCount,
+          last_error: null,
+        },
+      },
+      result: { ok: true, vault_path: vaultPath, vault_name: vaultName, is_vault: isVault, note_count: noteCount },
+    };
+  },
+
+  status(record) {
+    const c = record?.config || {};
+    return {
+      slug: this.slug,
+      status: record?.status || "disconnected",
+      is_enabled: !!record?.is_enabled,
+      vault_path: c.vault_path || null,
+      vault_name: c.vault_name || null,
+      note_count: c.note_count ?? null,
+      is_vault: c.is_vault ?? null,
+      auto_mcp: !!c.auto_mcp,
+      memory_sync: !!c.memory_sync,
+    };
+  },
+
+  deactivate() {
+    return { patch: { status: "inactive", is_enabled: false } };
+  },
+
+  // Generic MCP-reconcile hook (see host/daemon/api/integrations.js). Returns
+  // the desired `{ name, def }` for a community Obsidian MCP when the vault is
+  // active AND the user opted into `auto_mcp`; otherwise `def: null` so the
+  // reconcile removes any stale server. Command/args overridable via config.
+  mcpServer(record) {
+    const c = record?.config || {};
+    const active = record?.status === "active" && !!record?.is_enabled && !!c.auto_mcp && !!c.vault_path;
+    if (!active) return { name: "obsidian", def: null };
+    const command = c.mcp_command || "npx";
+    const args =
+      Array.isArray(c.mcp_args) && c.mcp_args.length ? c.mcp_args : ["-y", "obsidian-mcp", c.vault_path];
+    return { name: "obsidian", def: { command, args, enabled: true } };
+  },
+
+  actions: {
+    // Quick connectivity probe (web refresh / smoke test): list a few notes.
+    async notes(record) {
+      const vaultPath = resolveVaultPath(record?.config?.vault_path);
+      const notes = listNotes(vaultPath, { limit: 25 });
+      return { notes, count: listNotes(vaultPath, { limit: 10000 }).length, sample: notes };
+    },
+    // Mirror APX memory into the vault. Needs project context (all projects +
+    // the current one), passed as the 2nd arg by the daemon action dispatch.
+    async sync_memory(record, ctx = {}) {
+      const vaultPath = resolveVaultPath(record?.config?.vault_path);
+      const folder = record?.config?.memory_folder || "APX";
+      const { syncMemoryToVault, collectMemorySources } = await import("../obsidian-memory.js");
+      const sources = collectMemorySources(ctx);
+      return syncMemoryToVault({ vaultPath, folder, sources });
+    },
+  },
+};
+
+export default obsidianPlugin;

package/src/core/mcp/runner.js

@@ -18,6 +18,20 @@ function nowIso() {
   return new Date().toISOString();
 }
 
+// Serializes cold-starts that share an npm/npx cache dir. Two MCP processes
+// with the same command+args but different env — e.g. the same
+// `npx @ahdev/dokploy-mcp@1.6.0` registered in two projects pointing at
+// different DOKPLOY_URLs — resolve to ONE shared npm cache dir
+// (~/.npm/_npx/<hash>). npm does not guard that dir against concurrent writes,
+// so overlapping cold-starts corrupt it (ENOTEMPTY / partial node_modules) and
+// the server dies on start, which respawns and corrupts it again. Chaining
+// start-ups by spec keeps the cache-touching phase from ever overlapping.
+const startGates = new Map(); // spec key -> promise resolved when current starter finishes
+
+function startKey(command, args) {
+  return JSON.stringify([command, args || []]);
+}
+
 class McpProcess {
   constructor({ name, command, args = [], env = {} }) {
     this.name = name;
@@ -127,30 +141,50 @@ class McpProcess {
   async _ensureInitialized() {
     if (this._initialized) return;
     if (!this._initPromise) {
-      this._initPromise = (async () => {
-        await this._send(
-          "initialize",
-          {
-            protocolVersion: "2024-11-05",
-            capabilities: {},
-            clientInfo: { name: "apx-daemon", version: "0.1.0" },
-          },
-          10_000
-        );
-        try {
-          this.proc.stdin.write(
-            JSON.stringify({
-              jsonrpc: "2.0",
-              method: "notifications/initialized",
-            }) + "\n"
-          );
-        } catch {}
-        this._initialized = true;
-      })();
+      this._initPromise = this._gatedInit();
     }
     return this._initPromise;
   }
 
+  // Acquire the per-spec start gate around the whole (spawn + npm cache work +
+  // JSON-RPC initialize) sequence so processes sharing an npx cache never
+  // cold-start concurrently. See startGates.
+  async _gatedInit() {
+    const key = startKey(this.command, this.args);
+    const prev = startGates.get(key) || Promise.resolve();
+    let release;
+    const gate = new Promise((r) => (release = r));
+    // The next starter of this spec waits on us — whether we succeed or fail.
+    startGates.set(key, prev.then(() => gate, () => gate));
+    try {
+      await prev.catch(() => {});
+      await this._doInitialize();
+    } finally {
+      release();
+    }
+  }
+
+  async _doInitialize() {
+    await this._send(
+      "initialize",
+      {
+        protocolVersion: "2024-11-05",
+        capabilities: {},
+        clientInfo: { name: "apx-daemon", version: "0.1.0" },
+      },
+      10_000
+    );
+    try {
+      this.proc.stdin.write(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          method: "notifications/initialized",
+        }) + "\n"
+      );
+    } catch {}
+    this._initialized = true;
+  }
+
   async listTools() {
     await this._ensureInitialized();
     return collectToolPages((cursor) =>

package/src/core/memory/broker.js

@@ -87,6 +87,9 @@ export async function buildMemoryBlock(message, opts = {}) {
   const budgetMs = opts.budgetMs || DEFAULT_BUDGET_MS;
   const topK = opts.topK || DEFAULT_TOP_K;
   const store = opts.store || null;
+  // Scope isolation: the super-agent recalls only global rows ("global"), a
+  // project/agent turn recalls only its own ("project:<id>" / "agent:…").
+  const scope = opts.scope || "global";
   const query = clean(message);
 
   // memory.md entries are read synchronously and always make the deadline.
@@ -99,7 +102,7 @@ export async function buildMemoryBlock(message, opts = {}) {
       const { vector, embedder, dim } = await embedOne(query, opts.embed || {});
       const family = embedder.startsWith("ollama") ? "ollama" : "tf";
       const floor = MIN_SCORE[family] ?? 0;
-      const results = store.search(vector, { embedder, k: topK + 3 });
+      const results = store.search(vector, { embedder, k: topK + 3, scope });
       return results.filter((r) => r.score >= floor && (r.dim ?? dim) === dim);
     })();
     hits = await withTimeout(rag, budgetMs, []);

package/src/core/memory/index.js

@@ -30,14 +30,17 @@ let _store = null;
 let _ready = null;
 let _timer = null;
 let _cfg = {};
+let _projects = null;
 let _indexing = false;
 
 // Run one index pass unless one is already in flight (a full re-embed can take
 // longer than the timer interval — overlapping passes would race on clear()).
+// `_projects` (the daemon registry) lets the indexer reach each project's
+// .apc/memory.md; agent memory is walked straight off the filesystem.
 function indexOnce(note) {
   if (_indexing || !_store) return Promise.resolve();
   _indexing = true;
-  return indexNewMessages(_store, { embed: embedOptsFromConfig(_cfg), log: note })
+  return indexNewMessages(_store, { embed: embedOptsFromConfig(_cfg), projects: _projects, log: note })
     .catch(() => {})
     .finally(() => {
       _indexing = false;
@@ -58,7 +61,7 @@ function embedOptsFromConfig(config) {
 
 // Boot the subsystem (Pieza 1 file creation + Pieza 2 store/index). Safe to
 // call once from the daemon. Never throws.
-export async function initMemory({ config, log } = {}) {
+export async function initMemory({ config, log, projects } = {}) {
   const note = typeof log === "function" ? log : () => {};
   try {
     const created = ensureSelfMemoryFile();
@@ -71,6 +74,7 @@ export async function initMemory({ config, log } = {}) {
     return null;
   }
   _cfg = config || {};
+  _projects = projects || null;
   _ready = (async () => {
     try {
       _store = await openMemoryStore({ dbPath: DB_PATH, jsonPath: JSON_PATH, log: note });
@@ -151,6 +155,29 @@ export async function memoryBlockFor(message, { config, channel, budgetMs } = {}
       store,
       config,
       channel,
+      scope: "global", // super-agent recall — never pulls project/agent rows
+      budgetMs: budgetMs || config?.memory?.broker_budget_ms || 800,
+      topK: config?.memory?.rag_top_k || 5,
+      embed: embedOptsFromConfig(config),
+    });
+  } catch {
+    return "";
+  }
+}
+
+// Scoped recall for a specific project or agent turn. `scope` is the row channel
+// key: "project:<id>" or "agent:<projdir>:<slug>". `memoryPath` (optional) is
+// that scope's own notebook, read as the always-included flat slice. Returns ""
+// on any failure so the prompt builder can drop the block.
+export async function scopedMemoryBlockFor(message, { scope, memoryPath, config, budgetMs } = {}) {
+  try {
+    if (!scope || !memoryEnabled(config)) return "";
+    const store = await getMemoryStore();
+    return await buildMemoryBlock(message, {
+      store,
+      config,
+      scope,
+      memoryPath,
       budgetMs: budgetMs || config?.memory?.broker_budget_ms || 800,
       topK: config?.memory?.rag_top_k || 5,
       embed: embedOptsFromConfig(config),

package/src/core/memory/indexer.js

@@ -21,12 +21,14 @@ import fs from "node:fs";
 import path from "node:path";
 import { GLOBAL_MESSAGES_DIR, APX_HOME } from "../config/index.js";
 import { SELF_MEMORY_PATH, parseSelfMemoryEntries } from "../agent/self-memory.js";
+import { apcMemoryFile } from "../apc/paths.js";
 import { embedBatch, embedOne } from "./embeddings.js";
 
 export const CURSOR_PATH = path.join(APX_HOME, "memory-cursor.json");
 
 const BODY_CAP = 1200; // chars kept per user/agent chunk
 const TOOL_CAP = 400; // chars kept per tool-result chunk
+const SCOPED_CAP = 800; // chars kept per project/agent memory block
 
 function fnv1aHex(str) {
   let h = 0x811c9dc5;
@@ -37,6 +39,14 @@ function fnv1aHex(str) {
   return (h >>> 0).toString(16);
 }
 
+function readIfExists(p) {
+  try {
+    return fs.readFileSync(p, "utf8");
+  } catch {
+    return null;
+  }
+}
+
 function readCursor(cursorPath) {
   try {
     return JSON.parse(fs.readFileSync(cursorPath, "utf8"));
@@ -177,6 +187,78 @@ function collectMemoryChunks(store, memoryPath) {
   return fresh;
 }
 
+// Split free-form markdown (project/agent memory — NOT the dated-notebook
+// format) into meaningful blocks: blank-line separated, whitespace-collapsed,
+// capped, and filtered so empty template sections ("## Identity\n- ") never
+// pollute the store. Each block becomes one scoped chunk.
+function chunkFreeMarkdown(text) {
+  return String(text || "")
+    .split(/\n\s*\n/)
+    .map((block) => {
+      // Drop pure-heading blocks (a "# Title" with no body under it) — they add
+      // noise to retrieval. Keep blocks that have at least one non-heading line.
+      const lines = block.split("\n").map((l) => l.trim()).filter(Boolean);
+      if (!lines.some((l) => !l.startsWith("#"))) return "";
+      return block.replace(/\s+/g, " ").trim();
+    })
+    .filter((b) => meaningfulBody(b))
+    .map((b) => b.slice(0, SCOPED_CAP));
+}
+
+// Per-agent memory lives at ~/.apx/projects/<projdir>/agents/<slug>/memory.md.
+// Walkable straight off the filesystem — no registry needed. Scoped by channel
+// "agent:<projdir>:<slug>" so retrieval never leaks between agents.
+function collectAgentMemoryChunks(store, apxHome) {
+  const fresh = [];
+  const projectsRoot = path.join(apxHome, "projects");
+  let projDirs;
+  try {
+    projDirs = fs.readdirSync(projectsRoot);
+  } catch {
+    return fresh;
+  }
+  for (const projDir of projDirs) {
+    const agentsDir = path.join(projectsRoot, projDir, "agents");
+    let slugs;
+    try {
+      slugs = fs.readdirSync(agentsDir);
+    } catch {
+      continue;
+    }
+    for (const slug of slugs) {
+      const body = readIfExists(path.join(agentsDir, slug, "memory.md"));
+      if (body == null) continue;
+      const channel = `agent:${projDir}:${slug}`;
+      for (const block of chunkFreeMarkdown(body)) {
+        const id = `agentmem:${projDir}:${slug}:${fnv1aHex(block)}`;
+        if (store.hasId(id)) continue;
+        fresh.push({ id, source: "agent-memory", channel, ts: "", tag: "agent-memory", text: block });
+      }
+    }
+  }
+  return fresh;
+}
+
+// Project memory (.apc/memory.md) for every registered project. Needs the
+// registry to map id → repo path. Scoped by channel "project:<id>".
+function collectProjectMemoryChunks(store, projects) {
+  const fresh = [];
+  const list = typeof projects?.list === "function" ? projects.list() : Array.isArray(projects) ? projects : [];
+  for (const entry of list) {
+    const root = entry?.path;
+    if (!root) continue; // the default project (id 0) has no repo root
+    const body = readIfExists(apcMemoryFile(root));
+    if (body == null) continue;
+    const channel = `project:${entry.id}`;
+    for (const block of chunkFreeMarkdown(body)) {
+      const id = `projmem:${entry.id}:${fnv1aHex(block)}`;
+      if (store.hasId(id)) continue;
+      fresh.push({ id, source: "project-memory", channel, ts: "", tag: "project-memory", text: block });
+    }
+  }
+  return fresh;
+}
+
 // Run one incremental indexing pass. Returns { indexed, backend }.
 // `opts.embed` overrides embedding options (baseUrl/model/timeoutMs) for tests.
 export async function indexNewMessages(store, opts = {}) {
@@ -220,7 +302,12 @@ export async function indexNewMessages(store, opts = {}) {
 
   const { fresh: msgChunks, maxTsByChannel } = collectMessageChunks(store, cursor, messagesDir);
   const memChunks = collectMemoryChunks(store, memoryPath);
-  let chunks = [...msgChunks, ...memChunks];
+  // Scoped memory (Pieza 5): per-agent + per-project notebooks, tagged with a
+  // scoped channel so retrieval can be isolated. Idempotent by content hash, so
+  // re-derived every pass like memory.md (cheap, few blocks).
+  const agentChunks = collectAgentMemoryChunks(store, opts.apxHome || APX_HOME);
+  const projChunks = collectProjectMemoryChunks(store, opts.projects);
+  let chunks = [...msgChunks, ...memChunks, ...agentChunks, ...projChunks];
   if (chunks.length === 0) return { indexed: 0, backend: store.backend };
 
   // Cap per-run work so a huge first index doesn't block; the rest is picked

package/src/core/memory/store.js

@@ -8,18 +8,30 @@
 //
 // Both expose the same interface:
 //   upsert(rows)              rows: {id, source, channel, ts, tag, text, embedder, dim, vector}
-//   search(vector, {embedder, k, channel}) -> [{...row, score}]
+//   search(vector, {embedder, k, channel, scope}) -> [{...row, score}]
 //   hasId(id) / count()
 //   close()
 //
 // Cosine is only meaningful within one embedder space, so search() filters to
 // rows whose `embedder` matches the query's embedder. Everything here is
 // best-effort: open() never throws — on any failure it returns a JsonStore.
+//
+// Scope isolation (memory belongs to whoever wrote it):
+//   - project/agent memory rows carry a scoped `channel` ("project:<id>" or
+//     "agent:<projdir>:<slug>"). Global conversational rows use the channel name
+//     (telegram/web/…) or "memory".
+//   - search({scope}) keeps retrieval from leaking across scopes:
+//       scope === "global"  → EXCLUDE project:/agent: rows (super-agent recall)
+//       scope === "<value>" → ONLY rows whose channel equals that value
+//       scope omitted        → no scope filter (back-compat)
 
 import fs from "node:fs";
 import path from "node:path";
 import { cosineSim } from "./embeddings.js";
 
+export const SCOPE_PREFIXES = ["project:", "agent:"];
+const isScopedChannel = (c) => SCOPE_PREFIXES.some((p) => String(c || "").startsWith(p));
+
 function vecToBlob(vec) {
   const f = new Float32Array(vec);
   return Buffer.from(f.buffer, f.byteOffset, f.byteLength);
@@ -87,11 +99,13 @@ export class JsonStore {
     this._flush();
   }
 
-  search(vector, { embedder, k = 5, channel } = {}) {
+  search(vector, { embedder, k = 5, channel, scope } = {}) {
     const scored = [];
     for (const row of this.rows.values()) {
       if (embedder && row.embedder !== embedder) continue;
       if (channel && row.channel !== channel) continue;
+      if (scope === "global" && isScopedChannel(row.channel)) continue;
+      if (scope && scope !== "global" && row.channel !== scope) continue;
       if (!Array.isArray(row.vector) || row.vector.length !== vector.length) continue;
       scored.push({ ...row, score: cosineSim(vector, row.vector) });
     }
@@ -171,7 +185,7 @@ class SqliteVecStore {
     this.db.prepare("DELETE FROM chunks").run();
   }
 
-  search(vector, { embedder, k = 5, channel } = {}) {
+  search(vector, { embedder, k = 5, channel, scope } = {}) {
     const blob = vecToBlob(vector);
     const where = ["embedder = ?", "dim = ?"];
     const params = [embedder, vector.length];
@@ -179,6 +193,12 @@ class SqliteVecStore {
       where.push("channel = ?");
       params.push(channel);
     }
+    if (scope === "global") {
+      where.push("(channel NOT LIKE 'project:%' AND channel NOT LIKE 'agent:%')");
+    } else if (scope) {
+      where.push("channel = ?");
+      params.push(scope);
+    }
     const rows = this.db
       .prepare(
         `SELECT id, source, channel, ts, tag, text, embedder, dim,