@desplega.ai/agent-swarm 1.97.0 → 1.98.1

package/src/slack/blocks.ts

@@ -8,8 +8,9 @@
 import type { AgentTaskStatus, TaskAttachment } from "../types";
 import { buildAgentFsLiveUrl, getAppUrl } from "../utils/constants";
 
-// Slack limits section text to 3000 chars; we use 2900 for safety
-const MAX_SECTION_LENGTH = 2900;
+// Slack limits section text to 3000 chars; we use 2900 for safety.
+export const MAX_SECTION_LENGTH = 2900;
+export const MAX_BLOCKS_PER_COMPLETION_MESSAGE = 45;
 
 // biome-ignore lint/suspicious/noExplicitAny: Slack block types are complex unions; we build plain objects
 type SlackBlock = any;
@@ -38,24 +39,33 @@ export function getTaskUrl(taskId: string): string {
  * Convert GitHub-flavored markdown to Slack mrkdwn format.
  *
  * Key differences:
- * - GitHub: **bold**, *italic*, ~~strike~~, [text](url)
- * - Slack:  *bold*,  _italic_, ~strike~,   <url|text>
+ * - GitHub: **bold**, __bold__, *italic*, ~~strike~~, ### Header, [text](url)
+ * - Slack:  *bold*,  *bold*,   _italic_, ~strike~,   *Header*, text (url)
  */
 export function markdownToSlack(text: string): string {
   return (
     text
+      // Images: keep alt text and expose the URL plainly.
+      .replace(/!\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g, (_match, alt, url) =>
+        alt ? `${alt} (${url})` : url,
+      )
+      // Links: keep a plain URL fallback instead of Slack's <url|text> shortcut.
+      // Slack block auto-promotion has historically rejected that shortcut with
+      // invalid_blocks, while plain URLs remain copyable and auto-unfurlable.
+      .replace(/\[([^\]]+)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g, "$1 ($2)")
       // Headers to bold placeholder (# Header -> bold, protected from italic)
       .replace(/^#{1,6}\s+(.+)$/gm, "\uE000$1\uE001")
       // Bold **text** -> placeholder (to avoid italic chain converting *bold* to _italic_)
       .replace(/\*\*(.+?)\*\*/g, "\uE000$1\uE001")
+      // Bold __text__ -> placeholder
+      .replace(/__(.+?)__/g, "\uE000$1\uE001")
       // Italic *text* -> _text_ (single asterisks, now safe from bold placeholders)
       .replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, "_$1_")
+      // Italic _text_ already matches Slack mrkdwn; leave it alone.
       // Restore bold from placeholder -> *text*
       .replace(/\uE000(.+?)\uE001/g, "*$1*")
       // Strikethrough ~~text~~ -> ~text~
       .replace(/~~(.+?)~~/g, "~$1~")
-      // Links [text](url) -> <url|text>
-      .replace(/\[([^\]]+)\]\(([^)]+)\)/g, "<$2|$1>")
       // Inline code already works the same
       // Bullet points already work the same
       // Remove excessive blank lines
@@ -66,7 +76,7 @@ export function markdownToSlack(text: string): string {
 /**
  * Split text into chunks that fit within Slack's section text limit.
  */
-function splitText(text: string): string[] {
+export function splitSlackSectionText(text: string): string[] {
   if (text.length <= MAX_SECTION_LENGTH) return [text];
 
   const chunks: string[] = [];
@@ -248,17 +258,50 @@ export function buildCompletedBlocks(opts: {
 
   // Only include body if not minimal (agent didn't reply via slack-reply)
   if (!opts.minimal) {
-    for (const chunk of splitText(opts.body)) {
+    for (const chunk of splitSlackSectionText(opts.body)) {
       blocks.push(sectionBlock(chunk));
     }
   } else if (opts.trailer && opts.trailer.length > 0) {
-    for (const chunk of splitText(opts.trailer)) {
+    for (const chunk of splitSlackSectionText(opts.trailer)) {
       blocks.push(sectionBlock(chunk));
     }
   }
   return blocks;
 }
 
+/**
+ * Build one or more completed-task block payloads. The first payload carries
+ * the normal completion header; continuation payloads carry a compact part
+ * header. This keeps long completion summaries inside Slack's block limits
+ * without dropping body text.
+ */
+export function buildCompletedBlockBatches(opts: Parameters<typeof buildCompletedBlocks>[0]) {
+  const allBlocks = buildCompletedBlocks(opts);
+  if (allBlocks.length <= MAX_BLOCKS_PER_COMPLETION_MESSAGE) return [allBlocks];
+
+  const header = allBlocks[0];
+  const bodyBlocks = allBlocks.slice(1);
+  const bodyLimit = MAX_BLOCKS_PER_COMPLETION_MESSAGE - 1;
+  const batches: SlackBlock[][] = [];
+
+  for (let start = 0; start < bodyBlocks.length; start += bodyLimit) {
+    const partBlocks = bodyBlocks.slice(start, start + bodyLimit);
+    if (start === 0) {
+      batches.push([header, ...partBlocks]);
+    } else {
+      const part = batches.length + 1;
+      batches.push([
+        sectionBlock(
+          `↳ *${opts.agentName}* (${getTaskLink(opts.taskId)}) continued · part ${part}`,
+        ),
+        ...partBlocks,
+      ]);
+    }
+  }
+
+  return batches;
+}
+
 /**
  * Build blocks for a failed task response.
  * Single-line header, then error in code block.
@@ -369,7 +412,10 @@ function truncateOutput(text: string): string {
   const sentenceEnd = text.search(/\.\s/);
   const firstSentence = sentenceEnd !== -1 ? text.slice(0, sentenceEnd + 1) : text;
   if (firstSentence.length <= MAX_OUTPUT_LENGTH) return firstSentence;
-  return `${text.slice(0, MAX_OUTPUT_LENGTH)}…`;
+  const boundary = text.lastIndexOf(" ", MAX_OUTPUT_LENGTH);
+  const cut = boundary >= MAX_OUTPUT_LENGTH / 2 ? boundary : MAX_OUTPUT_LENGTH;
+  const omitted = text.length - cut;
+  return `${text.slice(0, cut).trimEnd()}… (${omitted} more chars; full output in thread)`;
 }
 
 /**
@@ -399,7 +445,7 @@ function renderChildDetail(node: TreeNode, indent: string): string[] {
   }
 
   if (node.status === "completed" && !node.slackReplySent && node.output) {
-    lines.push(`${indent}${truncateOutput(node.output)}`);
+    lines.push(`${indent}${truncateOutput(markdownToSlack(node.output))}`);
   }
 
   return lines;
@@ -423,7 +469,7 @@ function renderTree(root: TreeNode): string {
       lines.push(`    Error: ${root.failureReason}`);
     }
     if (root.status === "completed" && !root.slackReplySent && root.output) {
-      lines.push(`    ${truncateOutput(root.output)}`);
+      lines.push(`    ${truncateOutput(markdownToSlack(root.output))}`);
     }
     return lines.join("\n");
   }

package/src/slack/responses.ts

@@ -4,6 +4,7 @@ import type { Agent, AgentTask } from "../types";
 import { getSlackApp } from "./app";
 import {
   buildCancelledBlocks,
+  buildCompletedBlockBatches,
   buildCompletedBlocks,
   buildFailedBlocks,
   buildProgressBlocks,
@@ -74,7 +75,7 @@ export async function sendTaskResponse(task: AgentTask): Promise<boolean> {
       console.log(
         `[Slack] sendTaskResponse: task=${task.id} slackReplySent=${!!task.slackReplySent} minimal=${!!task.slackReplySent}`,
       );
-      const blocks = buildCompletedBlocks({
+      const completionOpts = {
         agentName,
         taskId: task.id,
         body,
@@ -84,15 +85,21 @@ export async function sendTaskResponse(task: AgentTask): Promise<boolean> {
         // trailing addendum so links are visible without expanding the card.
         minimal: !!task.slackReplySent,
         trailer: task.slackReplySent ? attachmentsBlock : undefined,
-      });
-      await sendWithPersona(client, {
-        channel: task.slackChannelId,
-        thread_ts: task.slackThreadTs,
-        text: task.slackReplySent ? `✅ ${agentName} completed` : body,
-        username: getAgentDisplayName(agent),
-        icon_emoji: getAgentEmoji(agent),
-        blocks,
-      });
+      };
+      const blockBatches = buildCompletedBlockBatches(completionOpts);
+      for (let i = 0; i < blockBatches.length; i++) {
+        await sendWithPersona(client, {
+          channel: task.slackChannelId,
+          thread_ts: task.slackThreadTs,
+          text:
+            task.slackReplySent || i > 0
+              ? `✅ ${agentName} completed${i > 0 ? ` (continued ${i + 1}/${blockBatches.length})` : ""}`
+              : body,
+          username: getAgentDisplayName(agent),
+          icon_emoji: getAgentEmoji(agent),
+          blocks: blockBatches[i],
+        });
+      }
     } else if (task.status === "failed") {
       const reason = task.failureReason || "Unknown error";
       const blocks = buildFailedBlocks({ agentName, taskId: task.id, reason });
@@ -199,6 +206,7 @@ export async function updateToFinal(task: AgentTask, messageTs: string): Promise
   const agentName = agent.name;
   let blocks: unknown[];
   let text: string;
+  let completionBlockBatches: unknown[][] | undefined;
 
   if (task.status === "completed") {
     const output = task.output || "Task completed.";
@@ -212,14 +220,16 @@ export async function updateToFinal(task: AgentTask, messageTs: string): Promise
     console.log(
       `[Slack] updateToFinal: task=${task.id} slackReplySent=${!!task.slackReplySent} minimal=${!!task.slackReplySent}`,
     );
-    blocks = buildCompletedBlocks({
+    const completionOpts = {
       agentName,
       taskId: task.id,
       body,
       duration,
       minimal: !!task.slackReplySent,
       trailer: task.slackReplySent ? attachmentsBlock : undefined,
-    });
+    };
+    completionBlockBatches = buildCompletedBlockBatches(completionOpts);
+    blocks = completionBlockBatches[0] ?? buildCompletedBlocks(completionOpts);
     text = task.slackReplySent ? `✅ ${agentName} completed` : body;
   } else if (task.status === "cancelled") {
     blocks = buildCancelledBlocks({ agentName, taskId: task.id });
@@ -238,6 +248,19 @@ export async function updateToFinal(task: AgentTask, messageTs: string): Promise
       // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
       blocks: blocks as any,
     });
+
+    if (completionBlockBatches) {
+      for (let i = 1; i < completionBlockBatches.length; i++) {
+        await sendWithPersona(app.client, {
+          channel: task.slackChannelId,
+          thread_ts: task.slackThreadTs ?? messageTs,
+          text: `✅ ${agentName} completed (continued ${i + 1}/${completionBlockBatches.length})`,
+          username: getAgentDisplayName(agent),
+          icon_emoji: getAgentEmoji(agent),
+          blocks: completionBlockBatches[i],
+        });
+      }
+    }
     return true;
   } catch (error) {
     console.error(`[Slack] Failed to update task message to final state:`, error);

package/src/slack/watcher.ts

@@ -696,13 +696,6 @@ export function startTaskWatcher(intervalMs = 3000): void {
           }
         }
 
-        // Skip tasks tracked in a tree — they're rendered by processTreeMessages()
-        // But mark as notified to prevent re-processing if tree is cleaned up
-        if (taskToTree.has(task.id)) {
-          notifiedCompletions.set(task.id, now);
-          continue;
-        }
-
         const completionKey = `completion:${task.id}`;
 
         // Skip if already notified or currently sending or sent recently
@@ -710,6 +703,34 @@ export function startTaskWatcher(intervalMs = 3000): void {
         const lastSent = lastSendTime.get(completionKey);
         if (lastSent && now - lastSent < MIN_SEND_INTERVAL) continue;
 
+        // Tasks tracked in a tree are still rendered by processTreeMessages().
+        // Successful tasks without their own slack-reply also get a full
+        // threaded completion message so the tree's compact preview is not the
+        // only place their output appears.
+        if (taskToTree.has(task.id)) {
+          if (task.status !== "completed" || task.slackReplySent) {
+            notifiedCompletions.set(task.id, now);
+            continue;
+          }
+
+          pendingSends.add(completionKey);
+          notifiedCompletions.set(task.id, now);
+          lastSendTime.set(completionKey, now);
+          try {
+            await sendTaskResponse(task);
+            console.log(
+              `[Slack] Sent full tree-tracked completion for task ${task.id.slice(0, 8)}`,
+            );
+          } catch (error) {
+            notifiedCompletions.delete(task.id);
+            lastSendTime.delete(completionKey);
+            console.error(`[Slack] Failed to send tree-tracked completion:`, error);
+          } finally {
+            pendingSends.delete(completionKey);
+          }
+          continue;
+        }
+
         // Mark as pending and notified BEFORE sending
         pendingSends.add(completionKey);
         notifiedCompletions.set(task.id, now);

package/src/tests/pricing-refresh.test.ts

@@ -0,0 +1,156 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, getActivePricingRow, getDb, getLogsByEventType, initDb } from "../be/db";
+import type { ModelsDevCache } from "../be/modelsdev-cache";
+import { refreshPricingFromModelsDev } from "../be/pricing-refresh";
+
+const TEST_DB_PATH = "./test-pricing-refresh.sqlite";
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+function responseFor(cache: ModelsDevCache, etag = '"test-etag"'): Response {
+  return new Response(JSON.stringify(cache), {
+    status: 200,
+    headers: { "content-type": "application/json", etag },
+  });
+}
+
+function openAiCache(input: number, output: number): ModelsDevCache {
+  return {
+    openai: {
+      models: {
+        "gpt-refresh-test": {
+          cost: { input, output },
+        },
+      },
+    },
+  };
+}
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+afterEach(() => {
+  const db = getDb();
+  db.prepare("DELETE FROM pricing").run();
+  db.prepare("DELETE FROM agent_log WHERE eventType LIKE 'pricing.refresh%'").run();
+});
+
+describe("models.dev runtime pricing refresh", () => {
+  test("inserts a new effective row when upstream price changes and no-ops identical prices", async () => {
+    const db = getDb();
+    db.prepare(
+      `INSERT INTO pricing
+       (provider, model, token_class, effective_from, price_per_million_usd, createdAt, lastUpdatedAt)
+       VALUES ('codex', 'gpt-refresh-test', 'input', 0, 1, 0, 0)`,
+    ).run();
+
+    const first = await refreshPricingFromModelsDev({
+      now: 1_000,
+      fetchImpl: async () => responseFor(openAiCache(2, 8), '"etag-1"'),
+    });
+    expect(first.status).toBe("refreshed");
+    expect(first.candidateRows).toBe(4);
+    expect(first.inserted).toBe(4);
+    expect(first.unchanged).toBe(0);
+
+    const activeChanged = getActivePricingRow("codex", "gpt-refresh-test", "input", 1_000);
+    expect(activeChanged?.effectiveFrom).toBe(1_000);
+    expect(activeChanged?.pricePerMillionUsd).toBe(2);
+
+    const second = await refreshPricingFromModelsDev({
+      now: 2_000,
+      fetchImpl: async () => responseFor(openAiCache(2, 8), '"etag-2"'),
+    });
+    expect(second.inserted).toBe(0);
+    expect(second.unchanged).toBe(4);
+
+    const rows = db
+      .prepare<{ effective_from: number }, []>(
+        `SELECT effective_from FROM pricing
+         WHERE provider = 'codex'
+           AND model = 'gpt-refresh-test'
+           AND token_class = 'input'
+         ORDER BY effective_from`,
+      )
+      .all();
+    expect(rows.map((row) => row.effective_from)).toEqual([0, 1_000]);
+  });
+
+  test("sends If-None-Match and short-circuits on HTTP 304", async () => {
+    await refreshPricingFromModelsDev({
+      now: 1_000,
+      fetchImpl: async () => responseFor(openAiCache(2, 8), '"etag-304"'),
+    });
+
+    let ifNoneMatch: string | null = null;
+    const result = await refreshPricingFromModelsDev({
+      now: 2_000,
+      fetchImpl: async (_input, init) => {
+        const headers = new Headers(init?.headers);
+        ifNoneMatch = headers.get("if-none-match");
+        return new Response(null, { status: 304 });
+      },
+    });
+
+    expect(ifNoneMatch).toBe('"etag-304"');
+    expect(result.status).toBe("not_modified");
+    expect(result.inserted).toBe(0);
+  });
+
+  test("prunes pricing history to the latest two effective rows per triple", async () => {
+    const db = getDb();
+    const insert = db.prepare(
+      `INSERT INTO pricing
+       (provider, model, token_class, effective_from, price_per_million_usd, createdAt, lastUpdatedAt)
+       VALUES ('codex', 'gpt-refresh-test', 'input', ?, ?, 0, 0)`,
+    );
+    insert.run(1_000, 1);
+    insert.run(2_000, 2);
+    insert.run(3_000, 3);
+
+    const result = await refreshPricingFromModelsDev({
+      now: 4_000,
+      fetchImpl: async () => responseFor(openAiCache(3, 8), '"etag-prune"'),
+    });
+
+    expect(result.pruned).toBe(1);
+    const rows = db
+      .prepare<{ effective_from: number }, []>(
+        `SELECT effective_from FROM pricing
+         WHERE provider = 'codex'
+           AND model = 'gpt-refresh-test'
+           AND token_class = 'input'
+         ORDER BY effective_from`,
+      )
+      .all();
+    expect(rows.map((row) => row.effective_from)).toEqual([2_000, 3_000]);
+  });
+
+  test("writes scrubbed audit log entries for successful refreshes", async () => {
+    await refreshPricingFromModelsDev({
+      now: 1_000,
+      fetchImpl: async () => responseFor(openAiCache(2, 8), '"etag-log"'),
+    });
+
+    const logs = getLogsByEventType("pricing.refresh");
+    expect(logs).toHaveLength(1);
+    expect(logs[0]?.newValue).toContain("inserted=4");
+    expect(logs[0]?.metadata).toContain('"etag":"\\"etag-log\\""');
+  });
+});

package/src/tests/profile-sync.test.ts

@@ -3,9 +3,12 @@ import {
   buildIdentityPayload,
   CLAUDE_MD_PATH,
   collectProfilePayloads,
+  contentSha256,
   extractSetupScriptContent,
   type FileReader,
+  IDENTITY_BASELINES_PATH,
   IDENTITY_MD_PATH,
+  type IdentityBaselines,
   postProfileUpdate,
   resolveClaudeMdPath,
   SETUP_SCRIPT_PATH,
@@ -280,3 +283,186 @@ describe("syncProfileFilesToServer (orchestration is non-fatal)", () => {
     }
   });
 });
+
+// ── Baseline comparison tests ─────────────────────────────────────────────
+// These test the fix for Lead's update-profile edits getting clobbered by
+// the worker's session-end sync. When a file's content hash matches the
+// baseline recorded at session start, it means the agent didn't modify it,
+// so session_sync skips it to preserve any DB-side edits made by Lead.
+
+describe("buildIdentityPayload (baseline comparison)", () => {
+  const baselines: IdentityBaselines = {
+    soulMd: contentSha256(LONG),
+    identityMd: contentSha256(LONG),
+    toolsMd: contentSha256("original tools"),
+    heartbeatMd: contentSha256("original heartbeat"),
+  };
+
+  test("skips files whose hash matches the baseline (unchanged during session)", () => {
+    const payload = buildIdentityPayload(
+      {
+        soulMd: LONG,
+        identityMd: LONG,
+        toolsMd: "original tools",
+        heartbeatMd: "original heartbeat",
+      },
+      baselines,
+    );
+    expect(payload).toEqual({});
+  });
+
+  test("includes files whose content differs from the baseline (modified during session)", () => {
+    const modifiedSoul = `${LONG} — agent added this`;
+    const payload = buildIdentityPayload(
+      {
+        soulMd: modifiedSoul,
+        identityMd: LONG, // unchanged
+        toolsMd: "modified tools",
+        heartbeatMd: "original heartbeat", // unchanged
+      },
+      baselines,
+    );
+    expect(payload.soulMd).toBe(modifiedSoul);
+    expect(payload.identityMd).toBeUndefined();
+    expect(payload.toolsMd).toBe("modified tools");
+    expect(payload.heartbeatMd).toBeUndefined();
+  });
+
+  test("without baselines (null), all files sync as before (backwards compat)", () => {
+    const payload = buildIdentityPayload(
+      { soulMd: LONG, identityMd: LONG, toolsMd: "tools" },
+      null,
+    );
+    expect(payload.soulMd).toBe(LONG);
+    expect(payload.identityMd).toBe(LONG);
+    expect(payload.toolsMd).toBe("tools");
+  });
+
+  test("without baselines (undefined), all files sync as before (backwards compat)", () => {
+    const payload = buildIdentityPayload({ soulMd: LONG, identityMd: LONG }, undefined);
+    expect(payload.soulMd).toBe(LONG);
+    expect(payload.identityMd).toBe(LONG);
+  });
+
+  test("a field missing from baselines is still synced (partial baseline)", () => {
+    const partial: IdentityBaselines = { soulMd: contentSha256(LONG) };
+    const payload = buildIdentityPayload({ soulMd: LONG, identityMd: LONG }, partial);
+    expect(payload.soulMd).toBeUndefined(); // matches baseline → skipped
+    expect(payload.identityMd).toBe(LONG); // no baseline → synced
+  });
+});
+
+describe("collectProfilePayloads (baseline integration)", () => {
+  const reader = (files: Record<string, string>): FileReader => {
+    return async (path: string) => files[path];
+  };
+
+  test("session_sync skips unchanged identity files when baselines exist", async () => {
+    const identityContent = LONG;
+    const toolsContent = "original tools";
+    const modifiedToolsContent = "modified tools";
+
+    const baselines: IdentityBaselines = {
+      soulMd: contentSha256(identityContent),
+      identityMd: contentSha256(identityContent),
+      toolsMd: contentSha256(toolsContent),
+    };
+
+    const files = reader({
+      [SOUL_MD_PATH]: identityContent,
+      [IDENTITY_MD_PATH]: identityContent,
+      [TOOLS_MD_PATH]: modifiedToolsContent,
+      [IDENTITY_BASELINES_PATH]: JSON.stringify(baselines),
+    });
+
+    const payloads = await collectProfilePayloads(["identity"], "session_sync", files);
+    expect(payloads).toHaveLength(1);
+    expect(payloads[0]?.body.toolsMd).toBe(modifiedToolsContent);
+    expect(payloads[0]?.body.soulMd).toBeUndefined();
+    expect(payloads[0]?.body.identityMd).toBeUndefined();
+  });
+
+  test("self_edit bypasses baselines (agent explicitly changed the file)", async () => {
+    const identityContent = LONG;
+
+    const files = reader({
+      [SOUL_MD_PATH]: identityContent,
+      [IDENTITY_MD_PATH]: identityContent,
+      [TOOLS_MD_PATH]: "tools",
+      [IDENTITY_BASELINES_PATH]: JSON.stringify({
+        soulMd: contentSha256(identityContent),
+        identityMd: contentSha256(identityContent),
+        toolsMd: contentSha256("tools"),
+      }),
+    });
+
+    const payloads = await collectProfilePayloads(["identity"], "self_edit", files);
+    expect(payloads).toHaveLength(1);
+    // self_edit should include ALL files regardless of baselines
+    expect(payloads[0]?.body.soulMd).toBe(identityContent);
+    expect(payloads[0]?.body.identityMd).toBe(identityContent);
+    expect(payloads[0]?.body.toolsMd).toBe("tools");
+  });
+
+  test("session_sync skips unchanged CLAUDE.md when baseline matches", async () => {
+    const claudeContent = "original claude md";
+    const baselines: IdentityBaselines = { claudeMd: contentSha256(claudeContent) };
+
+    const files = reader({
+      [CLAUDE_MD_PATH]: claudeContent,
+      [IDENTITY_BASELINES_PATH]: JSON.stringify(baselines),
+    });
+
+    const payloads = await collectProfilePayloads(["claude"], "session_sync", files);
+    expect(payloads).toEqual([]);
+  });
+
+  test("session_sync syncs modified CLAUDE.md even when baselines exist", async () => {
+    const baselines: IdentityBaselines = { claudeMd: contentSha256("original") };
+
+    const files = reader({
+      [CLAUDE_MD_PATH]: "modified claude md",
+      [IDENTITY_BASELINES_PATH]: JSON.stringify(baselines),
+    });
+
+    const payloads = await collectProfilePayloads(["claude"], "session_sync", files);
+    expect(payloads).toHaveLength(1);
+    expect(payloads[0]?.body.claudeMd).toBe("modified claude md");
+  });
+
+  test("session_sync proceeds normally when baselines file is missing", async () => {
+    const files = reader({
+      [TOOLS_MD_PATH]: "tools content",
+      // No IDENTITY_BASELINES_PATH → baselines will be null → no skipping
+    });
+
+    const payloads = await collectProfilePayloads(["identity"], "session_sync", files);
+    expect(payloads).toHaveLength(1);
+    expect(payloads[0]?.body.toolsMd).toBe("tools content");
+  });
+
+  test("all identity files unchanged → no identity payload at all", async () => {
+    const baselines: IdentityBaselines = {
+      soulMd: contentSha256(LONG),
+      identityMd: contentSha256(LONG),
+      toolsMd: contentSha256("tools"),
+      heartbeatMd: contentSha256("heartbeat"),
+    };
+
+    const files = reader({
+      [SOUL_MD_PATH]: LONG,
+      [IDENTITY_MD_PATH]: LONG,
+      [TOOLS_MD_PATH]: "tools",
+      ["/workspace/HEARTBEAT.md"]: "heartbeat",
+      [IDENTITY_BASELINES_PATH]: JSON.stringify(baselines),
+    });
+
+    const payloads = await collectProfilePayloads(
+      ["identity", "claude", "setup"],
+      "session_sync",
+      files,
+    );
+    // No identity payload (all skipped), no claude or setup (files missing)
+    expect(payloads).toEqual([]);
+  });
+});