engrm 0.4.33 → 0.4.34

package/README.md

@@ -226,6 +226,7 @@ The MCP server exposes tools that supported agents can call directly:
 | `recent_handoffs` | List recent saved handoffs for the current project or workspace |
 | `load_handoff` | Open a saved handoff as a resume point for a new session |
 | `refresh_chat_recall` | Rehydrate the separate chat lane from a Claude transcript when a long session feels under-captured |
+| `agent_memory_index` | Compare continuity and capture health across Claude Code, Codex, OpenClaw, and other agents |
 | `repair_recall` | Use when continuity feels thin; rehydrate recent recall from transcript or Claude history fallback |
 | `list_recall_items` | Use first when continuity feels fuzzy; list the best current handoffs, threads, chat snippets, and memory entries |
 | `load_recall_item` | Use after `list_recall_items`; load one exact recall item key |
@@ -402,6 +403,8 @@ What each tool is good for:
 
 - `capture_status` tells you whether prompt/tool hooks are live on this machine
 - `capture_quality` shows whether chat recall is transcript-backed, history-backed, or still hook-only across the workspace
+- `agent_memory_index` lets you compare Claude Code, Codex, and other agent sessions on the same repo, so cross-agent validation stops being guesswork
+- when multiple agents are active on the same repo, startup plus the MCP workbench now surface the active agent set and suggest `agent_memory_index` automatically
 - `memory_console` gives the quickest project snapshot, including whether continuity is `fresh`, `thin`, or `cold`
 - `resume_thread` is the fastest “get me back into the live thread” path when you want freshness, source, next actions, tool trail, chat, and one exact `load_recall_item(...)` suggestion in one place
 - `list_recall_items` is the deterministic directory-first path when you want to inspect the best candidate handoffs/threads before opening one exact item

package/dist/hooks/session-start.js

@@ -3144,7 +3144,7 @@ import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync
 import { join as join3 } from "node:path";
 import { homedir } from "node:os";
 var STATE_PATH = join3(homedir(), ".engrm", "config-fingerprint.json");
