@desplega.ai/agent-swarm 1.92.2 → 1.93.0

package/src/tests/skill-fs-writer.test.ts

@@ -0,0 +1,250 @@
+/**
+ * Unit tests for the pure, DB-free writeSkillsToFilesystem() helper.
+ *
+ * These tests drive the writer directly with crafted SkillFsEntry arrays,
+ * exercising: simple write, complex skill with bundled files, binary-file
+ * skip, rename → stale dir removed, marker-gated cleanup leaves unmanaged
+ * dirs intact, path-traversal name sanitization.
+ */
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  type SkillFsEntry,
+  SWARM_MARKER_FILE,
+  writeSkillsToFilesystem,
+} from "../utils/skill-fs-writer";
+
+const FAKE_HOME = join(tmpdir(), `skill-fs-writer-test-${process.pid}`);
+
+function skillEntry(
+  overrides: Partial<SkillFsEntry> & { name: string; content: string },
+): SkillFsEntry {
+  return {
+    id: `id-${overrides.name}`,
+    isComplex: false,
+    isEnabled: true,
+    isActive: true,
+    files: [],
+    ...overrides,
+  };
+}
+
+describe("writeSkillsToFilesystem", () => {
+  beforeAll(() => {
+    mkdirSync(FAKE_HOME, { recursive: true });
+  });
+
+  afterEach(() => {
+    // Clean up between tests
+    rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
+    rmSync(join(FAKE_HOME, ".pi"), { recursive: true, force: true });
+    rmSync(join(FAKE_HOME, ".codex"), { recursive: true, force: true });
+  });
+
+  afterAll(() => {
+    rmSync(FAKE_HOME, { recursive: true, force: true });
+  });
+
+  test("writes simple skill SKILL.md to claude dir", () => {
+    const entries = [skillEntry({ name: "my-skill", content: "# My Skill\n\nDoes stuff." })];
+    const result = writeSkillsToFilesystem(entries, "claude", FAKE_HOME);
+
+    expect(result.errors).toHaveLength(0);
+    expect(result.synced).toBe(1);
+
+    const skillFile = join(FAKE_HOME, ".claude", "skills", "my-skill", "SKILL.md");
+    expect(existsSync(skillFile)).toBe(true);
+    expect(readFileSync(skillFile, "utf-8")).toContain("Does stuff.");
+  });
+
+  test("writes swarm-managed marker alongside SKILL.md", () => {
+    const entries = [skillEntry({ name: "my-skill", content: "# My Skill" })];
+    writeSkillsToFilesystem(entries, "claude", FAKE_HOME);
+
+    const marker = join(FAKE_HOME, ".claude", "skills", "my-skill", SWARM_MARKER_FILE);
+    expect(existsSync(marker)).toBe(true);
+  });
+
+  test("writes to all harness dirs when harnessType is 'all'", () => {
+    const entries = [skillEntry({ name: "multi-skill", content: "# Multi" })];
+    const result = writeSkillsToFilesystem(entries, "all", FAKE_HOME);
+
+    expect(result.synced).toBe(3); // claude + pi + codex
+    expect(existsSync(join(FAKE_HOME, ".claude", "skills", "multi-skill", "SKILL.md"))).toBe(true);
+    expect(existsSync(join(FAKE_HOME, ".pi", "agent", "skills", "multi-skill", "SKILL.md"))).toBe(
+      true,
+    );
+    expect(existsSync(join(FAKE_HOME, ".codex", "skills", "multi-skill", "SKILL.md"))).toBe(true);
+  });
+
+  test("writes complex skill SKILL.md plus non-binary bundled files", () => {
+    const entries = [
+      skillEntry({
+        name: "complex-skill",
+        content: "# Complex Skill",
+        isComplex: true,
+        files: [
+          {
+            path: "references/guide.md",
+            content: "# Guide\n\nBundled reference.",
+            isBinary: false,
+          },
+        ],
+      }),
+    ];
+    const result = writeSkillsToFilesystem(entries, "claude", FAKE_HOME);
+
+    expect(result.errors).toHaveLength(0);
+    expect(result.synced).toBe(1);
+
+    const skillFile = join(FAKE_HOME, ".claude", "skills", "complex-skill", "SKILL.md");
+    const bundledFile = join(
+      FAKE_HOME,
+      ".claude",
+      "skills",
+      "complex-skill",
+      "references",
+      "guide.md",
+    );
+    expect(existsSync(skillFile)).toBe(true);
+    expect(existsSync(bundledFile)).toBe(true);
+    expect(readFileSync(bundledFile, "utf-8")).toContain("Bundled reference.");
+  });
+
+  test("skips binary bundled files", () => {
+    const entries = [
+      skillEntry({
+        name: "complex-skill",
+        content: "# Complex Skill",
+        isComplex: true,
+        files: [
+          { path: "references/guide.md", content: "# Guide", isBinary: false },
+          { path: "assets/logo.png", content: "[binary]", isBinary: true },
+        ],
+      }),
+    ];
+    writeSkillsToFilesystem(entries, "claude", FAKE_HOME);
+
+    const binaryFile = join(FAKE_HOME, ".claude", "skills", "complex-skill", "assets", "logo.png");
+    const textFile = join(
+      FAKE_HOME,
+      ".claude",
+      "skills",
+      "complex-skill",
+      "references",
+      "guide.md",
+    );
+    expect(existsSync(binaryFile)).toBe(false);
+    expect(existsSync(textFile)).toBe(true);
+  });
+
+  test("skips legacy complex skills with no files", () => {
+    const entries = [
+      skillEntry({
+        name: "legacy-complex",
+        content: "# Legacy",
+        isComplex: true,
+        files: [], // no files → skip
+      }),
+    ];
+    writeSkillsToFilesystem(entries, "claude", FAKE_HOME);
+
+    const skillDir = join(FAKE_HOME, ".claude", "skills", "legacy-complex");
+    expect(existsSync(skillDir)).toBe(false);
+  });
+
+  test("skips inactive skills", () => {
+    const entries = [
+      skillEntry({ name: "inactive-skill", content: "# Inactive", isActive: false }),
+    ];
+    const result = writeSkillsToFilesystem(entries, "claude", FAKE_HOME);
+
+    expect(result.synced).toBe(0);
+    expect(existsSync(join(FAKE_HOME, ".claude", "skills", "inactive-skill"))).toBe(false);
+  });
+
+  test("skips disabled skills", () => {
+    const entries = [
+      skillEntry({ name: "disabled-skill", content: "# Disabled", isEnabled: false }),
+    ];
+    const result = writeSkillsToFilesystem(entries, "claude", FAKE_HOME);
+
+    expect(result.synced).toBe(0);
+    expect(existsSync(join(FAKE_HOME, ".claude", "skills", "disabled-skill"))).toBe(false);
+  });
+
+  test("removes stale swarm-managed skill directory on rename", () => {
+    // First sync: write old-name
+    const first = [skillEntry({ name: "old-name", content: "# Old" })];
+    writeSkillsToFilesystem(first, "claude", FAKE_HOME);
+
+    const oldDir = join(FAKE_HOME, ".claude", "skills", "old-name");
+    expect(existsSync(oldDir)).toBe(true);
+
+    // Second sync: write new-name, old-name disappears
+    const second = [skillEntry({ name: "new-name", content: "# New" })];
+    const result = writeSkillsToFilesystem(second, "claude", FAKE_HOME);
+
+    expect(result.removed).toBeGreaterThanOrEqual(1);
+    expect(existsSync(oldDir)).toBe(false);
+    expect(existsSync(join(FAKE_HOME, ".claude", "skills", "new-name", "SKILL.md"))).toBe(true);
+  });
+
+  test("marker-gated cleanup leaves unmanaged dirs intact", () => {
+    // User-installed skill dir with no .swarm-managed marker
+    const foreignDir = join(FAKE_HOME, ".claude", "skills", "user-personal-skill");
+    mkdirSync(foreignDir, { recursive: true });
+    writeFileSync(join(foreignDir, "SKILL.md"), "user's own skill — keep me");
+
+    // Sync with a different skill set — should NOT touch the unmanaged dir
+    const entries = [skillEntry({ name: "swarm-skill", content: "# Swarm" })];
+    writeSkillsToFilesystem(entries, "claude", FAKE_HOME);
+
+    expect(existsSync(foreignDir)).toBe(true);
+    expect(readFileSync(join(foreignDir, "SKILL.md"), "utf-8")).toBe("user's own skill — keep me");
+  });
+
+  test("sanitizes path-traversal characters in skill names", () => {
+    const entries = [skillEntry({ name: "my/dangerous/../skill", content: "# Safe" })];
+    const result = writeSkillsToFilesystem(entries, "claude", FAKE_HOME);
+
+    expect(result.errors).toHaveLength(0);
+    const sanitizedDir = join(FAKE_HOME, ".claude", "skills", "my_dangerous____skill");
+    expect(existsSync(sanitizedDir)).toBe(true);
+  });
+
+  test("removes stale bundled files on re-sync", () => {
+    // First sync: write complex skill with one file
+    const first = [
+      skillEntry({
+        name: "complex-skill",
+        content: "# Complex",
+        isComplex: true,
+        files: [{ path: "references/guide.md", content: "# Guide", isBinary: false }],
+      }),
+    ];
+    writeSkillsToFilesystem(first, "claude", FAKE_HOME);
+
+    const skillDir = join(FAKE_HOME, ".claude", "skills", "complex-skill");
+    // Manually add a stale file that should be removed
+    writeFileSync(join(skillDir, "references", "stale.md"), "stale content");
+    expect(existsSync(join(skillDir, "references", "stale.md"))).toBe(true);
+
+    // Second sync: same skill, file not in new set → should be removed
+    const result = writeSkillsToFilesystem(first, "claude", FAKE_HOME);
+
+    expect(result.removed).toBeGreaterThanOrEqual(1);
+    expect(existsSync(join(skillDir, "references", "stale.md"))).toBe(false);
+    expect(existsSync(join(skillDir, "references", "guide.md"))).toBe(true);
+  });
+
+  test("returns empty result for empty entries", () => {
+    const result = writeSkillsToFilesystem([], "claude", FAKE_HOME);
+
+    expect(result.synced).toBe(0);
+    expect(result.removed).toBe(0);
+    expect(result.errors).toHaveLength(0);
+  });
+});

