fix: address review follow-up edge cases

Author: vicary

src/handlers/event.test.ts

@@ -785,7 +785,7 @@ describe("event handler", () => {
     );
   });
 
-  it("retries context-limit lookup after a transient provider failure", async () => {
+  it("caches the default context-limit after a transient provider failure", async () => {
     const sessionManager = new MockSessionManager();
     const state = sessionManager.createDefaultState("group-1", "user-1");
     sessionManager.setState("session-1", state);
@@ -846,8 +846,8 @@ describe("event handler", () => {
     });
     await flushPromises();
 
-    assertEquals(providerCalls, 2);
-    assertEquals(state.contextLimit, 123_456);
+    assertEquals(providerCalls, 1);
+    assertEquals(state.contextLimit, 200_000);
   });
 
   it("records supported non-special events into the hot-tier log for main sessions", async () => {

src/services/connection-manager.test.ts

@@ -419,6 +419,32 @@ describe("connection manager", () => {
     assertEquals(startError.state, "stopped");
   });
 
+  it("preserves the closing state when start is called during shutdown", async () => {
+    const closeGate = deferred<void>();
+    const manager = new GraphitiConnectionManager({
+      endpoint: "http://test",
+      connectionFactory: () => ({
+        connect: () => Promise.resolve(),
+        close: () => closeGate.promise,
+        callTool: () => Promise.resolve({ ok: true }),
+      }),
+    });
+
+    manager.start();
+    assertEquals(await manager.ready(10), true);
+
+    const stopPromise = manager.stop();
+    const startError = assertThrows(
+      () => manager.start(),
+      GraphitiOfflineError,
+    );
+
+    assertEquals(startError.state, "closing");
+
+    closeGate.resolve();
+    await stopPromise;
+  });
+
   it("surfaces typed errors after failed retry", async () => {
     let connectionIndex = 0;
     const manager = new GraphitiConnectionManager({

src/services/connection-manager.ts

@@ -250,8 +250,10 @@ export class GraphitiConnectionManager implements GraphitiToolCaller {
   start(): void {
     if (this.state === "closing" || this.state === "stopped") {
       throw new GraphitiOfflineError(
-        "stopped",
-        "Graphiti connection manager has been stopped and cannot be restarted",
+        this.state,
+        this.state === "closing"
+          ? "Graphiti connection manager is closing"
+          : "Graphiti connection manager has been stopped and cannot be restarted",
       );
     }
     if (this.started) return;

src/services/context-limit.ts

@@ -33,6 +33,8 @@ export async function resolveContextLimit(
     }
   } catch (err) {
     logger.warn("Failed to fetch provider context limit", err);
+    cache.set(modelKey, DEFAULT_CONTEXT_LIMIT);
+    return DEFAULT_CONTEXT_LIMIT;
   }
 
   return DEFAULT_CONTEXT_LIMIT;

src/services/graphiti-mcp.test.ts

@@ -37,4 +37,24 @@ describe("GraphitiMcpClient", () => {
 
     assertEquals(error.state, "stopped");
   });
+
+  it("marks unexpected search node failures as degraded", async () => {
+    const client = new GraphitiMcpClient({
+      start() {},
+      stop() {
+        return Promise.resolve();
+      },
+      ready() {
+        return Promise.resolve(true);
+      },
+      callTool() {
+        return Promise.reject(new Error("boom"));
+      },
+    });
+
+    assertEquals(await client.searchNodesWithStatus({ query: "test" }), {
+      nodes: [],
+      degraded: true,
+    });
+  });
 });

src/services/graphiti-mcp.ts

@@ -221,7 +221,7 @@ export class GraphitiMcpClient {
         return { nodes: [], degraded: true };
       }
       logger.error("searchNodes error", err);
-      return { nodes: [], degraded: false };
+      return { nodes: [], degraded: true };
     }
   }
 

src/services/logger.test.ts

@@ -170,6 +170,28 @@ describe("logger", () => {
       });
     });
 
+    it("falls back to console.warn when structured warn scheduling throws", async () => {
+      setSuppressConsoleWarningsDuringTestsOverride(false);
+      setWarningTaskScheduler(() => {
+        throw new Error("schedule failed");
+      });
+      setOpenCodeClient({
+        app: {
+          log: () => Promise.resolve(),
+        },
+      });
+
+      const { logger } = await import("./logger.ts");
+      logger.warn("warning", { code: 42 });
+
+      assertEquals(consoleWarnSpy.calls.length, 1);
+      assertEquals(consoleWarnSpy.calls[0].args, [
+        "[graphiti]",
+        "warning",
+        { code: 42 },
+      ]);
+    });
+
     it("should forward multiple arguments to error", async () => {
       const { logger } = await import("./logger.ts");
       const error = new Error("test");

src/services/logger.ts

@@ -88,7 +88,11 @@ export const logger = {
   warn: (...args: unknown[]) => {
     if (silentOverride) return;
     const payload = toWarningPayload(args);
-    if (logStructuredWarning(payload.message, payload.extra)) return;
+    try {
+      if (logStructuredWarning(payload.message, payload.extra)) return;
+    } catch {
+      // Fall back to console below when structured warning scheduling fails.
+    }
     if (shouldSuppressConsoleWarningsDuringTests()) return;
     console.warn(PREFIX, ...args);
   },

src/services/redis-cache.test.ts

@@ -2,6 +2,7 @@ import { assertEquals } from "jsr:@std/assert@^1.0.0";
 import { describe, it } from "jsr:@std/testing@^1.0.0/bdd";
 import { RedisCacheService } from "./redis-cache.ts";
 import { RedisClient } from "./redis-client.ts";
+import { memoryCacheMetaKey } from "./redis-events.ts";
 
 describe("redis cache", () => {
   it("stores cache entries per group without leaking across groups", async () => {
@@ -144,4 +145,22 @@ describe("redis cache", () => {
       lastRefresh: (await cache.get("group-1"))?.refreshedAt,
     });
   });
+
+  it("preserves a string lastRefresh value of 0 in metadata", async () => {
+    const redis = new RedisClient({ endpoint: "redis://unused" });
+    const cache = new RedisCacheService(redis, {
+      ttlSeconds: 300,
+      driftThreshold: 0.5,
+    });
+
+    await redis.setHashFields(memoryCacheMetaKey("group-1"), {
+      lastQuery: "query",
+      lastRefresh: "0",
+    }, 300);
+
+    assertEquals(await cache.getMeta("group-1"), {
+      lastQuery: "query",
+      lastRefresh: 0,
+    });
+  });
 });

src/services/redis-cache.ts

@@ -98,10 +98,13 @@ export class RedisCacheService {
     const raw = await this.redis.getHashAll(memoryCacheMetaKey(groupId));
     if (Object.keys(raw).length === 0) return null;
 
+    const hasLastRefresh = Object.hasOwn(raw, "lastRefresh");
+    const parsedLastRefresh = hasLastRefresh ? Number(raw.lastRefresh) : NaN;
+
     return {
       lastQuery: raw.lastQuery?.trim() || undefined,
-      lastRefresh: raw.lastRefresh && Number.isFinite(Number(raw.lastRefresh))
-        ? Number(raw.lastRefresh)
+      lastRefresh: Number.isFinite(parsedLastRefresh)
+        ? parsedLastRefresh
         : undefined,
     };
   }