claude-code-swarm 0.3.12 → 0.3.17

package/scripts/map-sidecar.mjs

@@ -24,6 +24,8 @@ import { SOCKET_PATH, PID_PATH, INBOX_SOCKET_PATH, sessionPaths, pluginDir } fro
 import { connectToMAP } from "../src/map-connection.mjs";
 import { createMeshPeer, createMeshInbox } from "../src/mesh-connection.mjs";
 import { createSocketServer, createCommandHandler } from "../src/sidecar-server.mjs";
+import { createContentProvider } from "../src/content-provider.mjs";
+import { startMemoryWatcher } from "../src/memory-watcher.mjs";
 import { readConfig } from "../src/config.mjs";
 import { createLogger, init as initLog } from "../src/log.mjs";
 import { configureNodePath, resolvePackage } from "../src/swarmkit-resolver.mjs";
@@ -50,6 +52,38 @@ const RECONNECT_INTERVAL_MS = parseInt(getArg("reconnect-interval", ""), 10) ||
 // Auth credential for server-driven auth negotiation (opaque — type determined by server)
 const AUTH_CREDENTIAL = getArg("credential", "");
 
+// Project context for swarm identification (sent as agent metadata)
+import { execSync } from "child_process";
+function getProjectContext() {
+  const context = {};
+  try { context.project = path.basename(process.cwd()); } catch {}
+  try {
+    context.branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {}
+  try {
+    const config = readConfig();
+    if (config.template) context.template = config.template;
+
+    // Include task_graph metadata when opentasks is enabled
+    if (config.opentasks?.enabled) {
+      try {
+        const opentasksDir = path.resolve(".opentasks");
+        const configPath = path.join(opentasksDir, "config.json");
+        const taskGraph = { path: opentasksDir };
+        if (fs.existsSync(configPath)) {
+          const otConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+          if (otConfig.location?.hash) taskGraph.location_hash = otConfig.location.hash;
+        }
+        context.task_graph = taskGraph;
+      } catch { /* opentasks config not available */ }
+    }
+  } catch {}
+  return context;
+}
+const PROJECT_CONTEXT = getProjectContext();
+
 // Configure NODE_PATH so dynamic imports of globally-installed packages
 // (@multi-agent-protocol/sdk, agent-inbox, agentic-mesh) resolve correctly.
 // Must happen before any dynamic import() calls.
@@ -186,6 +220,7 @@ function startSlowReconnectLoop() {
         scope: MAP_SCOPE,
         systemId: SYSTEM_ID,
         credential: AUTH_CREDENTIAL || undefined,
+        projectContext: PROJECT_CONTEXT,
         onMessage: () => resetInactivityTimer(),
       });
 
@@ -300,15 +335,77 @@ async function tryMeshTransport() {
   return true;
 }
 
+/**
+ * Register opentasks notification handlers on a MAP connection.
+ * Delegates to the extracted opentasks-connector module for testability.
+ */
+async function registerOpenTasksHandler(conn) {
+  const { registerOpenTasksHandler: _register } = await import("../src/opentasks-connector.mjs");
+  return _register(conn, {
+    scope: MAP_SCOPE,
+    onActivity: resetInactivityTimer,
+  });
+}
+
 /**
  * Start with direct MAP SDK WebSocket transport (fallback).
  */
