agent-working-memory 0.6.1 → 0.7.0

package/src/engine/activation.ts

@@ -21,7 +21,7 @@
 
 import { randomUUID } from 'node:crypto';
 import { baseLevelActivation, softplus } from '../core/decay.js';
-import { strengthenAssociation, CoActivationBuffer } from '../core/hebbian.js';
+import { strengthenAssociation, CoActivationBuffer, ValidationGatedBuffer } from '../core/hebbian.js';
 import { embed, cosineSimilarity } from '../core/embeddings.js';
 import { rerank } from '../core/reranker.js';
 import { expandQuery } from '../core/query-expander.js';
@@ -163,10 +163,12 @@ function jaccard(a: Set<string>, b: Set<string>): number {
 export class ActivationEngine {
   private store: EngramStore;
   private coActivationBuffer: CoActivationBuffer;
+  readonly validationGate: ValidationGatedBuffer;
 
   constructor(store: EngramStore) {
     this.store = store;
     this.coActivationBuffer = new CoActivationBuffer(50);
+    this.validationGate = new ValidationGatedBuffer();
   }
 
   /**
@@ -181,14 +183,18 @@ export class ActivationEngine {
     const abstentionThreshold = query.abstentionThreshold ?? 0;
     const adaptive = resolveAdaptiveParams(query);
 
+    // Resolve workspace scope: if workspace is set, search across all agents in that workspace
+    const agentIds = query.workspace
+      ? this.store.getWorkspaceAgentIds(query.agentId, query.workspace)
+      : [query.agentId];
+    const isWorkspaceScoped = agentIds.length > 1;
+
     // Phase -1: Coref expansion — if query has pronouns, append recent entity names
-    // Helps conversational recall where "she/he/they/it" refers to a named entity.
     let queryContext = query.context;
     const pronounPattern = /\b(she|he|they|her|his|him|their|it|that|this|there)\b/i;
     if (pronounPattern.test(queryContext)) {
-      // Pull recent entity names from the agent's most-accessed memories
       try {
-        const recentEntities = this.store.getEngramsByAgent(query.agentId, 'active')
+        const recentEntities = this.store.getEngramsByAgents(agentIds, 'active')
           .sort((a, b) => b.accessCount - a.accessCount)
           .slice(0, 10)
           .flatMap(e => e.tags.filter(t => t.length >= 3 && !/^(session-|low-|D\d)/.test(t)))
@@ -228,9 +234,9 @@ export class ActivationEngine {
     // Two-pass BM25: (1) keyword-stripped query for precision, (2) expanded query for recall.
     const keywordQuery = Array.from(tokenize(query.context)).join(' ');
     const bm25Keyword = keywordQuery.length > 2
-      ? this.store.searchBM25WithRank(query.agentId, keywordQuery, limit * 3)
+      ? this.store.searchBM25WithRankMultiAgent(agentIds, keywordQuery, limit * 3)
       : [];
-    const bm25Expanded = this.store.searchBM25WithRank(query.agentId, searchContext, limit * 3);
+    const bm25Expanded = this.store.searchBM25WithRankMultiAgent(agentIds, searchContext, limit * 3);
 
     // Merge: take the best BM25 score per engram from either pass
     const bm25ScoreMap = new Map<string, number>();
@@ -246,8 +252,8 @@ export class ActivationEngine {
       engram, bm25Score: bm25ScoreMap.get(id) ?? 0,
     }));
 
-    const allActive = this.store.getEngramsByAgent(
-      query.agentId,
+    const allActive = this.store.getEngramsByAgents(
+      agentIds,
       query.includeStaging ? undefined : 'active',
       query.includeRetracted ?? false
     );
@@ -402,7 +408,7 @@ export class ActivationEngine {
       // Take top 5 feedback terms and re-search
       const extraTerms = Array.from(feedbackTerms).slice(0, 5).join(' ');
       if (extraTerms) {
-        const feedbackBM25 = this.store.searchBM25WithRank(query.agentId, `${searchContext} ${extraTerms}`, limit * 2);
+        const feedbackBM25 = this.store.searchBM25WithRankMultiAgent(agentIds, `${searchContext} ${extraTerms}`, limit * 2);
         for (const r of feedbackBM25) {
           if (!candidateMap.has(r.engram.id)) {
             candidateMap.set(r.engram.id, r.engram);
@@ -632,13 +638,21 @@ export class ActivationEngine {
 
     const activatedIds = results.map(r => r.engram.id);
 
-    // Side effects: touch, co-activate, Hebbian update (skip for internal/system calls)
+    // Side effects: touch, co-activate, defer Hebbian to validation gate (skip for internal/system calls)
     if (!query.internal) {
       for (const id of activatedIds) {
         this.store.touchEngram(id);
       }
       this.coActivationBuffer.pushBatch(activatedIds);
-      this.updateHebbianWeights();
+      // Validation-gated Hebbian: defer strengthening until feedback arrives
+      const pairs = this.coActivationBuffer.getCoActivatedPairs(10_000);
+      const seen = new Set<string>();
+      const uniquePairs: [string, string][] = [];
+      for (const [a, b] of pairs) {
+        const key = a < b ? `${a}:${b}` : `${b}:${a}`;
+        if (!seen.has(key)) { seen.add(key); uniquePairs.push([a, b]); }
+      }
+      this.validationGate.addPending(activatedIds, uniquePairs);
 
       // Log activation event for eval
       const latencyMs = performance.now() - startTime;
@@ -658,10 +672,27 @@ export class ActivationEngine {
   }
 
   /**
-   * Beam search graph walk — replaces naive BFS.
-   * Scores paths (not just nodes), uses query-dependent edge filtering,
-   * and supports deeper exploration with focused beams.
+   * Multi-graph traversal (MAGMA-inspired).
+   *
+   * Instead of one beam search over all edge types, runs independent traversals
+   * per graph type with specialized scoring, then fuses the boosts.
+   *
+   * Four sub-graphs:
+   * - Semantic (connection + hebbian edges) → standard weight-based walk
+   * - Temporal (temporal edges) → recency-weighted (favor recent connections)
+   * - Causal (causal edges) → full weight walk (causal links are high-value)
+   * - Entity (bridge edges) → entity-tag-weighted walk
+   *
+   * Each sub-graph contributes independently to the final graph boost,
+   * weighted by configurable per-graph weights.
    */
+  private static readonly GRAPH_WEIGHTS = {
+    semantic: 0.40,   // connection + hebbian
+    temporal: 0.20,   // temporal edges
+    causal: 0.25,     // causal edges (high-value signal)
+    entity: 0.15,     // bridge edges
+  };
+
   private graphWalk(
     scored: { engram: Engram; score: number; phaseScores: PhaseScores; associations: Association[] }[],
     maxDepth: number,
@@ -670,85 +701,120 @@ export class ActivationEngine {
   ): void {
     const scoreMap = new Map(scored.map(s => [s.engram.id, s]));
     const MAX_TOTAL_BOOST = 0.25;
-    const BEAM_WIDTH = beamWidth;
 
-    // Seed the beam with high-scoring, text-relevant items
-    const beam = scored
-      .filter(item => item.phaseScores.textMatch >= 0.15)
-      .sort((a, b) => b.score - a.score)
-      .slice(0, BEAM_WIDTH);
+    // Define which edge types belong to each sub-graph
+    const graphTypes: Record<string, string[]> = {
+      semantic: ['connection', 'hebbian'],
+      temporal: ['temporal'],
+      causal: ['causal'],
+      entity: ['bridge'],
+    };
+
+    // Run independent traversals per sub-graph, accumulate boosts
+    const boostAccum = new Map<string, number>(); // engramId → total boost
 
-    // Track which engrams have been explored (avoid cycles)
-    const explored = new Set<string>();
+    for (const [graphName, edgeTypes] of Object.entries(graphTypes)) {
+      const graphWeight = ActivationEngine.GRAPH_WEIGHTS[graphName as keyof typeof ActivationEngine.GRAPH_WEIGHTS];
+      const subBeamWidth = Math.max(3, Math.ceil(beamWidth * graphWeight));
 
-    for (let depth = 0; depth < maxDepth; depth++) {
-      const nextBeam: typeof beam = [];
+      // Seed beam
+      const beam = scored
+        .filter(item => item.phaseScores.textMatch >= 0.15)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, subBeamWidth);
+
+      const explored = new Set<string>();
+
+      for (let depth = 0; depth < maxDepth; depth++) {
+        const nextBeam: typeof beam = [];
 
-      for (const item of beam) {
-        if (explored.has(item.engram.id)) continue;
-        explored.add(item.engram.id);
+        for (const item of beam) {
+          if (explored.has(item.engram.id)) continue;
+          explored.add(item.engram.id);
 
-        // Get associations — for depth > 0, fetch from store if not in scored set
-        const associations = item.associations.length > 0
-          ? item.associations
-          : this.store.getAssociationsFor(item.engram.id);
+          const associations = item.associations.length > 0
+            ? item.associations
+            : this.store.getAssociationsFor(item.engram.id);
 
-        for (const assoc of associations) {
-          const neighborId = assoc.fromEngramId === item.engram.id
-            ? assoc.toEngramId
-            : assoc.fromEngramId;
+          // Filter to only edges of this sub-graph type
+          const relevantEdges = associations.filter(a => edgeTypes.includes(a.type));
 
-          if (explored.has(neighborId)) continue;
+          for (const assoc of relevantEdges) {
+            const neighborId = assoc.fromEngramId === item.engram.id
+              ? assoc.toEngramId
+              : assoc.fromEngramId;
 
-          const neighbor = scoreMap.get(neighborId);
-          if (!neighbor) continue;
+            if (explored.has(neighborId)) continue;
+            const neighbor = scoreMap.get(neighborId);
+            if (!neighbor) continue;
 
-          // Query-dependent edge filtering: neighbor must have SOME relevance
-          // (textMatch > 0.05 for deeper hops, relaxed from 0.1)
-          const relevanceFloor = depth === 0 ? 0.1 : 0.05;
-          if (neighbor.phaseScores.textMatch < relevanceFloor) continue;
+            const relevanceFloor = depth === 0 ? 0.1 : 0.05;
+            if (neighbor.phaseScores.textMatch < relevanceFloor) continue;
 
-          // Skip if neighbor already at boost cap
-          if (neighbor.phaseScores.graphBoost >= MAX_TOTAL_BOOST) continue;
+            // Path score with graph-type-specific weighting
+            const normalizedWeight = Math.min(assoc.weight, 5.0) / 5.0;
+            let pathScore = item.score * normalizedWeight * Math.pow(hopPenalty, depth + 1);
 
-          // Path score: source score * edge weight * hop penalty^(depth+1)
-          const normalizedWeight = Math.min(assoc.weight, 5.0) / 5.0;
-          const pathScore = item.score * normalizedWeight * Math.pow(hopPenalty, depth + 1);
+            // Causal edges get a 2x boost — they represent verified reasoning chains
+            if (graphName === 'causal') pathScore *= 2.0;
 
-          const boost = Math.min(pathScore, 0.15, MAX_TOTAL_BOOST - neighbor.phaseScores.graphBoost);
-          if (boost > 0.001) {
-            neighbor.score += boost;
-            neighbor.phaseScores.graphBoost += boost;
-            nextBeam.push(neighbor);
+            // Weight by sub-graph importance
+            const boost = Math.min(pathScore * graphWeight, 0.15);
+            if (boost > 0.001) {
+              boostAccum.set(neighborId, (boostAccum.get(neighborId) ?? 0) + boost);
+              nextBeam.push(neighbor);
+            }
           }
         }
+
+        if (nextBeam.length === 0) break;
+        beam.length = 0;
+        beam.push(...nextBeam
+          .sort((a, b) => b.score - a.score)
+          .slice(0, subBeamWidth)
+        );
       }
+    }
 
-      // Prune beam for next depth level
-      if (nextBeam.length === 0) break;
-      beam.length = 0;
-      beam.push(...nextBeam
-        .sort((a, b) => b.score - a.score)
-        .slice(0, BEAM_WIDTH)
-      );
+    // Apply fused boosts to scored items
+    for (const [engramId, totalBoost] of boostAccum) {
+      const item = scoreMap.get(engramId);
+      if (!item) continue;
+      const capped = Math.min(totalBoost, MAX_TOTAL_BOOST - item.phaseScores.graphBoost);
+      if (capped > 0.001) {
+        item.score += capped;
+        item.phaseScores.graphBoost += capped;
+      }
     }
   }
 
-  private updateHebbianWeights(): void {
-    const pairs = this.coActivationBuffer.getCoActivatedPairs(10_000);
-    // Deduplicate pairs to prevent repeated strengthening
-    const seen = new Set<string>();
-    for (const [a, b] of pairs) {
-      const key = a < b ? `${a}:${b}` : `${b}:${a}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
+  /**
+   * Resolve validation-gated Hebbian update for a specific engram.
+   * Called by memory_feedback — only strengthens when retrieval was useful.
+   * This prevents hub toxicity from noisy co-retrieval (Kairos-inspired).
+   */
+  resolveHebbianFeedback(engramId: string, useful: boolean): number {
+    const { pairs, signal } = this.validationGate.resolveFeedback(engramId, useful);
+    let updated = 0;
 
+    for (const [a, b] of pairs) {
       const existing = this.store.getAssociation(a, b) ?? this.store.getAssociation(b, a);
       const currentWeight = existing?.weight ?? 0.1;
-      const newWeight = strengthenAssociation(currentWeight);
-      this.store.upsertAssociation(a, b, newWeight, 'hebbian');
-      this.store.upsertAssociation(b, a, newWeight, 'hebbian');
+
+      if (signal > 0) {
+        // Positive feedback → strengthen
+        const newWeight = strengthenAssociation(currentWeight, signal);
+        this.store.upsertAssociation(a, b, newWeight, 'hebbian');
+        this.store.upsertAssociation(b, a, newWeight, 'hebbian');
+      } else {
+        // Negative feedback → slight weakening (decay by signal magnitude)
+        const newWeight = Math.max(0.001, currentWeight * (1 + signal)); // signal is -0.3
+        this.store.upsertAssociation(a, b, newWeight, 'hebbian');
+        this.store.upsertAssociation(b, a, newWeight, 'hebbian');
+      }
+      updated++;
     }
+    return updated;
   }
 
   private explain(phases: PhaseScores, engram: Engram, associations: Association[]): string {

package/src/mcp.ts

@@ -26,7 +26,7 @@
 
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 
 // Load .env file if present (no external dependency)
 try {
@@ -113,64 +113,64 @@ consolidationScheduler.start();
 // Coordination DB handle — set when AWM_COORDINATION=true, used by memory_write for decision propagation
 let coordDb: import('better-sqlite3').Database | null = null;
 
-const server = new McpServer({
-  name: 'agent-working-memory',
-  version: '0.6.0',
-});
-
-server.registerResource(
-  'awm-overview',
-  'awm://server/overview',
-  {
-    title: 'AWM Overview',
-    description: 'AgentWorkingMemory MCP server metadata and discovery notes',
-    mimeType: 'text/markdown',
-  },
-  async () => ({
-    contents: [{
-      uri: 'awm://server/overview',
-      text: [
-        '# Agent Working Memory',
-        '',
-        `Agent: ${AGENT_ID}`,
-        `DB: ${DB_PATH}`,
-        `Coordination: ${process.env.AWM_COORDINATION === 'true' || process.env.AWM_COORDINATION === '1' ? 'enabled' : 'disabled'}`,
-        '',
-        'This MCP server primarily exposes tools such as `memory_restore`, `memory_recall`, `memory_write`, and task/checkpoint operations.',
-        'The resources below exist so generic MCP clients can discover the server through `resources/list` and `resources/templates/list`.',
-      ].join('\n'),
-      mimeType: 'text/markdown',
-    }],
-  })
-);
-
-server.registerResource(
-  'awm-memory-template',
-  new ResourceTemplate('awm://memory/{id}', { list: undefined }),
-  {
-    title: 'AWM Memory By ID',
-    description: 'Metadata resource template for a memory identifier',
-    mimeType: 'text/markdown',
-  },
-  async (_uri, variables) => ({
-    contents: [{
-      uri: `awm://memory/${variables.id ?? ''}`,
-      text: [
-        '# AWM Memory Reference',
-        '',
-        `Requested memory id: ${variables.id ?? ''}`,
-        '',
-        'Use the AWM memory tools for actual retrieval and mutation:',
-        '- `memory_recall` for cognitive retrieval',
-        '- `memory_restore` for session state',
-        '- `memory_feedback`, `memory_retract`, `memory_supersede` for memory maintenance',
-      ].join('\n'),
-      mimeType: 'text/markdown',
-    }],
-  })
-);
-
-// --- Auto-classification for memory types ---
+const server = new McpServer({
+  name: 'agent-working-memory',
+  version: '0.6.0',
+});
+
+server.registerResource(
+  'awm-overview',
+  'awm://server/overview',
+  {
+    title: 'AWM Overview',
+    description: 'AgentWorkingMemory MCP server metadata and discovery notes',
+    mimeType: 'text/markdown',
+  },
+  async () => ({
+    contents: [{
+      uri: 'awm://server/overview',
+      text: [
+        '# Agent Working Memory',
+        '',
+        `Agent: ${AGENT_ID}`,
+        `DB: ${DB_PATH}`,
+        `Coordination: ${process.env.AWM_COORDINATION === 'true' || process.env.AWM_COORDINATION === '1' ? 'enabled' : 'disabled'}`,
+        '',
+        'This MCP server primarily exposes tools such as `memory_restore`, `memory_recall`, `memory_write`, and task/checkpoint operations.',
+        'The resources below exist so generic MCP clients can discover the server through `resources/list` and `resources/templates/list`.',
+      ].join('\n'),
+      mimeType: 'text/markdown',
+    }],
+  })
+);
+
+server.registerResource(
+  'awm-memory-template',
+  new ResourceTemplate('awm://memory/{id}', { list: undefined }),
+  {
+    title: 'AWM Memory By ID',
+    description: 'Metadata resource template for a memory identifier',
+    mimeType: 'text/markdown',
+  },
+  async (_uri, variables) => ({
+    contents: [{
+      uri: `awm://memory/${variables.id ?? ''}`,
+      text: [
+        '# AWM Memory Reference',
+        '',
+        `Requested memory id: ${variables.id ?? ''}`,
+        '',
+        'Use the AWM memory tools for actual retrieval and mutation:',
+        '- `memory_recall` for cognitive retrieval',
+        '- `memory_restore` for session state',
+        '- `memory_feedback`, `memory_retract`, `memory_supersede` for memory maintenance',
+      ].join('\n'),
+      mimeType: 'text/markdown',
+    }],
+  })
+);
+
+// --- Auto-classification for memory types ---
 
 function classifyMemoryType(content: string): 'episodic' | 'semantic' | 'procedural' | 'unclassified' {
   const lower = content.toLowerCase();
@@ -378,6 +378,7 @@ Returns the most relevant memories ranked by text relevance, temporal recency, a
     use_reranker: z.boolean().optional().default(true).describe('Use cross-encoder re-ranking for better relevance (default true)'),
     use_expansion: z.boolean().optional().default(true).describe('Expand query with synonyms for better recall (default true)'),
     memory_type: z.enum(['episodic', 'semantic', 'procedural']).optional().describe('Filter by memory type (omit to search all types)'),
+    workspace: z.string().optional().describe('Search across all agents in this workspace (hive mode). Omit for agent-scoped recall only.'),
   },
   async (params) => {
     const queryText = params.query ?? params.context;
@@ -389,6 +390,8 @@ Returns the most relevant memories ranked by text relevance, temporal recency, a
         }],
       };
     }