-var CLIENT_VERSION = "0.4.33";
+var CLIENT_VERSION = "0.4.34";
 function hashFile(filePath) {
   try {
     if (!existsSync3(filePath))
@@ -5847,11 +5847,15 @@ function formatContextIndex(context, shownItems) {
 function formatInspectHints(context, visibleObservationIds = [], recallItems = []) {
   const hints = [];
   const continuityState = getStartupContinuityState(context);
+  const activeAgents = collectStartupAgents(context);
   if ((context.recentSessions?.length ?? 0) > 0) {
     hints.push("recent_sessions");
     hints.push("session_story");
     hints.push("create_handoff");
   }
+  if (activeAgents.length > 1) {
+    hints.push("agent_memory_index");
+  }
   if ((context.recentPrompts?.length ?? 0) > 0 || (context.recentToolEvents?.length ?? 0) > 0 || (context.recentChatMessages?.length ?? 0) > 0) {
     hints.push("activity_feed");
   }
@@ -5891,6 +5895,9 @@ function formatInspectHints(context, visibleObservationIds = [], recallItems = [
     ...fetchHint ? [`${c2.dim}Pull detail:${c2.reset} ${fetchHint}`] : []
   ];
 }
+function collectStartupAgents(context) {
+  return Array.from(new Set((context.recentSessions ?? []).map((session) => session.agent?.trim()).filter((agent) => Boolean(agent) && !agent.startsWith("engrm-")))).sort();
+}
 function formatStartupRecallPreview(recallItems) {
   const items = recallItems.slice(0, 3);
   if (items.length === 0)

package/dist/hooks/stop.js

@@ -3082,7 +3082,7 @@ function buildBeacon(db, config, sessionId, metrics) {
     sentinel_used: valueSignals.security_findings_count > 0,
     risk_score: riskScore,
     stacks_detected: stacks,
-    client_version: "0.4.33",
+    client_version: "0.4.34",
     context_observations_injected: metrics?.contextObsInjected ?? 0,
     context_total_available: metrics?.contextTotalAvailable ?? 0,
     recall_attempts: metrics?.recallAttempts ?? 0,

package/dist/server.js

@@ -18589,8 +18589,9 @@ function getProjectMemoryIndex(db, input) {
   const latestSummary = latestSession ? db.getSessionSummary(latestSession.session_id) : null;
   const recentOutcomes = observations.filter((obs) => ["bugfix", "feature", "refactor", "change", "decision"].includes(obs.type)).map((obs) => obs.title.trim()).filter((title) => title.length > 0 && !looksLikeFileOperationTitle4(title)).slice(0, 8);
   const captureSummary = summarizeCaptureState(recentSessions);
+  const activeAgents = collectActiveAgents(recentSessions);
   const topTypes = Object.entries(counts).map(([type, count]) => ({ type, count })).sort((a, b) => b.count - a.count || a.type.localeCompare(b.type)).slice(0, 5);
-  const suggestedTools = buildSuggestedTools(recentSessions, recentRequestsCount, recentToolsCount, observations.length, recentChatCount, recentChat.coverage_state);
+  const suggestedTools = buildSuggestedTools(recentSessions, recentRequestsCount, recentToolsCount, observations.length, recentChatCount, recentChat.coverage_state, activeAgents);
   const estimatedReadTokens = estimateTokens([
     recentOutcomes.join(`
 `),
@@ -18606,6 +18607,8 @@ function getProjectMemoryIndex(db, input) {
   return {
     project: project.name,
     canonical_id: project.canonical_id,
+    active_agents: activeAgents,
+    cross_agent_active: activeAgents.length > 1,
     continuity_state: continuityState,
     continuity_summary: describeContinuityState(continuityState),
     recall_mode: recallIndex.continuity_mode,
@@ -18732,11 +18735,17 @@ function summarizeCaptureState(sessions) {
   }
   return summary;
 }
-function buildSuggestedTools(sessions, requestCount, toolCount, observationCount, recentChatCount, chatCoverageState) {
+function collectActiveAgents(sessions) {
+  return Array.from(new Set(sessions.map((session) => session.agent?.trim()).filter((agent) => Boolean(agent) && !agent.startsWith("engrm-")))).sort();
+}
+function buildSuggestedTools(sessions, requestCount, toolCount, observationCount, recentChatCount, chatCoverageState, activeAgents) {
   const suggested = [];
   if (sessions.length > 0) {
     suggested.push("recent_sessions");
   }
+  if (activeAgents.length > 1) {
+    suggested.push("agent_memory_index");
+  }
   if (requestCount > 0 || toolCount > 0) {
     suggested.push("activity_feed");
   }
@@ -18761,7 +18770,7 @@ function buildSuggestedTools(sessions, requestCount, toolCount, observationCount
   if (recentChatCount > 0) {
     suggested.push("recent_chat", "search_chat");
   }
-  return Array.from(new Set(suggested)).slice(0, 5);
+  return Array.from(new Set(suggested)).slice(0, 6);
 }
 
 // src/tools/memory-console.ts
@@ -18819,8 +18828,11 @@ function getMemoryConsole(db, input) {
     user_id: input.user_id
   }) : null;
   const continuityState = projectIndex?.continuity_state ?? classifyContinuityState(requests.length, tools.length, recentHandoffs.length, recentChat.messages.length, sessions, (projectIndex?.recent_outcomes ?? []).length);
+  const activeAgents = projectIndex?.active_agents ?? collectActiveAgents(sessions);
   return {
     project: project?.name,
+    active_agents: activeAgents,
+    cross_agent_active: projectIndex?.cross_agent_active ?? activeAgents.length > 1,
     capture_mode: requests.length > 0 || tools.length > 0 ? "rich" : "observations-only",
     continuity_state: continuityState,
     continuity_summary: projectIndex?.continuity_summary ?? describeContinuityState(continuityState),
@@ -18858,13 +18870,15 @@ function getMemoryConsole(db, input) {
     assistant_checkpoint_types: projectIndex?.assistant_checkpoint_types ?? [],
     top_types: projectIndex?.top_types ?? [],
     estimated_read_tokens: projectIndex?.estimated_read_tokens,
-    suggested_tools: projectIndex?.suggested_tools ?? buildFallbackSuggestedTools(sessions.length, requests.length, tools.length, observations.length, recentHandoffs.length, recentChat.messages.length, recentChat.coverage_state)
+    suggested_tools: projectIndex?.suggested_tools ?? buildFallbackSuggestedTools(sessions.length, requests.length, tools.length, observations.length, recentHandoffs.length, recentChat.messages.length, recentChat.coverage_state, activeAgents.length)
   };
 }
-function buildFallbackSuggestedTools(sessionCount, requestCount, toolCount, observationCount, handoffCount, chatCount, chatCoverageState) {
+function buildFallbackSuggestedTools(sessionCount, requestCount, toolCount, observationCount, handoffCount, chatCount, chatCoverageState, activeAgentCount) {
   const suggested = [];
   if (sessionCount > 0)
     suggested.push("recent_sessions");
+  if (activeAgentCount > 1)
+    suggested.push("agent_memory_index");
   if (requestCount > 0 || toolCount > 0)
     suggested.push("activity_feed");
   if (requestCount > 0 || chatCount > 0 || observationCount > 0)
@@ -18883,7 +18897,7 @@ function buildFallbackSuggestedTools(sessionCount, requestCount, toolCount, obse
     suggested.push("refresh_chat_recall");
   if (chatCount > 0)
     suggested.push("recent_chat", "search_chat");
-  return Array.from(new Set(suggested)).slice(0, 5);
+  return Array.from(new Set(suggested)).slice(0, 6);
 }
 
 // src/tools/workspace-memory-index.ts
@@ -19529,6 +19543,192 @@ function getCaptureQuality(db, input = {}) {
   };
 }
 
+// src/tools/agent-memory-index.ts
+function getAgentMemoryIndex(db, input) {
+  const cwd = input.cwd ?? process.cwd();
+  const projectScoped = input.project_scoped !== false;
+  let projectId = null;
+  let projectName;
+  if (projectScoped) {
+    const detected = detectProject(cwd);
+    const project = db.getProjectByCanonicalId(detected.canonical_id);
+    if (project) {
+      projectId = project.id;
+      projectName = project.name;
+    }
+  }
+  const userFilter = input.user_id ? " AND s.user_id = ?" : "";
+  const userArgs = input.user_id ? [input.user_id] : [];
+  const projectFilter = projectId !== null ? " AND s.project_id = ?" : "";
+  const projectArgs = projectId !== null ? [projectId] : [];
+  const sessionRows = db.db.query(`SELECT
+         s.agent as agent,
+         COUNT(*) as session_count,
+         SUM(CASE WHEN ss.request IS NOT NULL OR ss.completed IS NOT NULL THEN 1 ELSE 0 END) as summary_session_count,
+         SUM(COALESCE(pc.prompt_count, 0)) as prompt_count,
+         SUM(COALESCE(tc.tool_event_count, 0)) as tool_event_count,
+         MAX(COALESCE(s.completed_at_epoch, s.started_at_epoch)) as last_seen_epoch
+       FROM sessions s
+       LEFT JOIN session_summaries ss ON ss.session_id = s.session_id
+       LEFT JOIN (
+         SELECT session_id, COUNT(*) as prompt_count
+         FROM user_prompts
+         GROUP BY session_id
+       ) pc ON pc.session_id = s.session_id
+       LEFT JOIN (
+         SELECT session_id, COUNT(*) as tool_event_count
+         FROM tool_events
+         GROUP BY session_id
+       ) tc ON tc.session_id = s.session_id
+       WHERE 1 = 1${projectFilter}${userFilter}
+       GROUP BY s.agent
+       ORDER BY last_seen_epoch DESC, s.agent ASC`).all(...projectArgs, ...userArgs).filter((row) => !isInternalAgent(row.agent));
+  const observationCounts = new Map;
+  const observationRows = db.db.query(`SELECT
+         COALESCE(s.agent, o.agent) as agent,
+         COUNT(*) as observation_count,
+         SUM(CASE WHEN o.type = 'message' AND o.concepts LIKE '%session-handoff%' THEN 1 ELSE 0 END) as handoff_count
+       FROM observations o
+       LEFT JOIN sessions s ON s.session_id = o.session_id
+       WHERE o.lifecycle IN ('active', 'aging', 'pinned')
+         AND o.superseded_by IS NULL
+         ${projectId !== null ? "AND o.project_id = ?" : ""}
+         ${input.user_id ? "AND (o.sensitivity != 'personal' OR o.user_id = ?)" : ""}
+       GROUP BY COALESCE(s.agent, o.agent)`).all(...projectId !== null ? [projectId] : [], ...input.user_id ? [input.user_id] : []).filter((row) => !isInternalAgent(row.agent));
+  for (const row of observationRows) {
+    observationCounts.set(row.agent, {
+      observation_count: row.observation_count,
+      handoff_count: row.handoff_count
+    });
+  }
+  const chatCoverage = new Map;
+  const chatRows = db.db.query(`SELECT
+         COALESCE(s.agent, cm.agent) as agent,
+         CASE
+           WHEN cm.source_kind = 'transcript' THEN 'transcript'
+           WHEN cm.remote_source_id LIKE 'history:%' THEN 'history'
+           ELSE 'hook'
+         END as origin_kind,
+         COUNT(*) as count
+       FROM chat_messages cm
+       LEFT JOIN sessions s ON s.session_id = cm.session_id
+       WHERE 1 = 1
+         ${projectId !== null ? "AND cm.project_id = ?" : ""}
+         ${input.user_id ? "AND cm.user_id = ?" : ""}
+       GROUP BY COALESCE(s.agent, cm.agent), origin_kind`).all(...projectId !== null ? [projectId] : [], ...input.user_id ? [input.user_id] : []).filter((row) => !isInternalAgent(row.agent));
+  for (const row of chatRows) {
+    const current = chatCoverage.get(row.agent) ?? {
+      chat_message_count: 0,
+      transcript_count: 0,
+      history_count: 0,
+      hook_count: 0
+    };
+    current.chat_message_count += row.count;
+    if (row.origin_kind === "transcript")
+      current.transcript_count += row.count;
+    else if (row.origin_kind === "history")
+      current.history_count += row.count;
+    else
+      current.hook_count += row.count;
+    chatCoverage.set(row.agent, current);
+  }
+  const recentSessions = db.getRecentSessions(projectId, 200, input.user_id).filter((session) => !isInternalAgent(session.agent));
+  const latestByAgent = new Map;
+  const devicesByAgent = new Map;
+  for (const session of recentSessions) {
+    if (!latestByAgent.has(session.agent))
+      latestByAgent.set(session.agent, session);
+    const devices = devicesByAgent.get(session.agent) ?? new Set;
+    if (session.device_id)
+      devices.add(session.device_id);
+    devicesByAgent.set(session.agent, devices);
+  }
+  const knownAgents = new Set([
+    ...sessionRows.map((row) => row.agent),
+    ...Array.from(observationCounts.keys()),
+    ...Array.from(chatCoverage.keys())
+  ]);
+  const agents = Array.from(knownAgents).map((agent) => {
+    const session = sessionRows.find((row) => row.agent === agent) ?? {
+      agent,
+      session_count: 0,
+      summary_session_count: 0,
+      prompt_count: 0,
+      tool_event_count: 0,
+      last_seen_epoch: null
+    };
+    const obs = observationCounts.get(agent) ?? { observation_count: 0, handoff_count: 0 };
+    const chat = chatCoverage.get(agent) ?? {
+      chat_message_count: 0,
+      transcript_count: 0,
+      history_count: 0,
+      hook_count: 0
+    };
+    const latestSession = latestByAgent.get(agent) ?? null;
+    return {
+      agent,
+      session_count: session.session_count,
+      summary_session_count: session.summary_session_count,
+      prompt_count: session.prompt_count,
+      tool_event_count: session.tool_event_count,
+      observation_count: obs.observation_count,
+      handoff_count: obs.handoff_count,
+      chat_message_count: chat.chat_message_count,
+      chat_coverage_state: chat.transcript_count > 0 ? "transcript-backed" : chat.history_count > 0 ? "history-backed" : chat.hook_count > 0 ? "hook-only" : "none",
+      continuity_state: classifyAgentContinuity(session.last_seen_epoch, session.prompt_count, session.tool_event_count, chat.chat_message_count, obs.handoff_count, obs.observation_count),
+      capture_state: classifyAgentCaptureState(session.prompt_count, session.tool_event_count, session.summary_session_count, obs.observation_count, chat.chat_message_count),
+      last_seen_epoch: session.last_seen_epoch,
+      latest_session_id: latestSession?.session_id ?? null,
+      latest_summary: latestSession?.current_thread ?? latestSession?.request ?? latestSession?.completed ?? null,
+      devices: Array.from(devicesByAgent.get(agent) ?? []).sort()
+    };
+  }).sort((a, b) => {
+    const epochA = a.last_seen_epoch ?? 0;
+    const epochB = b.last_seen_epoch ?? 0;
+    return epochB - epochA || a.agent.localeCompare(b.agent);
+  });
+  return {
+    project: projectName,
+    agents,
+    suggested_tools: buildSuggestedTools2(agents)
+  };
+}
+function isInternalAgent(agent) {
+  return !agent || agent.startsWith("engrm-");
+}
+function classifyAgentContinuity(lastSeenEpoch, promptCount, toolCount, chatCount, handoffCount, observationCount) {
+  if (!lastSeenEpoch)
+    return "cold";
+  const ageMs = Date.now() - lastSeenEpoch * 1000;
+  const hasStrongContinuity = promptCount > 0 || toolCount > 0 || chatCount > 0 || handoffCount > 0;
+  if (ageMs <= 3 * 24 * 60 * 60 * 1000 && hasStrongContinuity)
+    return "fresh";
+  if (observationCount > 0 || promptCount > 0 || toolCount > 0 || chatCount > 0)
+    return "thin";
+  return "cold";
+}
+function classifyAgentCaptureState(promptCount, toolCount, summarySessionCount, observationCount, chatCount) {
+  if (promptCount > 0 && toolCount > 0)
+    return "rich";
+  if (promptCount > 0 || toolCount > 0)
+    return "partial";
+  if (summarySessionCount > 0 || observationCount > 0 || chatCount > 0)
+    return "summary-only";
+  return "legacy";
+}
+function buildSuggestedTools2(agents) {
+  if (agents.length === 0)
+    return [];
+  const suggestions = ["recent_sessions", "capture_quality"];
+  if (agents.some((agent) => agent.continuity_state !== "fresh")) {
+    suggestions.push("resume_thread");
+  }
+  if (agents.some((agent) => agent.chat_coverage_state === "hook-only")) {
+    suggestions.push("repair_recall");
+  }
+  return suggestions;
+}
+
 // src/tools/tool-memory-index.ts
 function parseConcepts(value) {
   if (!value)
@@ -19732,9 +19932,12 @@ function getSessionContext(db, input) {
   const latestChatEpoch = recentChat.messages.length > 0 ? recentChat.messages[recentChat.messages.length - 1]?.created_at_epoch ?? null : null;
   const resumeTimestamp = latestChatEpoch ?? latestSession?.completed_at_epoch ?? latestSession?.started_at_epoch ?? null;
   const bestRecallItem = recallIndex.items.find((item) => item.kind !== "memory") ?? recallIndex.items[0] ?? null;
+  const activeAgents = collectActiveAgents(context.recentSessions ?? []);
   return {
     project_name: context.project_name,
     canonical_id: context.canonical_id,
+    active_agents: activeAgents,
+    cross_agent_active: activeAgents.length > 1,
     continuity_state: continuityState,
     continuity_summary: describeContinuityState(continuityState),
     recall_mode: recallIndex.continuity_mode,
@@ -19770,7 +19973,7 @@ function getSessionContext(db, input) {
     capture_state: captureState,
     raw_capture_active: recentRequests > 0 || recentTools > 0,
     estimated_read_tokens: estimateTokens(preview),
-    suggested_tools: buildSuggestedTools2(context, recentChat.coverage_state),
+    suggested_tools: buildSuggestedTools3(context, recentChat.coverage_state, activeAgents.length),
     preview
   };
 }
@@ -19801,11 +20004,14 @@ function parseJsonArray3(value) {
     return [];
   }
 }
-function buildSuggestedTools2(context, chatCoverageState) {
+function buildSuggestedTools3(context, chatCoverageState, activeAgentCount) {
   const tools = [];
   if ((context.recentSessions?.length ?? 0) > 0) {
     tools.push("recent_sessions");
   }
+  if (activeAgentCount > 1) {
+    tools.push("agent_memory_index");
+  }
   if ((context.recentPrompts?.length ?? 0) > 0 || (context.recentToolEvents?.length ?? 0) > 0) {
     tools.push("activity_feed");
   }
@@ -19833,7 +20039,7 @@ function buildSuggestedTools2(context, chatCoverageState) {
   if ((context.recentChatMessages?.length ?? 0) > 0) {
     tools.push("recent_chat", "search_chat");
   }
-  return Array.from(new Set(tools)).slice(0, 5);
+  return Array.from(new Set(tools)).slice(0, 6);
 }
 
 // src/tools/load-recall-item.ts
@@ -22459,7 +22665,7 @@ process.on("SIGTERM", () => {
 });
 var server = new McpServer({
   name: "engrm",
-  version: "0.4.33"
+  version: "0.4.34"
 });
 server.tool("save_observation", "Save an observation to memory", {
   type: exports_external.enum([
@@ -23441,7 +23647,8 @@ server.tool("memory_console", "Show a high-signal local overview of what Engrm c
     content: [
       {
         type: "text",
-        text: `${projectLine}` + `${captureLine}` + `Continuity: ${result.continuity_state} — ${result.continuity_summary}
+        text: `${projectLine}` + `${captureLine}` + `${result.active_agents.length > 0 ? `Agents active: ${result.active_agents.join(", ")}
+` : ""}` + `Continuity: ${result.continuity_state} — ${result.continuity_summary}
 ` + `Recall index: ${result.recall_mode} · ${result.recall_items_ready} items ready
 ` + `Resume readiness: ${result.resume_freshness} · ${result.resume_source_session_id ?? "(unknown session)"}${result.resume_source_device_id ? ` (${result.resume_source_device_id})` : ""}
 ` + `Chat recall: ${result.chat_coverage_state} · ${result.recent_chat.length} messages across ${result.recent_chat_sessions} sessions (transcript ${result.chat_source_summary.transcript}, history ${result.chat_source_summary.history}, hook ${result.chat_source_summary.hook})
@@ -23564,6 +23771,37 @@ ${projectLines}`
     ]
   };
 });
+server.tool("agent_memory_index", "Compare continuity and capture health across Claude Code, Codex, OpenClaw, and other agents for the current project or workspace.", {
+  cwd: exports_external.string().optional().describe("Project path to inspect. Defaults to the current working directory."),
+  project_scoped: exports_external.boolean().optional().describe("If true, limit results to the current project instead of the whole workspace."),
+  user_id: exports_external.string().optional().describe("Optional user override; defaults to the configured user.")
+}, async (params) => {
+  const result = getAgentMemoryIndex(db, {
+    cwd: params.cwd ?? process.cwd(),
+    project_scoped: params.project_scoped,
+    user_id: params.user_id ?? config2.user_id
+  });
+  const rows = result.agents.length > 0 ? result.agents.map((agent) => {
+    const lastSeen = agent.last_seen_epoch ? new Date(agent.last_seen_epoch * 1000).toISOString().replace("T", " ").slice(0, 16) : "unknown";
+    const latest = agent.latest_summary ? ` latest="${agent.latest_summary.replace(/\s+/g, " ").trim().slice(0, 120)}"` : "";
+    const devices = agent.devices.length > 0 ? ` devices=[${agent.devices.join(", ")}]` : "";
+    return `- ${agent.agent}: continuity=${agent.continuity_state} capture=${agent.capture_state} chat=${agent.chat_coverage_state} sessions=${agent.session_count} prompts=${agent.prompt_count} tools=${agent.tool_event_count} obs=${agent.observation_count} handoffs=${agent.handoff_count} chat_msgs=${agent.chat_message_count} last_seen=${lastSeen}${devices}${latest}`;
+  }).join(`
+`) : "- (none)";
+  return {
+    content: [
+      {
+        type: "text",
+        text: `${result.project ? `Project: ${result.project}
+
+` : ""}` + `Agent memory index:
+${rows}
+
+` + `Suggested next step: ${result.suggested_tools.join(", ") || "(none)"}`
+      }
+    ]
+  };
+});
 server.tool("tool_memory_index", "Show which tools are actually producing durable memory, which plugins they exercise, and what memory types they create.", {
   cwd: exports_external.string().optional().describe("Project path to inspect. Defaults to the current working directory."),
   project_scoped: exports_external.boolean().optional().describe("If true, limit results to the current project instead of the whole workspace."),
@@ -23649,6 +23887,7 @@ server.tool("session_context", "Preview the exact project memory context Engrm w
         type: "text",
         text: `Project: ${result.project_name}
 ` + `Canonical ID: ${result.canonical_id}
+` + `Agents active: ${result.active_agents.join(", ") || "(none)"}
 ` + `Continuity: ${result.continuity_state} — ${result.continuity_summary}
 ` + `Recall index: ${result.recall_mode} · ${result.recall_items_ready} items ready
 ` + `Open exact: ${result.best_recall_key ? `load_recall_item("${result.best_recall_key}")` : "(none)"}
@@ -23740,6 +23979,7 @@ server.tool("project_memory_index", "Show a typed local memory index for the cur
         type: "text",
         text: `Project: ${result.project}
 ` + `Canonical ID: ${result.canonical_id}
+` + `Agents active: ${result.active_agents.join(", ") || "(none)"}
 ` + `Continuity: ${result.continuity_state} — ${result.continuity_summary}
 ` + `Recall index: ${result.recall_mode} · ${result.recall_items_ready} items ready
 ` + `Resume readiness: ${result.resume_freshness} · ${result.resume_source_session_id ?? "(unknown session)"}${result.resume_source_device_id ? ` (${result.resume_source_device_id})` : ""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engrm",
-  "version": "0.4.33",
+  "version": "0.4.34",
   "description": "Shared memory across devices, sessions, and agents, with thin MCP tools for durable capture and live continuity",
   "mcpName": "io.github.dr12hes/engrm",
   "type": "module",