claude-code-swarm 0.3.11 → 0.3.16

package/src/__tests__/sessionlog.test.mjs

@@ -1,9 +1,36 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import path from "path";
 import fs from "fs";
-import { findActiveSession, buildTrajectoryCheckpoint } from "../sessionlog.mjs";
+import { execSync } from "child_process";
+import { findActiveSession, buildTrajectoryCheckpoint, ensureSessionlogEnabled, checkSessionlogStatus, dispatchSessionlogHook } from "../sessionlog.mjs";
 import { makeTmpDir, writeFile, makeConfig, cleanupTmpDir } from "./helpers.mjs";
 
+// Mock child_process for ensureSessionlogEnabled tests
+vi.mock("child_process", async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    execSync: vi.fn(actual.execSync),
+  };
+});
+
+// Mock swarmkit-resolver for resolvePackage
+vi.mock("../swarmkit-resolver.mjs", () => ({
+  resolvePackage: vi.fn().mockResolvedValue(null),
+}));
+
+// Mock config — preserve resolveTeamName/resolveScope for buildTrajectoryCheckpoint tests,
+// override readConfig for dispatchSessionlogHook mode tests
+vi.mock("../config.mjs", async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    readConfig: vi.fn(() => ({
+      sessionlog: { enabled: true, sync: "off", mode: "plugin" },
+    })),
+  };
+});
+
 describe("sessionlog", () => {
   let tmpDir;
   beforeEach(() => { tmpDir = makeTmpDir(); });
@@ -72,13 +99,18 @@ describe("sessionlog", () => {
       filesTouched: ["a.js", "b.js"],
       lastCheckpointID: "cp-42",
       turnCheckpointIDs: ["cp-40", "cp-41", "cp-42"],
-      tokenUsage: { input: 1000, output: 500 },
+      tokenUsage: { inputTokens: 1000, outputTokens: 500, cacheCreationTokens: 50, cacheReadTokens: 200, apiCallCount: 3 },
       extraField: "extra",
     };
 
-    it("sets agentId to teamName-sidecar", () => {
+    it("sets agent to teamName-sidecar (wire format)", () => {
       const cp = buildTrajectoryCheckpoint(baseState, "lifecycle", makeConfig());
-      expect(cp.agentId).toBe("test-team-sidecar");
+      expect(cp.agent).toBe("test-team-sidecar");
+    });
+
+    it("sets session_id from state.sessionID (wire format)", () => {
+      const cp = buildTrajectoryCheckpoint(baseState, "lifecycle", makeConfig());
+      expect(cp.session_id).toBe("sess-123");
     });
 
     it("builds checkpoint id from lastCheckpointID when available", () => {
@@ -92,10 +124,17 @@ describe("sessionlog", () => {
       expect(cp.id).toBe("sess-123-step10");
     });
 
-    it("builds human-readable label", () => {
+    it("builds human-readable label in metadata", () => {
       const cp = buildTrajectoryCheckpoint(baseState, "lifecycle", makeConfig());
-      expect(cp.label).toContain("Turn turn-5");
-      expect(cp.label).toContain("step 10");
+      expect(cp.metadata.label).toContain("Turn turn-5");
+      expect(cp.metadata.label).toContain("step 10");
+    });
+
+    it("defaults files_touched and checkpoints_count at lifecycle level", () => {
+      const cp = buildTrajectoryCheckpoint(baseState, "lifecycle", makeConfig());
+      expect(cp.files_touched).toEqual([]);
+      expect(cp.checkpoints_count).toBe(0);
+      expect(cp.token_usage).toBeUndefined();
     });
 
     it("includes base metadata at lifecycle level", () => {
@@ -106,15 +145,27 @@ describe("sessionlog", () => {
       expect(cp.metadata.stepCount).toBeUndefined();
     });
 
-    it("includes metrics at metrics level", () => {
+    it("promotes files_touched and token_usage to top level at metrics level", () => {
+      const cp = buildTrajectoryCheckpoint(baseState, "metrics", makeConfig());
+      expect(cp.files_touched).toEqual(["a.js", "b.js"]);
+      expect(cp.checkpoints_count).toBe(3);
+      expect(cp.token_usage).toEqual({
+        input_tokens: 1000,
+        output_tokens: 500,
+        cache_creation_tokens: 50,
+        cache_read_tokens: 200,
+        api_call_count: 3,
+      });
+    });
+
+    it("keeps stepCount and checkpoint IDs in metadata at metrics level", () => {
       const cp = buildTrajectoryCheckpoint(baseState, "metrics", makeConfig());
       expect(cp.metadata.stepCount).toBe(10);
-      expect(cp.metadata.filesTouched).toEqual(["a.js", "b.js"]);
-      expect(cp.metadata.tokenUsage).toEqual({ input: 1000, output: 500 });
       expect(cp.metadata.lastCheckpointID).toBe("cp-42");
+      expect(cp.metadata.turnCheckpointIDs).toEqual(["cp-40", "cp-41", "cp-42"]);
     });
 
-    it("includes all state fields at full level", () => {
+    it("includes all state fields in metadata at full level", () => {
       const cp = buildTrajectoryCheckpoint(baseState, "full", makeConfig());
       expect(cp.metadata.extraField).toBe("extra");
       expect(cp.metadata.stepCount).toBe(10);
@@ -131,9 +182,201 @@ describe("sessionlog", () => {
       expect(cp.metadata.endedAt).toBe("2024-01-01T01:00:00Z");
     });
 
-    it("sets sessionId from state.sessionID", () => {
+    it("handles legacy tokenUsage format (input/output instead of inputTokens/outputTokens)", () => {
+      const state = { ...baseState, tokenUsage: { input: 800, output: 400 } };
+      const cp = buildTrajectoryCheckpoint(state, "metrics", makeConfig());
+      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());
-      expect(cp.sessionId).toBe("sess-123");
+      // 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", () => {
+    beforeEach(() => {
+      vi.mocked(execSync).mockReset();
+    });
+
+    it("returns true immediately when sessionlog is already active", async () => {
+      // checkSessionlogStatus calls execSync twice: `which sessionlog` and `sessionlog status`
+      vi.mocked(execSync)
+        .mockImplementationOnce(() => "/usr/local/bin/sessionlog") // which
+        .mockImplementationOnce(() => "enabled: true\nstrategy: manual-commit"); // status
+      const result = await ensureSessionlogEnabled();
+      expect(result).toBe(true);
+    });
+
+    it("returns false when sessionlog is not installed", async () => {
+      vi.mocked(execSync).mockImplementationOnce(() => { throw new Error("not found"); }); // which
+      const result = await ensureSessionlogEnabled();
+      expect(result).toBe(false);
+    });
+
+    it("attempts CLI enable when installed but not enabled and resolvePackage returns null", async () => {
+      const { resolvePackage } = await import("../swarmkit-resolver.mjs");
+      vi.mocked(resolvePackage).mockResolvedValue(null);
+
+      // First two calls: checkSessionlogStatus (which + status)
+      // Third call: CLI fallback `sessionlog enable --agent claude-code`
+      vi.mocked(execSync)
+        .mockImplementationOnce(() => "/usr/local/bin/sessionlog") // which
+        .mockImplementationOnce(() => "enabled: false") // status → not enabled
+        .mockImplementationOnce(() => ""); // sessionlog enable succeeds
+      const result = await ensureSessionlogEnabled();
+      expect(result).toBe(true);
+    });
+
+    it("returns false when both programmatic and CLI enable fail", async () => {
+      const { resolvePackage } = await import("../swarmkit-resolver.mjs");
+      vi.mocked(resolvePackage).mockResolvedValue(null);
+
+      vi.mocked(execSync)
+        .mockImplementationOnce(() => "/usr/local/bin/sessionlog") // which
+        .mockImplementationOnce(() => "enabled: false") // status
+        .mockImplementationOnce(() => { throw new Error("enable failed"); }); // CLI fails
+      const result = await ensureSessionlogEnabled();
+      expect(result).toBe(false);
+    });
+
+    it("tries programmatic API before CLI fallback", async () => {
+      const { resolvePackage } = await import("../swarmkit-resolver.mjs");
+      const mockEnable = vi.fn().mockResolvedValue({ enabled: true });
+      vi.mocked(resolvePackage).mockResolvedValue({ enable: mockEnable });
+
+      vi.mocked(execSync)
+        .mockImplementationOnce(() => "/usr/local/bin/sessionlog") // which
+        .mockImplementationOnce(() => "enabled: false"); // status → not enabled
+      const result = await ensureSessionlogEnabled();
+      expect(result).toBe(true);
+      expect(mockEnable).toHaveBeenCalledWith({ agent: "claude-code", skipAgentHooks: true });
+    });
+  });
+
+  describe("dispatchSessionlogHook", () => {
+    function mockSessionlog(overrides = {}) {
+      return {
+        isEnabled: vi.fn().mockResolvedValue(true),
+        getAgent: vi.fn().mockReturnValue({ parseHookEvent: vi.fn().mockReturnValue({ type: "SessionStart" }) }),
+        hasHookSupport: vi.fn().mockReturnValue(true),
+        createLifecycleHandler: vi.fn().mockReturnValue({ dispatch: vi.fn() }),
+        createSessionStore: vi.fn().mockReturnValue({}),
+        createCheckpointStore: vi.fn().mockReturnValue({}),
+        ...overrides,
+      };
+    }
+
+    beforeEach(() => {
+      vi.mocked(execSync).mockReset();
+    });
+
+    it("skips dispatch when mode is 'standalone'", async () => {
+      const { readConfig } = await import("../config.mjs");
+      vi.mocked(readConfig).mockReturnValue({ sessionlog: { enabled: true, sync: "off", mode: "standalone" } });
+      const { resolvePackage } = await import("../swarmkit-resolver.mjs");
+      const mod = mockSessionlog();
+      vi.mocked(resolvePackage).mockResolvedValue(mod);
+      await dispatchSessionlogHook("session-start", { session_id: "s1" });
+      expect(mod.createLifecycleHandler().dispatch).not.toHaveBeenCalled();
+    });
+
+    it("dispatches when mode is 'plugin'", async () => {
+      const { readConfig } = await import("../config.mjs");
+      vi.mocked(readConfig).mockReturnValue({ sessionlog: { enabled: true, sync: "off", mode: "plugin" } });
+      const { resolvePackage } = await import("../swarmkit-resolver.mjs");
+      const mockDispatch = vi.fn();
+      const mockEvent = { type: "SessionStart", sessionID: "s1" };
+      const mockAgent = { parseHookEvent: vi.fn().mockReturnValue(mockEvent) };
+      vi.mocked(resolvePackage).mockResolvedValue(mockSessionlog({
+        getAgent: vi.fn().mockReturnValue(mockAgent),
+        createLifecycleHandler: vi.fn().mockReturnValue({ dispatch: mockDispatch }),
+      }));
+      await dispatchSessionlogHook("session-start", { session_id: "s1" });
+      expect(mockDispatch).toHaveBeenCalledWith(mockAgent, mockEvent);
+    });
+
+    it("bails silently when sessionlog package is not available", async () => {
+      const { readConfig } = await import("../config.mjs");
+      vi.mocked(readConfig).mockReturnValue({ sessionlog: { enabled: true, sync: "off", mode: "plugin" } });
+      const { resolvePackage } = await import("../swarmkit-resolver.mjs");
+      vi.mocked(resolvePackage).mockResolvedValue(null);
+      await dispatchSessionlogHook("session-start", { session_id: "s1" });
+    });
+
+    it("bails when isEnabled returns false", async () => {
+      const { readConfig } = await import("../config.mjs");
+      vi.mocked(readConfig).mockReturnValue({ sessionlog: { enabled: true, sync: "off", mode: "plugin" } });
+      const { resolvePackage } = await import("../swarmkit-resolver.mjs");
+      const mockDispatch = vi.fn();
+      vi.mocked(resolvePackage).mockResolvedValue(mockSessionlog({
+        isEnabled: vi.fn().mockResolvedValue(false),
+        createLifecycleHandler: vi.fn().mockReturnValue({ dispatch: mockDispatch }),
+      }));
+      await dispatchSessionlogHook("session-start", { session_id: "s1" });
+      expect(mockDispatch).not.toHaveBeenCalled();
+    });
+
+    it("bails when parseHookEvent returns null", async () => {
+      const { readConfig } = await import("../config.mjs");
+      vi.mocked(readConfig).mockReturnValue({ sessionlog: { enabled: true, sync: "off", mode: "plugin" } });
+      const { resolvePackage } = await import("../swarmkit-resolver.mjs");
+      const mockDispatch = vi.fn();
+      vi.mocked(resolvePackage).mockResolvedValue(mockSessionlog({
+        getAgent: vi.fn().mockReturnValue({ parseHookEvent: vi.fn().mockReturnValue(null) }),
+        createLifecycleHandler: vi.fn().mockReturnValue({ dispatch: mockDispatch }),
+      }));
+      await dispatchSessionlogHook("unknown-hook", {});
+      expect(mockDispatch).not.toHaveBeenCalled();
+    });
+
+    it("bails when getAgent returns null", async () => {
+      const { readConfig } = await import("../config.mjs");
+      vi.mocked(readConfig).mockReturnValue({ sessionlog: { enabled: true, sync: "off", mode: "plugin" } });
+      const { resolvePackage } = await import("../swarmkit-resolver.mjs");
+      const mockDispatch = vi.fn();
+      vi.mocked(resolvePackage).mockResolvedValue(mockSessionlog({
+        getAgent: vi.fn().mockReturnValue(null),
+        createLifecycleHandler: vi.fn().mockReturnValue({ dispatch: mockDispatch }),
+      }));
+      await dispatchSessionlogHook("session-start", { session_id: "s1" });
+      expect(mockDispatch).not.toHaveBeenCalled();
     });
   });
 });

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" });
       });
 

package/src/bootstrap.mjs

@@ -20,7 +20,7 @@ import { findSocketPath, isDaemonAlive, ensureDaemon } from "./opentasks-client.
 import { loadTeam } from "./template.mjs";
 import { killSidecar, startSidecar, sendToInbox } from "./sidecar-client.mjs";
 import { sendCommand } from "./map-events.mjs";
-import { checkSessionlogStatus, syncSessionlog, annotateSwarmSession } from "./sessionlog.mjs";
+import { checkSessionlogStatus, ensureSessionlogEnabled, syncSessionlog, annotateSwarmSession, hasStandaloneHooks } from "./sessionlog.mjs";
 import { resolveSwarmkit, configureNodePath } from "./swarmkit-resolver.mjs";
 
 /**
@@ -330,7 +330,7 @@ export async function backgroundInit(config, scope, dir, sessionId) {
       );
     }
 
-    // Sessionlog sync + swarm annotation
+    // Sessionlog sync + swarm annotation (enable already happened in fast path)
     if (config.map.enabled && config.sessionlog.sync !== "off") {
       tasks.push(syncSessionlog(config, sessionId).catch(() => {}));
     }
@@ -394,10 +394,23 @@ export async function bootstrap(pluginDirOverride, sessionId) {
     }
   }
 
-  // 3. Sessionlog status — actual check is slow (execSync), defer to background
+  // 3. Sessionlog: ensure enabled, detect standalone vs plugin mode.
+  //    Mode is resolved per-hook in dispatchSessionlogHook() — bootstrap just
+  //    ensures sessionlog infrastructure exists and reports status.
   let sessionlogStatus = "not installed";
   if (config.sessionlog.enabled) {
-    sessionlogStatus = "checking";
+    try {
+      const mode = config.sessionlog.mode || "auto";
+      const standalone = mode === "standalone" || (mode === "auto" && hasStandaloneHooks());
+      if (standalone) {
+        sessionlogStatus = "active (standalone)";
+      } else {
+        const enabled = await ensureSessionlogEnabled();
+        sessionlogStatus = enabled ? "active" : "installed but not enabled";
+      }
+    } catch {
+      sessionlogStatus = "checking";
+    }
   }
 
   // 4. Quick MAP status — report "starting" for session sidecars (actual startup is background)

package/src/config.mjs

@@ -8,6 +8,7 @@
  */
 
 import fs from "fs";
+import path from "path";
 import { CONFIG_PATH, GLOBAL_CONFIG_PATH } from "./paths.mjs";
 
 export const DEFAULTS = {
@@ -53,8 +54,10 @@ function readJsonFile(filePath) {
  * Never throws — returns defaults on any error.
  */
 export function readConfig(configPath = CONFIG_PATH, globalConfigPath = GLOBAL_CONFIG_PATH) {
-  const global = readJsonFile(globalConfigPath);
-  const project = readJsonFile(configPath);
+  // Resolve relative paths against process.cwd() — fs.readFileSync resolves
+  // against the OS working directory which may differ (e.g. worktrees, subdirs).
+  const global = readJsonFile(path.resolve(globalConfigPath));
+  const project = readJsonFile(path.resolve(configPath));
 
   // Project overrides global for each field (not deep merge — per-field fallthrough)
   const server = envStr("SWARM_MAP_SERVER") ?? project.map?.server ?? global.map?.server ?? undefined;
@@ -84,6 +87,7 @@ export function readConfig(configPath = CONFIG_PATH, globalConfigPath = GLOBAL_C
     sessionlog: {
       enabled: envBool("SWARM_SESSIONLOG_ENABLED") ?? Boolean(project.sessionlog?.enabled ?? global.sessionlog?.enabled),
       sync: envStr("SWARM_SESSIONLOG_SYNC") ?? project.sessionlog?.sync ?? global.sessionlog?.sync ?? DEFAULTS.sessionlogSync,
+      mode: envStr("SWARM_SESSIONLOG_MODE") ?? project.sessionlog?.mode ?? global.sessionlog?.mode ?? "auto",
     },
     opentasks: {
       enabled: envBool("SWARM_OPENTASKS_ENABLED") ?? Boolean(project.opentasks?.enabled ?? global.opentasks?.enabled),

package/src/content-provider.mjs

@@ -0,0 +1,176 @@
+/**
+ * content-provider.mjs — Trajectory content provider for claude-code-swarm
+ *
+ * Provides session transcript content for on-demand trajectory/content requests
+ * from the hub. Reads from sessionlog's session state to find the transcript,
+ * then serves the raw Claude Code JSONL.
+ *
+ * Two content sources:
+ * 1. Live session: reads directly from state.transcriptPath (active JSONL file)
+ * 2. Committed checkpoint: reads from sessionlog's checkpoint store (full.jsonl)
+ *
+ * Returns { metadata, transcript, prompts, context } matching the
+ * SessionContentProvider type from @multi-agent-protocol/sdk.
+ */
+
+import fs from "fs";
+import path from "path";
+import { SESSIONLOG_DIR } from "./paths.mjs";
+import { resolvePackage } from "./swarmkit-resolver.mjs";
+import { createLogger } from "./log.mjs";
+
+const log = createLogger("content-provider");
+
+/**
+ * Create a content provider function for the sidecar.
+ * The provider receives a checkpointId and returns transcript content.
+ *
+ * For live sessions, checkpointId may be the session ID or a checkpoint ID.
+ * We search sessionlog state to find the transcript path.
+ *
+ * @returns {Function} SessionContentProvider-compatible async function
+ */
+export function createContentProvider() {
+  return async function provideContent(checkpointId) {
+    try {
+      // 1. Try to find a live session with this checkpoint or session ID
+      const liveContent = await readLiveSessionContent(checkpointId);
+      if (liveContent) return liveContent;
+
+      // 2. Try to read from committed checkpoint store
+      const committedContent = await readCommittedContent(checkpointId);
+      if (committedContent) return committedContent;
+
+      log.warn("content not found for checkpoint", { checkpointId });
+      return null;
+    } catch (err) {
+      log.warn("content provider error", { checkpointId, error: err.message });
+      return null;
+    }
+  };
+}
+
+/**
+ * Read transcript content from a live (non-ended) sessionlog session.
+ * Searches all session state files for one that matches the checkpoint ID
+ * or has a matching session ID, then reads the transcript from disk.
+ */
+async function readLiveSessionContent(checkpointId) {
+  if (!fs.existsSync(SESSIONLOG_DIR)) return null;
+
+  let files;
+  try {
+    files = fs.readdirSync(SESSIONLOG_DIR).filter(f => f.endsWith(".json"));
+  } catch {
+    return null;
+  }
+
+  for (const f of files) {
+    try {
+      const statePath = path.join(SESSIONLOG_DIR, f);
+      const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+
+      // Match by session ID, checkpoint ID, or checkpoint in turnCheckpointIDs
+      const isMatch =
+        state.sessionID === checkpointId ||
+        state.lastCheckpointID === checkpointId ||
+        (state.turnCheckpointIDs || []).includes(checkpointId);
+
+      if (!isMatch) continue;
+
+      // Read the transcript from the path stored in session state
+      const transcriptPath = state.transcriptPath;
+      if (!transcriptPath || !fs.existsSync(transcriptPath)) {
+        log.warn("transcript path not found", { sessionID: state.sessionID, transcriptPath });
+        continue;
+      }
+
+      const transcript = fs.readFileSync(transcriptPath, "utf-8");
+
+      // Extract prompts from transcript (user messages)
+      const prompts = extractPrompts(transcript);
+
+      return {
+        metadata: {
+          sessionID: state.sessionID,
+          phase: state.phase,
+          stepCount: state.stepCount || 0,
+          filesTouched: state.filesTouched || [],
+          tokenUsage: state.tokenUsage || {},
+          startedAt: state.startedAt,
+          endedAt: state.endedAt,
+          source: "live",
+        },
+        transcript,
+        prompts,
+        context: `Session ${state.sessionID} (${state.phase})`,
+      };
+    } catch {
+      // Skip malformed files
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Read transcript content from sessionlog's committed checkpoint store.
+ * Uses sessionlog's library API via resolvePackage.
+ */
+async function readCommittedContent(checkpointId) {
+  try {
+    const sessionlogMod = await resolvePackage("sessionlog");
+    if (!sessionlogMod?.createCheckpointStore) return null;
+
+    const store = sessionlogMod.createCheckpointStore();
+    if (!store?.readSessionContent) return null;
+
+    // Try reading committed content (session index 0)
+    const content = await store.readSessionContent(checkpointId, 0);
+    if (!content) return null;
+
+    return {
+      metadata: {
+        ...content.metadata,
+        source: "committed",
+      },
+      transcript: content.transcript,
+      prompts: content.prompts,
+      context: content.context,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract user prompts from a Claude Code JSONL transcript.
+ */
+function extractPrompts(transcript) {
+  const prompts = [];
+  for (const line of transcript.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === "user") {
+        const msg = entry.message;
+        if (typeof msg === "string") {
+          prompts.push(msg);
+        } else if (msg?.content) {
+          if (typeof msg.content === "string") {
+            prompts.push(msg.content);
+          } else if (Array.isArray(msg.content)) {
+            const text = msg.content
+              .filter(b => b.type === "text" && b.text)
+              .map(b => b.text)
+              .join("\n");
+            if (text) prompts.push(text);
+          }
+        }
+      }
+    } catch {
+      // Skip malformed lines
+    }
+  }
+  return prompts.join("\n---\n");
+}

package/src/index.mjs

@@ -80,10 +80,13 @@ export {
 // Sessionlog
 export {
   checkSessionlogStatus,
+  ensureSessionlogEnabled,
+  hasStandaloneHooks,
   findActiveSession,
   buildTrajectoryCheckpoint,
   syncSessionlog,
   annotateSwarmSession,
+  dispatchSessionlogHook,
 } from "./sessionlog.mjs";
 
 // Template

package/src/map-connection.mjs

@@ -24,7 +24,7 @@ const log = createLogger("map");
  *   authRequired challenge with the server's preferred method + this credential.
  *   When absent, uses the standard SDK connect() for open mode servers.
  */
-export async function connectToMAP({ server, scope, systemId, onMessage, credential }) {
+export async function connectToMAP({ server, scope, systemId, onMessage, credential, projectContext }) {
   try {
     const mapSdk = await resolvePackage("@multi-agent-protocol/sdk");
     if (!mapSdk) throw new Error("@multi-agent-protocol/sdk not available");
@@ -38,12 +38,16 @@ export async function connectToMAP({ server, scope, systemId, onMessage, credent
       role: "sidecar",
       scopes: [scope],
       capabilities: {
-        trajectory: { canReport: true },
+        trajectory: { canReport: true, canServeContent: true },
         tasks: { canCreate: true, canAssign: true, canUpdate: true, canList: true },
+        ...(projectContext?.task_graph ? {
+          opentasks: { canQuery: true, canLink: true, canAnnotate: true, canTask: true },
+        } : {}),
       },
       metadata: {
         systemId,
         type: "claude-code-swarm-sidecar",
+        ...(projectContext || {}),
       },
       reconnection: {
         enabled: true,