@mastra/factory 0.24.0-alpha.0 → 0.24.0-alpha.10

package/dist/integrations/slack/integration.js

@@ -2,11 +2,27 @@ import { createSlackConnectRoutes } from "./connect-route.js";
 import { SlackFeedPublisher } from "./feed-publisher.js";
 import { createSlackChannelsConfig } from "./slack.js";
 //#region src/integrations/slack/integration.ts
+/** Slack renders the status inline next to the app name; keep it to one short line. */
+const MAX_STATUS_LENGTH = 80;
+/**
+* Turns a tool's `description` arg ("Listing the repo root") into a status
+* line that reads after the app name ("<App> is listing the repo root…").
+* Only the first line counts: issue/PR creators carry whole bodies there.
+*/
+function describeToolCall(args) {
+	if (!args || typeof args !== "object") return void 0;
+	const { description } = args;
+	if (typeof description !== "string") return void 0;
+	const line = description.split("\n").map((part) => part.replace(/\s+/g, " ").trim()).find(Boolean);
+	if (!line) return void 0;
+	const text = line.length > MAX_STATUS_LENGTH ? `${line.slice(0, MAX_STATUS_LENGTH - 1)}…` : line;
+	return `is ${/^[A-Z][a-z]/.test(text) ? text.charAt(0).toLowerCase() + text.slice(1) : text}`;
+}
 const factoryTypingStatus = (chunk) => {
 	switch (chunk.type) {
 		case "reasoning-delta": return "is thinking...";
 		case "text-delta": return "is typing...";
-		case "tool-call": return "is working...";
+		case "tool-call": return describeToolCall(chunk.payload.args) ?? "is working...";
 		default: return;
 	}
 };
