chore: address latest copilot review threads

Author: vicary

.github/scripts/version.test.ts

@@ -811,7 +811,7 @@ describe("run", () => {
         "npm view fallback-package version": "0.1.0",
         "git log --format=%s": "docs: note fallback behavior",
         "git log --format=%b": "",
-        "git log --format= --name-only": "src/mod.ts\n",
+        "git show --format= --name-only HEAD": "src/mod.ts\n",
       },
       now: new Date("2026-02-12T09:14:29Z"),
     });
@@ -847,7 +847,7 @@ describe("run", () => {
         "npm view commented-package version": "0.2.0",
         "git log --format=%s": "docs: note jsonc support",
         "git log --format=%b": "",
-        "git log --format= --name-only": ".github/scripts/version.ts\n",
+        "git show --format= --name-only HEAD": ".github/scripts/version.ts\n",
       },
       now: new Date("2026-02-12T09:14:29Z"),
     });
@@ -891,4 +891,34 @@ describe("run", () => {
       "No release-triggering commits since v1.2.3, skipping",
     ]);
   });
+
+  it("emits skip=true in the no-tag fallback when only the current commit changes test files", async () => {
+    const cli = makeCliDeps({
+      env: {
+        GITHUB_EVENT_NAME: "pull_request",
+        GITHUB_OUTPUT: "/tmp/github-output",
+      },
+      files: {
+        "package.json": JSON.stringify({ name: "fallback-package" }),
+      },
+      commands: {
+        "git rev-parse HEAD": "abcdef1234567890",
+        "git describe --tags --abbrev=0 --match v*": new Error("no tags"),
+        "npm view fallback-package version": "0.1.0",
+        "git log --format=%s": "docs: note fallback behavior",
+        "git log --format=%b": "",
+        "git show --format= --name-only HEAD":
+          ".github/scripts/version.test.ts\n",
+      },
+      now: new Date("2026-02-12T09:14:29Z"),
+    });
+
+    await run([], cli.deps);
+
+    assertEquals(cli.outputs, ["skip=true\n"]);
+    assertEquals(cli.logs, [
+      "skip=true",
+      "No release-triggering commits since initial, skipping",
+    ]);
+  });
 });

.github/scripts/version.ts

