chore: address copilot reviews

Author: vicary

README.md

@@ -186,13 +186,11 @@ values. Canonical nested values take precedence when both forms are supplied.
 
 ### Retained Compatibility
 
-The canonical hot-tier config shape is now `redis.*`. For backward
-compatibility, the loader still accepts legacy nested `falkordb.*` values. Only
-the original Graphiti top-level aliases remain supported. Precedence is:
+The canonical hot-tier config shape is `redis.*`. Only the original Graphiti
+top-level aliases remain supported for backward compatibility. Precedence is:
 
 1. `redis.*` (canonical)
-2. `falkordb.*` (legacy nested compatibility)
-3. top-level Graphiti aliases such as `endpoint` and `groupIdPrefix`
+2. top-level Graphiti aliases such as `endpoint` and `groupIdPrefix`
 
 ### Legacy Top-Level Keys
 
@@ -205,9 +203,7 @@ still accepted and map to their nested equivalents:
 | `groupIdPrefix`  | `graphiti.groupIdPrefix`  |
 | `driftThreshold` | `graphiti.driftThreshold` |
 
-Legacy nested `falkordb.*` keys remain accepted as compatibility aliases for the
-same `redis.*` settings. Removed top-level Redis aliases are no longer
-supported.
+Removed top-level Redis aliases are no longer supported.
 
 ## How It Works
 

src/config.test.ts

@@ -253,4 +253,22 @@ describe("config", () => {
     assertEquals(config.graphiti.endpoint, "http://localhost:8000/mcp");
     assertEquals(config.redis.endpoint, "redis://localhost:6379");
   });
+
+  it("fails open based on stable discovery error code instead of message text", () => {
+    setConfigExplorerAdapterForTesting(() => ({
+      search() {
+        throw new ConfigLoadError("different discovery wording", {
+          code: "config-discovery-search",
+        });
+      },
+      load() {
+        return null;
+      },
+    }));
+
+    const config = loadConfig();
+
+    assertEquals(config.graphiti.endpoint, "http://localhost:8000/mcp");
+    assertEquals(config.redis.endpoint, "redis://localhost:6379");
+  });
 });

src/config.ts

@@ -22,13 +22,24 @@ const DEFAULT_CONFIG = {
 
 type ConfigLoadResult = { config: unknown } | null;
 
+type ConfigLoadErrorCode =
+  | "config-discovery-init"
+  | "config-discovery-search"
+  | "config-file-load"
+  | "config-invalid";
+
 export class ConfigLoadError extends Error {
   override cause: unknown;
+  readonly code: ConfigLoadErrorCode;
 
-  constructor(message: string, options?: { cause?: unknown }) {
+  constructor(
+    message: string,
+    options: { cause?: unknown; code: ConfigLoadErrorCode },
+  ) {
     super(message);
     this.name = "ConfigLoadError";
     this.cause = options?.cause;
+    this.code = options.code;
   }
 }
 
@@ -117,6 +128,7 @@ const assertExplicitUrl = (
   if (isValidUrlString(value)) return;
   throw new ConfigLoadError(
     `Invalid Graphiti config value for ${fieldName}: expected a valid URL`,
+    { code: "config-invalid" },
   );
 };
 
@@ -226,7 +238,7 @@ const getConfigExplorerAdapter = (): ConfigExplorerAdapter => {
   } catch (err) {
     throw new ConfigLoadError(
       "Unable to initialize Graphiti config discovery",
-      { cause: err },
+      { cause: err, code: "config-discovery-init" },
     );
   }
 };
@@ -244,7 +256,7 @@ const loadConfigFile = (
     if (err instanceof ConfigLoadError) throw err;
     throw new ConfigLoadError(
       `Unable to load Graphiti config file: ${filePath}`,
-      { cause: err },
+      { cause: err, code: "config-file-load" },
     );
   }
 };
@@ -270,6 +282,7 @@ const searchConfig = (
     if (err instanceof ConfigLoadError) throw err;
     throw new ConfigLoadError("Unable to discover Graphiti config", {
       cause: err,
+      code: "config-discovery-search",
     });
   }
 };
@@ -287,10 +300,9 @@ const loadLegacyConfig = (
 };
 
 const isDiscoveryInfrastructureFailure = (error: unknown): boolean =>
