@agentprojectcontext/apx 1.68.0 → 1.70.0

package/src/host/daemon/api/agents.js

@@ -25,6 +25,40 @@ import {
 import { agentToResponse } from "./shared.js";
 import { normalizeVaultPatch } from "#core/apc/agents-vault.js";
 import { PERMISSION_MODES } from "#core/constants/permissions.js";
+import { listConversations } from "#core/stores/conversations.js";
+import { listTasks } from "#core/stores/tasks.js";
+import { listRoutines } from "#core/stores/routines.js";
+import { readProjectMessages } from "#core/stores/messages.js";
+
+// Attach a per-agent activity summary ({ threads, records, tasks, heartbeats })
+// to a list of agent responses. Reads each store once and tallies by agent, so
+// the whole list costs O(stores) rather than O(agents × stores). Gated behind
+// `?stats=1` on the list endpoint since it touches the message ledger.
+function attachAgentStats(p, agents) {
+  const store = p.storagePath || p.path;
+  const tally = (rows, key) => {
+    const m = Object.create(null);
+    for (const r of rows) {
+      const a = typeof key === "function" ? key(r) : r?.[key];
+      if (a) m[a] = (m[a] || 0) + 1;
+    }
+    return m;
+  };
+  let tasksByAgent = {}, hbByAgent = {}, recByAgent = {};
+  try { tasksByAgent = tally(listTasks(store, { state: "all" }), "agent"); } catch { /* no task store */ }
+  try { hbByAgent = tally(listRoutines(store), (r) => r?.spec?.agent); } catch { /* no routines */ }
+  try { recByAgent = tally(readProjectMessages(store, { limit: 1000 }), "agent_slug"); } catch { /* no ledger */ }
+  for (const a of agents) {
+    let threads = 0;
+    try { threads = listConversations(store, a.slug).length; } catch { /* none */ }
+    a.stats = {
+      threads,
+      records: recByAgent[a.slug] || 0,
+      tasks: tasksByAgent[a.slug] || 0,
+      heartbeats: hbByAgent[a.slug] || 0,
+    };
+  }
+}
 
 // Autonomy mirrors the super-agent permission modes (total/automatico/permiso).
 // An invalid value is dropped rather than persisted so a typo can't silently
@@ -123,7 +157,9 @@ export function register(app, { projects, project }) {
   app.get("/projects/:pid/agents", (req, res) => {
     const p = project(req, res);
     if (!p) return;
-    res.json(readAgents(p.path).map(agentToResponse));
+    const agents = readAgents(p.path).map(agentToResponse);
+    if (req.query.stats === "1") attachAgentStats(p, agents);
+    res.json(agents);
   });
 
   app.get("/projects/:pid/agents/:slug", (req, res) => {

package/src/host/daemon/api/integrations.js

@@ -23,6 +23,7 @@ import {
   defaultIntegrationsStorage,
   listCatalog,
   getPluginService,
+  reconcilePluginMcp,
 } from "#core/integrations/index.js";
 
 function normalizeScope(raw) {
@@ -43,7 +44,23 @@ function storagePathForScope(scope, p, projects) {
   return p.storagePath || null;
 }
 
-export function register(app, { projects, project }) {
+export function register(app, { projects, project, registries }) {
+  // Keep a plugin's optional auto-registered MCP server (svc.mcpServer hook) in
+  // lockstep with its stored state. Best-effort: a failure here must not break
+  // the configure/validate/deactivate/delete response. `storagePath` is the one
+  // the handler wrote to (so global-scope records resolve from the default
+  // store), `scope` is the integration scope ("project" | "global").
+  function reconcileMcp(svc, storagePath, scope, p) {
+    if (typeof svc?.mcpServer !== "function") return;
+    try {
+      const record = storagePath ? new IntegrationStore(storagePath).get(svc.slug) : null;
+      const desired = svc.mcpServer(record);
+      reconcilePluginMcp({ desired, integrationScope: scope, project: p, projects, registries });
+    } catch {
+      /* best-effort MCP reconcile — ignore */
+    }
+  }
+
   // List stored integrations in the chosen scope (secrets redacted).
   app.get("/projects/:pid/integrations", (req, res) => {
     const p = project(req, res);
@@ -107,6 +124,7 @@ export function register(app, { projects, project }) {
     try {
       const { patch } = svc.configure(store.get(req.params.slug), req.body || {});
       const record = store.upsert(req.params.slug, patch);
+      reconcileMcp(svc, storagePath, scope, p);
       res.status(201).json(redactRecord(record));
     } catch (e) {
       res.status(400).json({ error: e.message });
@@ -129,6 +147,7 @@ export function register(app, { projects, project }) {
     try {
       const { patch, result } = await svc.validate(record);
       store.upsert(req.params.slug, patch);
+      reconcileMcp(svc, storagePath, scope, p);
       if (result && result.ok === false) return res.status(400).json(result);
       res.json(result);
     } catch (e) {
@@ -150,6 +169,7 @@ export function register(app, { projects, project }) {
     if (!store.get(req.params.slug)) return res.status(404).json({ error: "integration not configured" });
     const { patch } = svc.deactivate(store.get(req.params.slug));
     const record = store.upsert(req.params.slug, patch);
+    reconcileMcp(svc, storagePath, scope, p);
     res.json(svc.status(record));
   });
 
@@ -170,7 +190,10 @@ export function register(app, { projects, project }) {
     const record = new IntegrationStore(storagePath).get(req.params.slug);
     if (!record) return res.status(404).json({ error: "integration not configured" });
     try {
-      res.json(await fn.call(svc.actions, record));
+      // Actions get a 2nd ctx arg (existing plugins ignore it). Obsidian's
+      // sync_memory uses it to reach every project's memory.md.
+      const actionCtx = { storagePath, scope, project: p, projects, registries };
+      res.json(await fn.call(svc.actions, record, actionCtx));
     } catch (e) {
       res.status(400).json({ error: e.message });
     }
@@ -186,6 +209,8 @@ export function register(app, { projects, project }) {
     if (!storagePath) return res.status(400).json({ error: "project has no storage path" });
     const removed = new IntegrationStore(storagePath).remove(req.params.slug);
     if (!removed) return res.status(404).end();
+    // Record is gone → svc.mcpServer(null) yields def:null → drop any auto MCP.
+    reconcileMcp(getPluginService(req.params.slug), storagePath, scope, p);
     res.status(204).end();
   });
 }

package/src/host/daemon/api/mcps.js

@@ -96,7 +96,7 @@ export function register(app, { projects, registries, project }) {
     } catch (e) {
       return res.status(400).json({ error: e.message });
     }
-    registries.shutdown();
+    registries.evictName(name);
     projects.rebuild(p.id);
     const entry = registries.for(p).getByName(name);
     res.status(201).json(entry);
@@ -150,7 +150,7 @@ export function register(app, { projects, registries, project }) {
     } catch (e) {
       return res.status(400).json({ error: e.message });
     }
-    registries.shutdown();
+    registries.evictName(req.params.name);
     projects.rebuild(p.id);
     res.status(204).end();
   });

package/src/host/daemon/index.js

@@ -147,6 +147,12 @@ class RegistryCache {
   for(projectEntry) {
     return this.ensure(projectEntry);
   }
+  // Evict one MCP by name from every cached registry so its live process
+  // respawns with fresh config on next use. Used after add/remove instead of
+  // shutting down (and cold-restarting) every MCP across every project.
+  evictName(name) {
+    for (const r of this.byProjectId.values()) r.evict(name);
+  }
   shutdown() {
     for (const r of this.byProjectId.values()) r.shutdown();
     this.byProjectId.clear();
@@ -238,7 +244,7 @@ async function main() {
     // Cross-channel memory: ensure ~/.apx/memory.md exists, open the vector
     // store, and start the incremental RAG indexer. Best-effort — never blocks
     // boot and never throws into the daemon.
-    initMemory({ config: cfg, log }).catch((e) => log(`memory: init failed: ${e?.message || e}`));
+    initMemory({ config: cfg, log, projects }).catch((e) => log(`memory: init failed: ${e?.message || e}`));
     // Skill Inspector: if enabled, refresh its vector index in the background so
     // any SKILL.md added/edited while the daemon was down is picked up without a
     // manual `apx skills index`. Best-effort; never blocks boot.

package/src/interfaces/cli/commands/obsidian.js

@@ -0,0 +1,79 @@
+// `apx obsidian` — configure and drive the Obsidian integration from the CLI.
+// Thin client over the generic integrations daemon API (the same routes the web
+// panel uses), so scoping stays consistent: `--global` (or `--scope global`)
+// targets the default space; otherwise the current/`--project` project. A vault
+// is a local directory of Markdown notes; connecting it lets APX agents read,
+// search and write notes, optionally auto-registers an Obsidian MCP, and lets
+// you mirror APX memory into the vault.
+import { http } from "../http.js";
+import { resolveProjectId } from "./project.js";
+
+const SLUG = "obsidian";
+
+function resolveScope(flags = {}) {
+  if (flags.global) return "global";
+  const s = flags.scope ? String(flags.scope).toLowerCase() : "project";
+  if (s === "default") return "global";
+  if (s !== "project" && s !== "global") {
+    throw new Error(`unknown --scope "${flags.scope}" (use project|global)`);
+  }
+  return s;
+}
+
+function scopeQuery(scope) {
+  return `?scope=${encodeURIComponent(scope)}`;
+}
+
+export async function cmdObsidianSet(args) {
+  const vaultPath = args._[0];
+  if (!vaultPath) throw new Error("apx obsidian set: missing <vault-path>");
+  const scope = resolveScope(args.flags);
+  const pid = await resolveProjectId(args?.flags?.project);
+  const body = { vault_path: vaultPath };
+  if (args.flags.mcp) body.auto_mcp = true;
+  if (args.flags.memory || args.flags["memory-sync"]) body.memory_sync = true;
+
+  const q = scopeQuery(scope);
+  await http.post(`/projects/${pid}/integrations/${SLUG}/configure${q}`, body);
+  try {
+    const r = await http.post(`/projects/${pid}/integrations/${SLUG}/validate${q}`, {});
+    const badge = r.is_vault ? "Obsidian vault" : "folder (no .obsidian)";
+    console.log(`✓ Obsidian connected (${scope}) — ${r.vault_name} · ${r.note_count} notes · ${badge}`);
+    console.log(`  ${r.vault_path}`);
+    if (body.auto_mcp) console.log("  auto-MCP: on — an 'obsidian' MCP server was registered for this scope");
+    if (body.memory_sync) console.log("  memory-sync: on — run `apx obsidian sync` to mirror APX memory into the vault");
+  } catch (e) {
+    throw new Error(`Vault path saved but validation failed: ${e.message}`);
+  }
+}
+
+export async function cmdObsidianStatus(args) {
+  const scope = resolveScope(args.flags);
+  const pid = await resolveProjectId(args?.flags?.project);
+  const s = await http.get(`/projects/${pid}/integrations/${SLUG}${scopeQuery(scope)}`);
+  if (!s || s.status === "disconnected") {
+    console.log(`(Obsidian not configured in scope "${scope}")`);
+    return;
+  }
+  console.log(`Obsidian — ${s.status}${s.is_enabled ? " (enabled)" : ""}`);
+  if (s.vault_path) console.log(`  vault: ${s.vault_path}`);
+  if (s.vault_name) console.log(`  name:  ${s.vault_name}`);
+  if (s.note_count != null) console.log(`  notes: ${s.note_count}`);
+  console.log(`  auto-MCP:    ${s.auto_mcp ? "on" : "off"}`);
+  console.log(`  memory-sync: ${s.memory_sync ? "on" : "off"}`);
+}
+
+export async function cmdObsidianSync(args) {
+  const scope = resolveScope(args.flags);
+  const pid = await resolveProjectId(args?.flags?.project);
+  const r = await http.post(`/projects/${pid}/integrations/${SLUG}/action/sync_memory${scopeQuery(scope)}`, {});
+  console.log(`✓ Synced ${r.count} memory file(s) → vault folder "${r.folder}" (${r.changed} changed)`);
+  for (const n of r.notes || []) console.log(`  ${n.changed ? "↑" : "="} ${n.note}`);
+}
+
+export async function cmdObsidianRemove(args) {
+  const scope = resolveScope(args.flags);
+  const pid = await resolveProjectId(args?.flags?.project);
+  await http.delete(`/projects/${pid}/integrations/${SLUG}${scopeQuery(scope)}`);
+  console.log(`Removed Obsidian integration (scope: ${scope})`);
+}

package/src/interfaces/cli/index.js

@@ -101,6 +101,12 @@ import {
   cmdPermission,
 } from "./commands/config.js";
 import { cmdPluginsList, cmdPluginStatus } from "./commands/plugins.js";
+import {
+  cmdObsidianSet,
+  cmdObsidianStatus,
+  cmdObsidianSync,
+  cmdObsidianRemove,
+} from "./commands/obsidian.js";
 import { cmdDesktopStart, cmdDesktopStop, cmdDesktopRestart, cmdDesktopStatus, cmdDesktopInstall, cmdDesktopUninstall, desktopRunning } from "./commands/desktop.js";
 import { cmdVoiceSay, cmdVoiceListen, cmdVoiceProviders } from "./commands/voice.js";
 import { cmdSkillsAdd, cmdSkillsList, cmdSkillsStatus, cmdSkillsSync, cmdSkillsIndex, cmdSkillsInspect, cmdSkillsInspector } from "./commands/skills.js";
@@ -715,6 +721,30 @@ const HELP_TOPICS = new Map(Object.entries({
       "apx sessions list --engine codex --dir /Volumes/work/iacrmar",
     ],
   }),
+  obsidian: topic({
+    title: "apx obsidian",
+    summary: "Connect an Obsidian vault so agents can read, search and write notes; mirror APX memory into it.",
+    usage: ["apx obsidian <subcommand> [--global | --project <name|id|path>]"],
+    commands: [
+      ["set <vault-path>", "Connect a vault (validates the path). Add --mcp / --memory to enable extras."],
+      ["status", "Show the configured vault, note count and toggles for the scope."],
+      ["sync", "Mirror APX memory (global + projects) into the vault, without duplicates."],
+      ["remove | rm", "Disconnect the vault (also removes any auto-registered MCP)."],
+    ],
+    options: [
+      ["--global", "Target the default space (shared by all projects) instead of the current project."],
+      ["--scope <project|global>", "Explicit scope (alias of --global)."],
+      ["--mcp", "On `set`: auto-register an 'obsidian' MCP server pointing at the vault."],
+      ["--memory", "On `set`: enable memory sync (then run `apx obsidian sync`)."],
+      ["--project <name|id|path>", "Pin command to a specific project."],
+    ],
+    examples: [
+      "apx obsidian set ~/Obsidian/Work --project appsi",
+      "apx obsidian set ~/Obsidian/Personal --global --mcp --memory",
+      "apx obsidian sync --global",
+      "apx obsidian status",
+    ],
+  }),
   mcp: topic({
     title: "apx mcp",
     summary: "Manage and call MCP servers merged from APC and supported IDE configs.",
@@ -2135,6 +2165,12 @@ function buildHelp(version) {
     hCmd("apx mcp logs <name>",        36, "spawn/init log + stderr tail"),
     hCmd("apx mcp check",              36, "audit multi-source merge"),
 
+    hSec("Obsidian"),
+    hCmd("apx obsidian set <path>",    36, "connect a vault  --global  --project P  --mcp  --memory"),
+    hCmd("apx obsidian status",        36, "show configured vault + toggles"),
+    hCmd("apx obsidian sync",          36, "mirror APX memory into the vault (no duplicates)"),
+    hCmd("apx obsidian remove",        36, "disconnect the vault"),
+
     hSec("Daemon Service"),
     hCmd("apx daemon start",           36, ""),
     hCmd("apx daemon reload",          36, "reload ~/.apx/config.json without restart"),
@@ -2313,7 +2349,7 @@ function findHelpTopic(argv) {
 // Flags that never take a value. Without this the parser would greedily
 // swallow the following positional (e.g. `apx exec --code "hi"` would set
 // flags.code = "hi" and drop the prompt). Boolean flags always resolve to true.
-const BOOLEAN_FLAGS = new Set(["code", "verbose"]);
+const BOOLEAN_FLAGS = new Set(["code", "verbose", "global", "mcp", "memory"]);
 
 function parseArgs(argv) {
   const args = { _: [], flags: {} };
@@ -2501,6 +2537,17 @@ async function dispatch(cmd, rest) {
         break;
       }
 
+      case "obsidian": {
+        const sub = rest[0];
+        const a = parseArgs(rest.slice(1));
+        if (!sub || sub === "status" || sub === "show") await cmdObsidianStatus(a);
+        else if (sub === "set" || sub === "connect" || sub === "add") await cmdObsidianSet(a);
+        else if (sub === "sync") await cmdObsidianSync(a);
+        else if (sub === "remove" || sub === "rm" || sub === "disconnect") await cmdObsidianRemove(a);
+        else die(`unknown obsidian subcommand: ${sub}\nUsage: apx obsidian <set|status|sync|remove> [--global|--project <p>]`);
+        break;
+      }
+
       case "daemon": {
         const sub = rest[0];
         const a = parseArgs(rest.slice(1));