+    // Use workspace from param, env var, or omit for agent-scoped
+    const workspace = params.workspace ?? process.env.AWM_WORKSPACE ?? undefined;
     const results = await activationEngine.activate({
       agentId: AGENT_ID,
       context: queryText,
@@ -398,6 +401,7 @@ Returns the most relevant memories ranked by text relevance, temporal recency, a
       useReranker: params.use_reranker,
       useExpansion: params.use_expansion,
       memoryType: params.memory_type,
+      workspace,
     });
 
     // Auto-checkpoint: track recall
@@ -456,10 +460,13 @@ Always call this after using a recalled memory so the system learns what's valua
       store.updateConfidence(engram.id, engram.confidence + delta);
     }
 
+    // Validation-gated Hebbian: resolve pending co-activation pairs for this engram
+    const hebbianUpdated = activationEngine.resolveHebbianFeedback(params.engram_id, params.useful);
+
     return {
       content: [{
         type: 'text' as const,
-        text: `Feedback: ${params.useful ? '+useful' : '-not useful'}`,
+        text: `Feedback: ${params.useful ? '+useful' : '-not useful'}${hebbianUpdated > 0 ? ` (${hebbianUpdated} association${hebbianUpdated > 1 ? 's' : ''} ${params.useful ? 'strengthened' : 'weakened'})` : ''}`,
       }],
     };
   }
