@desplega.ai/agent-swarm 1.87.0 → 1.88.0

package/src/tests/http-api-integration.test.ts

@@ -1257,6 +1257,119 @@ describe("Memory", () => {
     expect(body.memoryIds).toBeDefined();
   });
 
+  test("POST /api/memory/index — gates runner session summaries for automatic task classes", async () => {
+    const automaticCases = [
+      { label: "schedule source", source: "schedule", taskType: "maintenance", tags: [] },
+      { label: "system source", source: "system", taskType: "maintenance", tags: [] },
+      { label: "scheduled tag", source: "mcp", taskType: "maintenance", tags: ["scheduled"] },
+      { label: "schedule tag", source: "mcp", taskType: "maintenance", tags: ["schedule:test"] },
+      {
+        label: "auto-generated tag",
+        source: "mcp",
+        taskType: "maintenance",
+        tags: ["auto-generated"],
+      },
+      { label: "heartbeat", source: "mcp", taskType: "heartbeat", tags: [] },
+      { label: "heartbeat checklist", source: "mcp", taskType: "heartbeat-checklist", tags: [] },
+      { label: "boot triage", source: "mcp", taskType: "boot-triage", tags: [] },
+      { label: "health check", source: "mcp", taskType: "health-check", tags: [] },
+      {
+        label: "monitor suffix",
+        source: "mcp",
+        taskType: "claude-code-changelog-monitor",
+        tags: [],
+      },
+      { label: "digest suffix", source: "mcp", taskType: "daily-blocker-digest", tags: [] },
+    ];
+
+    for (const taskCase of automaticCases) {
+      const task = await post("/api/tasks", {
+        agentId: ids.leadAgent,
+        body: {
+          task: `Automatic memory integration test: ${taskCase.label}`,
+          agentId: ids.workerAgent,
+          source: taskCase.source,
+          taskType: taskCase.taskType,
+          tags: taskCase.tags,
+        },
+      });
+      expect(task.status).toBe(201);
+
+      const { status, body } = await post("/api/memory/index", {
+        agentId: ids.workerAgent,
+        body: {
+          content: `Runner summary that should not persist for ${taskCase.label}.`,
+          name: `automatic-session-summary-${taskCase.label}`,
+          scope: "agent",
+          source: "session_summary",
+          sourceTaskId: task.body.id,
+        },
+      });
+      expect(status).toBe(202);
+      expect(body.queued).toBe(false);
+      expect(body.memoryIds).toEqual([]);
+      expect(body.skipped).toBe("automatic_task_memory_disabled");
+    }
+  });
+
+  test("POST /api/memory/index — lets runner session summaries opt in for automatic tasks", async () => {
+    const task = await post("/api/tasks", {
+      agentId: ids.leadAgent,
+      body: {
+        task: "Scheduled memory integration opt-in test",
+        agentId: ids.workerAgent,
+        source: "schedule",
+        taskType: "daily-digest",
+        tags: ["schedule:test"],
+      },
+    });
+    expect(task.status).toBe(201);
+
+    const { status, body } = await post("/api/memory/index", {
+      agentId: ids.workerAgent,
+      body: {
+        content: "Runner summary with reusable learning that explicitly opts into persistence.",
+        name: "automatic-session-summary-opt-in",
+        scope: "agent",
+        source: "session_summary",
+        sourceTaskId: task.body.id,
+        persistMemory: true,
+      },
+    });
+    expect(status).toBe(202);
+    expect(body.queued).toBe(true);
+    expect(body.memoryIds.length).toBeGreaterThan(0);
+  });
+
+  test("POST /api/memory/index — keeps runner session summaries for manual tasks", async () => {
+    const task = await post("/api/tasks", {
+      agentId: ids.leadAgent,
+      body: {
+        task: "Manual memory integration test",
+        agentId: ids.workerAgent,
+      },
+    });
+    expect(task.status).toBe(201);
+
+    const { status, body } = await post("/api/memory/index", {
+      agentId: ids.workerAgent,
+      body: {
+        content: "Runner summary that should persist for a manual task.",
+        name: "manual-session-summary",
+        scope: "agent",
+        source: "session_summary",
+        sourceTaskId: task.body.id,
+      },
+    });
+    expect(status).toBe(202);
+    expect(body.queued).toBe(true);
+    expect(body.memoryIds.length).toBeGreaterThan(0);
+
+    const memory = await get(`/api/memory/${body.memoryIds[0]}`, { agentId: ids.workerAgent });
+    expect(memory.status).toBe(200);
+    expect(memory.body.memory.sourceTaskId).toBe(task.body.id);
+  });
+
   test("POST /api/memory/search — missing query returns 400", async () => {
     const { status } = await post("/api/memory/search", {
       body: {},

package/src/tests/kapso-client.test.ts

@@ -1,5 +1,9 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { sendKapsoText } from "../integrations/kapso/client";
+import {
+  markKapsoMessageRead,
+  sendKapsoReaction,
+  sendKapsoText,
+} from "../integrations/kapso/client";
 
 const originalFetch = globalThis.fetch;
 
@@ -92,3 +96,72 @@ describe("sendKapsoText", () => {
     expect(result.errorMessage).toContain("Invalid API key");
   });
 });
+
+describe("Kapso message actions", () => {
+  test("markKapsoMessageRead can include the typing indicator", async () => {
+    let captured: { url: string; body: unknown } | null = null;
+    globalThis.fetch = (async (url: string, init: RequestInit) => {
+      captured = { url, body: JSON.parse(init.body as string) };
+      return new Response(JSON.stringify({ success: true }), { status: 200 });
+    }) as typeof fetch;
+
+    const result = await markKapsoMessageRead({
+      apiBaseUrl: "https://api.kapso.ai",
+      apiKey: "k",
+      phoneNumberId: "p",
+      messageId: "wamid.IN",
+      typingIndicatorType: "text",
+    });
+
+    expect(result.ok).toBe(true);
+    expect(captured!.url).toBe("https://api.kapso.ai/meta/whatsapp/v24.0/p/messages");
+    expect(captured!.body).toEqual({
+      messaging_product: "whatsapp",
+      status: "read",
+      message_id: "wamid.IN",
+      typing_indicator: { type: "text" },
+    });
+  });
+
+  test("sendKapsoReaction posts the eyes reaction payload", async () => {
+    let body: Record<string, unknown> | null = null;
+    globalThis.fetch = (async (_url: string, init: RequestInit) => {
+      body = JSON.parse(init.body as string);
+      return new Response(JSON.stringify({ messages: [{ id: "wamid.REACT" }] }), {
+        status: 200,
+      });
+    }) as typeof fetch;
+
+    const result = await sendKapsoReaction({
+      apiBaseUrl: "https://api.kapso.ai",
+      apiKey: "k",
+      phoneNumberId: "p",
+      to: "34679077777",
+      messageId: "wamid.IN",
+      emoji: "👀",
+    });
+
+    expect(result.ok).toBe(true);
+    expect(body).toEqual({
+      messaging_product: "whatsapp",
+      recipient_type: "individual",
+      to: "34679077777",
+      type: "reaction",
+      reaction: { message_id: "wamid.IN", emoji: "👀" },
+    });
+  });
+
+  test("message action errors return structured failures", async () => {
+    mockFetch(400, { error: { message: "bad message id" } });
+
+    const result = await markKapsoMessageRead({
+      apiBaseUrl: "https://api.kapso.ai",
+      apiKey: "k",
+      phoneNumberId: "p",
+      messageId: "wamid.BAD",
+    });
+
+    expect(result.ok).toBe(false);
+    expect(result.errorMessage).toBe("bad message id");
+  });
+});

package/src/tests/kapso-inbound.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
 import crypto from "node:crypto";
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { closeDb, createAgent, createUser, getKv, getTaskById, initDb } from "../be/db";
@@ -11,6 +11,7 @@ const TEST_DB_PATH = "./test-kapso-inbound.sqlite";
 const HMAC_SECRET = "kapso-test-hmac-secret";
 
 let agentId: string;
+const originalFetch = globalThis.fetch;
 
 function makePayload(opts: {
   phoneNumberId: string;
@@ -77,13 +78,21 @@ beforeAll(() => {
   }
   initDb(TEST_DB_PATH);
   process.env.KAPSO_WEBHOOK_HMAC_SECRET = HMAC_SECRET;
+  process.env.KAPSO_API_KEY = "kapso-test-api-key";
+  process.env.KAPSO_API_BASE_URL = "https://kapso.test";
   const agent = createAgent({ name: "KapsoWorker", isLead: false, status: "idle" });
   agentId = agent.id;
 });
 
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
 afterAll(() => {
   closeDb();
   delete process.env.KAPSO_WEBHOOK_HMAC_SECRET;
+  delete process.env.KAPSO_API_KEY;
+  delete process.env.KAPSO_API_BASE_URL;
   for (const suffix of ["", "-wal", "-shm"]) {
     try {
       require("node:fs").unlinkSync(`${TEST_DB_PATH}${suffix}`);
@@ -205,12 +214,18 @@ describe("routeKapsoInbound", () => {
 });
 
 describe("handleWebhooks — Kapso HMAC gate", () => {
-  test("valid HMAC + mapping hit → 200 and task routing", async () => {
+  test("valid HMAC + mapping hit → auto-acknowledges inbound, then 200 and task routing", async () => {
     putKapsoNumberMapping({
       phoneNumberId: "pn-http",
       agentId,
       createdAt: new Date().toISOString(),
     });
+    const calls: Array<{ url: string; body: Record<string, unknown> }> = [];
+    globalThis.fetch = (async (url: string, init: RequestInit) => {
+      calls.push({ url, body: JSON.parse(init.body as string) });
+      return new Response(JSON.stringify({ success: true }), { status: 200 });
+    }) as typeof fetch;
+
     const rawBody = JSON.stringify(
       makePayload({ phoneNumberId: "pn-http", messageId: "wamid.HTTP_OK" }),
     );
@@ -221,9 +236,52 @@ describe("handleWebhooks — Kapso HMAC gate", () => {
     expect(handled).toBe(true);
     expect(captured.status).toBe(200);
     expect(JSON.parse(captured.body)).toMatchObject({ received: true, routing: "task" });
+    expect(calls).toHaveLength(2);
+    expect(
+      calls.every((call) => call.url === "https://kapso.test/meta/whatsapp/v24.0/pn-http/messages"),
+    ).toBe(true);
+    expect(calls.map((call) => call.body)).toContainEqual({
+      messaging_product: "whatsapp",
+      status: "read",
+      message_id: "wamid.HTTP_OK",
+      typing_indicator: { type: "text" },
+    });
+    expect(calls.map((call) => call.body)).toContainEqual({
+      messaging_product: "whatsapp",
+      recipient_type: "individual",
+      to: "34679077777",
+      type: "reaction",
+      reaction: { message_id: "wamid.HTTP_OK", emoji: "👀" },
+    });
+  });
+
+  test("Kapso acknowledgement failures do not block webhook success", async () => {
+    putKapsoNumberMapping({
+      phoneNumberId: "pn-http-ack-fail",
+      agentId,
+      createdAt: new Date().toISOString(),
+    });
+    globalThis.fetch = (async () => {
+      throw new Error("kapso unavailable");
+    }) as typeof fetch;
+
+    const rawBody = JSON.stringify(
+      makePayload({ phoneNumberId: "pn-http-ack-fail", messageId: "wamid.HTTP_ACK_FAIL" }),
+    );
+    const { req, res, captured } = fakeReqRes(rawBody, {
+      "x-webhook-signature": sign(HMAC_SECRET, rawBody),
+    });
+    const handled = await handleWebhooks(req, res, KAPSO_PATH);
+
+    expect(handled).toBe(true);
+    expect(captured.status).toBe(200);
+    expect(JSON.parse(captured.body)).toMatchObject({ received: true, routing: "task" });
   });
 
   test("valid HMAC + no mapping → 200 no_mapping (fallback, does not break)", async () => {
+    globalThis.fetch = (async () =>
+      new Response(JSON.stringify({ success: true }), { status: 200 })) as typeof fetch;
+
     const rawBody = JSON.stringify(
       makePayload({ phoneNumberId: "pn-http-unmapped", messageId: "wamid.HTTP_NOMAP" }),
     );

package/src/tests/opencode-adapter.test.ts

@@ -7,6 +7,7 @@
  */
 
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { Event as OpencodeEvent } from "@opencode-ai/sdk";
 import type { ProviderEvent, ProviderResult, ProviderSessionConfig } from "../providers/types";
@@ -640,3 +641,97 @@ describe("OpencodeAdapter — per-task isolation (DES-300)", () => {
     await Bun.$`rm -rf /tmp/opencode-data-task-cfg-json`.quiet().nothrow();
   });
 });
+
+// ── Phase 4: context-mode in-process plugin ────────────────────────────────────
+
+describe("OpencodeAdapter — context-mode plugin wiring (phase 4)", () => {
+  let prevContextModeDisabled: string | undefined;
+  let prevContextModePluginPath: string | undefined;
+  // The global npm install of context-mode is absent in the test env, so point
+  // the override at a real temp file to make resolution succeed deterministically.
+  const fakePluginPath = "/tmp/ctx-mode-opencode-plugin.test.js";
+
+  beforeEach(() => {
+    prevContextModeDisabled = process.env.CONTEXT_MODE_DISABLED;
+    prevContextModePluginPath = process.env.CONTEXT_MODE_OPENCODE_PLUGIN_PATH;
+    lastCreateOpencodeConfig = undefined;
+    mock.restore();
+  });
+
+  afterEach(() => {
+    // Never leak the env mutations across tests.
+    if (prevContextModeDisabled === undefined) delete process.env.CONTEXT_MODE_DISABLED;
+    else process.env.CONTEXT_MODE_DISABLED = prevContextModeDisabled;
+    if (prevContextModePluginPath === undefined)
+      delete process.env.CONTEXT_MODE_OPENCODE_PLUGIN_PATH;
+    else process.env.CONTEXT_MODE_OPENCODE_PLUGIN_PATH = prevContextModePluginPath;
+    Bun.$`rm -rf /tmp/opencode-task-1.json /tmp/opencode-data-task-1`.quiet().nothrow();
+    Bun.$`rm -rf /tmp/test/.opencode`.quiet().nothrow();
+    Bun.$`rm -f ${fakePluginPath}`.quiet().nothrow();
+  });
+
+  /** Pull the opencode config object passed to createOpencode. */
+  function getBuiltConfig(): { plugin?: string[]; mcp?: Record<string, unknown> } {
+    const opts = lastCreateOpencodeConfig as {
+      config?: { plugin?: string[]; mcp?: Record<string, unknown> };
+    };
+    expect(opts.config).toBeDefined();
+    return opts.config as { plugin?: string[]; mcp?: Record<string, unknown> };
+  }
+
+  test("resolveContextModePluginPath returns the override path when it exists", async () => {
+    writeFileSync(fakePluginPath, "// test plugin\n");
+    process.env.CONTEXT_MODE_OPENCODE_PLUGIN_PATH = fakePluginPath;
+    const { resolveContextModePluginPath } = await import("../providers/opencode-adapter");
+    expect(resolveContextModePluginPath()).toBe(fakePluginPath);
+  });
+
+  test("resolveContextModePluginPath returns null when the override path is missing", async () => {
+    process.env.CONTEXT_MODE_OPENCODE_PLUGIN_PATH = "/tmp/ctx-mode-does-not-exist.js";
+    const { resolveContextModePluginPath } = await import("../providers/opencode-adapter");
+    expect(resolveContextModePluginPath()).toBeNull();
+  });
+
+  test("plugin array includes the resolved context-mode plugin path when available", async () => {
+    delete process.env.CONTEXT_MODE_DISABLED;
+    writeFileSync(fakePluginPath, "// test plugin\n");
+    process.env.CONTEXT_MODE_OPENCODE_PLUGIN_PATH = fakePluginPath;
+    const events: OpencodeEvent[] = [
+      { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
+    ];
+    await driveSession(events, testConfig({ taskId: "task-1" }));
+
+    const built = getBuiltConfig();
+    expect(built.plugin).toContain(fakePluginPath);
+    // The bare package name must never be used — opencode can't resolve it offline.
+    expect(built.plugin).not.toContain("context-mode");
+  });
+
+  test("plugin array excludes context-mode when CONTEXT_MODE_DISABLED=true", async () => {
+    process.env.CONTEXT_MODE_DISABLED = "true";
+    writeFileSync(fakePluginPath, "// test plugin\n");
+    process.env.CONTEXT_MODE_OPENCODE_PLUGIN_PATH = fakePluginPath;
+    const events: OpencodeEvent[] = [
+      { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
+    ];
+    await driveSession(events, testConfig({ taskId: "task-1" }));
+
+    const built = getBuiltConfig();
+    expect(built.plugin).not.toContain(fakePluginPath);
+    expect(built.plugin).not.toContain("context-mode");
+  });
+
+  test("context-mode does NOT appear in the mcp block", async () => {
+    delete process.env.CONTEXT_MODE_DISABLED;
+    writeFileSync(fakePluginPath, "// test plugin\n");
+    process.env.CONTEXT_MODE_OPENCODE_PLUGIN_PATH = fakePluginPath;
+    const events: OpencodeEvent[] = [
+      { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
+    ];
+    await driveSession(events, testConfig({ taskId: "task-1" }));
+
+    const built = getBuiltConfig();
+    expect(built.mcp).toBeDefined();
+    expect(built.mcp?.["context-mode"]).toBeUndefined();
+  });
+});

package/src/tests/prompt-template-session.test.ts

@@ -90,10 +90,12 @@ describe("Session templates — registration", () => {
     }
   });
 
-  test("total of 19 session/system templates registered", () => {
+  test("total of 20 session/system templates registered", () => {
     const all = getAllTemplateDefinitions();
     const sessionSystem = all.filter((d) => d.category === "system" || d.category === "session");
-    expect(sessionSystem.length).toBe(19);
+    // 20 = the original 19 + `system.session.worker.pi` (a pi-specific worker
+    // composite that omits the context_mode block — see session-templates.ts).
+    expect(sessionSystem.length).toBe(20);
   });
 });
 

package/src/tests/self-improvement.test.ts

@@ -10,6 +10,11 @@ import {
   initDb,
 } from "../be/db";
 import { SqliteMemoryStore } from "../be/memory/providers/sqlite-store";
+import {
+  isAutomaticOrRecurringTaskCompletion,
+  isScheduledTaskCompletion,
+  shouldPersistTaskCompletionMemory,
+} from "../memory/automatic-task-gate";
 import { getBasePrompt } from "../prompts/base-prompt";
 
 const TEST_DB_PATH = "./test-self-improvement.sqlite";
@@ -143,6 +148,90 @@ describe("Self-Improvement Mechanisms", () => {
       expect(shortContent.length).toBeLessThan(30);
       // In store-progress, this would return early without creating memory
     });
+
+    test("manual task completions persist memory by default", () => {
+      const task = createTaskExtended("Manual implementation task", {
+        agentId: workerId,
+        source: "mcp",
+        priority: 50,
+        tags: ["memory", "bug-fix"],
+      });
+
+      expect(isScheduledTaskCompletion(task)).toBe(false);
+      expect(shouldPersistTaskCompletionMemory(task)).toBe(true);
+    });
+
+    test("scheduled task completions skip memory by default", () => {
+      const task = createTaskExtended("Run heartbeat checklist", {
+        agentId: workerId,
+        source: "schedule",
+        priority: 50,
+        tags: ["scheduled", "schedule:heartbeat-checklist"],
+      });
+
+      expect(isScheduledTaskCompletion(task)).toBe(true);
+      expect(isAutomaticOrRecurringTaskCompletion(task)).toBe(true);
+      expect(shouldPersistTaskCompletionMemory(task)).toBe(false);
+    });
+
+    test("heartbeat checklist completions skip memory without schedule tags", () => {
+      const task = createTaskExtended("Run heartbeat checklist", {
+        agentId: workerId,
+        source: "mcp",
+        priority: 60,
+        taskType: "heartbeat-checklist",
+        tags: ["checklist", "auto-generated"],
+      });
+
+      expect(isScheduledTaskCompletion(task)).toBe(false);
+      expect(isAutomaticOrRecurringTaskCompletion(task)).toBe(true);
+      expect(shouldPersistTaskCompletionMemory(task)).toBe(false);
+    });
+
+    test("boot triage completions skip memory by default", () => {
+      const task = createTaskExtended("Triage reboot-interrupted work", {
+        agentId: workerId,
+        source: "mcp",
+        priority: 80,
+        taskType: "boot-triage",
+        tags: ["boot", "triage", "auto-generated"],
+      });
+
+      expect(isAutomaticOrRecurringTaskCompletion(task)).toBe(true);
+      expect(shouldPersistTaskCompletionMemory(task)).toBe(false);
+    });
+
+    test("monitor and digest completions skip memory by default", () => {
+      const monitorTask = createTaskExtended("Check Claude Code changelog", {
+        agentId: workerId,
+        source: "schedule",
+        priority: 50,
+        taskType: "monitoring",
+        tags: ["health", "schedule:claude-code-changelog-monitor"],
+      });
+      const digestTask = createTaskExtended("Compile daily blocker digest", {
+        agentId: workerId,
+        source: "schedule",
+        priority: 50,
+        tags: ["scheduled", "schedule:daily-blocker-digest"],
+      });
+
+      expect(isAutomaticOrRecurringTaskCompletion(monitorTask)).toBe(true);
+      expect(shouldPersistTaskCompletionMemory(monitorTask)).toBe(false);
+      expect(isAutomaticOrRecurringTaskCompletion(digestTask)).toBe(true);
+      expect(shouldPersistTaskCompletionMemory(digestTask)).toBe(false);
+    });
+
+    test("scheduled task completions can opt in to memory persistence", () => {
+      const task = createTaskExtended("Daily digest found reusable incident pattern", {
+        agentId: workerId,
+        source: "schedule",
+        priority: 50,
+        tags: ["scheduled", "schedule:daily-blocker-digest"],
+      });
+
+      expect(shouldPersistTaskCompletionMemory(task, true)).toBe(true);
+    });
   });
 
   // ==========================================================================

package/src/tests/skill-update-scope.test.ts

@@ -2,6 +2,7 @@ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { closeDb, createAgent, createSkill, getSkillById, initDb } from "../be/db";
+import { registerSkillDeleteTool } from "../tools/skills/skill-delete";
 import { registerSkillUpdateTool } from "../tools/skills/skill-update";
 
 const TEST_DB_PATH = "./test-skill-update-scope.sqlite";
@@ -39,7 +40,30 @@ async function callSkillUpdate(
   return result as { structuredContent: StructuredContent };
 }
 
-describe("skill-update scope promotion", () => {
+async function callSkillDelete(
+  server: McpServer,
+  callerAgentId: string | undefined,
+  args: Record<string, unknown>,
+): Promise<{ structuredContent: StructuredContent }> {
+  // biome-ignore lint/complexity/noBannedTypes: accessing internal MCP SDK type for test
+  const tools = (server as unknown as { _registeredTools: Record<string, { handler: Function }> })
+    ._registeredTools;
+  const handler = tools["skill-delete"].handler;
+
+  const extra = {
+    sessionId: "test-session",
+    requestInfo: {
+      headers: {
+        "x-agent-id": callerAgentId ?? "",
+      },
+    },
+  };
+
+  const result = await handler(args, extra);
+  return result as { structuredContent: StructuredContent };
+}
+
+describe("skill mutation tools", () => {
   let server: McpServer;
 
   beforeAll(async () => {
@@ -59,6 +83,7 @@ describe("skill-update scope promotion", () => {
 
     server = new McpServer({ name: "test-skill-update-scope", version: "1.0.0" });
     registerSkillUpdateTool(server);
+    registerSkillDeleteTool(server);
   });
 
   afterAll(async () => {
@@ -162,4 +187,66 @@ describe("skill-update scope promotion", () => {
     expect(stored?.scope).toBe("agent");
     expect(stored?.isEnabled).toBe(false);
   });
+
+  test("system-default skill content updates are rejected", async () => {
+    const skill = createSkill({
+      name: "system-content-locked",
+      description: "System content lock",
+      content: "---\nname: system-content-locked\ndescription: System content lock\n---\n\nBody.",
+      type: "personal",
+      scope: "swarm",
+      ownerAgentId: WORKER_ID,
+      systemDefault: true,
+    });
+
+    const result = await callSkillUpdate(server, LEAD_ID, {
+      skillId: skill.id,
+      content: "---\nname: system-content-locked\ndescription: Changed\n---\n\nChanged.",
+    });
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toContain("system-managed");
+
+    const stored = getSkillById(skill.id);
+    expect(stored?.description).toBe("System content lock");
+    expect(stored?.version).toBe(1);
+  });
+
+  test("system-default skill enable toggle remains allowed", async () => {
+    const skill = createSkill({
+      name: "system-toggle-allowed",
+      description: "System toggle",
+      content: "---\nname: system-toggle-allowed\ndescription: System toggle\n---\n\nBody.",
+      type: "personal",
+      scope: "swarm",
+      ownerAgentId: WORKER_ID,
+      systemDefault: true,
+    });
+
+    const result = await callSkillUpdate(server, LEAD_ID, {
+      skillId: skill.id,
+      isEnabled: false,
+    });
+
+    expect(result.structuredContent.success).toBe(true);
+    expect(getSkillById(skill.id)?.isEnabled).toBe(false);
+  });
+
+  test("system-default skill deletes are rejected", async () => {
+    const skill = createSkill({
+      name: "system-delete-locked",
+      description: "System delete lock",
+      content: "---\nname: system-delete-locked\ndescription: System delete lock\n---\n\nBody.",
+      type: "personal",
+      scope: "swarm",
+      ownerAgentId: WORKER_ID,
+      systemDefault: true,
+    });
+
+    const result = await callSkillDelete(server, LEAD_ID, { skillId: skill.id });
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toContain("system-managed");
+    expect(getSkillById(skill.id)).not.toBeNull();
+  });
 });

package/src/tests/slack-blocks.test.ts

@@ -821,6 +821,21 @@ describe("buildTreeBlocks", () => {
     expect(blocks.length).toBe(2);
   });
 
+  test("offered root shows offered icon without undefined text", () => {
+    const root: TreeNode = {
+      taskId: makeTaskId("loff0001"),
+      agentName: "OfferedAgent",
+      status: "offered",
+      children: [],
+    };
+
+    const blocks = buildTreeBlocks([root]);
+    const text = blocks[0].text.text;
+
+    expect(text).toContain("📨 *OfferedAgent*");
+    expect(text).not.toContain("undefined");
+  });
+
   test("cancelled root shows cancel icon with no cancel button", () => {
     const root: TreeNode = {
       taskId: makeTaskId("mmmm0001"),