fix(bench-server): translate CALENDAR umbrella -> lifeops.calendar.* (P0-5)

Adds umbrella-unwrap in lifeops-bench-handler.applyAction so eliza's
emitted CALENDAR(subaction=create_event, ...) routes to the granular
calendar handler instead of silently no-op'ing. Mirrors what the
Python runner does at the _u_calendar layer.

Per docs/audits/lifeops-2026-05-11/SYNTHESIS-IMPLEMENTATION-PLAN.md P0-5.
Unblocks eliza state mutations on calendar write scenarios.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: lalalune

packages/app-core/src/benchmark/__tests__/lifeops-bench-handler.test.ts

@@ -11,7 +11,10 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { Readable } from "node:stream";
 import { describe, expect, it } from "vitest";
-import { LifeOpsBenchHandler } from "../lifeops-bench-handler.js";
+import {
+  LifeOpsBenchHandler,
+  translateUmbrellaAction,
+} from "../lifeops-bench-handler.js";
 import { LifeOpsFakeBackend } from "../lifeops-fake-backend.js";
 
 // --------------------------------------------------------------------------
@@ -689,3 +692,182 @@ describe("LifeOpsBenchHandler", () => {
     expect(parsed.tool_calls[0].error).toMatch(/unsupported/);
   });
 });
+
+// --------------------------------------------------------------------------
+// P0-5: CALENDAR umbrella → calendar.<subaction> translation.
+// --------------------------------------------------------------------------
+
+describe("translateUmbrellaAction (P0-5)", () => {
+  it("maps CALENDAR(subaction=create_event) to calendar.create_event and strips subaction", () => {
+    const translated = translateUmbrellaAction("CALENDAR", {
+      subaction: "create_event",
+      calendar_id: "cal_primary",
+      title: "deep work",
+      start: "2026-05-11T14:00:00Z",
+      end: "2026-05-11T14:30:00Z",
+    });
+    expect(translated.name).toBe("calendar.create_event");
+    expect(translated.kwargs).toEqual({
+      calendar_id: "cal_primary",
+      title: "deep work",
+      start: "2026-05-11T14:00:00Z",
+      end: "2026-05-11T14:30:00Z",
+    });
+  });
+
+  it("maps CALENDAR(subaction=delete_event) to calendar.cancel_event and strips subaction", () => {
+    const translated = translateUmbrellaAction("CALENDAR", {
+      subaction: "delete_event",
+      id: "ev1",
+    });
+    expect(translated.name).toBe("calendar.cancel_event");
+    expect(translated.kwargs).toEqual({ id: "ev1" });
+  });
+
+  it("passes CALENDAR without subaction through unchanged", () => {
+    const kwargs = { query: "meeting" };
+    const translated = translateUmbrellaAction("CALENDAR", kwargs);
+    expect(translated.name).toBe("CALENDAR");
+    expect(translated.kwargs).toBe(kwargs);
+  });
+
+  it("passes non-CALENDAR umbrellas through unchanged", () => {
+    const kwargs = { subaction: "send", text: "hi" };
+    const translated = translateUmbrellaAction("MESSAGE", kwargs);
+    expect(translated.name).toBe("MESSAGE");
+    expect(translated.kwargs).toBe(kwargs);
+  });
+});
+
+describe("LifeOpsBenchHandler CALENDAR umbrella unwrap (P0-5)", () => {
+  async function runUmbrellaScenario(args: {
+    taskId: string;
+    toolName: string;
+    toolArguments: Record<string, unknown>;
+  }): Promise<{ worldHashBefore: string; worldHashAfter: string }> {
+    const path = writeFixture();
+    const handler = new LifeOpsBenchHandler({
+      invokePlanner: async () => ({
+        text: "ok",
+        toolCalls: [
+          {
+            id: "c1",
+            name: args.toolName,
+            arguments: args.toolArguments,
+          },
+        ],
+      }),
+    });
+
+    // reset
+    {
+      const req = fakeReq("POST", {
+        task_id: args.taskId,
+        world_snapshot_path: path,
+        now_iso: "2026-05-10T12:00:00Z",
+      });
+      const res = fakeRes();
+      await handler.tryHandle(req, res, "/api/benchmark/lifeops_bench/reset");
+      expect(res.getStatus()).toBe(200);
+    }
+
+    // pre-state
+    const session = handler.getSession(args.taskId);
+    if (!session) throw new Error("session missing after reset");
+    const worldHashBefore = session.backend.stateHash();
+
+    // message
+    {
+      const req = fakeReq("POST", { task_id: args.taskId, text: "go" });
+      const res = fakeRes();
+      await handler.tryHandle(req, res, "/api/benchmark/lifeops_bench/message");
+      expect(res.getStatus()).toBe(200);
+      const parsed = JSON.parse(res.getBody());
+      expect(parsed.tool_calls[0]).toMatchObject({
+        name: args.toolName,
+        ok: true,
+      });
+    }
+
+    const worldHashAfter = session.backend.stateHash();
+    return { worldHashBefore, worldHashAfter };
+  }
+
+  it("CALENDAR(subaction=create_event, …) produces the same state mutation as calendar.create_event", async () => {
+    const kwargs = {
+      calendar_id: "cal_primary",
+      title: "deep work",
+      start: "2026-05-11T14:00:00Z",
+      end: "2026-05-11T14:30:00Z",
+    };
+
+    const umbrella = await runUmbrellaScenario({
+      taskId: "umbrella-create",
+      toolName: "CALENDAR",
+      toolArguments: { subaction: "create_event", ...kwargs },
+    });
+    const granular = await runUmbrellaScenario({
+      taskId: "granular-create",
+      toolName: "calendar.create_event",
+      toolArguments: kwargs,
+    });
+
+    expect(umbrella.worldHashBefore).toEqual(granular.worldHashBefore);
+    expect(umbrella.worldHashAfter).toEqual(granular.worldHashAfter);
+    expect(umbrella.worldHashAfter).not.toEqual(umbrella.worldHashBefore);
+  });
+
+  it("CALENDAR(subaction=delete_event, …) produces the same state mutation as calendar.cancel_event", async () => {
+    const kwargs = { id: "ev1" };
+
+    const umbrella = await runUmbrellaScenario({
+      taskId: "umbrella-delete",
+      toolName: "CALENDAR",
+      toolArguments: { subaction: "delete_event", ...kwargs },
+    });
+    const granular = await runUmbrellaScenario({
+      taskId: "granular-delete",
+      toolName: "calendar.cancel_event",
+      toolArguments: kwargs,
+    });
+
+    expect(umbrella.worldHashBefore).toEqual(granular.worldHashBefore);
+    expect(umbrella.worldHashAfter).toEqual(granular.worldHashAfter);
+    expect(umbrella.worldHashAfter).not.toEqual(umbrella.worldHashBefore);
+  });
+
+  it("CALENDAR without subaction does not crash and is reported as a tool_call", async () => {
+    const path = writeFixture();
+    const handler = new LifeOpsBenchHandler({
+      invokePlanner: async () => ({
+        text: "ok",
+        toolCalls: [
+          {
+            id: "c1",
+            name: "CALENDAR",
+            arguments: { query: "meeting" },
+          },
+        ],
+      }),
+    });
+
+    {
+      const req = fakeReq("POST", {
+        task_id: "umbrella-bare",
+        world_snapshot_path: path,
+        now_iso: "2026-05-10T12:00:00Z",
+      });
+      const res = fakeRes();
+      await handler.tryHandle(req, res, "/api/benchmark/lifeops_bench/reset");
+      expect(res.getStatus()).toBe(200);
+    }
+
+    const req = fakeReq("POST", { task_id: "umbrella-bare", text: "go" });
+    const res = fakeRes();
+    await handler.tryHandle(req, res, "/api/benchmark/lifeops_bench/message");
+    expect(res.getStatus()).toBe(200);
+    const parsed = JSON.parse(res.getBody());
+    expect(parsed.tool_calls).toHaveLength(1);
+    expect(parsed.tool_calls[0].name).toBe("CALENDAR");
+  });
+});

