@@ -0,0 +1,5 @@
+---
+"@plotday/twister": minor
+---
+
+Added: `Connector.hiddenChannels` — declare that a connector's channels are internal detail rather than a user choice. Channels are still reported and mirrored so links keep their channel attribution, but no channel picker is shown and enable/disable is not offered. Use it for connectors whose sync scope is decided by rules rather than channel selection.
@@ -52,4 +52,18 @@ describe("transformSlackThread", () => {
     });
     expect(link.notes?.[0]?.author).toEqual(link.author);
   });
+
+  it("does not ask the platform to re-group the messages", () => {
+    // Outside a direct conversation, Slack's own reply threads are a real,
+    // user-visible grouping. Folding consecutive messages on top of that
+    // would merge separate conversations that happen to run back to back.
+    const link = transformSlackThread(
+      [{ type: "message", ts: "3000.0001", user: "U1", text: "Standalone" }],
+      "C123"
+    );
+
+    expect(
+      (link as unknown as { autoThread?: unknown }).autoThread
+    ).toBeUndefined();
+  });
 });
@@ -3,6 +3,7 @@ import type {
   Action,
   NewLinkWithNotes,
   NewActor,
+  NewContact,
   NewReactions,
 } from "@plotday/twister/plot";
 import { slackNameToUnicode } from "./slack-emoji";
@@ -297,6 +298,22 @@ export class SlackApi {
     };
   }
 