@@ -673,6 +680,7 @@ Use this at the start of every session or after compaction to pick up where you
           minScore: 0.05,
           useReranker: true,
           useExpansion: true,
+          workspace: process.env.AWM_WORKSPACE ?? undefined,
         });
         recalledMemories = results.map(r => ({
           id: r.engram.id,
@@ -983,6 +991,7 @@ This ensures your state is saved before you start, and primes recall with releva
         minScore: 0.05,
         useReranker: true,
         useExpansion: true,
+        workspace: process.env.AWM_WORKSPACE ?? undefined,
       });
 
       if (results.length > 0) {

package/src/storage/sqlite.ts

@@ -329,6 +329,83 @@ export class EngramStore {
     return (this.db.prepare(query).all(...params) as any[]).map(r => this.rowToEngram(r));
   }
 
+  /**
+   * Get engrams across multiple agents (workspace-scoped recall).
+   * Used when workspace mode is enabled for hive memory sharing.
+   */
+  getEngramsByAgents(agentIds: string[], stage?: EngramStage, includeRetracted: boolean = false): Engram[] {
+    if (agentIds.length === 0) return [];
+    if (agentIds.length === 1) return this.getEngramsByAgent(agentIds[0], stage, includeRetracted);
+
+    const placeholders = agentIds.map(() => '?').join(',');
+    let query = `SELECT * FROM engrams WHERE agent_id IN (${placeholders})`;
+    const params: any[] = [...agentIds];
+
+    if (stage) {
+      query += ' AND stage = ?';
+      params.push(stage);
+    }
+    if (!includeRetracted) {
+      query += ' AND retracted = 0';
+    }
+
+    return (this.db.prepare(query).all(...params) as any[]).map(r => this.rowToEngram(r));
+  }
+
+  /**
+   * BM25 search across multiple agents (workspace-scoped).
+   */
+  searchBM25WithRankMultiAgent(agentIds: string[], query: string, limit: number = 10): { engram: Engram; bm25Score: number }[] {
+    if (agentIds.length === 0) return [];
+    if (agentIds.length === 1) return this.searchBM25WithRank(agentIds[0], query, limit);
+
+    const sanitized = query
+      .replace(/[^\w\s]/g, '')
+      .split(/\s+/)
+      .filter(w => w.length > 1)
+      .map(w => `"${w}"`)
+      .join(' OR ');
+
+    if (!sanitized) return [];
+
+    try {
+      const placeholders = agentIds.map(() => '?').join(',');
+      const rows = this.db.prepare(`
+        SELECT e.*, rank FROM engrams e
+        JOIN engrams_fts ON e.rowid = engrams_fts.rowid
+        WHERE engrams_fts MATCH ? AND e.agent_id IN (${placeholders}) AND e.retracted = 0
+        ORDER BY rank
+        LIMIT ?
+      `).all(sanitized, ...agentIds, limit) as any[];
+
+      return rows.map(r => ({
+        engram: this.rowToEngram(r),
+        bm25Score: Math.abs(r.rank ?? 0) / (1 + Math.abs(r.rank ?? 0)),
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Get all distinct agent IDs that share a workspace (requires coord_agents table).
+   * Returns just the queried agentId if coordination tables don't exist.
+   */
+  getWorkspaceAgentIds(agentId: string, workspace: string): string[] {
+    try {
+      const rows = this.db.prepare(
+        `SELECT DISTINCT id FROM coord_agents WHERE workspace = ? AND status != 'dead'`
+      ).all(workspace) as Array<{ id: string }>;
+      const ids = rows.map(r => r.id);
+      // Ensure the querying agent is always included
+      if (!ids.includes(agentId)) ids.push(agentId);
+      return ids;
+    } catch {
+      // No coordination tables — fall back to single agent
+      return [agentId];
+    }
+  }
+
   /**
    * Touch an engram: increment access count, update last_accessed, and
    * nudge confidence upward. Each retrieval is weak evidence the memory

package/src/types/engram.ts

@@ -186,6 +186,7 @@ export interface ActivationQuery {
   internal?: boolean;          // Skip access count increment, Hebbian update, and event logging (for system calls)
   memoryType?: MemoryType;     // Filter by memory type (episodic, semantic, procedural)
   mode?: QueryMode;            // Pipeline mode — 'auto' by default
+  workspace?: string;          // Search across all agents in this workspace (hive mode). If unset, agent-scoped only.
 }
 
 /**