Fix cache edge cases

Author: lan17

src/agent-control-plugin.ts

@@ -189,6 +189,9 @@ export default function register(api: OpenClawPluginApi) {
   const syncAgent = async (state: AgentState): Promise<void> => {
     if (state.syncPromise) {
       await state.syncPromise;
+      if (state.lastSyncedStepsHash !== state.stepsHash) {
+        await syncAgent(state);
+      }
       return;
     }
     if (state.lastSyncedStepsHash === state.stepsHash) {

src/session-store.ts

@@ -135,7 +135,8 @@ function resolveSessionAgentId(
   if (parts.length >= 2 && parts[0] === "agent" && parts[1]) {
     return parts[1];
   }
-  return asString(sourceAgentId);
+  const normalizedSourceAgentId = asString(sourceAgentId);
+  return normalizedSourceAgentId === "default" ? undefined : normalizedSourceAgentId;
 }
 
 function readSessionIdentityFromEntry(entry: Record<string, unknown>): SessionIdentitySnapshot {

test/agent-control-plugin.test.ts

@@ -482,6 +482,45 @@ describe("agent-control plugin logging and blocking", () => {
     expect(clientMocks.evaluationEvaluate).toHaveBeenCalledTimes(2);
   });
 
+  it("waits for catch-up sync before evaluating joined callers when steps change", async () => {
+    // Given one tool call changes the step catalog while a joined caller waits on an in-flight sync
+    const api = createMockApi({
+      serverUrl: "http://localhost:8000",
+    });
+    const syncDeferred = createDeferred<void>();
+    clientMocks.agentsInit
+      .mockImplementationOnce(() => syncDeferred.promise)
+      .mockResolvedValueOnce(undefined);
+    resolveStepsForContextMock
+      .mockResolvedValueOnce([{ type: "tool", name: "shell" }])
+      .mockResolvedValueOnce([
+        { type: "tool", name: "shell" },
+        { type: "tool", name: "grep" },
+      ]);
+
+    // When the joined caller updates steps before the original sync resolves
+    register(api.api);
+    const first = runBeforeToolCall(api);
+    await Promise.resolve();
+    await Promise.resolve();
+    const second = runBeforeToolCall(api, { toolName: "grep" });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(clientMocks.agentsInit).toHaveBeenCalledTimes(1);
+    expect(clientMocks.evaluationEvaluate).not.toHaveBeenCalled();
+
+    syncDeferred.resolve(undefined);
+    await Promise.all([first, second]);
+
+    // Then both callers wait until the catch-up sync completes before evaluating
+    expect(clientMocks.agentsInit).toHaveBeenCalledTimes(2);
+    expect(clientMocks.evaluationEvaluate).toHaveBeenCalledTimes(2);
+    expect(clientMocks.evaluationEvaluate.mock.invocationCallOrder[0]).toBeGreaterThan(
+      clientMocks.agentsInit.mock.invocationCallOrder[1] ?? 0,
+    );
+  });
+
   it("skips resyncing when the step catalog has not changed", async () => {
     // Given a source agent whose step catalog is unchanged across two tool calls
     const api = createMockApi({

test/session-store.test.ts

@@ -299,6 +299,51 @@ describe("resolveSessionIdentity", () => {
     expect(mocks.importOpenClawInternalModule).not.toHaveBeenCalled();
   });
 
+  it("uses the OpenClaw default store for legacy keys when source agent is synthetic default", async () => {
+    // Given the plugin fallback source agent ID is the synthetic default value
+    const { resolveSessionIdentity, mocks } = await loadSessionStoreModule({
+      throws: true,
+    });
+    const loadConfig = vi.fn(() => ({
+      session: {
+        store: "/tmp/{agentId}/sessions.json",
+      },
+    }));
+    const resolveStorePath = vi.fn(
+      (storePath?: string, opts?: { agentId?: string }) =>
+        (storePath ?? "").replace("{agentId}", opts?.agentId ?? "main"),
+    );
+    const loadSessionStore = vi.fn(() => ({
+      "legacy-session": {
+        origin: {
+          provider: "slack",
+          chatType: "direct",
+          label: "Alice",
+        },
+      },
+    }));
+    const api = createApi({ loadConfig, resolveStorePath, loadSessionStore });
+
+    // When identity is resolved for a non-agent-prefixed session key
+    const identity = await resolveSessionIdentity({
+      api,
+      sourceAgentId: "default",
+      sessionKey: "legacy-session",
+    });
+
+    // Then the OpenClaw runtime resolves its own default agent store
+    expect(identity).toMatchObject({
+      provider: "slack",
+      type: "direct",
+      label: "Alice",
+    });
+    expect(resolveStorePath).toHaveBeenCalledWith("/tmp/{agentId}/sessions.json", {
+      agentId: undefined,
+    });
+    expect(loadSessionStore).toHaveBeenCalledWith("/tmp/main/sessions.json");
+    expect(mocks.importOpenClawInternalModule).not.toHaveBeenCalled();
+  });
+
   it("uses injected runtime helpers before falling back to internal imports", async () => {
     // Given OpenClaw provides session-store helpers through the plugin runtime
     const { resolveSessionIdentity, mocks } = await loadSessionStoreModule({