+  /**
+   * Ids of the user groups `userId` belongs to. Requires the `usergroups:read`
+   * scope; callers must check the grant before calling, since a missing scope
+   * surfaces as a permanent error that would flag the whole connection.
+   */
+  public async getUserGroupsForUser(userId: string): Promise<string[]> {
+    const data = await this.call("usergroups.list", { include_users: "true" });
+    const groups = (data.usergroups ?? []) as Array<{
+      id: string;
+      users?: string[];
+    }>;
+    return groups
+      .filter((group) => group.users?.includes(userId))
+      .map((group) => group.id);
+  }
+
   public async getConversationHistory(
     channelId: string,
     cursor?: string,
@@ -569,7 +586,7 @@ export function slackUserInfoFromUser(user: SlackUser): SlackUserInfo {
 }
 
 /**
- * Converts a Slack user ID to a NewActor. Always returns an actor: with no
+ * Converts a Slack user ID to a NewContact. Always returns a contact: with no
  * resolvable name or email it falls back to the raw user id as the name.
  *
  * That fallback is a healing placeholder, not poison. `users.info` being
@@ -579,8 +596,14 @@ export function slackUserInfoFromUser(user: SlackUser): SlackUserInfo {
  * crediting the connection itself. The API treats a contact whose name equals
  * its own account id as unresolved and replaces it with the real name as soon
  * as `users.info` succeeds, so the id never sticks.
+ *
+ * Declared return type is `NewContact` (the contact-shaped half of the
+ * `NewActor` union), not `NewActor` — every branch below already returns a
+ * contact shape, so widening to the precise type lets callers that need a
+ * guaranteed `name`/`email` (e.g. deriving a DM title or `accessContacts`)
+ * use this directly instead of duplicating the fallback logic.
  */
-function slackUserToNewActor(userId: string, info?: SlackUserInfo): NewActor {
+export function slackUserToNewActor(userId: string, info?: SlackUserInfo): NewContact {
   const source = {
     accountId: userId,
     ...(info?.handle ? { descriptor: `@${info.handle}` } : {}),
@@ -735,14 +758,6 @@ export function transformSlackThread(
     notes: [],
     preview: firstText || null,
     ...(initialSync ? { unread: false, archived: false } : {}),
-    // Opt into sequential auto-threading, keyed on the channel. A no-op
-    // unless the connection enabled it. 1:1 DMs (channel id "D…") read as one
-    // continuous conversation, so fold every message into a single running
-    // thread; channels and group DMs use the LLM continuation check.
-    autoThread: {
-      key: channelId,
-      mode: channelId.startsWith("D") ? "fold" : "sequential",
-    },
   };
 
   // Create Notes for all messages (including first). Reactions live
 
@@ -0,0 +1,239 @@
+import { describe, expect, it } from "vitest";
+
+import { assembleSlackDmLink } from "./slack-dm";
+import type { SlackMessage, SlackUserInfo } from "./slack-api";
+
+function msg(ts: string, user: string, text: string, threadTs?: string): SlackMessage {
+  return { type: "message", ts, user, text, ...(threadTs ? { thread_ts: threadTs } : {}) };
+}
+
+describe("assembleSlackDmLink", () => {
+  it("keys a 1:1 DM on the counterparty", () => {
+    const link = assembleSlackDmLink({
+      channelId: "D111",
+      counterpartyUserId: "U222",
+      messages: [msg("100.1", "U222", "hi")],
+      initialSync: false,
+    });
+
+    expect(link?.source).toBe("slack:person:U222");
+    expect(link?.sources).toEqual(["slack:person:U222", "slack:chat:D111"]);
+    expect(link?.type).toBe("dm");
+    expect(link?.channelId).toBe("D111");
+    expect(link?.meta?.direct).toBe(true);
+  });
+
+  it("keys a group DM on the conversation", () => {
+    const link = assembleSlackDmLink({
+      channelId: "G333",
+      counterpartyUserId: null,
+      messages: [msg("100.1", "U222", "hi all")],
+      initialSync: false,
+    });
+
+    expect(link?.source).toBe("slack:chat:G333");
+    expect(link?.sources).toEqual(["slack:chat:G333"]);
+  });
+
+  it("creates one note per message, oldest first, keyed on ts", () => {
+    const link = assembleSlackDmLink({
+      channelId: "D111",
+      counterpartyUserId: "U222",
+      messages: [msg("102.0", "U222", "third"), msg("100.0", "U222", "first")],
+      initialSync: false,
+    });
+
+    expect(link?.notes?.map((n) => n.key)).toEqual(["100.0", "102.0"]);
+    expect(link?.notes?.map((n) => n.content)).toEqual(["first", "third"]);
+  });
+
+  it("records the newest message as meta.threadTs so a to-do star has something to target", () => {
+    // A DM is one permanent, ever-growing link with no single message of its
+    // own, so onThreadToDo needs a message to anchor a star on. Without this,
+    // starring a synced (as opposed to composed-from-Plot) DM is a silent
+    // no-op — onThreadToDo bails out whenever meta.threadTs is missing.
+    const link = assembleSlackDmLink({
+      channelId: "D111",
+      counterpartyUserId: "U222",
+      messages: [msg("100.0", "U222", "first"), msg("102.0", "U222", "third")],
+      initialSync: false,
+    });
+
+    expect(link?.meta?.threadTs).toBe("102.0");
+  });
+
+  it("marks a threaded reply with reNote pointing at its parent", () => {
+    const link = assembleSlackDmLink({
+      channelId: "D111",
+      counterpartyUserId: "U222",
+      messages: [msg("100.0", "U222", "parent"), msg("101.0", "U222", "reply", "100.0")],
+      initialSync: false,
+    });
+
+    expect(link?.notes?.[0]?.reNote).toBeUndefined();
+    expect(link?.notes?.[1]?.reNote).toEqual({ key: "100.0" });
+  });
+
+  it("does not mark a thread parent as its own reply", () => {
+    const link = assembleSlackDmLink({
+      channelId: "D111",
+      counterpartyUserId: "U222",
+      messages: [msg("100.0", "U222", "parent", "100.0")],
+      initialSync: false,
+    });
+
+    expect(link?.notes?.[0]?.reNote).toBeUndefined();
+  });
+
+  it("suppresses unread and archived state on initial sync", () => {
+    const link = assembleSlackDmLink({
+      channelId: "D111",
+      counterpartyUserId: "U222",
+      messages: [msg("100.0", "U222", "hi")],
+      initialSync: true,
+    });
+
+    expect(link?.unread).toBe(false);
+    expect(link?.archived).toBe(false);
+  });
+
+  it("returns null when there are no messages", () => {
+    expect(
+      assembleSlackDmLink({
+        channelId: "D111",
+        counterpartyUserId: "U222",
+        messages: [],
+        initialSync: false,
+      })
+    ).toBeNull();
+  });
+
+  it("derives title from counterparty's name when userInfos is provided", () => {
+    const userInfos = new Map<string, SlackUserInfo>([
+      ["U222", { name: "Alice", email: "alice@example.com", handle: "alice" }],
+    ]);
+
+    const link = assembleSlackDmLink({
+      channelId: "D111",
+      counterpartyUserId: "U222",
+      messages: [msg("100.0", "U222", "hello")],
+      initialSync: false,
+      userInfos,
+    });
+
+    expect(link?.title).toBe("Alice");
+    expect(link?.accessContacts?.[0]?.name).toBe("Alice");
+    expect(link?.accessContacts?.[0]?.email).toBe("alice@example.com");
+  });
+
+  it("sets a real author on every note", () => {
+    const link = assembleSlackDmLink({
+      channelId: "D111",
+      counterpartyUserId: "U222",
+      messages: [msg("100.0", "U222", "hi")],
+      initialSync: false,
+    });
+
+    expect(link?.notes?.[0]?.author).toBeDefined();
+    expect(
+      link?.notes?.[0]?.author && "source" in link.notes[0].author
+        ? link.notes[0].author.source?.accountId
+        : undefined
+    ).toBe("U222");
+  });
+
+  it("omits unread/archived (does not hardcode them) when initialSync is false", () => {
+    const link = assembleSlackDmLink({
+      channelId: "D111",
+      counterpartyUserId: "U222",
+      messages: [msg("100.0", "U222", "hi")],
+      initialSync: false,
+    });
+
+    expect(link).not.toHaveProperty("unread");
+    expect(link).not.toHaveProperty("archived");
+  });
+
+  it("still carries a counterparty contact and no clobbered title when userInfos hasn't resolved", () => {
+    const link = assembleSlackDmLink({
+      channelId: "D111",
+      counterpartyUserId: "U222",
+      messages: [msg("100.0", "U222", "hi")],
+      initialSync: false,
+      // No userInfos at all — a cold or rate-limited sync.
+    });
+
+    // CRITICAL 1: accessContacts must not vanish just because users.info
+    // hasn't resolved — it's the filing signal for link creation, which
+    // only happens once.
+    expect(link?.accessContacts).toBeDefined();
+    expect(link?.accessContacts?.[0]?.source?.accountId).toBe("U222");
+
+    // CRITICAL 2: title must be omitted (preserving any existing stored
+    // title) rather than clobbered with a placeholder — neither the raw
+    // Slack user id nor a generic constant string.
+    expect(link).not.toHaveProperty("title");
+  });
+
+  it("carries file/image attachments as fileRef actions", () => {
+    const message: SlackMessage = {
+      type: "message",
+      ts: "100.0",
+      user: "U222",
+      text: "check this out",
+      files: [
+        {
+          id: "F123",
+          name: "screenshot.png",
+          mimetype: "image/png",
+          size: 4096,
+          original_w: 800,
+          original_h: 600,
+        },
+      ],
+    };
+
+    const link = assembleSlackDmLink({
+      channelId: "D111",
+      counterpartyUserId: "U222",
+      messages: [message],
+      initialSync: false,
+    });
+
+    expect(link?.notes?.[0]?.actions).toEqual([
+      {
+        type: "fileRef",
+        ref: "F123",
+        fileName: "screenshot.png",
+        fileSize: 4096,
+        mimeType: "image/png",
+        imageWidth: 800,
+        imageHeight: 600,
+      },
+    ]);
+  });
+
+  it("sets checkForTasks on every note", () => {
+    const link = assembleSlackDmLink({
+      channelId: "D111",
+      counterpartyUserId: "U222",
+      messages: [msg("100.0", "U222", "hi")],
+      initialSync: false,
+    });
+
+    expect(link?.notes?.[0]?.checkForTasks).toBe(true);
+  });
+
+  it("sets a canonical Slack sourceUrl anchored on the latest message", () => {
+    const link = assembleSlackDmLink({
+      channelId: "D111",
+      counterpartyUserId: "U222",
+      messages: [msg("100.0", "U222", "first"), msg("102.0", "U222", "second")],
+      initialSync: false,
+    });
+
+    expect(link?.sourceUrl).toBe(
+      "https://slack.com/app_redirect?channel=D111&message_ts=102.0"
+    );
+  });
+});
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"@plotday/twister": minor
 +---
++
 +Added: `Connector.hiddenChannels` — declare that a connector's channels are internal detail rather than a user choice. Channels are still reported and mirrored so links keep their channel attribution, but no channel picker is shown and enable/disable is not offered. Use it for connectors whose sync scope is decided by rules rather than channel selection.