-  error instanceof ConfigLoadError && (
-    error.message === "Unable to initialize Graphiti config discovery" ||
-    error.message === "Unable to discover Graphiti config"
-  );
+  error instanceof ConfigLoadError &&
+  (error.code === "config-discovery-init" ||
+    error.code === "config-discovery-search");
 
 export function loadConfig(directory?: string): GraphitiConfig {
   try {

src/handlers/event.test.ts

@@ -1118,7 +1118,7 @@ describe("event handler", () => {
     );
   });
 
-  it("does not cache the default context-limit after a transient provider failure", async () => {
+  it("caches the fallback 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);
@@ -1179,8 +1179,8 @@ describe("event handler", () => {
     });
     await flushPromises();
 
-    assertEquals(providerCalls, 2);
-    assertEquals(state.contextLimit, 123_456);
+    assertEquals(providerCalls, 1);
+    assertEquals(state.contextLimit, 200_000);
   });
 
   it("caches unknown provider/model misses to avoid repeated lookups", async () => {
@@ -1933,6 +1933,11 @@ describe("event handler", () => {
     assertEquals(redisEvents.calls.length, 1);
     assertEquals(redisEvents.calls[0].sessionId, "session-1");
     assertEquals(redisEvents.calls[0].category, "file.read");
+    assertEquals(
+      sessionManager.activeMarks.includes("child-session"),
+      true,
+    );
+    assertEquals(sessionManager.activeMarks.includes("session-1"), true);
   });
 
   it("routes child assistant buffering and completion through the canonical parent session", async () => {

src/handlers/event.ts

@@ -400,6 +400,7 @@ export function createEventHandler(deps: EventHandlerDeps): EventHook {
     const { state, resolved, canonicalSessionId } = await sessionManager
       .resolveSessionState(sessionId);
     if (!resolved || !state?.isMain || !canonicalSessionId) return;
+    sessionManager.markResolvedSessionActive(sessionId, canonicalSessionId);
 
     for (
       const structured of extractStructuredEvents({

src/services/batch-drain.test.ts

@@ -465,6 +465,42 @@ describe("batch drain", () => {
 
     const second = await drain.drainGroup("group-1", failingGraphiti as never);
     assertEquals(second.status, "dead-letter");
+    assertEquals(second.drained, 0);
+    assertEquals(await redis.getListLength(drainPendingKey("group-1")), 0);
+    assertEquals(await redis.getListLength(drainDeadKey("group-1")), 1);
+  });
+
+  it("reports only successfully ingested events when a batch dead-letters mid-batch", async () => {
+    const { redis, events, drain } = await createDeps({
+      drain: { batchSize: 2 },
+    });
+    const first = createSessionEvent("message", "user", {
+      summary: "first",
+      body: "first",
+    });
+    const second = createSessionEvent("message", "user", {
+      summary: "second",
+      body: "second",
+    });
+    await events.recordEvent("session-1", "group-1", first);
+    await events.recordEvent("session-1", "group-1", second);
+    await redis.setString(
+      drainRetryKey("group-1", `${first.id}:${second.id}`),
+      JSON.stringify({ attempts: 1, nextAttemptAt: 0 }),
+      60,
+    );
+
+    let calls = 0;
+    const result = await drain.drainGroup("group-1", {
+      addMemory() {
+        calls += 1;
+        if (calls === 2) {
+          throw new Error("boom");
+        }
+      },
+    } as never);
+
+    assertEquals(result, { status: "dead-letter", drained: 1 });
     assertEquals(await redis.getListLength(drainPendingKey("group-1")), 0);
     assertEquals(await redis.getListLength(drainDeadKey("group-1")), 1);
   });

src/services/batch-drain.ts

@@ -243,6 +243,10 @@ export class BatchDrainService {
 
       if (attempts >= this.options.drainRetryMax) {
         const remainingEntries = batch.slice(checkpointedCount);
+        let drainedCount = 0;
+        for (const entry of batch.slice(0, checkpointedCount)) {
+          if (drainableEntryIds.has(entry.event.id)) drainedCount += 1;
+        }
         logger.warn("Moving drain batch to dead-letter", {
           groupId,
           eventIds: remainingEntries.map((entry) => entry.event.id),
@@ -254,7 +258,7 @@ export class BatchDrainService {
           batch,
         );
         await this.redis.deleteKey(drainRetryKey(groupId, batchKey));
-        return { status: "dead-letter", drained: remainingEntries.length };
+        return { status: "dead-letter", drained: drainedCount };
       }
 
       await this.events.releaseClaim(groupId, claimed.claimToken);

src/services/context-limit.test.ts

@@ -0,0 +1,82 @@
+import { assertEquals } from "jsr:@std/assert@^1.0.0";
+import { resolveContextLimit } from "./context-limit.ts";
+
+Deno.test("resolveContextLimit caches fallback defaults after provider lookup failure", async () => {
+  const cache = new Map<string, number>();
+  let calls = 0;
+  const client = {
+    provider: {
+      list: () => {
+        calls += 1;
+        return Promise.reject(new Error("provider unavailable"));
+      },
+    },
+  };
+
+  assertEquals(
+    await resolveContextLimit(
+      "openai",
+      "gpt-5",
+      client as never,
+      undefined,
+      cache,
+    ),
+    200_000,
+  );
+  assertEquals(
+    await resolveContextLimit(
+      "openai",
+      "gpt-5",
+      client as never,
+      undefined,
+      cache,
+    ),
+    200_000,
+  );
+
+  assertEquals(calls, 1);
+});
+
+Deno.test("resolveContextLimit keeps fallback caches scoped per normalized directory", async () => {
+  const cache = new Map<string, number>();
+  const calls: string[] = [];
+  const client = {
+    provider: {
+      list: ({ query }: { query?: { directory?: string } }) => {
+        calls.push(query?.directory ?? "");
+        return Promise.reject(new Error("provider unavailable"));
+      },
+    },
+  };
+
+  assertEquals(
+    await resolveContextLimit(
+      "openai",
+      "gpt-5",
+      client as never,
+      "/tmp/project-a",
+      cache,
+    ),
+    200_000,
+  );
+  assertEquals(
+    await resolveContextLimit(
+      "openai",
+      "gpt-5",
+      client as never,
+      "/tmp/project-a",
+      cache,
+    ),
+    200_000,
+  );
+  assertEquals(
+    await resolveContextLimit("openai", "gpt-5", client as never, "   ", cache),
+    200_000,
+  );
+  assertEquals(
+    await resolveContextLimit("openai", "gpt-5", client as never, "", cache),
+    200_000,
+  );
+
+  assertEquals(calls, ["/tmp/project-a", ""]);
+});

src/services/context-limit.ts

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