pi-automem-bridge 0.2.3 → 0.2.4

package/README.md

@@ -34,7 +34,7 @@ Plenty of agents can store a memory. Far fewer reach for it when it counts — o
 
 Once installed, the bridge hooks into pi's session lifecycle:
 
-- **At session start** it runs your startup recall queries against AutoMem and injects the results — your preferences, working style, and environment — into the system prompt.
+- **At session start** it eagerly warms the AutoMem MCP connection, runs your startup recall queries, and injects the results — your preferences, working style, and environment — into the system prompt.
 - **Before each turn** it recalls memories relevant to the current task and the detected project, again injected silently.
 - **When the agent writes a memory** the candidate passes through the write pipeline — normalize → secret-scan → policy check → dedupe → confirm or auto-store — so nothing unvetted reaches AutoMem.
 - **Relationship tools** let the agent link memories or record corrections with provenance, building a connected graph over time.
@@ -78,7 +78,8 @@ Add an MCP server entry named `automem` to `~/.pi/agent/mcp.json`, pointing at t
       "url": "https://your-automem-server.example.com/mcp",
       "headers": {
         "Authorization": "Bearer ${AUTOMEM_TOKEN}"
-      }
+      },
+      "lifecycle": "keep-alive"
     }
   }
 }
@@ -86,6 +87,8 @@ Add an MCP server entry named `automem` to `~/.pi/agent/mcp.json`, pointing at t
 
 This is the one step that can't be automated: the package has no way to know your server's address or auth token, and writing credentials on your behalf would be unsafe. Use `${ENV_VAR}` interpolation for the token — never hardcode secrets. The entry must be named `automem` (the name the extension looks for by default), or set a different name via `mcpServerName` in step 4.
 
+`"lifecycle": "keep-alive"` is strongly recommended. pi-mcp-adapter defaults MCP servers to `"lazy"`, which means the AutoMem sidecar may not connect until a tool is called. Memory should be available from the first prompt, so `keep-alive` connects at startup and reconnects automatically if the connection drops. `eager` also connects at startup, but it does not auto-reconnect.
+
 **Don't want to hand-edit JSON?** pi is a coding agent — tell it to do it: *"add an `automem` MCP server to my `mcp.json` at `https://my-server.example.com/mcp`, using `${AUTOMEM_TOKEN}` for auth."* Keep the real token in your environment so it never touches the file or the chat.
 
 ### 3. Reload pi
@@ -205,6 +208,8 @@ Controls how much of the recalled context shows in chat. Injection into the syst
 
 Recall is best-effort context enrichment, so it runs on a short, bounded timeout instead of the full MCP request timeout — a slow or unreachable AutoMem server degrades gracefully to no injection rather than blocking your prompt. Tune with `turnRecall.timeoutMs` (default `8000`) and `startupRecall.timeoutMs` (default `15000`).
 
