agent-working-memory 0.7.3 → 0.7.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-working-memory",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "Cognitive memory layer for AI agents — activation-based retrieval, salience filtering, associative connections",
   "type": "module",
   "main": "dist/index.js",

package/src/api/routes.ts

@@ -705,7 +705,7 @@ export function registerRoutes(app: FastifyInstance, deps: MemoryDeps): void {
     const base: Record<string, unknown> = {
       status: 'ok',
       timestamp: new Date().toISOString(),
-      version: '0.7.2',
+      version: '0.7.4',
       coordination: coordEnabled,
     };
     if (coordEnabled) {

package/src/cli.ts

@@ -334,7 +334,7 @@ async function exportMemories() {
   const agents = [...new Set(memories.map((m: any) => m.agent_id))];
 
   const exportData = {
-    version: '0.7.2',
+    version: '0.7.4',
     exported_at: new Date().toISOString(),
     source_db: dbPath,
     agent_filter: agentFilter,

package/src/coordination/index.ts

@@ -11,7 +11,7 @@ import type { EngramStore } from '../storage/sqlite.js';
 import { ZodError } from 'zod';
 import { initCoordinationTables } from './schema.js';
 import { registerCoordinationRoutes } from './routes.js';
-import { cleanSlate, pruneOldHeartbeats, purgeDeadAgents } from './stale.js';
+import { cleanSlate, pruneOldHeartbeats, purgeDeadAgents, cleanupStale } from './stale.js';
 import { createWriteMutex, needsWriteLock } from './write-mutex.js';
 import { createEventBus, type CoordinationEventBus } from './events.js';
 import { loadPlugins, teardownPlugins } from './plugin-loader.js';
@@ -106,6 +106,25 @@ export function initCoordination(app: FastifyInstance, db: Database.Database, st
     }, 60 * 60 * 1000),
   );
 
+  // Periodic stale-agent cleanup every 5 min with 600s threshold (10 min idle).
+  // Forgiving for long-running edits — workers should pulse every 60s during active
+  // work, so 10 min without a pulse is genuinely dead. This catches the
+  // "alive but not seeing each other" pattern where workers' processes persist
+  // but their heartbeats stop. Without this scheduled, only an explicit
+  // POST /stale/cleanup call (made by the coordinator agent on startup) ever
+  // fires cleanupStale, leaving zombie agents accumulating between coordinator
+  // sessions.
+  cleanupIntervals.push(
+    setInterval(() => {
+      try {
+        const result = cleanupStale(db, 600);
+        if (result.cleaned > 0) {
+          console.log(`  [stale-cleanup] auto-cleaned ${result.stale.length} stale agent(s), ${result.cleaned} resource(s) released`);
+        }
+      } catch { /* db may be closed */ }
+    }, 5 * 60 * 1000),
+  );
+
   // Periodic channel liveness probe every 60s — mark unreachable sessions as disconnected
   cleanupIntervals.push(
     setInterval(async () => {

package/src/coordination/routes.ts

@@ -33,6 +33,45 @@ function coordLog(msg: string): void {
   console.log(`${ts()} [coord] ${msg}`);
 }
 
+/**
+ * In-process counters for channel push telemetry.
+ * Reset on coordinator restart — intended for short-window observability
+ * ("ship it, watch numbers for a day"). Persistent counters would need a
+ * coord_metrics table; deferred until we know what's worth keeping.
+ *
+ * Fields:
+ *   attempts            — every call to deliverToChannel (HTTP push to worker)
+ *   delivered           — fetch returned 2xx
+ *   failed_http         — fetch returned non-2xx (worker reachable but rejected)
+ *   failed_unreachable  — fetch threw (timeout, ECONNREFUSED, etc.)
+ *   no_session          — push intent existed but no connected session
+ *   fallback_mailbox    — push failed, message queued to mailbox instead
+ *   session_disconnects — session marked 'disconnected' after delivery failure
+ */
+interface ChannelMetrics {
+  attempts: number;
+  delivered: number;
+  failed_http: number;
+  failed_unreachable: number;
+  no_session: number;
+  fallback_mailbox: number;
+  session_disconnects: number;
+  started_at: number;
+}
+
+function createChannelMetrics(): ChannelMetrics {
+  return {
+    attempts: 0,
+    delivered: 0,
+    failed_http: 0,
+    failed_unreachable: 0,
+    no_session: 0,
+    fallback_mailbox: 0,
+    session_disconnects: 0,
+    started_at: Date.now(),
+  };
+}
+
 /**
  * Optional session-token check.
  * If X-Session-Token header is present and doesn't match the stored token → returns false (caller should 403).
@@ -47,6 +86,9 @@ function sessionTokenOk(db: Database.Database, agentId: string, req: import('fas
 }
 
 export function registerCoordinationRoutes(app: FastifyInstance, db: Database.Database, store?: EngramStore, eventBus?: import('./events.js').CoordinationEventBus): void {
+  // Channel push telemetry — process-scoped counters. See ChannelMetrics docs above.
+  const channelMetrics = createChannelMetrics();
+
 
   // Request logging — one line per request with method, url, status, response time
   app.addHook('onRequest', async (request) => {
@@ -132,9 +174,14 @@ export function registerCoordinationRoutes(app: FastifyInstance, db: Database.Da
       const sessionToken = wasDead ? randomUUID() : (
         (db.prepare(`SELECT session_token FROM coord_agents WHERE id = ?`).get(existing.id) as { session_token: string | null }).session_token ?? randomUUID()
       );
+      // role IS updated on every checkin — agents know their own role and
+      // re-registrations may correct stale role values (e.g., when an old
+      // coord_agents row was inserted with role='orchestrator' before the
+      // 'coordinator' role was canonical, or when the channel-server's
+      // hardcoded role='worker' overwrote a real role).
       db.prepare(
-        `UPDATE coord_agents SET last_seen = datetime('now'), status = CASE WHEN status = 'dead' THEN 'idle' ELSE status END, pid = COALESCE(?, pid), capabilities = COALESCE(?, capabilities), workspace = COALESCE(?, workspace), session_token = ? WHERE id = ?`
-      ).run(pid ?? null, capsJson, workspace ?? null, sessionToken, existing.id);
+        `UPDATE coord_agents SET last_seen = datetime('now'), status = CASE WHEN status = 'dead' THEN 'idle' ELSE status END, role = ?, pid = COALESCE(?, pid), capabilities = COALESCE(?, capabilities), workspace = COALESCE(?, workspace), session_token = ? WHERE id = ?`
+      ).run(role, pid ?? null, capsJson, workspace ?? null, sessionToken, existing.id);
 
       const eventType = wasDead ? 'reconnected' : 'heartbeat';
       const detail = wasDead ? `${name} reconnected (was dead)` : `heartbeat from ${name}`;
@@ -544,6 +591,9 @@ export function registerCoordinationRoutes(app: FastifyInstance, db: Database.Da
             `UPDATE coord_channel_sessions SET last_push_at = datetime('now'), push_count = push_count + 1 WHERE agent_id = ?`
           ).run(agentId);
         }
+      } else {
+        // Session disappeared between intent record and delivery — race or rapid disconnect
+        channelMetrics.no_session++;
       }
     }
 
@@ -1359,28 +1409,41 @@ export function registerCoordinationRoutes(app: FastifyInstance, db: Database.Da
     const q = workersQuerySchema.safeParse(req.query);
     const { capability, status: filterStatus, workspace } = q.success ? q.data : { capability: undefined, status: undefined, workspace: undefined };
 
+    // Join with coord_channel_sessions so the coordinator agent can compute
+    // alive=true for workers that have a connected channel session even when
+    // their /pulse is stale. Without this, /workers under-reports liveness
+    // during long tool-call sequences where the worker is processing but
+    // hasn't called /pulse for >5min — leading to false-positive duplicate
+    // spawns. Channel sessions get probed every 60s (coordination/index.ts:111),
+    // so a stale channel-server.js gets status='disconnected' within 60-120s.
     let workers = workspace
       ? db.prepare(
-          `SELECT id, name, role, status, current_task, capabilities, workspace, last_seen,
-                  ROUND((julianday('now') - julianday(last_seen)) * 86400) AS seconds_since_seen
-           FROM coord_agents
-           WHERE status != 'dead' AND role NOT IN ('orchestrator', 'coordinator') AND workspace = ?
-           ORDER BY name LIMIT 200`
+          `SELECT a.id, a.name, a.role, a.status, a.current_task, a.capabilities, a.workspace, a.last_seen,
+                  ROUND((julianday('now') - julianday(a.last_seen)) * 86400) AS seconds_since_seen,
+                  cs.status AS channel_status, cs.last_push_at AS channel_last_push
+           FROM coord_agents a
+           LEFT JOIN coord_channel_sessions cs ON cs.agent_id = a.id
+           WHERE a.status != 'dead' AND a.role NOT IN ('orchestrator', 'coordinator') AND a.workspace = ?
+           ORDER BY a.name LIMIT 200`
         ).all(workspace) as Array<{
           id: string; name: string; role: string; status: string;
           current_task: string | null; capabilities: string | null;
           workspace: string | null; last_seen: string; seconds_since_seen: number;
+          channel_status: string | null; channel_last_push: string | null;
         }>
       : db.prepare(
-          `SELECT id, name, role, status, current_task, capabilities, workspace, last_seen,
-                  ROUND((julianday('now') - julianday(last_seen)) * 86400) AS seconds_since_seen
-           FROM coord_agents
-           WHERE status != 'dead' AND role NOT IN ('orchestrator', 'coordinator')
-           ORDER BY name LIMIT 200`
+          `SELECT a.id, a.name, a.role, a.status, a.current_task, a.capabilities, a.workspace, a.last_seen,
+                  ROUND((julianday('now') - julianday(a.last_seen)) * 86400) AS seconds_since_seen,
+                  cs.status AS channel_status, cs.last_push_at AS channel_last_push
+           FROM coord_agents a
+           LEFT JOIN coord_channel_sessions cs ON cs.agent_id = a.id
+           WHERE a.status != 'dead' AND a.role NOT IN ('orchestrator', 'coordinator')
+           ORDER BY a.name LIMIT 200`
         ).all() as Array<{
           id: string; name: string; role: string; status: string;
           current_task: string | null; capabilities: string | null;
           workspace: string | null; last_seen: string; seconds_since_seen: number;
+          channel_status: string | null; channel_last_push: string | null;
         }>;
 
     if (capability) {
@@ -1409,7 +1472,14 @@ export function registerCoordinationRoutes(app: FastifyInstance, db: Database.Da
       workspace: w.workspace,
       lastSeen: w.last_seen,
       secondsSinceSeen: w.seconds_since_seen,
-      alive: w.seconds_since_seen < 300,
+      // alive = recent /pulse OR connected channel session.
+      // Channel sessions get probed every 60s and marked 'disconnected'
+      // when unreachable, so a connected session is reliable proof of life
+      // even during long tool sequences where the worker hasn't pulsed.
+      // Prevents duplicate worker spawns when /pulse is stale but worker is busy.
+      alive: w.seconds_since_seen < 300 || w.channel_status === 'connected',
+      channelStatus: w.channel_status,
+      channelLastPush: w.channel_last_push,
     }));
 
     return reply.send({
@@ -1691,6 +1761,32 @@ export function registerCoordinationRoutes(app: FastifyInstance, db: Database.Da
     lines.push('# TYPE coord_uptime_seconds gauge');
     lines.push(`coord_uptime_seconds ${uptime}`);
 
+    // ─── Channel push telemetry (process-scoped, reset on restart) ───
+    lines.push('# HELP coord_channel_push_attempts_total Total channel push attempts since coordinator startup');
+    lines.push('# TYPE coord_channel_push_attempts_total counter');
+    lines.push(`coord_channel_push_attempts_total ${channelMetrics.attempts}`);
+
+    lines.push('# HELP coord_channel_push_delivered_total Successful channel deliveries');
+    lines.push('# TYPE coord_channel_push_delivered_total counter');
+    lines.push(`coord_channel_push_delivered_total ${channelMetrics.delivered}`);
+
+    lines.push('# HELP coord_channel_push_failed_total Failed channel deliveries by reason');
+    lines.push('# TYPE coord_channel_push_failed_total counter');
+    lines.push(`coord_channel_push_failed_total{reason="http"} ${channelMetrics.failed_http}`);
+    lines.push(`coord_channel_push_failed_total{reason="unreachable"} ${channelMetrics.failed_unreachable}`);
+
+    lines.push('# HELP coord_channel_no_session_total Push attempts where agent had no connected session');
+    lines.push('# TYPE coord_channel_no_session_total counter');
+    lines.push(`coord_channel_no_session_total ${channelMetrics.no_session}`);
+
+    lines.push('# HELP coord_channel_fallback_mailbox_total Pushes that fell back to mailbox after delivery failure');
+    lines.push('# TYPE coord_channel_fallback_mailbox_total counter');
+    lines.push(`coord_channel_fallback_mailbox_total ${channelMetrics.fallback_mailbox}`);
+
+    lines.push('# HELP coord_channel_session_disconnects_total Sessions marked disconnected after delivery failure');
+    lines.push('# TYPE coord_channel_session_disconnects_total counter');
+    lines.push(`coord_channel_session_disconnects_total ${channelMetrics.session_disconnects}`);
+
     return reply.type('text/plain; version=0.0.4; charset=utf-8').send(lines.join('\n') + '\n');
   });
 
@@ -1800,6 +1896,7 @@ export function registerCoordinationRoutes(app: FastifyInstance, db: Database.Da
   async function deliverToChannel(
     agentId: string, channelUrl: string, content: string, meta?: Record<string, string>
   ): Promise<{ delivered: boolean; error?: string }> {
+    channelMetrics.attempts++;
     try {
       const res = await fetch(`${channelUrl}/push`, {
         method: 'POST',
@@ -1808,11 +1905,15 @@ export function registerCoordinationRoutes(app: FastifyInstance, db: Database.Da
         signal: AbortSignal.timeout(5000),
       });
       if (!res.ok) {
+        channelMetrics.failed_http++;
         return { delivered: false, error: `channel returned ${res.status}` };
       }
+      channelMetrics.delivered++;
       return { delivered: true };
     } catch (err) {
       // Connection refused / timeout → worker process is dead, mark session disconnected
+      channelMetrics.failed_unreachable++;
+      channelMetrics.session_disconnects++;
       db.prepare(
         `UPDATE coord_channel_sessions SET status = 'disconnected' WHERE agent_id = ?`
       ).run(agentId);
@@ -1822,11 +1923,40 @@ export function registerCoordinationRoutes(app: FastifyInstance, db: Database.Da
     }
   }
 
-  /** POST /channel/push — Push a message to an agent. Tries live delivery first, falls back to mailbox queue. */
+  /** POST /channel/push — Push a message to an agent. Tries live delivery first, falls back to mailbox queue.
+   *
+   * Two addressing modes:
+   *   - {agentId, message}                — direct UUID
+   *   - {role, workspace, message}        — server resolves to most-recently-seen alive agent
+   *                                          matching role+workspace. Used by workers to notify
+   *                                          coordinator (whose UUID changes across restarts).
+   */
   app.post('/channel/push', async (request, reply) => {
     const parsed = channelPushSchema.safeParse(request.body);
     if (!parsed.success) return reply.status(400).send({ error: parsed.error.flatten() });
-    const { agentId, message } = parsed.data;
+    const { message } = parsed.data;
+    let { agentId } = parsed.data;
+
+    // Role-based addressing — resolve to a concrete agentId
+    if (!agentId && parsed.data.role && parsed.data.workspace) {
+      const resolved = db.prepare(
+        `SELECT id FROM coord_agents
+         WHERE role = ? AND workspace = ? AND status != 'dead'
+         ORDER BY last_seen DESC
+         LIMIT 1`
+      ).get(parsed.data.role, parsed.data.workspace) as { id: string } | undefined;
+      if (!resolved) {
+        return reply.status(404).send({
+          error: `No alive agent found for role='${parsed.data.role}' workspace='${parsed.data.workspace}'`,
+        });
+      }
+      agentId = resolved.id;
+    }
+
+    // Type narrowing — Zod refine guarantees agentId is set by this point,
+    // but TypeScript can't see through the refine. This guard is unreachable
+    // in practice (would have 400'd earlier).
+    if (!agentId) return reply.status(400).send({ error: 'Internal: agentId resolution failed' });
 
     const agent = db.prepare(`SELECT name, workspace FROM coord_agents WHERE id = ?`).get(agentId) as { name: string; workspace: string | null } | undefined;
     if (!agent) return reply.status(404).send({ error: 'Agent not found' });
@@ -1853,6 +1983,10 @@ export function registerCoordinationRoutes(app: FastifyInstance, db: Database.Da
         return reply.send({ ok: true, delivered: true, channelId: session.channel_id });
       }
       // Live delivery failed — fall through to mailbox
+      channelMetrics.fallback_mailbox++;
+    } else {
+      // No connected session — push went straight to mailbox
+      channelMetrics.no_session++;
     }
 
     // Queue to mailbox (delivered on next /next poll)
@@ -1914,4 +2048,48 @@ export function registerCoordinationRoutes(app: FastifyInstance, db: Database.Da
 
     return reply.send({ probed: results.length, alive, dead, results });
   });
+
+  /**
+   * GET /telemetry/channels — Channel push delivery telemetry.
+   *
+   * Counters reset on coordinator restart (in-process). Use this to answer:
+   *   "Are channels reliable enough to depend on, or do we need a polling fallback?"
+   *
+   * Response shape:
+   *   {
+   *     since: ISO timestamp of when counters started,
+   *     uptime_seconds: number,
+   *     attempts, delivered, failed_http, failed_unreachable,
+   *     no_session, fallback_mailbox, session_disconnects: number,
+   *     delivery_rate: 0..1 (delivered / attempts) or null if zero attempts,
+   *     per_agent: [{ agent_name, push_count, last_push_at, status }]
+   *   }
+   */
+  app.get('/telemetry/channels', async (_request, reply) => {
+    const perAgent = db.prepare(`
+      SELECT a.name AS agent_name, cs.push_count, cs.last_push_at, cs.status,
+             cs.connected_at
+      FROM coord_channel_sessions cs
+      JOIN coord_agents a ON a.id = cs.agent_id
+      ORDER BY cs.push_count DESC, cs.connected_at DESC
+    `).all();
+
+    const deliveryRate = channelMetrics.attempts > 0
+      ? channelMetrics.delivered / channelMetrics.attempts
+      : null;
+
+    return reply.send({
+      since: new Date(channelMetrics.started_at).toISOString(),
+      uptime_seconds: Math.round((Date.now() - channelMetrics.started_at) / 1000),
+      attempts: channelMetrics.attempts,
+      delivered: channelMetrics.delivered,
+      failed_http: channelMetrics.failed_http,
+      failed_unreachable: channelMetrics.failed_unreachable,
+      no_session: channelMetrics.no_session,
+      fallback_mailbox: channelMetrics.fallback_mailbox,
+      session_disconnects: channelMetrics.session_disconnects,
+      delivery_rate: deliveryRate,
+      per_agent: perAgent,
+    });
+  });
 }

package/src/coordination/schemas.ts

@@ -210,10 +210,25 @@ export const channelDeregisterSchema = z.object({
   agentId: z.string().uuid(),
 });
 
+/**
+ * Push to an agent's channel session. Accepts either:
+ *   - agentId (direct addressing — caller knows the UUID)
+ *   - role + workspace (role-based addressing — server resolves to the most
+ *     recently-seen alive agent matching that role and workspace)
+ *
+ * Role-based addressing is the right choice when a worker wants to notify the
+ * coordinator: workers don't know the coordinator's UUID (it changes across
+ * coordinator restarts) but they do know the role and their own workspace.
+ */
 export const channelPushSchema = z.object({
-  agentId: z.string().uuid(),
+  agentId: z.string().uuid().optional(),
+  role: agentRoleEnum.optional(),
+  workspace: z.string().min(1).max(50).optional(),
   message: z.string().min(1).max(10000),
-});
+}).refine(
+  (d) => d.agentId !== undefined || (d.role !== undefined && d.workspace !== undefined),
+  { message: 'Must provide either agentId, or both role and workspace' }
+);
 
 // ─── Stats ─────────────────────────────────────────────────────
 

package/src/core/salience.ts

@@ -13,7 +13,33 @@
 import type { SalienceFeatures, MemoryClass } from '../types/index.js';
 import type { EngramStore } from '../storage/sqlite.js';
 
-export type SalienceEventType = 'decision' | 'friction' | 'surprise' | 'causal' | 'observation';
+export type SalienceEventType = 'decision' | 'friction' | 'surprise' | 'causal' | 'observation' | 'user_feedback';
+
+/**
+ * Auto-detect user-feedback memories: content that begins with a known user's
+ * name + a feedback verb. These memories represent direct human decisions and
+ * must never be discarded. Examples:
+ *   "Robert verbatim: 'LMS programs-first like CRM'"
+ *   "Katherine said the CEC cycle resets on promotion"
+ *   "Nancy directed Tier 1 has no grace period"
+ *
+ * Why this exists: the BM25 novelty check collapses near-duplicates regardless
+ * of whether the content is a NEW decision or a repeat observation. User
+ * feedback often shares terminology with prior memories ("LMS", "ECP",
+ * "officials") and gets discarded at salience 0.14 (verified in activity log
+ * 2026-05-06T19:08:47). Detecting "Robert said X" → canonical class bypasses
+ * the salience filter entirely.
+ *
+ * Tune the name list as new staff join. Pattern requires word boundary at
+ * start so "Roberta" or "Hannahs" don't match.
+ */
+const USER_FEEDBACK_PATTERN = /^(Robert|Katherine|Catherine|Nancy|Brandy|Brandi|Hannah|Marilyn|Kaylee|Pete|Abby|Tom|Wendy|Sita|Nick|Rob|Joan|Jennifer|Cindy|Jason|Alex|Molly)\s+(said|verbatim|feedback|asked|wants|prefers|requested|requested|directed|decided|confirmed|clarified|chose|specified|explained)\b/i;
+
+/** Returns true if the content looks like direct user feedback that should auto-promote to canonical. */
+export function detectUserFeedback(content: string): boolean {
+  if (typeof content !== 'string' || content.length === 0) return false;
+  return USER_FEEDBACK_PATTERN.test(content.trim());
+}
 
 export interface SalienceInput {
   content: string;
@@ -56,15 +82,28 @@ export function evaluateSalience(
   activeThreshold: number = 0.4,
   stagingThreshold: number = 0.2
 ): SalienceResult {
+  // Auto-detect user feedback before scoring. If content matches the pattern,
+  // force eventType='user_feedback' and memoryClass='canonical'. This bypasses
+  // the BM25 novelty floor that was discarding pivotal user decisions at 0.14.
+  let resolvedEventType: SalienceEventType = input.eventType ?? 'observation';
+  let resolvedMemoryClass: MemoryClass = input.memoryClass ?? 'working';
+  let autoPromoted = false;
+  if (detectUserFeedback(input.content)) {
+    resolvedEventType = 'user_feedback';
+    resolvedMemoryClass = 'canonical';
+    autoPromoted = true;
+  }
+
   const features: SalienceFeatures = {
     surprise: input.surprise ?? 0,
     decisionMade: input.decisionMade ?? false,
     causalDepth: input.causalDepth ?? 0,
     resolutionEffort: input.resolutionEffort ?? 0,
-    eventType: input.eventType ?? 'observation',
+    eventType: resolvedEventType,
   };
 
   const reasonCodes: string[] = [];
+  if (autoPromoted) reasonCodes.push('auto:user_feedback');
 
   // Novelty: 1.0 = completely new info, 0 = exact duplicate exists
   // Default to 0.8 (assume mostly novel) when caller doesn't check
@@ -91,13 +130,14 @@ export function evaluateSalience(
     case 'friction': typeBonus = 0.2; reasonCodes.push('event:friction'); break;
     case 'surprise': typeBonus = 0.25; reasonCodes.push('event:surprise'); break;
     case 'causal': typeBonus = 0.2; reasonCodes.push('event:causal'); break;
+    case 'user_feedback': typeBonus = 0.3; reasonCodes.push('event:user_feedback'); break;
     case 'observation': break;
   }
 
   let score = Math.min(surpriseScore + decisionScore + causalScore + effortScore + noveltyScore + typeBonus, 1.0);
 
   // Memory class overrides
-  const memoryClass = input.memoryClass ?? 'working';
+  const memoryClass = resolvedMemoryClass;
 
   if (memoryClass === 'canonical') {
     // Canonical memories: salience floor of 0.7, never go to staging

package/src/index.ts

@@ -177,7 +177,7 @@ async function main() {
 
   // Start server
   await app.listen({ port: PORT, host: '0.0.0.0' });
-  console.log(`AgentWorkingMemory v0.7.2 listening on port ${PORT}`);
+  console.log(`AgentWorkingMemory v0.7.4 listening on port ${PORT}`);
 
   // Graceful shutdown
   const shutdown = async () => {

package/src/mcp.ts

@@ -78,7 +78,7 @@ const INCOGNITO = process.env.AWM_INCOGNITO === '1' || process.env.AWM_INCOGNITO
 
 if (INCOGNITO) {
   console.error('AWM: incognito mode — all memory tools disabled, nothing will be recorded');
-  const server = new McpServer({ name: 'agent-working-memory', version: '0.7.2' });
+  const server = new McpServer({ name: 'agent-working-memory', version: '0.7.4' });
   const transport = new StdioServerTransport();
   server.connect(transport).catch(err => {
     console.error('MCP server failed:', err);
@@ -115,7 +115,7 @@ let coordDb: import('better-sqlite3').Database | null = null;
 
 const server = new McpServer({
   name: 'agent-working-memory',
-  version: '0.7.2',
+  version: '0.7.4',
 });
 
 server.registerResource(