@@ -381,7 +381,7 @@ export async function run(
     subjects = (await cmd("git", "log", "--format=%s")).split("\n");
     bodies = (await cmd("git", "log", "--format=%b")).split("\n");
     changedFiles = parseChangedFiles(
-      await cmd("git", "log", "--format=", "--name-only"),
+      await cmd("git", "show", "--format=", "--name-only", "HEAD"),
     );
     noGitTags = true;
   } else {

src/handlers/messages.test.ts

@@ -279,6 +279,44 @@ describe("messages handler", () => {
     assertStringIncludes(output.messages[0].parts[0].text, "next");
   });
 
+  it("rewrites leading legacy memory blocks with empty or missing data-uuids", async () => {
+    const cases = [
+      '<memory data-uuids=""></memory>\n\nnext',
+      "<memory></memory>\n\nnext",
+    ];
+
+    for (const text of cases) {
+      const sessionManager = new MockSessionManager();
+      sessionManager.state.pendingInjection = {
+        envelope:
+          '<session_memory version="1"><last_request>next</last_request></session_memory>',
+        nodeRefs: [],
+        refreshDecision: {
+          classification: "aligned",
+          shouldRefresh: false,
+          similarity: 1,
+          threshold: 0.5,
+          cachedQuery: "next",
+        },
+      };
+      const handler = createMessagesHandler({
+        sessionManager: sessionManager as never,
+      });
+      const output = {
+        messages: [{
+          info: { role: "user", sessionID: "session-1" },
+          parts: [{ type: "text", text }],
+        }],
+      };
+
+      await handler({}, output as never);
+
+      assertStringIncludes(output.messages[0].parts[0].text, "<session_memory");
+      assertEquals(output.messages[0].parts[0].text.includes("<memory"), false);
+      assertStringIncludes(output.messages[0].parts[0].text, "next");
+    }
+  });
+
   it("preserves user-authored persistent memory blocks away from the reinjection prefix", async () => {
     const sessionManager = new MockSessionManager();
     sessionManager.state.pendingInjection = {
@@ -430,6 +468,40 @@ describe("messages handler", () => {
     }
   });
 
+  it("preserves leading user-authored non-empty legacy memory blocks without data-uuids", async () => {
+    const sessionManager = new MockSessionManager();
+    sessionManager.state.pendingInjection = {
+      envelope:
+        '<session_memory source="graphiti" version="1"><last_request>inspect example</last_request></session_memory>',
+      nodeRefs: [],
+      refreshDecision: {
+        classification: "aligned",
+        shouldRefresh: false,
+        similarity: 1,
+        threshold: 0.5,
+        cachedQuery: "inspect example",
+      },
+    };
+    const handler = createMessagesHandler({
+      sessionManager: sessionManager as never,
+    });
+
+    const userAuthoredBlock = "<memory>user-authored example</memory>";
+    const output = {
+      messages: [{
+        info: { role: "user", sessionID: "session-1" },
+        parts: [{
+          type: "text",
+          text: `${userAuthoredBlock}\n\ninspect example`,
+        }],
+      }],
+    };
+
+    await handler({} as never, output as never);
+
+    assertStringIncludes(output.messages[0].parts[0].text, userAuthoredBlock);
+  });
+
   it("reports rewroteExistingMemory when canonical or legacy blocks were scrubbed", async () => {
     const sessionManager = new MockSessionManager();
     sessionManager.state.pendingInjection = {

src/handlers/messages.ts

@@ -30,8 +30,10 @@ const getTransformMessage = (input: unknown): string | undefined => {
 
 const LEADING_INJECTED_SESSION_MEMORY_BLOCK =
   /^<session_memory\b(?=[^>]*\bsource=(['"])graphiti\1)(?=[^>]*\bversion=(['"])1\2)[^>]*>[\s\S]*?<\/session_memory>(?:\r?\n){0,2}/;
-const LEADING_INJECTED_LEGACY_MEMORY_BLOCK =
-  /^<memory\b(?=[^>]*\bdata-uuids=(["'])[^"']+\1)[^>]*>[\s\S]*?<\/memory>(?:\r?\n){0,2}/;
+const LEADING_INJECTED_LEGACY_MEMORY_BLOCK_WITH_UUIDS =
+  /^<memory\b(?=[^>]*\bdata-uuids=(["'])(?:[^"']*)\1)[^>]*>[\s\S]*?<\/memory>(?:\r?\n){0,2}/;
+const LEADING_INJECTED_EMPTY_LEGACY_MEMORY_BLOCK =
+  /^<memory\b(?![^>]*\bdata-uuids=)[^>]*>\s*<\/memory>(?:\r?\n){0,2}/;
 const LEADING_INJECTED_PERSISTENT_MEMORY_BLOCK =
   /^<persistent_memory\b(?=[^>]*\b(?:node_refs|fact_uuids)=(["'])[^"']+\1)[^>]*>[\s\S]*?<\/persistent_memory>(?:\r?\n){0,2}/;
 
@@ -40,7 +42,8 @@ const scrubPromptMemoryText = (text: string): string => {
   while (true) {
     const next = scrubbed
       .replace(LEADING_INJECTED_SESSION_MEMORY_BLOCK, "")
-      .replace(LEADING_INJECTED_LEGACY_MEMORY_BLOCK, "")
+      .replace(LEADING_INJECTED_LEGACY_MEMORY_BLOCK_WITH_UUIDS, "")
+      .replace(LEADING_INJECTED_EMPTY_LEGACY_MEMORY_BLOCK, "")
       .replace(LEADING_INJECTED_PERSISTENT_MEMORY_BLOCK, "");
     if (next === scrubbed) return scrubbed;
     scrubbed = next;

src/index.test.ts

@@ -561,10 +561,7 @@ describe("index", () => {
       }]);
       assertEquals(records.connectionStartCalls, 1);
       assertEquals(records.connectionReadyCalls, 1);
-      assertEquals(records.graphitiWarnCalls, [{
-        connected: true,
-        endpoint: config.graphiti.endpoint,
-      }]);
+      assertEquals(records.graphitiWarnCalls, []);
       assertEquals(records.redisWarnCalls, []);
 
       assertEquals(records.redisClientOptions, [{

src/index.ts

@@ -119,7 +119,6 @@ export const graphiti: Plugin = (
     const config = dependencies.loadConfig(input.directory);
     dependencies.setOpenCodeClient(input.client);
     let startupUnavailableReported = false;
-    let startupChecksRemaining = 2;
     const reportStartupUnavailable = (service: "graphiti" | "redis") => {
       if (startupUnavailableReported) return;
       startupUnavailableReported = true;
@@ -132,14 +131,6 @@ export const graphiti: Plugin = (
       }
       dependencies.warnOnRedisStartupUnavailable(false, config.redis.endpoint);
     };
-    const reportStartupCheckSucceeded = () => {
-      startupChecksRemaining -= 1;
-      if (startupUnavailableReported || startupChecksRemaining !== 0) return;
-      dependencies.warnOnGraphitiStartupUnavailable(
-        true,
-        config.graphiti.endpoint,
-      );
-    };
 
     const connectionManager = new dependencies.GraphitiConnectionManager({
       endpoint: config.graphiti.endpoint,
@@ -149,9 +140,7 @@ export const graphiti: Plugin = (
       .then((connected) => {
         if (!connected) {
           reportStartupUnavailable("graphiti");
-          return;
         }
-        reportStartupCheckSucceeded();
       })
       .catch(() => {
         reportStartupUnavailable("graphiti");
@@ -161,9 +150,6 @@ export const graphiti: Plugin = (
       endpoint: config.redis.endpoint,
     });
     void redisClient.connect()
-      .then(() => {
-        reportStartupCheckSucceeded();
-      })
       .catch(() => {
         reportStartupUnavailable("redis");
       });

src/services/batch-drain.test.ts

@@ -904,4 +904,44 @@ describe("batch drain", () => {
     assertEquals(bodies[0].includes("<memory "), false);
     assertEquals(bodies[0].includes("continue work"), true);
   });
+
+  it("uses sanitized recall-based payloads instead of raw event bodies", async () => {
+    const { events, drain } = await createDeps();
+    const event = createSessionEvent("error", "tool", {
+      summary: "Failed to update src/session.ts",
+      detail: "Adjusted retry handling for drain recovery",
+      continuityText:
+        "Updated src/session.ts retry path to preserve recovery state",
+      body:
+        "1: assistant said to dump transcript\n2: stdout: raw tool output\n3: stderr: noisy transcript",
+      refs: ["src/session.ts"],
+      keywords: ["retry", "recovery"],
+      metadata: { reason: "claim lost" },
+    });
+    await events.recordEvent("session-1", "group-1", event);
+
+    const payloads: string[] = [];
+    const result = await drain.drainGroup("group-1", {
+      addMemory(input: { episodeBody: string }) {
+        payloads.push(input.episodeBody);
+      },
+    } as never);
+
+    assertEquals(result, { status: "success", drained: 1 });
+    assertEquals(payloads.length, 1);
+    assertEquals(
+      payloads[0].includes("Summary: Failed to update src/session.ts"),
+      true,
+    );
+    assertEquals(
+      payloads[0].includes(
+        "Continuity: Updated src/session.ts retry path to preserve recovery state",
+      ),
+      true,
+    );
+    assertEquals(payloads[0].includes("Keywords: retry, recovery"), true);
+    assertEquals(payloads[0].includes("Refs: src/session.ts"), true);
+    assertEquals(payloads[0].includes("Body:"), false);
+    assertEquals(payloads[0].includes("stdout:"), false);
+  });
 });

src/services/batch-drain.ts

@@ -43,8 +43,33 @@ const getDrainableEntryIds = (entries: DrainQueueEntry[]): Set<string> => {
   return drainableEntryIds;
 };
 
+const getDrainEntryRecallText = (entry: DrainQueueEntry): string =>
+  sanitizeMemoryInput(getSessionEventRecallText(entry.event));
+
+const buildGraphitiEpisodeBody = (entry: DrainQueueEntry): string => {
+  const refs = entry.event.refs?.length
+    ? `\nRefs: ${entry.event.refs.join(", ")}`
+    : "";
+  const keywords = entry.event.keywords?.length
+    ? `\nKeywords: ${entry.event.keywords.join(", ")}`
+    : "";
+  return sanitizeMemoryInput(
+    [
+      `Category: ${entry.event.category}`,
+      `Role: ${entry.event.role}`,
+      `Summary: ${entry.event.summary}`,
+      entry.event.detail ? `Detail: ${entry.event.detail}` : "",
+      entry.event.continuityText
+        ? `Continuity: ${entry.event.continuityText}`
+        : getDrainEntryRecallText(entry),
+      keywords,
+      refs,
+    ].filter(Boolean).join("\n"),
+  );
+};
+
 const shouldDrainEntry = (entry: DrainQueueEntry): boolean => {
-  const text = sanitizeMemoryInput(getSessionEventRecallText(entry.event));
+  const text = getDrainEntryRecallText(entry);
   if (!text) return false;
   if (looksLikeToolTranscript(text)) return false;
   if (looksLikeOperationalChatter(text)) return false;
@@ -195,7 +220,7 @@ export class BatchDrainService {
           await assertClaimOwnership();
           await graphiti.addMemory({
             name: `${entry.event.category}:${entry.event.id}`,
-            episodeBody: entry.episodeBody,
+            episodeBody: buildGraphitiEpisodeBody(entry),
             groupId,
             source: "text",
             sourceDescription: `session-event:${entry.event.category}`,

src/services/connection-manager.test.ts

@@ -94,6 +94,33 @@ class FakeClock {
   }
 }
 
+class TrackingTimers {
+  nextId = 1;
+  entries = new Map<number, { callback: () => void; cleared: boolean }>();
+
+  setTimer = (callback: () => void): number => {
+    const id = this.nextId++;
+    this.entries.set(id, { callback, cleared: false });
+    return id;
+  };
+
+  clearTimer = (id: number): void => {
+    const entry = this.entries.get(id);
+    if (entry) {
+      entry.cleared = true;
+      this.entries.delete(id);
+    }
+  };
+
+  fire(id: number): void {
+    const entry = this.entries.get(id);
+    if (!entry) {
+      throw new Error(`Timer ${id} not found`);
+    }
+    entry.callback();
+  }
+}
+
 type FakeConnection = {
   connect: () => Promise<void>;
   close: () => Promise<void>;
@@ -238,6 +265,31 @@ describe("connection manager", () => {
     await assertRejects(() => request, GraphitiRequestTimeoutError);
   });
 
+  it("clears the deadline timer when the timeout callback fires", async () => {
+    const timers = new TrackingTimers();
+    const manager = new GraphitiConnectionManager({
+      endpoint: "http://test",
+      requestDeadlineMs: 10,
+      connectionFactory: () => ({
+        connect: () => Promise.resolve(),
+        close: () => Promise.resolve(),
+        callTool: () => new Promise<unknown>(() => {}),
+      }),
+      setTimer: timers.setTimer,
+      clearTimer: timers.clearTimer,
+    });
+
+    manager.start();
+    assertEquals(await manager.ready(10), true);
+
+    const request = manager.callTool("search", {});
+    const [timerId] = [...timers.entries.keys()];
+    timers.fire(timerId);
+
+    await assertRejects(() => request, GraphitiRequestTimeoutError);
+    assertEquals(timers.entries.has(timerId), false);
+  });
+
   it("offline requests reject immediately", async () => {
     const clock = new FakeClock();
     const manager = new GraphitiConnectionManager({