@@ -17,6 +33,21 @@ const factoryTypingStatus = (chunk) => {
 function adapterOverrides(options) {
 	return Object.fromEntries(Object.entries(options ?? {}).filter(([, value]) => value !== void 0));
 }
+/**
+* Factory defaults under the caller's overrides. Tool calls stay out of the
+* thread: a Factory session runs hundreds of them, and a row per call (or a
+* card per call) buries the reply. Progress shows through the typing status
+* instead, which names the tool's current step; the session link carries the
+* full trace. `grouped` remains available via `adapterOptions` for callers
+* who want Slack's "Thinking Steps" widget.
+*/
+function factoryAdapterOptions(overrides) {
+	return {
+		typingStatus: factoryTypingStatus,
+		toolDisplay: "hidden",
+		...overrides
+	};
+}
 var SlackIntegration = class {
 	id = "slack";
 	/**
@@ -52,11 +83,7 @@ var SlackIntegration = class {
 			modelDefaults: ctx.storage.modelDefaults,
 			workItems: ctx.runtime?.workItems,
 			feed: ctx.feed,
-			adapterOptions: {
-				toolDisplay: "hidden",
-				typingStatus: factoryTypingStatus,
-				...adapterOverrides(this.#config.adapterOptions)
-			}
+			adapterOptions: factoryAdapterOptions(adapterOverrides(this.#config.adapterOptions))
 		});
 	}
 	feedPublisher(ctx) {

package/dist/integrations/slack/integration.js.map

@@ -1 +1 @@
-{"version":3,"file":"integration.js","names":["#config","#repoBackedSessions"],"sources":["../../../src/integrations/slack/integration.ts"],"sourcesContent":["/**\n * `SlackIntegration` — Slack as a `FactoryIntegration`.\n *\n * Slack contributes two things to a factory: the chat channels that carry\n * inbound messages into agent runs (`channels()`), and the browser-facing\n * account-link routes that bind a Slack sender to a Mastra tenant (`routes()`).\n * Both used to be assembled by hand in the deploy entry, which had to reach\n * into the prepared agent controller by string key, resolve storage domains\n * itself, mint its own state signer, and splice routes onto the factory's\n * assembled server config. Implementing the integration interface instead means\n * the factory does all of that the same way it already does for GitHub and\n * Linear, and the entry's job shrinks to reading Slack's env vars once.\n *\n * Slack ships as a factory built-in alongside GitHub and Linear (it originally\n * lived in `mastracode/web` to keep `@mastra/slack`/`chat` out of this package;\n * the team reversed that so `create-factory` consumers get Slack channels out\n * of the box). The integration interface remains open — third parties still add\n * capabilities by implementing `FactoryIntegration` from outside the package.\n */\n\nimport type { TypingStatusFn } from '@mastra/core/channels';\nimport type { ApiRoute } from '@mastra/core/server';\nimport type { SlackAdapterChannelConfig } from '@mastra/slack';\n\nimport type { WorkItemFeedPublisher } from '../../storage/domains/comments/feed-sync.js';\nimport type { FactoryChannelsConfig, FactoryIntegration, IntegrationContext } from '../base.js';\n\nimport { createSlackConnectRoutes } from './connect-route.js';\nimport { SlackFeedPublisher } from './feed-publisher.js';\nimport { createSlackChannelsConfig } from './slack.js';\n\n/**\n * Slack app credentials, read from env ONCE by the deploy entry. `signingSecret`\n * is required because the Slack adapter validates it at construction — an\n * integration constructed without it would throw during `prepare()` rather than\n * reporting itself unconfigured.\n */\nexport interface SlackIntegrationConfig {\n  /** Verifies inbound Slack request signatures. Required. */\n  signingSecret: string;\n  /** Bot token used to post replies and ephemeral cards. */\n  botToken?: string;\n  /**\n   * OAuth client credentials. Required for account linking: \"Sign in with\n   * Slack\" (OIDC) is the only flow that writes a link, so without these the\n   * settings surface reports `canConnect: false` and no sender can link.\n   */\n  clientId?: string;\n  clientSecret?: string;\n  /**\n   * HTTPS origin Slack redirects back to. Slack requires HTTPS, so locally this\n   * is the tunnel origin rather than the app's own public URL.\n   */\n  oidcRedirectBaseUrl?: string;\n  /** SPA origin the post-connect redirect returns to. */\n  uiOrigin?: string;\n  /**\n   * Overrides for the Slack channel adapter entry.\n   *\n   * @example\n   * ```ts\n   * new SlackIntegration({\n   *   signingSecret,\n   *   adapterOptions: {\n   *     streaming: true,\n   *     toolDisplay: 'grouped',\n   *   },\n   * });\n   * ```\n   */\n  adapterOptions?: SlackAdapterChannelConfig;\n}\n\nconst factoryTypingStatus: TypingStatusFn = chunk => {\n  switch (chunk.type) {\n    case 'reasoning-delta':\n      return 'is thinking...';\n    case 'text-delta':\n      return 'is typing...';\n    case 'tool-call':\n      return 'is working...';\n    default:\n      return undefined;\n  }\n};\n\n/**\n * Drops keys the caller set to `undefined` so spreading the overrides cannot\n * erase the Factory defaults they sit on top of.\n */\nfunction adapterOverrides(options: SlackAdapterChannelConfig | undefined): SlackAdapterChannelConfig {\n  return Object.fromEntries(\n    Object.entries(options ?? {}).filter(([, value]) => value !== undefined),\n  ) as SlackAdapterChannelConfig;\n}\n\nexport class SlackIntegration implements FactoryIntegration {\n  readonly id = 'slack';\n  /**\n   * The OIDC connect flow round-trips a signed `state` through Slack, so the\n   * replica handling the callback must be able to verify a state a different\n   * replica signed.\n   */\n  readonly requiresStableStateSigner = true;\n\n  readonly #config: SlackIntegrationConfig;\n  /**\n   * Whether `channels()` found a source-control owner on the context and wired\n   * repo-backed sessions. Set at the channels() attach path, which runs once at\n   * boot before diagnostics are served.\n   */\n  #repoBackedSessions = false;\n\n  constructor(config: SlackIntegrationConfig) {\n    if (!config.signingSecret) {\n      throw new Error(\n        \"SlackIntegration: 'signingSecret' is required — Slack cannot verify inbound requests without it.\",\n      );\n    }\n    this.#config = config;\n  }\n\n  channels(ctx: IntegrationContext): FactoryChannelsConfig {\n    // Repo-backed sessions select the source-control provider from the linked\n    // repository on each Factory project.\n    const sourceControls =\n      ctx.storage.sourceControls ?? (ctx.storage.sourceControlOwner ? [ctx.storage.sourceControlOwner] : []);\n    this.#repoBackedSessions = sourceControls.length > 0;\n    return createSlackChannelsConfig({\n      slack: {\n        clientId: this.#config.clientId,\n        clientSecret: this.#config.clientSecret,\n        signingSecret: this.#config.signingSecret,\n        botToken: this.#config.botToken,\n      },\n      accountLinks: ctx.storage.channelIdentity,\n      projects: ctx.storage.projects,\n      sourceControls,\n      modelDefaults: ctx.storage.modelDefaults,\n      workItems: ctx.runtime?.workItems,\n      feed: ctx.feed,\n      adapterOptions: {\n        toolDisplay: 'hidden',\n        typingStatus: factoryTypingStatus,\n        ...adapterOverrides(this.#config.adapterOptions),\n      },\n    });\n  }\n\n  feedPublisher(ctx: IntegrationContext): WorkItemFeedPublisher {\n    return new SlackFeedPublisher({ controller: ctx.controller });\n  }\n\n  routes(ctx: IntegrationContext): ApiRoute[] {\n    const { clientId, clientSecret, oidcRedirectBaseUrl, uiOrigin } = this.#config;\n    return createSlackConnectRoutes({\n      auth: ctx.auth,\n      accountLinks: ctx.storage.channelIdentity,\n      tenantStateSigner: ctx.stateSigner,\n      oidc:\n        clientId && clientSecret && oidcRedirectBaseUrl\n          ? { clientId, clientSecret, redirectBaseUrl: oidcRedirectBaseUrl, uiOrigin }\n          : undefined,\n      projects: ctx.storage.projects,\n    });\n  }\n\n  diagnostics(): Record<string, unknown> {\n    const { clientId, clientSecret, botToken, oidcRedirectBaseUrl } = this.#config;\n    return {\n      configured: true,\n      botTokenConfigured: Boolean(botToken),\n      oidcConfigured: Boolean(clientId && clientSecret && oidcRedirectBaseUrl),\n      repoBackedSessions: this.#repoBackedSessions,\n    };\n  }\n}\n"],"mappings":";;;;AAyEA,MAAM,uBAAsC,UAAS;CACnD,QAAQ,MAAM,MAAd;EACE,KAAK,mBACH,OAAO;EACT,KAAK,cACH,OAAO;EACT,KAAK,aACH,OAAO;EACT,SACE;CACJ;AACF;;;;;AAMA,SAAS,iBAAiB,SAA2E;CACnG,OAAO,OAAO,YACZ,OAAO,QAAQ,WAAW,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,WAAW,UAAU,KAAA,CAAS,CACzE;AACF;AAEA,IAAa,mBAAb,MAA4D;CAC1D,KAAc;;;;;;CAMd,4BAAqC;CAErC;;;;;;CAMA,sBAAsB;CAEtB,YAAY,QAAgC;EAC1C,IAAI,CAAC,OAAO,eACV,MAAM,IAAI,MACR,kGACF;EAEF,KAAKA,UAAU;CACjB;CAEA,SAAS,KAAgD;EAGvD,MAAM,iBACJ,IAAI,QAAQ,mBAAmB,IAAI,QAAQ,qBAAqB,CAAC,IAAI,QAAQ,kBAAkB,IAAI,CAAC;EACtG,KAAKC,sBAAsB,eAAe,SAAS;EACnD,OAAO,0BAA0B;GAC/B,OAAO;IACL,UAAU,KAAKD,QAAQ;IACvB,cAAc,KAAKA,QAAQ;IAC3B,eAAe,KAAKA,QAAQ;IAC5B,UAAU,KAAKA,QAAQ;GACzB;GACA,cAAc,IAAI,QAAQ;GAC1B,UAAU,IAAI,QAAQ;GACtB;GACA,eAAe,IAAI,QAAQ;GAC3B,WAAW,IAAI,SAAS;GACxB,MAAM,IAAI;GACV,gBAAgB;IACd,aAAa;IACb,cAAc;IACd,GAAG,iBAAiB,KAAKA,QAAQ,cAAc;GACjD;EACF,CAAC;CACH;CAEA,cAAc,KAAgD;EAC5D,OAAO,IAAI,mBAAmB,EAAE,YAAY,IAAI,WAAW,CAAC;CAC9D;CAEA,OAAO,KAAqC;EAC1C,MAAM,EAAE,UAAU,cAAc,qBAAqB,aAAa,KAAKA;EACvE,OAAO,yBAAyB;GAC9B,MAAM,IAAI;GACV,cAAc,IAAI,QAAQ;GAC1B,mBAAmB,IAAI;GACvB,MACE,YAAY,gBAAgB,sBACxB;IAAE;IAAU;IAAc,iBAAiB;IAAqB;GAAS,IACzE,KAAA;GACN,UAAU,IAAI,QAAQ;EACxB,CAAC;CACH;CAEA,cAAuC;EACrC,MAAM,EAAE,UAAU,cAAc,UAAU,wBAAwB,KAAKA;EACvE,OAAO;GACL,YAAY;GACZ,oBAAoB,QAAQ,QAAQ;GACpC,gBAAgB,QAAQ,YAAY,gBAAgB,mBAAmB;GACvE,oBAAoB,KAAKC;EAC3B;CACF;AACF"}
+{"version":3,"file":"integration.js","names":["#config","#repoBackedSessions"],"sources":["../../../src/integrations/slack/integration.ts"],"sourcesContent":["/**\n * `SlackIntegration` — Slack as a `FactoryIntegration`.\n *\n * Slack contributes two things to a factory: the chat channels that carry\n * inbound messages into agent runs (`channels()`), and the browser-facing\n * account-link routes that bind a Slack sender to a Mastra tenant (`routes()`).\n * Both used to be assembled by hand in the deploy entry, which had to reach\n * into the prepared agent controller by string key, resolve storage domains\n * itself, mint its own state signer, and splice routes onto the factory's\n * assembled server config. Implementing the integration interface instead means\n * the factory does all of that the same way it already does for GitHub and\n * Linear, and the entry's job shrinks to reading Slack's env vars once.\n *\n * Slack ships as a factory built-in alongside GitHub and Linear (it originally\n * lived in `mastracode/web` to keep `@mastra/slack`/`chat` out of this package;\n * the team reversed that so `create-factory` consumers get Slack channels out\n * of the box). The integration interface remains open — third parties still add\n * capabilities by implementing `FactoryIntegration` from outside the package.\n */\n\nimport type { TypingStatusFn } from '@mastra/core/channels';\nimport type { ApiRoute } from '@mastra/core/server';\nimport type { SlackAdapterChannelConfig } from '@mastra/slack';\n\nimport type { WorkItemFeedPublisher } from '../../storage/domains/comments/feed-sync.js';\nimport type { FactoryChannelsConfig, FactoryIntegration, IntegrationContext } from '../base.js';\n\nimport { createSlackConnectRoutes } from './connect-route.js';\nimport { SlackFeedPublisher } from './feed-publisher.js';\nimport { createSlackChannelsConfig } from './slack.js';\n\n/**\n * Slack app credentials, read from env ONCE by the deploy entry. `signingSecret`\n * is required because the Slack adapter validates it at construction — an\n * integration constructed without it would throw during `prepare()` rather than\n * reporting itself unconfigured.\n */\nexport interface SlackIntegrationConfig {\n  /** Verifies inbound Slack request signatures. Required. */\n  signingSecret: string;\n  /** Bot token used to post replies and ephemeral cards. */\n  botToken?: string;\n  /**\n   * OAuth client credentials. Required for account linking: \"Sign in with\n   * Slack\" (OIDC) is the only flow that writes a link, so without these the\n   * settings surface reports `canConnect: false` and no sender can link.\n   */\n  clientId?: string;\n  clientSecret?: string;\n  /**\n   * HTTPS origin Slack redirects back to. Slack requires HTTPS, so locally this\n   * is the tunnel origin rather than the app's own public URL.\n   */\n  oidcRedirectBaseUrl?: string;\n  /** SPA origin the post-connect redirect returns to. */\n  uiOrigin?: string;\n  /**\n   * Overrides for the Slack channel adapter entry.\n   *\n   * @example\n   * ```ts\n   * new SlackIntegration({\n   *   signingSecret,\n   *   adapterOptions: {\n   *     streaming: true,\n   *     toolDisplay: 'grouped',\n   *   },\n   * });\n   * ```\n   */\n  adapterOptions?: SlackAdapterChannelConfig;\n}\n\n/** Slack renders the status inline next to the app name; keep it to one short line. */\nconst MAX_STATUS_LENGTH = 80;\n\n/**\n * Turns a tool's `description` arg (\"Listing the repo root\") into a status\n * line that reads after the app name (\"<App> is listing the repo root…\").\n * Only the first line counts: issue/PR creators carry whole bodies there.\n */\nfunction describeToolCall(args: unknown): string | undefined {\n  if (!args || typeof args !== 'object') return undefined;\n  const { description } = args as { description?: unknown };\n  if (typeof description !== 'string') return undefined;\n  const line = description\n    .split('\\n')\n    .map(part => part.replace(/\\s+/g, ' ').trim())\n    .find(Boolean);\n  if (!line) return undefined;\n  const text = line.length > MAX_STATUS_LENGTH ? `${line.slice(0, MAX_STATUS_LENGTH - 1)}…` : line;\n  // Drop the sentence-case capital (\"Listing\" → \"listing\") but leave acronyms\n  // and identifiers (\"PR lookup\", \"CI status\") alone.\n  return `is ${/^[A-Z][a-z]/.test(text) ? text.charAt(0).toLowerCase() + text.slice(1) : text}`;\n}\n\nconst factoryTypingStatus: TypingStatusFn = chunk => {\n  switch (chunk.type) {\n    case 'reasoning-delta':\n      return 'is thinking...';\n    case 'text-delta':\n      return 'is typing...';\n    case 'tool-call':\n      return describeToolCall(chunk.payload.args) ?? 'is working...';\n    default:\n      return undefined;\n  }\n};\n\n/**\n * Drops keys the caller set to `undefined` so spreading the overrides cannot\n * erase the Factory defaults they sit on top of.\n */\nfunction adapterOverrides(options: SlackAdapterChannelConfig | undefined): SlackAdapterChannelConfig {\n  return Object.fromEntries(\n    Object.entries(options ?? {}).filter(([, value]) => value !== undefined),\n  ) as SlackAdapterChannelConfig;\n}\n\n/**\n * Factory defaults under the caller's overrides. Tool calls stay out of the\n * thread: a Factory session runs hundreds of them, and a row per call (or a\n * card per call) buries the reply. Progress shows through the typing status\n * instead, which names the tool's current step; the session link carries the\n * full trace. `grouped` remains available via `adapterOptions` for callers\n * who want Slack's \"Thinking Steps\" widget.\n */\nfunction factoryAdapterOptions(overrides: SlackAdapterChannelConfig): SlackAdapterChannelConfig {\n  return { typingStatus: factoryTypingStatus, toolDisplay: 'hidden', ...overrides };\n}\n\nexport class SlackIntegration implements FactoryIntegration {\n  readonly id = 'slack';\n  /**\n   * The OIDC connect flow round-trips a signed `state` through Slack, so the\n   * replica handling the callback must be able to verify a state a different\n   * replica signed.\n   */\n  readonly requiresStableStateSigner = true;\n\n  readonly #config: SlackIntegrationConfig;\n  /**\n   * Whether `channels()` found a source-control owner on the context and wired\n   * repo-backed sessions. Set at the channels() attach path, which runs once at\n   * boot before diagnostics are served.\n   */\n  #repoBackedSessions = false;\n\n  constructor(config: SlackIntegrationConfig) {\n    if (!config.signingSecret) {\n      throw new Error(\n        \"SlackIntegration: 'signingSecret' is required — Slack cannot verify inbound requests without it.\",\n      );\n    }\n    this.#config = config;\n  }\n\n  channels(ctx: IntegrationContext): FactoryChannelsConfig {\n    // Repo-backed sessions select the source-control provider from the linked\n    // repository on each Factory project.\n    const sourceControls =\n      ctx.storage.sourceControls ?? (ctx.storage.sourceControlOwner ? [ctx.storage.sourceControlOwner] : []);\n    this.#repoBackedSessions = sourceControls.length > 0;\n    return createSlackChannelsConfig({\n      slack: {\n        clientId: this.#config.clientId,\n        clientSecret: this.#config.clientSecret,\n        signingSecret: this.#config.signingSecret,\n        botToken: this.#config.botToken,\n      },\n      accountLinks: ctx.storage.channelIdentity,\n      projects: ctx.storage.projects,\n      sourceControls,\n      modelDefaults: ctx.storage.modelDefaults,\n      workItems: ctx.runtime?.workItems,\n      feed: ctx.feed,\n      adapterOptions: factoryAdapterOptions(adapterOverrides(this.#config.adapterOptions)),\n    });\n  }\n\n  feedPublisher(ctx: IntegrationContext): WorkItemFeedPublisher {\n    return new SlackFeedPublisher({ controller: ctx.controller });\n  }\n\n  routes(ctx: IntegrationContext): ApiRoute[] {\n    const { clientId, clientSecret, oidcRedirectBaseUrl, uiOrigin } = this.#config;\n    return createSlackConnectRoutes({\n      auth: ctx.auth,\n      accountLinks: ctx.storage.channelIdentity,\n      tenantStateSigner: ctx.stateSigner,\n      oidc:\n        clientId && clientSecret && oidcRedirectBaseUrl\n          ? { clientId, clientSecret, redirectBaseUrl: oidcRedirectBaseUrl, uiOrigin }\n          : undefined,\n      projects: ctx.storage.projects,\n    });\n  }\n\n  diagnostics(): Record<string, unknown> {\n    const { clientId, clientSecret, botToken, oidcRedirectBaseUrl } = this.#config;\n    return {\n      configured: true,\n      botTokenConfigured: Boolean(botToken),\n      oidcConfigured: Boolean(clientId && clientSecret && oidcRedirectBaseUrl),\n      repoBackedSessions: this.#repoBackedSessions,\n    };\n  }\n}\n"],"mappings":";;;;;AA0EA,MAAM,oBAAoB;;;;;;AAO1B,SAAS,iBAAiB,MAAmC;CAC3D,IAAI,CAAC,QAAQ,OAAO,SAAS,UAAU,OAAO,KAAA;CAC9C,MAAM,EAAE,gBAAgB;CACxB,IAAI,OAAO,gBAAgB,UAAU,OAAO,KAAA;CAC5C,MAAM,OAAO,YACV,MAAM,IAAI,CAAC,CACX,KAAI,SAAQ,KAAK,QAAQ,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAC7C,KAAK,OAAO;CACf,IAAI,CAAC,MAAM,OAAO,KAAA;CAClB,MAAM,OAAO,KAAK,SAAS,oBAAoB,GAAG,KAAK,MAAM,GAAG,oBAAoB,CAAC,EAAE,KAAK;CAG5F,OAAO,MAAM,cAAc,KAAK,IAAI,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,KAAK,MAAM,CAAC,IAAI;AACzF;AAEA,MAAM,uBAAsC,UAAS;CACnD,QAAQ,MAAM,MAAd;EACE,KAAK,mBACH,OAAO;EACT,KAAK,cACH,OAAO;EACT,KAAK,aACH,OAAO,iBAAiB,MAAM,QAAQ,IAAI,KAAK;EACjD,SACE;CACJ;AACF;;;;;AAMA,SAAS,iBAAiB,SAA2E;CACnG,OAAO,OAAO,YACZ,OAAO,QAAQ,WAAW,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,WAAW,UAAU,KAAA,CAAS,CACzE;AACF;;;;;;;;;AAUA,SAAS,sBAAsB,WAAiE;CAC9F,OAAO;EAAE,cAAc;EAAqB,aAAa;EAAU,GAAG;CAAU;AAClF;AAEA,IAAa,mBAAb,MAA4D;CAC1D,KAAc;;;;;;CAMd,4BAAqC;CAErC;;;;;;CAMA,sBAAsB;CAEtB,YAAY,QAAgC;EAC1C,IAAI,CAAC,OAAO,eACV,MAAM,IAAI,MACR,kGACF;EAEF,KAAKA,UAAU;CACjB;CAEA,SAAS,KAAgD;EAGvD,MAAM,iBACJ,IAAI,QAAQ,mBAAmB,IAAI,QAAQ,qBAAqB,CAAC,IAAI,QAAQ,kBAAkB,IAAI,CAAC;EACtG,KAAKC,sBAAsB,eAAe,SAAS;EACnD,OAAO,0BAA0B;GAC/B,OAAO;IACL,UAAU,KAAKD,QAAQ;IACvB,cAAc,KAAKA,QAAQ;IAC3B,eAAe,KAAKA,QAAQ;IAC5B,UAAU,KAAKA,QAAQ;GACzB;GACA,cAAc,IAAI,QAAQ;GAC1B,UAAU,IAAI,QAAQ;GACtB;GACA,eAAe,IAAI,QAAQ;GAC3B,WAAW,IAAI,SAAS;GACxB,MAAM,IAAI;GACV,gBAAgB,sBAAsB,iBAAiB,KAAKA,QAAQ,cAAc,CAAC;EACrF,CAAC;CACH;CAEA,cAAc,KAAgD;EAC5D,OAAO,IAAI,mBAAmB,EAAE,YAAY,IAAI,WAAW,CAAC;CAC9D;CAEA,OAAO,KAAqC;EAC1C,MAAM,EAAE,UAAU,cAAc,qBAAqB,aAAa,KAAKA;EACvE,OAAO,yBAAyB;GAC9B,MAAM,IAAI;GACV,cAAc,IAAI,QAAQ;GAC1B,mBAAmB,IAAI;GACvB,MACE,YAAY,gBAAgB,sBACxB;IAAE;IAAU;IAAc,iBAAiB;IAAqB;GAAS,IACzE,KAAA;GACN,UAAU,IAAI,QAAQ;EACxB,CAAC;CACH;CAEA,cAAuC;EACrC,MAAM,EAAE,UAAU,cAAc,UAAU,wBAAwB,KAAKA;EACvE,OAAO;GACL,YAAY;GACZ,oBAAoB,QAAQ,QAAQ;GACpC,gBAAgB,QAAQ,YAAY,gBAAgB,mBAAmB;GACvE,oBAAoB,KAAKC;EAC3B;CACF;AACF"}

package/dist/integrations/slack/slack.d.ts

@@ -121,9 +121,20 @@ export declare function resolveFactoryForLink({ thread, link, key, accountLinks,
     accountLinks: ChannelIdentityStorage;
     projects?: FactoryProjectsStorage;
 }): Promise<FactoryRouteResult>;
+/**
+ * Session ids of repo-backed Slack threads, keyed by the message that started
+ * them. The resourceId resolver records the session it found or created; the
+ * thread-id resolver, which core runs next for the same message, names the new
+ * thread after it.
+ */
+export type SlackStartedSessions = WeakMap<object, string>;
 /**
  * Resolve the resourceId for a NEW Slack channel thread. A linked sender whose
- * factory has a repository gets a Factory user-session id — the controller
+ * factory has a repository gets a Factory session. A channel thread belongs to
+ * the Factory: its resourceId is the Factory id, so the thread shares the
+ * Factory's memory. A DM is private to the sender, so it runs under the
+ * sender's user id and shares memory with their own sessions. The session id is recorded in `startedSessions` for the
+ * thread-id resolver. The controller
  * session then materializes the repo sandbox via the factory's dynamic
  * workspace (clone + PAT), the session shows up in the web Sessions list, and
  * View Session deep-links land on the normal workspace route.
@@ -147,17 +158,17 @@ export declare function resolveFactoryForLink({ thread, link, key, accountLinks,
  * Pure lookups only — cards for unlinked/unrouted senders are the dispatch
  * gate's job; this hook must never post.
  */
-export declare function createChannelResourceIdResolver(deps: SlackChannelDeps): ResolveResourceId;
+export declare function createChannelResourceIdResolver(deps: SlackChannelDeps, startedSessions?: SlackStartedSessions): ResolveResourceId;
 /**
  * Thread id for a NEW Slack channel thread. Repo-backed threads take the
- * user-session id AS their thread id, matching the web convention
+ * session id AS their thread id, matching the web convention
  * (FactoryStartCoordinator seeds threads with threadId = sessionId) so
  * `/workspaces/{sessionId}/threads/{sessionId}` resolves Slack-created
- * sessions exactly like web-created ones — no `?resourceId=` override needed.
+ * sessions exactly like web-created ones — no `?sessionId=` override needed.
  * Chat-only threads keep the default random id: their `channel:...`
  * resourceId is a memory key, not a unique thread id.
  */
-export declare const resolveChannelThreadId: ResolveThreadId;
+export declare function createChannelThreadIdResolver(startedSessions: SlackStartedSessions): ResolveThreadId;
 /** Create channel sessions with their Factory ownership present in initial controller state. */
 export declare function createChannelSessionResolver(deps: SlackChannelDeps): ChannelSessionResolve;
 /**

package/dist/integrations/slack/slack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slack.d.ts","sourceRoot":"","sources":["../../../src/integrations/slack/slack.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"slack.d.ts","sourceRoot":"","sources":["../../../src/integrations/slack/slack.ts"],"names":[],"mappings":"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"}

package/dist/integrations/slack/slack.js

@@ -1,8 +1,12 @@
 import { actorFromChannelAuthor } from "../../storage/domains/comments/actor.js";
+import { FACTORY_INTERACTIVE_KEY } from "../../auth.js";
+import { isRunBound, memoryResourceOf, sessionStampCounts } from "../../session/session-threads.js";
 import { primeTenantCredentialsForRequestContext, primeTenantCredentialsForTenant } from "../../routes/tenant-credentials.js";
 import { readRequestContextOrgId, seedSessionOrg } from "../../session/org-seed.js";
 import { prepareSessionRunContext } from "../subscription-session.js";
 import { FactorySourceControlConflictError, createSourceControlSessionLookup, hydrateFactorySession, resolveFactorySessionModel, resolveFactorySourceControl, resolvePrimaryEnvironmentRepository } from "../../session/factory-session.js";
+import { FACTORY_SLACK_SENDER_KEY } from "../../tools/scope.js";
+import { markNewChannelSession } from "../../session/channel-session-link-processor.js";
 import { resolveEmojiShortcodes } from "./emoji.js";
 import { slackCommentSource } from "./feed-publisher.js";
 import { ChannelSessionRejectedError } from "@mastra/core/channels";
@@ -149,7 +153,11 @@ function threadBranch(threadId) {
 }
 /**
 * Resolve the resourceId for a NEW Slack channel thread. A linked sender whose
-* factory has a repository gets a Factory user-session id — the controller
+* factory has a repository gets a Factory session. A channel thread belongs to
+* the Factory: its resourceId is the Factory id, so the thread shares the
+* Factory's memory. A DM is private to the sender, so it runs under the
+* sender's user id and shares memory with their own sessions. The session id is recorded in `startedSessions` for the
+* thread-id resolver. The controller
 * session then materializes the repo sandbox via the factory's dynamic
 * workspace (clone + PAT), the session shows up in the web Sessions list, and
 * View Session deep-links land on the normal workspace route.
@@ -173,7 +181,7 @@ function threadBranch(threadId) {
 * Pure lookups only — cards for unlinked/unrouted senders are the dispatch
 * gate's job; this hook must never post.
 */
-function createChannelResourceIdResolver(deps) {
+function createChannelResourceIdResolver(deps, startedSessions = /* @__PURE__ */ new WeakMap()) {
 	const { accountLinks, projects } = deps;
 	const sourceControls = configuredSourceControls(deps);
 	return async ({ platform, thread, message }) => {
@@ -216,13 +224,17 @@ function createChannelResourceIdResolver(deps) {
 			});
 			if (!repo.found) throw new SlackSessionStartError(repo.reason === "connection" ? "Could not start a session: connect source control to this Factory project." : "Could not start a session: link a repository to this Factory project.");
 			const branch = threadBranch(thread.id);
+			const memoryResourceId = thread.isDM ? link.userId : factoryProjectId;
 			const existing = await sourceControl.sessions.getForBranch({
 				factoryProjectId,
 				userId: link.userId,
 				branch
 			});
-			if (existing) return existing.sessionId;
-			return (await sourceControl.sessions.create({
+			if (existing) {
+				startedSessions.set(message, existing.sessionId);
+				return memoryResourceId;
+			}
+			const session = await sourceControl.sessions.create({
 				sessionId: globalThis.crypto.randomUUID(),
 				projectRepositoryId: repo.projectRepositoryId,
 				factoryProjectId,
@@ -231,7 +243,9 @@ function createChannelResourceIdResolver(deps) {
 				branch,
 				baseBranch: repo.baseBranch,
 				visibility: thread.isDM ? "private" : "org"
-			})).sessionId;
+			});
+			startedSessions.set(message, session.sessionId);
+			return memoryResourceId;
 		} catch (error) {
 			if (error instanceof ChannelSessionRejectedError || error instanceof SlackSessionStartError) throw error;
 			if (error instanceof FactorySourceControlConflictError) throw new SlackSessionStartError("Could not start a session: this Factory project has repositories from more than one source-control provider.", { cause: error });
@@ -242,22 +256,55 @@ function createChannelResourceIdResolver(deps) {
 }
 /**
 * Thread id for a NEW Slack channel thread. Repo-backed threads take the
-* user-session id AS their thread id, matching the web convention
+* session id AS their thread id, matching the web convention
 * (FactoryStartCoordinator seeds threads with threadId = sessionId) so
 * `/workspaces/{sessionId}/threads/{sessionId}` resolves Slack-created
-* sessions exactly like web-created ones — no `?resourceId=` override needed.
+* sessions exactly like web-created ones — no `?sessionId=` override needed.
 * Chat-only threads keep the default random id: their `channel:...`
 * resourceId is a memory key, not a unique thread id.
 */
-const resolveChannelThreadId = ({ resourceId, defaultThreadId }) => resourceId.startsWith("channel:") ? defaultThreadId : resourceId;
+function createChannelThreadIdResolver(startedSessions) {
+	return ({ message, defaultThreadId }) => startedSessions.get(message) ?? defaultThreadId;
+}
+/**
+* The Factory session a repo-backed Slack thread belongs to. A thread under
+* the Factory resource is stamped with its session id (the startup migration
+* stamps threads it moved there). An unmigrated thread runs under its session
+* id as its resource, and a newer thread is named after its session. A stamp
+* or thread id only counts under that session's memory resource; a thread
+* named after a session it can't claim is refused. With no session row for
+* either, the thread is addressed by its own id and fails authorization like
+* any session without a row.
+*/
+const UNCLAIMED_SESSION = Symbol("unclaimed-session");
+async function slackThreadSessionId(sessions, thread, loadThread, runs) {
+	if (thread.resourceId.startsWith("channel:")) return null;
+	const claims = async (sessionId) => {
+		const row = await sessions.getBySessionId(sessionId);
+		if (!row) return false;
+		if (sessionId !== thread.id && !sessionStampCounts(row, thread.resourceId)) return false;
+		const own = sessionId === thread.id ? thread : await loadThread(sessionId);
+		return thread.resourceId === memoryResourceOf(row, own, await isRunBound(row, runs));
+	};
+	const stamped = thread.metadata?.factorySessionId;
+	if (typeof stamped === "string" && stamped && await claims(stamped)) return stamped;
+	if (await sessions.getSourceControlBySessionId(thread.resourceId)) return thread.resourceId;
+	if (await claims(thread.id)) return thread.id;
+	if (await sessions.getBySessionId(thread.id)) return UNCLAIMED_SESSION;
+	return thread.id;
+}
 /** Create channel sessions with their Factory ownership present in initial controller state. */
 function createChannelSessionResolver(deps) {
 	const sourceControlSessions = createSourceControlSessionLookup(configuredSourceControls(deps));
 	return async ({ controller, thread, requestContext }) => {
-		const sourceControl = thread.resourceId.startsWith("channel:") ? null : await sourceControlSessions.getSourceControlBySessionId(thread.resourceId);
-		const session = sourceControl ? await sourceControl.sessions.getBySessionId(thread.resourceId) : null;
+		const stored = thread.metadata?.factorySessionId || thread.resourceId.startsWith("channel:") ? thread : await controller.queryThreadById({ threadId: thread.id }) ?? thread;
+		const resolved = await slackThreadSessionId(sourceControlSessions, stored, (threadId) => controller.queryThreadById({ threadId }), deps.workItems);
+		if (resolved === UNCLAIMED_SESSION) throw new Error(`Slack thread ${thread.id} is named after a Factory session it doesn't belong to.`);
+		const sessionId = resolved ?? thread.resourceId;
+		const sourceControl = sessionId.startsWith("channel:") ? null : await sourceControlSessions.getSourceControlBySessionId(sessionId);
+		const session = sourceControl ? await sourceControl.sessions.getBySessionId(sessionId) : null;
 		return controller.createSession({
-			id: thread.resourceId,
+			id: sessionId,
 			ownerId: controller.id,
 			resourceId: thread.resourceId,
 			threadId: thread.id,
@@ -296,15 +343,16 @@ function createChannelSessionStartHook(deps) {
 		await seedSessionOrg(session, readRequestContextOrgId(requestContext));
 		if (!projects) return;
 		if (thread.resourceId.startsWith("channel:")) return;
-		const sourceControl = await sourceControlSessions.getSourceControlBySessionId(thread.resourceId);
+		const sessionId = session.identity.getId();
+		const sourceControl = await sourceControlSessions.getSourceControlBySessionId(sessionId);
 		if (!sourceControl) return;
-		const sourceSession = await sourceControl.sessions.getBySessionId(thread.resourceId);
+		const sourceSession = await sourceControl.sessions.getBySessionId(sessionId);
 		if (!sourceSession?.factoryProjectId) return;
 		const threadId = session.thread.getId();
 		const binding = threadId && deps.workItems ? await deps.workItems.findRunBindingByThread({
 			orgId: sourceSession.orgId,
-			resourceId: thread.resourceId,
-			sessionId: thread.resourceId,
+			resourceId: session.identity.getResourceId(),
+			sessionId,
 			threadId,
 			rejectAmbiguous: true
 		}) : null;
@@ -332,11 +380,15 @@ function createChannelSessionStartHook(deps) {
 			userId: owner.userId,
 			credentialScope: sessionModel.modelScope
 		});
-		const modeId = session.mode.get();
 		const activeThreadId = session.thread.getId();
+		if (activeThreadId) await session.thread.setSettingOn({
+			threadId: activeThreadId,
+			key: "factorySessionId",
+			value: sessionId
+		});
 		if (await migratePersistedModelSelection({
 			getMetadata: async () => activeThreadId ? (await session.thread.getById({ threadId: activeThreadId }))?.metadata ?? {} : {},
-			modeId,
+			modeId: session.mode.get(),
 			set: (key, value) => activeThreadId ? session.thread.setSettingOn({
 				threadId: activeThreadId,
 				key,
@@ -413,13 +465,17 @@ async function prepareExistingSessionOwnerContext(thread, deps, ctx, options) {
 		return "ready";
 	}
 	if (sourceControls.length === 0 || internalThread.resourceId.startsWith("channel:")) return "ready";
-	if (!options.expectedOrgId) throw new Error(`Could not authorize the owner of Slack Factory session ${internalThread.resourceId}: the sender's account link has no organization.`);
-	const preparation = await prepareSessionRunContext(ctx.requestContext, internalThread.resourceId, { sessions: createSourceControlSessionLookup(sourceControls) }, { expectedOrgId: options.expectedOrgId });
+	const sessions = createSourceControlSessionLookup(sourceControls);
+	const memory = await ctx.mastra?.getStorage()?.getStore("memory");
+	const resolved = await slackThreadSessionId(sessions, internalThread, async (threadId) => memory?.getThreadById({ threadId }), deps.workItems);
+	if (resolved === UNCLAIMED_SESSION) return "access-denied";
+	const sessionId = resolved ?? internalThread.resourceId;
+	const sessionRow = await sessions.getBySessionId(sessionId);
+	if (sessionRow && sessionRow.orgId === options.expectedOrgId && sessionRow.visibility === "private" && sessionRow.userId !== options.senderUserId) return "access-denied";
+	if (!options.expectedOrgId) throw new Error(`Could not authorize the owner of Slack Factory session ${sessionId}: the sender's account link has no organization.`);
+	const preparation = await prepareSessionRunContext(ctx.requestContext, sessionId, { sessions }, { expectedOrgId: options.expectedOrgId });
 	if (preparation === "organization-mismatch") return preparation;
-	if (preparation !== "prepared") {
-		const reason = preparation === "session-not-found" ? "no source-control session row exists for it, or its project repository row is missing" : "its source-control session row has no organization";
-		throw new Error(`Could not authorize the owner of Slack Factory session ${internalThread.resourceId}: ${reason}.`);
-	}
+	if (preparation !== "prepared") throw new Error(`Could not authorize the owner of Slack Factory session ${sessionId}: ${preparation === "session-not-found" ? "no source-control session row exists for it, or its project repository row is missing" : "its source-control session row has no organization"}.`);
 	return "ready";
 }
 /**
@@ -446,10 +502,16 @@ async function gateDispatch(thread, message, deps, ctx, options = { requireInter
 			id: sender.link.userId,
 			organizationId: sender.link.orgId
 		});
-		if (await prepareExistingSessionOwnerContext(thread, deps, ctx, {
+		const ownerContext = await prepareExistingSessionOwnerContext(thread, deps, ctx, {
 			expectedOrgId: sender.link.orgId,
+			senderUserId: sender.link.userId,
 			requireInternalThread: options.requireInternalThread
-		}) === "organization-mismatch") {
+		});
+		if (ownerContext === "access-denied") {
+			await thread.post("This private Factory session belongs to another user.");
+			return null;
+		}
+		if (ownerContext === "organization-mismatch") {
 			await thread.post("This thread belongs to a Factory session in another organization.");
 			return null;
 		}
@@ -461,10 +523,19 @@ async function gateDispatch(thread, message, deps, ctx, options = { requireInter
 			projects
 		});
 		if (route.status === "blocked") return null;
-		if (route.status === "resolved") return { routed: {
-			link: sender.link,
-			factoryProjectId: route.factoryProjectId
-		} };
+		if (route.status === "resolved") {
+			if (sender.link.orgId) {
+				ctx.requestContext.set(FACTORY_SLACK_SENDER_KEY, {
+					userId: sender.link.userId,
+					orgId: sender.link.orgId
+				});
+				ctx.requestContext.set(FACTORY_INTERACTIVE_KEY, true);
+			}
+			return { routed: {
+				link: sender.link,
+				factoryProjectId: route.factoryProjectId
+			} };
+		}
 	}
 	return {};
 }
@@ -528,38 +599,37 @@ async function reportPreDispatchError(thread, message, ctx, error) {
 		})}`);
 	}
 }
+/**
+* What the sender sees while nothing has been posted yet. Core's typing
+* wrapper only sets a status once the agent stream yields its first chunk,
+* and everything before that — credential priming, session rows, the
+* controller start hook, model time-to-first-token — is silent. Pin the same
+* status Factory's `typingStatus` uses for reasoning so the bot visibly
+* "picks up" as soon as the gate passes, and the stream's own status replaces
+* it without a visual change. Slack clears it on the first post; core clears
+* it when a run ends without posting.
+*/
+const EARLY_TYPING_STATUS = "is thinking...";
+function acknowledgeReceipt(thread, deps) {
+	if (deps.adapterOptions?.typingStatus === false) return;
+	thread.startTyping(EARLY_TYPING_STATUS).catch((error) => {
+		console.warn("[slack] early typing status failed", {
+			thread: thread.id,
+			error
+		});
+	});
+}
 function createNewSessionChatHandler(deps) {
 	return async (thread, message, defaultHandler, ctx) => {
-		let gate;
-		let isNewSession;
 		try {
-			gate = await gateDispatch(thread, message, deps, ctx);
-			if (!gate) return;
-			isNewSession = !await thread.isSubscribed();
+			if (!await gateDispatch(thread, message, deps, ctx)) return;
+			if (!await thread.isSubscribed()) markNewChannelSession(ctx.requestContext);
+			acknowledgeReceipt(thread, deps);
 		} catch (error) {
 			await reportPreDispatchError(thread, message, ctx, error);
 			return;
 		}
 		await defaultHandler(thread, message);
-		if (!isNewSession) return;
-		const internalThread = await findInternalThread(ctx.mastra, thread);
-		if (!internalThread) {
-			console.warn("[onMention] no internal thread found for", thread.id);
-			return;
-		}
-		const isChatOnly = internalThread.resourceId.startsWith("channel:");
-		const workspaceSegment = isChatOnly ? "channel" : encodeURIComponent(internalThread.resourceId);
-		const threadPath = gate.routed ? `/factories/${encodeURIComponent(gate.routed.factoryProjectId)}/workspaces/${workspaceSegment}/threads/${encodeURIComponent(internalThread.id)}` : `/threads/${internalThread.id}`;
-		const needsResourceParam = isChatOnly || !gate.routed;
-		const deepLink = process.env.MASTRACODE_PUBLIC_URL ? needsResourceParam ? `${process.env.MASTRACODE_PUBLIC_URL}${threadPath}?resourceId=${encodeURIComponent(internalThread.resourceId)}` : `${process.env.MASTRACODE_PUBLIC_URL}${threadPath}` : void 0;
-		if (!deepLink) return;
-		await thread.post(Card({
-			title: "New session started",
-			children: [Actions([LinkButton({
-				url: deepLink,
-				label: "View session"
-			})])]
-		}));
 	};
 }
 /**
@@ -622,6 +692,7 @@ const createHandlers = (deps) => {
 				await reportPreDispatchError(thread, message, ctx, error);
 				return;
 			}
+			acknowledgeReceipt(thread, deps);
 			await defaultHandler(thread, message);
 		},
 		onMention: newSessionChatHandler,
@@ -633,23 +704,25 @@ function createSlackChannelsConfig(deps) {
 		...deps.slack,
 		webClientOptions: { timeout: SLACK_REQUEST_TIMEOUT_MS }
 	});
+	const slack = deps.adapterOptions?.streaming === false ? {
+		adapter,
+		...deps.adapterOptions
+	} : {
+		adapter,
+		...deps.adapterOptions,
+		streaming: deps.adapterOptions?.streaming ?? true
+	};
+	const startedSessions = /* @__PURE__ */ new WeakMap();
 	return {
-		adapters: { slack: deps.adapterOptions?.streaming === false ? {
-			adapter,
-			...deps.adapterOptions
-		} : {
-			adapter,
-			...deps.adapterOptions,
-			streaming: deps.adapterOptions?.streaming ?? true
-		} },
+		adapters: { slack },
 		handlers: createHandlers(deps),
-		resolveResourceId: createChannelResourceIdResolver(deps),
-		resolveThreadId: resolveChannelThreadId,
+		resolveResourceId: createChannelResourceIdResolver(deps, startedSessions),
+		resolveThreadId: createChannelThreadIdResolver(startedSessions),
 		resolveSession: createChannelSessionResolver(deps),
 		onSessionStart: createChannelSessionStartHook(deps)
 	};
 }
 //#endregion
-export { createChannelResourceIdResolver, createChannelSessionResolver, createChannelSessionStartHook, createHandlers, createSlackChannelsConfig, resolveChannelThreadId, resolveFactoryForLink, resolveLinkedSender, slackThreadSource };
+export { createChannelResourceIdResolver, createChannelSessionResolver, createChannelSessionStartHook, createChannelThreadIdResolver, createHandlers, createSlackChannelsConfig, resolveFactoryForLink, resolveLinkedSender, slackThreadSource };
 
 //# sourceMappingURL=slack.js.map