package/src/tests/slack-attachments-block.test.ts

@@ -4,7 +4,6 @@ import type { TaskAttachment } from "../types";
 
 // Slack block types are open unions — the builder returns `any`; we read it
 // as `any` in the test to inspect the runtime shape.
-// biome-ignore lint/suspicious/noExplicitAny: see comment above
 type SlackBlock = any;
 
 function mkAttachment(overrides: Partial<TaskAttachment>): TaskAttachment {

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

@@ -941,7 +941,6 @@ function mkAttachment(overrides: Partial<TaskAttachment>): TaskAttachment {
   };
 }
 
-// biome-ignore lint/suspicious/noExplicitAny: section blocks are loose plain objects
 type AnyBlock = any;
 
 function sectionTexts(blocks: AnyBlock[]): string[] {

package/src/tests/slack-channel-join.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, mock, test } from "bun:test";
+import type { WebClient } from "@slack/web-api";
+import { withAutoJoin } from "../slack/channel-join";
+
+// Mirrors the shape @slack/web-api's platformErrorFromResult produces:
+// message = "An API error occurred: <code>", data.error = "<code>"
+function makePlatformError(code: string): Error {
+  const err = new Error(`An API error occurred: ${code}`);
+  (err as unknown as { data: { error: string } }).data = { error: code };
+  return err;
+}
+
+describe("withAutoJoin", () => {
+  test("success: fn called once, join not called", async () => {
+    const joinFn = mock(() => Promise.resolve({}));
+    const client = { conversations: { join: joinFn } } as unknown as WebClient;
+    const fn = mock(() => Promise.resolve("ok"));
+
+    const result = await withAutoJoin(client, "C123", fn);
+    expect(result).toBe("ok");
+    expect(fn).toHaveBeenCalledTimes(1);
+    expect(joinFn).not.toHaveBeenCalled();
+  });
+
+  test("not_in_channel: calls join then retries fn exactly once", async () => {
+    const joinFn = mock(() => Promise.resolve({}));
+    const client = { conversations: { join: joinFn } } as unknown as WebClient;
+    let callCount = 0;
+    const fn = mock(async () => {
+      callCount++;
+      if (callCount === 1) throw makePlatformError("not_in_channel");
+      return "retried-ok";
+    });
+
+    const result = await withAutoJoin(client, "CPUB", fn);
+    expect(result).toBe("retried-ok");
+    expect(fn).toHaveBeenCalledTimes(2);
+    expect(joinFn).toHaveBeenCalledTimes(1);
+    expect(joinFn).toHaveBeenCalledWith({ channel: "CPUB" });
+  });
+
+  test("private channel: join fails with method_not_supported_for_channel_type → descriptive error", async () => {
+    const joinFn = mock(() => {
+      throw makePlatformError("method_not_supported_for_channel_type");
+    });
+    const client = { conversations: { join: joinFn } } as unknown as WebClient;
+    const fn = mock(() => {
+      throw makePlatformError("not_in_channel");
+    });
+
+    await expect(withAutoJoin(client, "CPRIV", fn)).rejects.toThrow("invite the bot");
+    expect(joinFn).toHaveBeenCalledTimes(1);
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  test("non-not_in_channel error: rethrown without join", async () => {
+    const joinFn = mock(() => Promise.resolve({}));
+    const client = { conversations: { join: joinFn } } as unknown as WebClient;
+    const fn = mock(() => {
+      throw makePlatformError("channel_not_found");
+    });
+
+    await expect(withAutoJoin(client, "C123", fn)).rejects.toThrow("channel_not_found");
+    expect(joinFn).not.toHaveBeenCalled();
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  test("retry is bounded: second fn error propagates without another join", async () => {
+    const joinFn = mock(() => Promise.resolve({}));
+    const client = { conversations: { join: joinFn } } as unknown as WebClient;
+    // Every call throws not_in_channel, but we only join once and retry once
+    const fn = mock(() => {
+      throw makePlatformError("not_in_channel");
+    });
+
+    await expect(withAutoJoin(client, "C123", fn)).rejects.toThrow("not_in_channel");
+    expect(fn).toHaveBeenCalledTimes(2);
+    expect(joinFn).toHaveBeenCalledTimes(1); // no infinite loop
+  });
+});

package/src/tests/slack-identity-resolution.test.ts

@@ -62,7 +62,6 @@ function makeMockClient(byUserId: Record<string, MockUsersInfoResponse | "throw"
     },
   };
   return {
-    // biome-ignore lint/suspicious/noExplicitAny: shape-matched to WebClient's users.info call site.
     client: client as any,
     callCounts,
   };

package/src/tests/structured-output.test.ts

@@ -233,7 +233,6 @@ describe("AgentTaskConfigSchema — outputSchema", () => {
   test("accepts outputSchema in config", async () => {
     const { AgentTaskExecutor } = await import("../workflows/executors/agent-task");
     const executor = new AgentTaskExecutor({
-      // biome-ignore lint/suspicious/noExplicitAny: mock DB for test
       db: {} as any,
       eventBus: { emit: () => {}, on: () => {}, off: () => {} },
       interpolate: (t: string) => t,
@@ -257,7 +256,6 @@ describe("AgentTaskConfigSchema — outputSchema", () => {
   test("accepts followUpConfig in config", async () => {
     const { AgentTaskExecutor } = await import("../workflows/executors/agent-task");
     const executor = new AgentTaskExecutor({
-      // biome-ignore lint/suspicious/noExplicitAny: mock DB for test
       db: {} as any,
       eventBus: { emit: () => {}, on: () => {}, off: () => {} },
       interpolate: (t: string) => t,

package/src/tests/use-dismissible-card.test.ts

@@ -49,7 +49,6 @@ class MemoryStorage {
 
 afterEach(() => {
   // Clean up the global between tests so leakage can't mask bugs.
-  // biome-ignore lint/suspicious/noExplicitAny: test-only shim
   delete (globalThis as any).localStorage;
 });
 
@@ -82,7 +81,6 @@ describe("deriveStorageKey", () => {
 describe("dismiss / restore round-trip via localStorage shape", () => {
   test("dismiss writes '1' under the namespaced key; restore removes it", () => {
     const storage = new MemoryStorage();
-    // biome-ignore lint/suspicious/noExplicitAny: test-only shim
     (globalThis as any).localStorage = storage;
 
     const key = deriveStorageKey("http://localhost:3013", "home-welcome");
@@ -101,7 +99,6 @@ describe("dismiss / restore round-trip via localStorage shape", () => {
 
   test("namespace isolation: dismissing on apiUrl A does not affect apiUrl B", () => {
     const storage = new MemoryStorage();
-    // biome-ignore lint/suspicious/noExplicitAny: test-only shim
     (globalThis as any).localStorage = storage;
 
     const keyA = deriveStorageKey("http://a.local:3013", "home-welcome");
@@ -118,7 +115,6 @@ describe("graceful failure when localStorage throws", () => {
   test("setItem throw is swallowed by the hook's try/catch contract", () => {
     const storage = new MemoryStorage();
     storage.setThrowOnSet(true);
-    // biome-ignore lint/suspicious/noExplicitAny: test-only shim
     (globalThis as any).localStorage = storage;
 
     const key = deriveStorageKey("http://localhost:3013", "home-welcome");

package/src/tools/schedules/create-schedule.ts

@@ -76,10 +76,10 @@ export const registerCreateScheduleTool = (server: McpServer) => {
           .optional()
           .describe("Whether the schedule is enabled (default: true)"),
         model: z
-          .enum(["haiku", "sonnet", "opus"])
+          .enum(["haiku", "sonnet", "opus", "fable"])
           .optional()
           .describe(
-            "Model to use for tasks created by this schedule ('haiku', 'sonnet', or 'opus'). If not set, uses agent/global config or defaults to 'opus'.",
+            "Model to use for tasks created by this schedule ('haiku', 'sonnet', 'opus', or 'fable'). If not set, uses agent/global config or defaults to 'opus'.",
           ),
       }),
       outputSchema: z.object({

package/src/tools/schedules/update-schedule.ts

@@ -44,7 +44,7 @@ export const registerUpdateScheduleTool = (server: McpServer) => {
         timezone: z.string().optional().describe("New timezone"),
         enabled: z.boolean().optional().describe("Enable or disable the schedule"),
         model: z
-          .enum(["haiku", "sonnet", "opus"])
+          .enum(["haiku", "sonnet", "opus", "fable"])
           .nullable()
           .optional()
           .describe("Model to use for tasks created by this schedule. Set to null to clear."),

package/src/tools/send-task.ts

@@ -54,10 +54,10 @@ export const sendTaskInputSchema = z.object({
       "VCS repo identifier (e.g., 'desplega-ai/agent-swarm' for GitHub or 'group/project' for GitLab). Links the task to a registered repo for workspace context.",
     ),
   model: z
-    .enum(["haiku", "sonnet", "opus"])
+    .enum(["haiku", "sonnet", "opus", "fable"])
     .optional()
     .describe(
-      "Model to use for this task ('haiku', 'sonnet', or 'opus'). If not set, uses agent/global config MODEL_OVERRIDE or defaults to 'opus'.",
+      "Model to use for this task ('haiku', 'sonnet', 'opus', or 'fable'). If not set, uses agent/global config MODEL_OVERRIDE or defaults to 'opus'.",
     ),
   allowDuplicate: z
     .boolean()

package/src/tools/slack-post.ts

@@ -2,6 +2,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { getAgentById } from "@/be/db";
 import { getSlackApp } from "@/slack/app";
+import { withAutoJoin } from "@/slack/channel-join";
 import { markdownToSlack } from "@/slack/responses";
 import { createToolRegistrar } from "@/tools/utils";
 
@@ -68,22 +69,24 @@ export const registerSlackPostTool = (server: McpServer) => {
       try {
         const slackMessage = markdownToSlack(message);
 
-        const result = await app.client.chat.postMessage({
-          channel: channelId,
-          text: slackMessage, // Fallback for notifications
-          username: agent.name,
-          icon_emoji: ":crown:",
-          ...(threadTs ? { thread_ts: threadTs } : {}),
-          blocks: [
-            {
-              type: "section",
-              text: {
-                type: "mrkdwn",
-                text: slackMessage,
+        const result = await withAutoJoin(app.client, channelId, () =>
+          app.client.chat.postMessage({
+            channel: channelId,
+            text: slackMessage, // Fallback for notifications
+            username: agent.name,
+            icon_emoji: ":crown:",
+            ...(threadTs ? { thread_ts: threadTs } : {}),
+            blocks: [
+              {
+                type: "section",
+                text: {
+                  type: "mrkdwn",
+                  text: slackMessage,
+                },
               },
-            },
-          ],
-        });
+            ],
+          }),
+        );
 
         const messageTs = result.ts;
 

package/src/tools/slack-read.ts

@@ -2,6 +2,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { getAgentById, getInboxMessageById, getTaskById } from "@/be/db";
 import { getSlackApp } from "@/slack/app";
+import { withAutoJoin } from "@/slack/channel-join";
 import { downloadFile } from "@/slack/files";
 import { extractSlackMessageText } from "@/slack/message-text";
 import { createToolRegistrar } from "@/tools/utils";
@@ -216,19 +217,16 @@ export const registerSlackReadTool = (server: McpServer) => {
         let rawMessages: RawMessage[] = [];
 
         if (slackThreadTs) {
-          // Fetch thread replies
-          const result = await client.conversations.replies({
-            channel: slackChannelId,
-            ts: slackThreadTs,
-            limit,
-          });
+          // Fetch thread replies — auto-join public channels on not_in_channel
+          const result = await withAutoJoin(client, slackChannelId, () =>
+            client.conversations.replies({ channel: slackChannelId, ts: slackThreadTs!, limit }),
+          );
           rawMessages = (result.messages || []) as RawMessage[];
         } else {
-          // Fetch channel history
-          const result = await client.conversations.history({
-            channel: slackChannelId,
-            limit,
-          });
+          // Fetch channel history — auto-join public channels on not_in_channel
+          const result = await withAutoJoin(client, slackChannelId, () =>
+            client.conversations.history({ channel: slackChannelId, limit }),
+          );
           rawMessages = (result.messages || []) as RawMessage[];
         }
 

package/src/tools/slack-reply.ts

@@ -8,6 +8,7 @@ import {
   markTaskSlackReplySent,
 } from "@/be/db";
 import { getSlackApp } from "@/slack/app";
+import { withAutoJoin } from "@/slack/channel-join";
 import { markdownToSlack } from "@/slack/responses";
 import { createToolRegistrar } from "@/tools/utils";
 
@@ -118,22 +119,24 @@ export const registerSlackReplyTool = (server: McpServer) => {
       try {
         const slackMessage = markdownToSlack(message);
 
-        await app.client.chat.postMessage({
-          channel: slackChannelId,
-          thread_ts: slackThreadTs,
-          text: slackMessage, // Fallback for notifications
-          username: agent.name,
-          icon_emoji: agent.isLead ? ":crown:" : ":robot_face:",
-          blocks: [
-            {
-              type: "section",
-              text: {
-                type: "mrkdwn",
-                text: slackMessage,
+        await withAutoJoin(app.client, slackChannelId, () =>
+          app.client.chat.postMessage({
+            channel: slackChannelId,
+            thread_ts: slackThreadTs,
+            text: slackMessage, // Fallback for notifications
+            username: agent.name,
+            icon_emoji: agent.isLead ? ":crown:" : ":robot_face:",
+            blocks: [
+              {
+                type: "section",
+                text: {
+                  type: "mrkdwn",
+                  text: slackMessage,
+                },
               },
-            },
-          ],
-        });
+            ],
+          }),
+        );
 
         // After successful postMessage, mark task as having a Slack reply
         if (taskId) {

package/src/tools/slack-start-thread.ts

@@ -2,6 +2,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { getAgentById } from "@/be/db";
 import { getSlackApp } from "@/slack/app";
+import { withAutoJoin } from "@/slack/channel-join";
 import { markdownToSlack } from "@/slack/responses";
 import { createToolRegistrar } from "@/tools/utils";
 
@@ -62,21 +63,23 @@ export const registerSlackStartThreadTool = (server: McpServer) => {
       try {
         const slackMessage = markdownToSlack(message);
 
-        const result = await app.client.chat.postMessage({
-          channel: channelId,
-          text: slackMessage, // Fallback for notifications
-          username: agent.name,
-          icon_emoji: ":crown:",
-          blocks: [
-            {
-              type: "section",
-              text: {
-                type: "mrkdwn",
-                text: slackMessage,
+        const result = await withAutoJoin(app.client, channelId, () =>
+          app.client.chat.postMessage({
+            channel: channelId,
+            text: slackMessage, // Fallback for notifications
+            username: agent.name,
+            icon_emoji: ":crown:",
+            blocks: [
+              {
+                type: "section",
+                text: {
+                  type: "mrkdwn",
+                  text: slackMessage,
+                },
               },
-            },
-          ],
-        });
+            ],
+          }),
+        );
 
         const ts = result.ts;
         const resolvedChannelId = result.channel ?? channelId;

package/src/tools/task-action.ts

@@ -66,10 +66,10 @@ export const taskActionInputSchema = z.object({
       "Working directory (absolute path) for the agent to start in. Only used with 'create' action.",
     ),
   model: z
-    .enum(["haiku", "sonnet", "opus"])
+    .enum(["haiku", "sonnet", "opus", "fable"])
     .optional()
     .describe(
-      "Model to use for the created task ('haiku', 'sonnet', or 'opus'). Only used with 'create' action.",
+      "Model to use for the created task ('haiku', 'sonnet', 'opus', or 'fable'). Only used with 'create' action.",
     ),
 });
 

package/src/types.ts

@@ -247,6 +247,10 @@ export const AgentTaskSchema = z.object({
   provider: ProviderNameSchema.optional(),
   providerMeta: z.record(z.string(), z.unknown()).optional(),
 
+  // Harness variant — sub-variant within a provider (e.g. "bridge" vs "stock" for claude)
+  harnessVariant: z.string().optional(),
+  harnessVariantMeta: z.record(z.string(), z.unknown()).optional(),
+
   // Aggregated session cost for task list/read models. Undefined means no
   // session cost rows have been recorded for this task.
   totalCostUsd: z.number().min(0).optional(),
@@ -1579,6 +1583,13 @@ export const ScriptRunSchema = z.object({
 });
 export type ScriptRun = z.infer<typeof ScriptRunSchema>;
 
+export const ScriptRunListItemSchema = ScriptRunSchema.omit({
+  source: true,
+  args: true,
+  output: true,
+});
+export type ScriptRunListItem = z.infer<typeof ScriptRunListItemSchema>;
+
 export const ScriptRunJournalEntrySchema = z.object({
   id: z.string().uuid(),
   runId: z.string().uuid(),