+pi-mcp-adapter supports `lazy`, `eager`, and `keep-alive` MCP lifecycles. Use `keep-alive` for AutoMem. The bridge also performs an eager health check at session start to warm the AutoMem connection; if that early check races startup and misses, later turns retry with a short timeout and run the missed startup recall after AutoMem recovers. `/automem-status` is still useful for manual diagnostics, but it is not required as a startup kick.
+
 ---
 
 ## Development

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-automem-bridge",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Automatic long-term memory recall and policy-gated writes for pi agents via AutoMem MCP",
   "keywords": [
     "pi-package",

package/src/commands/status.ts

@@ -3,7 +3,7 @@
  */
 
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { automemHealth, setAutoMemMcpServerName } from "../mcp-client";
+import { automemHealth, getAutoMemMcpLifecycle, setAutoMemMcpServerName } from "../mcp-client";
 import { loadConfig } from "../config";
 
 export function registerStatusCommand(pi: {
@@ -19,6 +19,15 @@ export function registerStatusCommand(pi: {
       setAutoMemMcpServerName(config.mcpServerName);
 
       ctx.ui.notify("Checking AutoMem...", "info");
+      try {
+        const lifecycle = getAutoMemMcpLifecycle();
+        ctx.ui.notify("MCP lifecycle: " + lifecycle, lifecycle === "lazy" ? "warning" : "info");
+        if (lifecycle === "lazy") {
+          ctx.ui.notify('Set lifecycle to "keep-alive" in ~/.pi/agent/mcp.json so AutoMem connects at startup and reconnects automatically.', "warning");
+        }
+      } catch (err) {
+        ctx.ui.notify("Could not inspect MCP lifecycle: " + err, "warning");
+      }
 
       const health = await automemHealth();
 

package/src/index.ts

@@ -9,7 +9,7 @@
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { loadConfig } from "./config";
-import { automemHealth, discoverTools, setAutoMemMcpServerName } from "./mcp-client";
+import { automemHealth, discoverTools, getAutoMemMcpLifecycle, setAutoMemMcpServerName } from "./mcp-client";
 import { startupRecall, turnRecall, type RecallResult } from "./recall";
 import { detectProject } from "./project-detect";
 import { buildContextMessage } from "./context-injector";
@@ -24,6 +24,7 @@ export default function (pi: ExtensionAPI) {
   let autoMemHealthy = false;
   let autoMemCount: number | undefined;
   let startupInjected = false;
+  let startupRecallAttempted = false;
   let startupResult: RecallResult = { text: "", count: 0, truncated: false };
 
   // Register commands and write tools
@@ -37,32 +38,11 @@ export default function (pi: ExtensionAPI) {
     config = loadConfig();
     setAutoMemMcpServerName(config.mcpServerName);
 
-    try {
-      await discoverTools();
-      const health = await automemHealth();
-      autoMemHealthy = health.healthy;
-      autoMemCount = health.memoryCount;
-
-      if (health.healthy) {
-        const count = health.memoryCount != null ? " (" + health.memoryCount + ")" : "";
-        ctx.ui.notify("AutoMem: healthy" + count, "info");
-      } else {
-        ctx.ui.notify("AutoMem: unhealthy - " + (health.error || "unreachable"), "warning");
-      }
-    } catch (err) {
-      autoMemHealthy = false;
-      ctx.ui.notify("AutoMem health check failed: " + err, "warning");
-    }
+    notifyIfLazyMcpLifecycle(ctx);
+    await refreshAutoMemHealth(ctx, false);
 
     if (config.startupRecall.enabled && autoMemHealthy) {
-      try {
-        startupResult = await startupRecall(config);
-        if (startupResult.count > 0 && config.startupRecall.showStatus) {
-          ctx.ui.notify("AutoMem: recalled " + startupResult.count + " memories at startup", "info");
-        }
-      } catch (err) {
-        ctx.ui.notify("AutoMem startup recall failed: " + err, "warning");
-      }
+      await runStartupRecall(ctx);
     }
 
     updateStatusWidget(ctx);
@@ -70,7 +50,17 @@ export default function (pi: ExtensionAPI) {
 
   // before_agent_start - Turn-level recall + context injection
   pi.on("before_agent_start", async function(event: any, ctx: any) {
-    if (!autoMemHealthy) return;
+    if (!autoMemHealthy) {
+      const recovered = await refreshAutoMemHealth(ctx, true);
+      if (!recovered) {
+        updateStatusWidget(ctx);
+        return;
+      }
+    }
+
+    if (config.startupRecall.enabled && !startupRecallAttempted) {
+      await runStartupRecall(ctx);
+    }
 
     const prompt = event.prompt || "";
     if (!prompt.trim()) return;
@@ -135,9 +125,70 @@ export default function (pi: ExtensionAPI) {
     autoMemHealthy = false;
     autoMemCount = undefined;
     startupInjected = false;
+    startupRecallAttempted = false;
     startupResult = { text: "", count: 0, truncated: false };
   });
 
+  async function refreshAutoMemHealth(ctx: any, recoveringFromOffline: boolean): Promise<boolean> {
+    try {
+      if (!recoveringFromOffline) {
+        await discoverTools();
+      }
+
+      const healthTimeout = recoveringFromOffline
+        ? Math.max(1000, Math.min(3000, Number(config.turnRecall.timeoutMs || 3000)))
+        : 30000;
+      const health = await automemHealth(healthTimeout);
+      autoMemHealthy = health.healthy;
+      autoMemCount = health.memoryCount;
+
+      if (health.healthy) {
+        const count = health.memoryCount != null ? " (" + health.memoryCount + ")" : "";
+        ctx.ui.notify(recoveringFromOffline ? "AutoMem: recovered" + count : "AutoMem: healthy" + count, "info");
+      } else if (!recoveringFromOffline) {
+        ctx.ui.notify("AutoMem: unhealthy - " + (health.error || "unreachable"), "warning");
+      }
+
+      return health.healthy;
+    } catch (err) {
+      autoMemHealthy = false;
+      if (!recoveringFromOffline) {
+        ctx.ui.notify("AutoMem health check failed: " + err, "warning");
+      } else {
+        console.warn("[automem] AutoMem still unavailable during turn health retry: " + err);
+      }
+      return false;
+    }
+  }
+
+  async function runStartupRecall(ctx: any): Promise<void> {
+    startupRecallAttempted = true;
+    try {
+      startupResult = await startupRecall(config);
+      startupRecallAttempted = startupResult.failed !== true;
+      if (startupResult.count > 0 && config.startupRecall.showStatus) {
+        ctx.ui.notify("AutoMem: recalled " + startupResult.count + " memories at startup", "info");
+      }
+    } catch (err) {
+      startupRecallAttempted = false;
+      ctx.ui.notify("AutoMem startup recall failed: " + err, "warning");
+    }
+  }
+
+  function notifyIfLazyMcpLifecycle(ctx: any): void {
+    try {
+      const lifecycle = getAutoMemMcpLifecycle();
+      if (lifecycle === "lazy") {
+        ctx.ui.notify(
+          'AutoMem MCP lifecycle is "lazy". For automatic memory on every session, set the automem server in ~/.pi/agent/mcp.json to "lifecycle": "keep-alive".',
+          "warning",
+        );
+      }
+    } catch (err) {
+      console.warn("[automem] could not inspect MCP lifecycle: " + err);
+    }
+  }
+
   function updateStatusWidget(ctx: any) {
     const theme = ctx.ui.theme;
     if (autoMemHealthy) {

package/src/mcp-client.ts

@@ -19,11 +19,13 @@ export interface McpCallResult {
   isError?: boolean;
 }
 
-export interface McpHealth {
-  healthy: boolean;
-  memoryCount?: number;
-  error?: string;
-}
+export interface McpHealth {
+  healthy: boolean;
+  memoryCount?: number;
+  error?: string;
+}
+
+export type McpLifecycle = "lazy" | "eager" | "keep-alive" | string;
 
 // ---------------------------------------------------------------------------
 // MCP config reader
@@ -34,7 +36,7 @@ export interface McpHealth {
 // cheap stat signature (mtime + size — the same quick-check make/rsync use), so
 // an in-place mcp.json edit is still picked up even within a single mtime tick.
 // An empty signature (stat failed) never matches, forcing a fresh read.
-interface CachedServerConfig { url: string; auth: string; signature: string }
+interface CachedServerConfig { url: string; auth: string; lifecycle: McpLifecycle; signature: string }
 let mcpConfigCache: Map<string, CachedServerConfig> = new Map();
 
 function loadMcpServerConfig(serverName: string): CachedServerConfig {
@@ -57,9 +59,9 @@ function loadMcpServerConfig(serverName: string): CachedServerConfig {
   // different tools, so drop the discovery cache too.
   if (cached) discoveredTools = null;
 
-  const mcpJson = JSON.parse(readFileSync(mcpJsonPath, "utf8")) as {
-    mcpServers?: Record<string, { url: string; headers?: Record<string, string> }>;
-  };
+  const mcpJson = JSON.parse(readFileSync(mcpJsonPath, "utf8")) as {
+    mcpServers?: Record<string, { url: string; headers?: Record<string, string>; lifecycle?: string }>;
+  };
 
   const server = mcpJson.mcpServers ? mcpJson.mcpServers[serverName] : undefined;
   if (!server) {
@@ -68,13 +70,14 @@ function loadMcpServerConfig(serverName: string): CachedServerConfig {
   }
 
   const entry: CachedServerConfig = {
-    url: server.url,
-    auth: resolveEnvVars(server.headers?.Authorization || ""),
-    signature,
-  };
-  mcpConfigCache.set(serverName, entry);
-  return entry;
-}
+    url: server.url,
+    auth: resolveEnvVars(server.headers?.Authorization || ""),
+    lifecycle: server.lifecycle || "lazy",
+    signature,
+  };
+  mcpConfigCache.set(serverName, entry);
+  return entry;
+}
 
 // ---------------------------------------------------------------------------
 // Response parsing — handles both JSON and text/event-stream (SSE)
@@ -114,9 +117,14 @@ export function setAutoMemMcpServerName(serverName: string | undefined): void {
   }
 }
 
-function getAutoMemMcpServerName(): string {
-  return process.env.AUTOMEM_MCP_SERVER || configuredServerName || "automem";
-}
+function getAutoMemMcpServerName(): string {
+  return process.env.AUTOMEM_MCP_SERVER || configuredServerName || "automem";
+}
+
+export function getAutoMemMcpLifecycle(): McpLifecycle {
+  const serverName = getAutoMemMcpServerName();
+  return loadMcpServerConfig(serverName).lifecycle;
+}
 
 async function mcpCall(
   tool: string,
@@ -310,9 +318,9 @@ export async function automemRecall(
   return mcpCall(resolveToolName("recall_memory"), args, timeoutMs);
 }
 
-export async function automemHealth(): Promise<McpHealth> {
-  try {
-    const result = await mcpCall(resolveToolName("check_database_health"), {});
+export async function automemHealth(timeoutMs: number = 30000): Promise<McpHealth> {
+  try {
+    const result = await mcpCall(resolveToolName("check_database_health"), {}, timeoutMs);
     const text = result.content && result.content[0] ? result.content[0].text : undefined;
     if (text) {
       try {

package/src/recall.ts

@@ -179,19 +179,21 @@ function formatMemoriesForContext(
 // Startup recall
 // ---------------------------------------------------------------------------
 
-export interface RecallResult {
-  text: string;
-  count: number;
-  truncated: boolean;
-}
+export interface RecallResult {
+  text: string;
+  count: number;
+  truncated: boolean;
+  failed?: boolean;
+}
 
 export async function startupRecall(config: AutoMemConfig): Promise<RecallResult> {
   if (!config.startupRecall.enabled) {
     return { text: "", count: 0, truncated: false };
   }
 
-  const allMemories: FormattedMemory[] = [];
-  const seenIds = new Set<string>();
+  const allMemories: FormattedMemory[] = [];
+  const seenIds = new Set<string>();
+  let failedQueries = 0;
 
   for (let q = 0; q < config.startupRecall.queries.length; q++) {
     const query = config.startupRecall.queries[q];
@@ -219,16 +221,17 @@ export async function startupRecall(config: AutoMemConfig): Promise<RecallResult
           }
         }
       }
-    } catch (err) {
-      console.warn('[automem] startup recall query failed: "' + query + '" - ' + err);
-    }
-  }
+    } catch (err) {
+      failedQueries++;
+      console.warn('[automem] startup recall query failed: "' + query + '" - ' + err);
+    }
+  }
 
   const maxBytes = config.startupRecall.maxBytes;
   const { text, included, overflowed } = formatMemoriesForContext(allMemories, maxBytes);
   const truncated = included < allMemories.length || overflowed;
 
-  return { text, count: allMemories.length, truncated };
+  return { text, count: allMemories.length, truncated, failed: failedQueries > 0 };
 }
 
 // ---------------------------------------------------------------------------
@@ -276,8 +279,8 @@ export async function turnRecall(
     const truncated = included < memories.length || overflowed;
 
     return { text: formatted, count: memories.length, truncated };
-  } catch (err) {
-    console.warn("[automem] turn recall failed: " + err);
-    return { text: "", count: 0, truncated: false };
-  }
-}
+  } catch (err) {
+    console.warn("[automem] turn recall failed: " + err);
+    return { text: "", count: 0, truncated: false, failed: true };
+  }
+}