+/**
+ * Register the trajectory/content.request notification handler on a connection.
+ * When the hub sends a content request, the sidecar reads the transcript
+ * from sessionlog and responds with a trajectory/content.response notification.
+ */
+function registerContentHandler(conn) {
+  if (!conn || typeof conn.onNotification !== "function") return;
+
+  const contentProvider = createContentProvider();
+
+  conn.onNotification("trajectory/content.request", async (params) => {
+    const requestId = params?.request_id;
+    const checkpointId = params?.checkpoint_id;
+    if (!requestId) return;
+
+    log.info("content request received", { requestId, checkpointId });
+    resetInactivityTimer();
+
+    try {
+      const content = checkpointId ? await contentProvider(checkpointId) : null;
+
+      if (content) {
+        conn.sendNotification("trajectory/content.response", {
+          request_id: requestId,
+          transcript: content.transcript,
+          metadata: content.metadata,
+          prompts: content.prompts,
+          context: content.context,
+        });
+        log.info("content response sent", { requestId, size: content.transcript.length });
+      } else {
+        conn.sendNotification("trajectory/content.response", {
+          request_id: requestId,
+          error: "Content not found",
+        });
+        log.warn("content not found", { requestId, checkpointId });
+      }
+    } catch (err) {
+      log.error("content provider error", { requestId, error: err.message });
+      try {
+        conn.sendNotification("trajectory/content.response", {
+          request_id: requestId,
+          error: err.message,
+        });
+      } catch { /* ignore */ }
+    }
+  });
+}
+
 async function startWebSocketTransport() {
   connection = await connectToMAP({
     server: MAP_SERVER,
     scope: MAP_SCOPE,
     systemId: SYSTEM_ID,
     credential: AUTH_CREDENTIAL || undefined,
+    projectContext: PROJECT_CONTEXT,
     onMessage: () => {
       resetInactivityTimer();
     },
@@ -316,6 +413,16 @@ async function startWebSocketTransport() {
 
   transportMode = "websocket";
 
+  // Register trajectory content handler for on-demand transcript serving
+  if (connection) {
+    registerContentHandler(connection);
+  }
+
+  // Register opentasks connector for remote graph queries (only when opentasks is enabled)
+  if (connection && PROJECT_CONTEXT.task_graph) {
+    await registerOpenTasksHandler(connection);
+  }
+
   // Start agent-inbox with MAP connection (legacy mode)
   if (INBOX_CONFIG && connection) {
     inboxInstance = await startLegacyAgentInbox(connection);
@@ -411,6 +518,31 @@ async function main() {
     return commandHandler(command, client);
   });
 
+  // Start memory file watcher if minimem is enabled
+  const sidecarConfig = readConfig();
+  if (sidecarConfig.minimem?.enabled) {
+    const minimemDir = sidecarConfig.minimem?.dir || ".swarm/minimem";
+    const memWatcher = startMemoryWatcher(minimemDir, (_event) => {
+      // Send bridge-memory-sync through the command handler
+      // This reuses the same callExtension path as the PostToolUse hook
+      const fakeClient = {
+        write: () => {},
+        writable: true,
+      };
+      commandHandler({
+        action: "bridge-memory-sync",
+        agentId: SESSION_ID || "minimem",
+        timestamp: new Date().toISOString(),
+      }, fakeClient);
+    });
+
+    // Clean up watcher on exit
+    if (memWatcher) {
+      process.on("exit", () => memWatcher.close());
+      process.on("SIGTERM", () => memWatcher.close());
+    }
+  }
+
   // Start inactivity timer
   resetInactivityTimer();
 

package/src/__tests__/memory-sync.test.mjs

@@ -0,0 +1,132 @@
+/**
+ * Unit tests for minimem → MAP sync bridge
+ *
+ * Tests the bridge command builder (map-events.mjs) that converts
+ * minimem MCP tool usage into MAP sync commands.
+ */
+
+import { describe, it, expect } from "vitest";
+import { buildMinimemBridgeCommand } from "../map-events.mjs";
+
+describe("buildMinimemBridgeCommand", () => {
+  describe("write operations (should emit)", () => {
+    it("emits for memory_append tool", () => {
+      const cmd = buildMinimemBridgeCommand({
+        tool_name: "minimem__memory_append",
+        tool_input: { text: "Decided to use Redis" },
+        tool_output: '{"content":[{"text":"Appended to memory/2026-03-27.md"}]}',
+      });
+
+      expect(cmd).not.toBeNull();
+      expect(cmd.action).toBe("bridge-memory-sync");
+      expect(cmd.timestamp).toBeDefined();
+    });
+
+    it("emits for memory_upsert tool", () => {
+      const cmd = buildMinimemBridgeCommand({
+        tool_name: "minimem__memory_upsert",
+        tool_input: { path: "memory/decision.md", content: "# Decision" },
+      });
+
+      expect(cmd).not.toBeNull();
+      expect(cmd.action).toBe("bridge-memory-sync");
+    });
+
+    it("emits for tool names containing 'append'", () => {
+      const cmd = buildMinimemBridgeCommand({
+        tool_name: "minimem__appendToday",
+        tool_input: { text: "some note" },
+      });
+
+      expect(cmd).not.toBeNull();
+      expect(cmd.action).toBe("bridge-memory-sync");
+    });
+
+    it("emits for tool names containing 'upsert'", () => {
+      const cmd = buildMinimemBridgeCommand({
+        tool_name: "minimem__upsert_file",
+        tool_input: { path: "memory/test.md" },
+      });
+
+      expect(cmd).not.toBeNull();
+    });
+
+    it("includes session_id as agentId", () => {
+      const cmd = buildMinimemBridgeCommand({
+        tool_name: "minimem__memory_append",
+        tool_input: { text: "test" },
+        session_id: "sess-abc-123",
+      });
+
+      expect(cmd.agentId).toBe("sess-abc-123");
+    });
+
+    it("defaults agentId to 'minimem' when no session_id", () => {
+      const cmd = buildMinimemBridgeCommand({
+        tool_name: "minimem__memory_append",
+        tool_input: { text: "test" },
+      });
+
+      expect(cmd.agentId).toBe("minimem");
+    });
+  });
+
+  describe("read operations (should NOT emit)", () => {
+    it("does not emit for memory_search", () => {
+      const cmd = buildMinimemBridgeCommand({
+        tool_name: "minimem__memory_search",
+        tool_input: { query: "redis caching" },
+      });
+
+      expect(cmd).toBeNull();
+    });
+
+    it("does not emit for memory_get_details", () => {
+      const cmd = buildMinimemBridgeCommand({
+        tool_name: "minimem__memory_get_details",
+        tool_input: { results: [] },
+      });
+
+      expect(cmd).toBeNull();
+    });
+
+    it("does not emit for knowledge_search", () => {
+      const cmd = buildMinimemBridgeCommand({
+        tool_name: "minimem__knowledge_search",
+        tool_input: { query: "database" },
+      });
+
+      expect(cmd).toBeNull();
+    });
+
+    it("does not emit for knowledge_graph", () => {
+      const cmd = buildMinimemBridgeCommand({
+        tool_name: "minimem__knowledge_graph",
+        tool_input: { nodeId: "k-test" },
+      });
+
+      expect(cmd).toBeNull();
+    });
+
+    it("does not emit for knowledge_path", () => {
+      const cmd = buildMinimemBridgeCommand({
+        tool_name: "minimem__knowledge_path",
+        tool_input: { fromId: "k-a", toId: "k-b" },
+      });
+
+      expect(cmd).toBeNull();
+    });
+  });
+
+  describe("edge cases", () => {
+    it("handles missing tool_name", () => {
+      const cmd = buildMinimemBridgeCommand({});
+      expect(cmd).toBeNull();
+    });
+
+    it("handles empty tool_name", () => {
+      const cmd = buildMinimemBridgeCommand({ tool_name: "" });
+      expect(cmd).toBeNull();
+    });
+  });
+});

package/src/__tests__/memory-watcher.test.mjs

@@ -0,0 +1,104 @@
+/**
+ * Unit tests for memory file watcher
+ */
+
+import { describe, it, expect, afterEach, vi } from "vitest";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { startMemoryWatcher } from "../memory-watcher.mjs";
+
+describe("startMemoryWatcher", () => {
+  let tmpDir;
+  let watcher;
+
+  afterEach(() => {
+    if (watcher) {
+      watcher.close();
+      watcher = null;
+    }
+    if (tmpDir) {
+      try { rmSync(tmpDir, { recursive: true }); } catch {}
+      tmpDir = null;
+    }
+  });
+
+  it("returns null for non-existent directory", () => {
+    const result = startMemoryWatcher("/nonexistent/path", () => {});
+    expect(result).toBeNull();
+  });
+
+  it("returns null for empty/undefined dir", () => {
+    expect(startMemoryWatcher("", () => {})).toBeNull();
+    expect(startMemoryWatcher(undefined, () => {})).toBeNull();
+  });
+
+  it("returns a watcher handle with close method", () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "mem-watch-"));
+    mkdirSync(join(tmpDir, "memory"), { recursive: true });
+
+    watcher = startMemoryWatcher(tmpDir, () => {});
+    expect(watcher).not.toBeNull();
+    expect(typeof watcher.close).toBe("function");
+  });
+
+  it("detects new .md file and calls onSync", async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "mem-watch-"));
+    mkdirSync(join(tmpDir, "memory"), { recursive: true });
+
+    const onSync = vi.fn();
+    watcher = startMemoryWatcher(tmpDir, onSync);
+
+    // Wait for watcher to be ready
+    await new Promise((r) => setTimeout(r, 500));
+
+    // Write a new .md file
+    writeFileSync(join(tmpDir, "memory", "test-note.md"), "# Test Note\nContent here.");
+
+    // Wait for debounce (2s) + buffer
+    await new Promise((r) => setTimeout(r, 3500));
+
+    expect(onSync).toHaveBeenCalled();
+    const call = onSync.mock.calls[0][0];
+    expect(call.type).toBe("add");
+    expect(call.path).toContain("test-note.md");
+  }, 10_000);
+
+  it("ignores non-.md files", async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "mem-watch-"));
+
+    const onSync = vi.fn();
+    watcher = startMemoryWatcher(tmpDir, onSync);
+
+    await new Promise((r) => setTimeout(r, 500));
+
+    // Write non-.md files
+    writeFileSync(join(tmpDir, "index.db"), "binary data");
+    writeFileSync(join(tmpDir, "config.json"), "{}");
+
+    await new Promise((r) => setTimeout(r, 3500));
+
+    expect(onSync).not.toHaveBeenCalled();
+  }, 10_000);
+
+  it("debounces rapid changes", async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "mem-watch-"));
+    mkdirSync(join(tmpDir, "memory"), { recursive: true });
+
+    const onSync = vi.fn();
+    watcher = startMemoryWatcher(tmpDir, onSync);
+
+    await new Promise((r) => setTimeout(r, 500));
+
+    // Write multiple files rapidly
+    writeFileSync(join(tmpDir, "memory", "note1.md"), "# Note 1");
+    writeFileSync(join(tmpDir, "memory", "note2.md"), "# Note 2");
+    writeFileSync(join(tmpDir, "memory", "note3.md"), "# Note 3");
+
+    // Wait for debounce
+    await new Promise((r) => setTimeout(r, 3500));
+
+    // Should only fire once (debounced)
+    expect(onSync).toHaveBeenCalledTimes(1);
+  }, 10_000);
+});