packages/app-core/src/benchmark/lifeops-bench-handler.ts

@@ -115,6 +115,51 @@ export interface LifeOpsBenchHandlerOptions {
 const DEFAULT_MAX_BODY_BYTES = 16 * 1024 * 1024;
 const ROUTE_PREFIX = "/api/benchmark/lifeops_bench";
 
+/**
+ * Maps `CALENDAR(subaction=X)` to the granular dotted method the fake backend
+ * exposes directly. Eliza's planner emits umbrella actions
+ * (`CALENDAR(subaction=create_event, …)`) while
+ * `LifeOpsFakeBackend.applyAction` keys off dotted names
+ * (`calendar.create_event`). Without this translation the calendar umbrella
+ * lands on the backend's umbrella router only by coincidence of name and
+ * silently no-ops on subactions the umbrella router does not implement, which
+ * is the root cause of the calendar state-mutation gap (synthesis plan P0-5).
+ *
+ * Entries here must point at routes that exist in
+ * `LifeOpsFakeBackend.SUPPORTED_METHODS`.
+ */
+const CALENDAR_SUBACTION_TO_GRANULAR: Record<string, string> = {
+  create_event: "calendar.create_event",
+  update_event: "calendar.move_event",
+  move_event: "calendar.move_event",
+  delete_event: "calendar.cancel_event",
+  cancel_event: "calendar.cancel_event",
+  list_events: "calendar.list_events",
+  search_events: "calendar.list_events",
+};
+
+/**
+ * Unwraps an umbrella tool call (currently CALENDAR) into the dotted granular
+ * form the fake backend dispatches directly, stripping `subaction` from the
+ * forwarded kwargs. When no mapping applies the original `{ name, kwargs }`
+ * is returned unchanged so the backend's umbrella router (or its
+ * `LifeOpsBackendUnsupportedError`) still owns the response.
+ */
+export function translateUmbrellaAction(
+  name: string,
+  kwargs: Record<string, unknown>,
+): { name: string; kwargs: Record<string, unknown> } {
+  if (name !== "CALENDAR") return { name, kwargs };
+  const subaction = kwargs.subaction;
+  if (typeof subaction !== "string" || subaction.length === 0) {
+    return { name, kwargs };
+  }
+  const granular = CALENDAR_SUBACTION_TO_GRANULAR[subaction];
+  if (!granular) return { name, kwargs };
+  const { subaction: _stripped, ...rest } = kwargs;
+  return { name: granular, kwargs: rest };
+}
+
 export class LifeOpsBenchHandler {
   private readonly sessions = new Map<string, LifeOpsBenchSession>();
   private readonly invokePlanner: LifeOpsPlannerInvocation;
@@ -287,10 +332,11 @@ export class LifeOpsBenchHandler {
     const executed: ToolCallRecord[] = [];
     for (const call of plannerResult.toolCalls) {
       const id = call.id ?? `call_${executed.length}`;
+      const translated = translateUmbrellaAction(call.name, call.arguments);
       try {
         const result: ActionResult = session.backend.applyAction(
-          call.name,
-          call.arguments,
+          translated.name,
+          translated.kwargs,
         );
         executed.push({
           id,