package/src/__tests__/opentasks-connector.test.mjs

@@ -0,0 +1,216 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { registerOpenTasksHandler } from "../opentasks-connector.mjs";
+
+// ── Mock factories ──────────────────────────────────────────────────────────
+
+const MOCK_METHODS = {
+  QUERY_REQUEST: "opentasks/query.request",
+  LINK_REQUEST: "opentasks/link.request",
+  ANNOTATE_REQUEST: "opentasks/annotate.request",
+  TASK_REQUEST: "opentasks/task.request",
+};
+
+function createMockConnection() {
+  const handlers = new Map();
+  return {
+    onNotification: vi.fn((method, handler) => {
+      handlers.set(method, handler);
+    }),
+    sendNotification: vi.fn(),
+    // Test helper: fire a notification as if the hub sent it
+    _fireNotification(method, params) {
+      const handler = handlers.get(method);
+      if (handler) return handler(params);
+    },
+    _handlers: handlers,
+  };
+}
+
+function createMockOpentasks() {
+  const connector = {
+    handleNotification: vi.fn(),
+  };
+  return {
+    createClient: vi.fn(() => ({ /* mock client */ })),
+    createMAPConnector: vi.fn(() => connector),
+    MAP_CONNECTOR_METHODS: { ...MOCK_METHODS },
+    _connector: connector,
+  };
+}
+
+function createMockOpentasksClient(socketPath = "/tmp/opentasks/daemon.sock") {
+  return {
+    findSocketPath: vi.fn(() => socketPath),
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("registerOpenTasksHandler", () => {
+  let mockConn;
+  let mockOpentasks;
+  let mockOtClient;
+
+  beforeEach(() => {
+    mockConn = createMockConnection();
+    mockOpentasks = createMockOpentasks();
+    mockOtClient = createMockOpentasksClient();
+  });
+
+  const callRegister = (connOverride, optsOverride = {}) =>
+    registerOpenTasksHandler(connOverride ?? mockConn, {
+      scope: "swarm:test",
+      importOpentasks: async () => mockOpentasks,
+      importOpentasksClient: async () => mockOtClient,
+      ...optsOverride,
+    });
+
+  it("creates a client with the socket path from findSocketPath", async () => {
+    await callRegister();
+
+    expect(mockOtClient.findSocketPath).toHaveBeenCalled();
+    expect(mockOpentasks.createClient).toHaveBeenCalledWith({
+      socketPath: "/tmp/opentasks/daemon.sock",
+      autoConnect: true,
+    });
+  });
+
+  it("creates a MAP connector with the client and a send function", async () => {
+    await callRegister();
+
+    expect(mockOpentasks.createMAPConnector).toHaveBeenCalledTimes(1);
+    const callArgs = mockOpentasks.createMAPConnector.mock.calls[0][0];
+
+    // Should pass the client returned by createClient
+    expect(callArgs.client).toBeDefined();
+    // Should pass a send function
+    expect(typeof callArgs.send).toBe("function");
+    // Should pass agentId derived from scope
+    expect(callArgs.agentId).toBe("swarm:test-sidecar");
+  });
+
+  it("registers onNotification for all 4 request methods", async () => {
+    await callRegister();
+
+    expect(mockConn.onNotification).toHaveBeenCalledTimes(4);
+
+    const registeredMethods = mockConn.onNotification.mock.calls.map((c) => c[0]);
+    expect(registeredMethods).toContain(MOCK_METHODS.QUERY_REQUEST);
+    expect(registeredMethods).toContain(MOCK_METHODS.LINK_REQUEST);
+    expect(registeredMethods).toContain(MOCK_METHODS.ANNOTATE_REQUEST);
+    expect(registeredMethods).toContain(MOCK_METHODS.TASK_REQUEST);
+  });
+
+  it("forwards notifications to connector.handleNotification", async () => {
+    await callRegister();
+
+    const params = { request_id: "req-1", query: "status:open" };
+    await mockConn._fireNotification(MOCK_METHODS.QUERY_REQUEST, params);
+
+    expect(mockOpentasks._connector.handleNotification).toHaveBeenCalledWith(
+      MOCK_METHODS.QUERY_REQUEST,
+      params,
+    );
+  });
+
+  it("passes empty object when notification params are missing", async () => {
+    await callRegister();
+
+    await mockConn._fireNotification(MOCK_METHODS.TASK_REQUEST, undefined);
+
+    expect(mockOpentasks._connector.handleNotification).toHaveBeenCalledWith(
+      MOCK_METHODS.TASK_REQUEST,
+      {},
+    );
+  });
+
+  it("calls the send function on the connector via sendNotification", async () => {
+    await callRegister();
+
+    // Get the send function that was passed to createMAPConnector
+    const sendFn = mockOpentasks.createMAPConnector.mock.calls[0][0].send;
+    sendFn("opentasks/query.response", { data: "result" });
+
+    expect(mockConn.sendNotification).toHaveBeenCalledWith(
+      "opentasks/query.response",
+      { data: "result" },
+    );
+  });
+
+  it("does not throw when sendNotification fails in the send callback", async () => {
+    mockConn.sendNotification.mockImplementation(() => {
+      throw new Error("connection closed");
+    });
+
+    await callRegister();
+
+    const sendFn = mockOpentasks.createMAPConnector.mock.calls[0][0].send;
+    // Should not throw
+    expect(() => sendFn("method", {})).not.toThrow();
+  });
+
+  it("calls onActivity callback when a notification fires", async () => {
+    const onActivity = vi.fn();
+    await callRegister(undefined, { onActivity });
+
+    await mockConn._fireNotification(MOCK_METHODS.LINK_REQUEST, { request_id: "r1" });
+
+    expect(onActivity).toHaveBeenCalledTimes(1);
+  });
+
+  it("does nothing when conn is null", async () => {
+    // Should not throw
+    await registerOpenTasksHandler(null, {
+      scope: "swarm:test",
+      importOpentasks: async () => mockOpentasks,
+      importOpentasksClient: async () => mockOtClient,
+    });
+
+    expect(mockOpentasks.createClient).not.toHaveBeenCalled();
+  });
+
+  it("does nothing when conn lacks onNotification", async () => {
+    await registerOpenTasksHandler({ sendNotification: vi.fn() }, {
+      scope: "swarm:test",
+      importOpentasks: async () => mockOpentasks,
+      importOpentasksClient: async () => mockOtClient,
+    });
+
+    expect(mockOpentasks.createClient).not.toHaveBeenCalled();
+  });
+
+  it("does nothing when opentasks module is missing createMAPConnector", async () => {
+    const brokenModule = { createClient: vi.fn() }; // no createMAPConnector
+
+    await registerOpenTasksHandler(mockConn, {
+      scope: "swarm:test",
+      importOpentasks: async () => brokenModule,
+      importOpentasksClient: async () => mockOtClient,
+    });
+
+    expect(mockConn.onNotification).not.toHaveBeenCalled();
+  });
+
+  it("does nothing when opentasks import throws", async () => {
+    await registerOpenTasksHandler(mockConn, {
+      scope: "swarm:test",
+      importOpentasks: async () => { throw new Error("module not found"); },
+      importOpentasksClient: async () => mockOtClient,
+    });
+
+    expect(mockConn.onNotification).not.toHaveBeenCalled();
+  });
+
+  it("uses custom socket path from findSocketPath", async () => {
+    const customClient = createMockOpentasksClient("/custom/path/daemon.sock");
+
+    await callRegister(undefined, {
+      importOpentasksClient: async () => customClient,
+    });
+
+    expect(mockOpentasks.createClient).toHaveBeenCalledWith({
+      socketPath: "/custom/path/daemon.sock",
+      autoConnect: true,
+    });
+  });
+});

package/src/__tests__/sessionlog.test.mjs

@@ -188,6 +188,46 @@ describe("sessionlog", () => {
       expect(cp.token_usage.input_tokens).toBe(800);
       expect(cp.token_usage.output_tokens).toBe(400);
     });
+
+    it("includes project name from cwd in metadata", () => {
+      const cp = buildTrajectoryCheckpoint(baseState, "lifecycle", makeConfig());
+      expect(cp.metadata.project).toBeDefined();
+      expect(typeof cp.metadata.project).toBe("string");
+      expect(cp.metadata.project.length).toBeGreaterThan(0);
+    });
+
+    it("includes git branch as top-level wire format field", () => {
+      const cp = buildTrajectoryCheckpoint(baseState, "lifecycle", makeConfig());
+      // branch may be null in CI/non-git environments, but should be defined
+      expect("branch" in cp).toBe(true);
+    });
+
+    it("includes firstPrompt from session state when available", () => {
+      const state = { ...baseState, firstPrompt: "fix the bug in server.ts" };
+      const cp = buildTrajectoryCheckpoint(state, "lifecycle", makeConfig());
+      expect(cp.metadata.firstPrompt).toBe("fix the bug in server.ts");
+    });
+
+    it("truncates long firstPrompt to 200 chars", () => {
+      const state = { ...baseState, firstPrompt: "x".repeat(300) };
+      const cp = buildTrajectoryCheckpoint(state, "lifecycle", makeConfig());
+      expect(cp.metadata.firstPrompt.length).toBe(200);
+    });
+
+    it("omits firstPrompt when not in session state", () => {
+      const cp = buildTrajectoryCheckpoint(baseState, "lifecycle", makeConfig());
+      expect(cp.metadata.firstPrompt).toBeUndefined();
+    });
+
+    it("includes template from config when configured", () => {
+      const cp = buildTrajectoryCheckpoint(baseState, "lifecycle", makeConfig({ template: "gsd" }));
+      expect(cp.metadata.template).toBe("gsd");
+    });
+
+    it("omits template when not configured", () => {
+      const cp = buildTrajectoryCheckpoint(baseState, "lifecycle", makeConfig({ template: "" }));
+      expect(cp.metadata.template).toBeUndefined();
+    });
   });
 
   describe("ensureSessionlogEnabled", () => {

package/src/__tests__/sidecar-server.test.mjs

@@ -229,13 +229,13 @@ describe("sidecar-server", () => {
 
       it("falls back to broadcast with trajectory.checkpoint payload when callExtension throws", async () => {
         mockConnection.callExtension.mockRejectedValueOnce(new Error("not supported"));
-        const cp = { id: "cp1", agentId: "a", sessionId: "s", label: "l", metadata: { phase: "active" } };
+        const cp = { id: "cp1", agent: "a", session_id: "s", files_touched: [], token_usage: null, metadata: { phase: "active" } };
         await handler({ action: "trajectory-checkpoint", checkpoint: cp }, mockClient);
         expect(mockConnection.send).toHaveBeenCalled();
         const [, payload] = mockConnection.send.mock.calls[0];
         expect(payload.type).toBe("trajectory.checkpoint");
         expect(payload.checkpoint.id).toBe("cp1");
-        expect(payload.checkpoint.agentId).toBe("a");
+        expect(payload.checkpoint.agent).toBe("a");
         expect(payload.checkpoint.metadata).toEqual({ phase: "active" });
       });