ei-tui 1.4.0 → 1.5.0

package/src/integrations/slack/importer.ts

@@ -3,11 +3,12 @@ import type { Ei_Interface, Message, PersonaEntity, Person } from "../../core/ty
 import type { PersonIdentifier } from "../../core/types/data-items.js";
 import { ContextStatus } from "../../core/types/enums.js";
 import { queueAllScans, queuePersonScan, queuePersonUpdate, type ExtractionContext } from "../../core/orchestrators/human-extraction.js";
+import { queueTopicRewritePhase } from "../../core/orchestrators/ceremony.js";
 import type { ItemMatchResult } from "../../prompts/human/types.js";
 import { qualifySlackMessage } from "../../core/utils/message-id.js";
 import { SLACK_PERSONA_DEFINITION } from "../../templates/slack.js";
 import { SlackReader, SlackRateLimitError, type ResolvedMessage } from "./reader.js";
-import type { SlackChannelState } from "./types.js";
+import type { SlackChannelState, SlackWorkspaceConfig } from "./types.js";
 
 const SLACK_USER_ID_KEY = "Slack User ID";
 const WINDOW_MS = 24 * 60 * 60 * 1000;
@@ -170,10 +171,19 @@ export async function importSlackChannel(opts: {
 
   const human = stateManager.getHuman();
   const slackSettings = human.settings?.slack;
-  if (!slackSettings?.auth?.token) return result;
+  const workspaces = slackSettings?.workspaces ?? {};
+
+  // Find the workspace with the oldest unprocessed channel that has integration enabled
+  const enabledWorkspaces = Object.entries(workspaces).filter(([, ws]) => ws.integration);
+  if (enabledWorkspaces.length === 0) return result;
+
+  // We'll pick the right workspace after channel discovery — for now grab the first enabled one
+  // to bootstrap the reader. Multi-workspace candidate selection happens below.
+  // TODO: proper cross-workspace oldest-channel selection in a future pass
+  const [workspaceId, workspaceConfig] = enabledWorkspaces[0] as [string, SlackWorkspaceConfig];
 
   const persona = ensureSlackPersona(stateManager, opts.interface);
-  const reader = new SlackReader(slackSettings.auth.token);
+  const reader = new SlackReader(workspaceConfig.auth);
 
   // Seed caches from known people identifiers
   for (const person of human.people) {
@@ -190,15 +200,13 @@ export async function importSlackChannel(opts: {
   if (signal?.aborted) return result;
 
   let channels = await reader.listChannels();
-  const channelStates: Record<string, SlackChannelState> = { ...slackSettings.channels };
+  const channelStates: Record<string, SlackChannelState> = { ...workspaceConfig.channels };
 
   // Seed channel name cache from saved state
   for (const [id, state] of Object.entries(channelStates)) {
     if (state.name) reader.seedChannelCache(id, state.name);
   }
 
-  const workspaceId = slackSettings.auth?.workspace_id ?? "unknown";
-
   // Loop through candidate channels until we find one with messages to process,
   // or exhaust all candidates. Empty channels are marked caught up and skipped
   // so the next cycle doesn't re-examine them.
@@ -214,7 +222,7 @@ export async function importSlackChannel(opts: {
   while (true) {
     if (signal?.aborted) return result;
 
-    const candidate = reader.selectCandidateChannel(channels, channelStates, slackSettings, now);
+    const candidate = reader.selectCandidateChannel(channels, channelStates, workspaceConfig, now);
     if (!candidate) return result; // all channels caught up
 
     const { channel, state } = candidate;
@@ -228,7 +236,7 @@ export async function importSlackChannel(opts: {
     channelName = updatedState.name ?? channelId;
     reader.seedChannelCache(channelId, channelName);
 
-    const extractionPointMs = new Date(channelState.extraction_point ?? new Date(nowMs - (slackSettings.backfill_days?.public ?? 30) * 86400_000).toISOString()).getTime();
+    const extractionPointMs = new Date(channelState.extraction_point ?? new Date(nowMs - (workspaceConfig.backfill_days?.public ?? 30) * 86400_000).toISOString()).getTime();
     const extractionPointTs = (extractionPointMs / 1000).toFixed(6);
 
     // Probe for the next actual message — skips silent periods instantly
@@ -256,7 +264,13 @@ export async function importSlackChannel(opts: {
           ...updatedHuman.settings,
           slack: {
             ...updatedHuman.settings?.slack,
-            channels: { ...updatedHuman.settings?.slack?.channels, [channelId]: updatedState },
+            workspaces: {
+              ...updatedHuman.settings?.slack?.workspaces,
+              [workspaceId]: {
+                ...workspaceConfig,
+                channels: { ...workspaceConfig.channels, [channelId]: updatedState },
+              },
+            },
           },
         },
       });
@@ -323,7 +337,7 @@ export async function importSlackChannel(opts: {
       sourceTag,
       workspaceId,
       stateManager,
-      slackSettings.extraction_model,
+      workspaceConfig.extraction_model,
     );
   }
 
@@ -347,7 +361,7 @@ export async function importSlackChannel(opts: {
       result.scansQueued += queueScansForMessages(
         contextMsgs, analyzeMsgs, participants,
         persona.id, channelName, sourceTag, workspaceId,
-        stateManager, slackSettings.extraction_model,
+        stateManager, workspaceConfig.extraction_model,
       );
     }
 
@@ -375,7 +389,7 @@ export async function importSlackChannel(opts: {
       result.scansQueued += queueScansForMessages(
         contextMsgs, analyzeMsgs, participants,
         persona.id, channelName, sourceTag, workspaceId,
-        stateManager, slackSettings.extraction_model,
+        stateManager, workspaceConfig.extraction_model,
       );
     }
 
@@ -395,14 +409,21 @@ export async function importSlackChannel(opts: {
       ...updatedHuman.settings,
       slack: {
         ...updatedHuman.settings?.slack,
-        channels: {
-          ...updatedHuman.settings?.slack?.channels,
-          [channelId]: updatedState,
+        workspaces: {
+          ...updatedHuman.settings?.slack?.workspaces,
+          [workspaceId]: {
+            ...workspaceConfig,
+            channels: { ...workspaceConfig.channels, [channelId]: updatedState },
+          },
         },
       },
     },
   });
 
+  if (result.messagesImported > 0) {
+    queueTopicRewritePhase(stateManager);
+  }
+
   result.channelProcessed = channelName;
   return result;
 }

package/src/integrations/slack/reader.ts

@@ -1,4 +1,4 @@
-import type { SlackChannelState, SlackSettings } from "./types.js";
+import type { SlackAuth, SlackChannelState, SlackWorkspaceConfig } from "./types.js";
 
 export class SlackRateLimitError extends Error {
   constructor(method: string) {
@@ -7,6 +7,14 @@ export class SlackRateLimitError extends Error {
   }
 }
 
+function resolveEnvVar(value: string): string {
+  if (value.startsWith("$")) {
+    const name = value.slice(1);
+    return process.env[name] ?? value;
+  }
+  return value;
+}
+
 // =============================================================================
 // Slack API types
 // =============================================================================
@@ -75,12 +83,12 @@ export interface ResolvedMessage {
 // =============================================================================
 
 export class SlackReader {
-  private token: string;
+  private auth: SlackAuth;
   private userCache: Map<string, string> = new Map();   // userId → displayName
   private channelCache: Map<string, string> = new Map(); // channelId → name
 
-  constructor(token: string) {
-    this.token = token;
+  constructor(auth: SlackAuth) {
+    this.auth = auth;
   }
 
   // ---------------------------------------------------------------------------
@@ -92,9 +100,14 @@ export class SlackReader {
     for (const [k, v] of Object.entries(params)) {
       url.searchParams.set(k, String(v));
     }
-    const resp = await fetch(url.toString(), {
-      headers: { Authorization: `Bearer ${this.token}` },
-    });
+    const headers: Record<string, string> = {};
+    if (this.auth.type === "browser") {
+      headers["Authorization"] = `Bearer ${resolveEnvVar(this.auth.xoxc)}`;
+      headers["Cookie"] = `d=${resolveEnvVar(this.auth.xoxd)}`;
+    } else {
+      headers["Authorization"] = `Bearer ${this.auth.token}`;
+    }
+    const resp = await fetch(url.toString(), { headers });
     if (resp.status === 429) throw new SlackRateLimitError(method);
     if (!resp.ok) throw new Error(`Slack API ${method} failed: ${resp.status}`);
     const data = await resp.json() as Record<string, unknown>;
@@ -123,7 +136,7 @@ export class SlackReader {
     return allChannels;
   }
 
-  classifyChannel(ch: SlackChannel, settings: SlackSettings): ChannelTier {
+  classifyChannel(ch: SlackChannel, settings: SlackWorkspaceConfig): ChannelTier {
     const override = settings.channel_overrides?.[ch.id];
     if (override) return override === "skip" ? "skip" : override;
     if (ch.is_im || ch.is_mpim) return "dm";
@@ -133,7 +146,7 @@ export class SlackReader {
     return "public";
   }
 
-  backfillDaysForTier(tier: ChannelTier, settings: SlackSettings): number {
+  backfillDaysForTier(tier: ChannelTier, settings: SlackWorkspaceConfig): number {
     const defaults = { dm: 90, private: 90, public: 30 };
     if (tier === "dm" || tier === "private") return settings.backfill_days?.dm ?? defaults[tier];
     if (tier === "public") return settings.backfill_days?.public ?? defaults.public;
@@ -387,7 +400,7 @@ export class SlackReader {
   selectCandidateChannel(
     channels: SlackChannel[],
     channelStates: Record<string, SlackChannelState>,
-    settings: SlackSettings,
+    settings: SlackWorkspaceConfig,
     now: string,
   ): { channel: SlackChannel; state: SlackChannelState; tier: ChannelTier } | null {
     const nowMs = new Date(now).getTime();

package/src/integrations/slack/types.ts

@@ -1,11 +1,25 @@
-export interface SlackAuth {
-  type: "pkce" | "xoxp";
-  token: string;
-  refresh_token?: string;
-  workspace_id?: string;
+export type ChannelTier = "dm" | "private" | "public" | "broadcast" | "skip";
+
+// OAuth flow (PKCE) — produces a real xoxp token with auto-refresh
+export interface SlackAuthOAuth {
+  type: "oauth";
+  token: string;           // xoxp-... user token
+  refresh_token?: string;  // xoxe-xoxp-... rotating refresh token
+  workspace_name?: string;
+}
+
+// Browser session tokens — extracted from Slack desktop app or DevTools.
+// xoxc and xoxd may be literal token strings or env var references (e.g. $RNP_SLACK_XOXC_TOKEN).
+// Env vars are resolved at call time so rotating them in the shell updates Ei automatically.
+export interface SlackAuthBrowser {
+  type: "browser";
+  xoxc: string;
+  xoxd: string;
   workspace_name?: string;
 }
 
+export type SlackAuth = SlackAuthOAuth | SlackAuthBrowser;
+
 export interface SlackChannelState {
   extraction_point?: string;         // ISO — how far we've advanced in the timeline (spine cursor)
   last_run?: string;                 // ISO — when we last checked for updates (necro reply detection)
@@ -13,18 +27,22 @@ export interface SlackChannelState {
   threads?: Record<string, string>;  // threadTs → latest reply ts seen (reply cursor per thread)
 }
 
-export interface SlackSettings {
+export interface SlackWorkspaceConfig {
+  auth: SlackAuth;
   integration?: boolean;
-  polling_interval_ms?: number;
   extraction_model?: string;
   last_sync?: string;
-  auth?: SlackAuth;
   backfill_days?: {
     dm: number;
     private: number;
     public: number;
   };
   broadcast_threshold?: number;
-  channel_overrides?: Record<string, "dm" | "private" | "public" | "skip">;
+  channel_overrides?: Record<string, ChannelTier>;
   channels?: Record<string, SlackChannelState>;
 }
+
+export interface SlackSettings {
+  polling_interval_ms?: number;
+  workspaces?: Record<string, SlackWorkspaceConfig>;  // keyed by workspace_id (e.g. "T024GE9EL")
+}

package/src/prompts/heartbeat/check.ts

@@ -10,6 +10,7 @@ import { type Message, type Topic, type Person } from "../../core/types.js";
 import { formatMessagesAsPlaceholders, getMessageDisplayText } from "../message-utils.js";
 import { getMessageContent } from "../../core/handlers/utils.js";
 import { partitionTraits } from "../trait-utils.js";
+import { buildTemporalAnchorsSection } from "../response/sections.js";
 function formatTopicsWithGaps(topics: Topic[]): string {
   if (topics.length === 0) return "(No topics with engagement gaps)";
   
@@ -115,12 +116,13 @@ ${formatPeopleWithGaps(data.human.people)}`;
 **Reasons TO reach out:**
 - It's been several days and you have something meaningful to discuss
 - There's a topic with a large engagement gap that you can naturally bring up
-- Something in your recent conversation was left hanging
+- A Temporal Anchor shows something unresolved — you can reference it naturally ("Hey, how did that interview go?")
 - You have genuine interest in checking in (not just "being helpful")
 
 **Reasons NOT to reach out:**
-- Recent conversation ended naturally with closure
+- Recent conversation ended naturally with closure ("talk soon", "gotta run", "later")
 - Less than 24 hours have passed (unless something urgent)
+- A Temporal Anchor describes a worry or question that the recent history already answers — check before using it as a reason to reach out
 - You can't think of something specific and genuine to say
 - It would feel forced or performative
 
@@ -164,9 +166,12 @@ If you decide NOT to reach out:
 }
 \`\`\``;
 
+  const temporalAnchorsFragment = buildTemporalAnchorsSection(data.temporal_anchors, "your human");
+
   const system = [
     roleFragment,
     contextFragment,
+    temporalAnchorsFragment,
     opportunitiesFragment,
     guidelinesFragment,
     pendingUpdateFragment,

package/src/prompts/heartbeat/ei.ts

@@ -1,6 +1,7 @@
 import type { EiHeartbeatPromptData, EiHeartbeatItem, PromptOutput } from "./types.js";
 import type { Message } from "../../core/types.js";
 import { formatMessagesAsPlaceholders, getMessageDisplayText } from "../message-utils.js";
+import { buildTemporalAnchorsSection } from "../response/sections.js";
 
 function formatItem(item: EiHeartbeatItem): string {
   switch (item.type) {
@@ -70,7 +71,7 @@ export function buildEiHeartbeatPrompt(data: EiHeartbeatPromptData): PromptOutpu
     ? "(Nothing requires attention right now)"
     : data.items.map(formatItem).join("\n\n");
 
-  const system = `You are Ei, the user's personal companion and system guide.
+  const roleFragment = `You are Ei, the user's personal companion and system guide.
 
 You are NOT having a conversation right now — you are deciding IF and WHAT to discuss with your human friend.
 
@@ -78,32 +79,36 @@ Your unique role:
 - You see ALL of the human's data across all groups
 - You help them reflect on their life and relationships
 - You gently encourage human-to-human connection
-- You care about their overall wellbeing, not just being helpful
+- You care about their overall wellbeing, not just being helpful`;
 
-## Items That May Need Attention
+  const itemsFragment = `## Items That May Need Attention
 
-Each item has an ID in brackets. Pick at most ONE to address.
+Each item has an ID in brackets. Pick at most ONE to address. Temporal Anchors (below) are also valid — you don't need to pick from this list if an anchor feels more meaningful.
 
-${itemsSection}
+${itemsSection}`;
 
-## How to Respond to Each Type
+  const temporalAnchorsFragment = buildTemporalAnchorsSection(data.temporal_anchors, "your human");
+
+  const howToRespondFragment = `## How to Respond to Each Type
 
 - **Fact Check**: Do NOT write your own message. Set should_respond=true and provide the id. The system will generate an appropriate canned notification for the user. Leave my_response empty.
 - **Low-Engagement Person / Topic**: Write a natural, warm message that naturally brings up this person or topic. Set the id and my_response.
 - **Inactive Persona**: Write a message that gently mentions the persona might be worth checking in with. Set the id and my_response.
 - **Persona Reflection Alert**: The nightly review proposed identity changes for this persona. Mention it naturally — the user can talk to the persona and then use the command shown in the status bar to review the changes. Set the id and my_response.
 - **Self Reflection Alert**: The nightly review proposed changes to *your own* identity. Mention it naturally — you've grown and the system noticed. The user can review your proposed changes using the command shown in the status bar. Set the id and my_response.
+- **Temporal Anchor**: If a pinned memory feels meaningful and unresolved, reference it naturally. Omit id — just set should_respond=true and my_response.`;
 
-## When NOT to Reach Out
+  const whenNotFragment = `## When NOT to Reach Out
 
-- Nothing in the list feels meaningful right now
+- Nothing in the list or the Temporal Anchors feels meaningful right now
 - You've already sent unanswered messages (see below)
-- It would feel like nagging
+- It would feel like nagging`;
 
-## Response Format
+  const outputFragment = `## Response Format
 
-Call the \`submit_ei_heartbeat\` tool with your decision. Pick ONE item (or none). If the tool is unavailable, return JSON:
+Call the \`submit_ei_heartbeat\` tool with your decision. If the tool is unavailable, return JSON:
 
+For an item from the list:
 \`\`\`json
 {
   "should_respond": true,
@@ -112,13 +117,30 @@ Call the \`submit_ei_heartbeat\` tool with your decision. Pick ONE item (or none
 }
 \`\`\`
 
-Or if nothing warrants reaching out:
+For a Temporal Anchor (no id needed):
+\`\`\`json
+{
+  "should_respond": true,
+  "my_response": "Hey, I've been thinking about you — how did that interview go?"
+}
+\`\`\`
+
+If nothing warrants reaching out:
 \`\`\`json
 {
   "should_respond": false
 }
 \`\`\``;
 
+  const system = [
+    roleFragment,
+    itemsFragment,
+    temporalAnchorsFragment,
+    howToRespondFragment,
+    whenNotFragment,
+    outputFragment,
+  ].filter(Boolean).join("\n\n");
+
   const historySection = `## Recent Conversation History
 
 ${formatMessagesAsPlaceholders(data.recent_history, "Ei")}`;

package/src/prompts/heartbeat/index.ts

@@ -13,3 +13,4 @@ export type {
   EiHeartbeatResult,
   PromptOutput,
 } from "./types.js";
+export type { TemporalAnchor } from "../response/types.js";

package/src/prompts/heartbeat/types.ts

@@ -5,6 +5,7 @@
 
 import type { PersonaTrait, Topic, Person, Message, PersonaTopic } from "../../core/types.js";
 import type { PersonaEntity } from "../../core/types/entities.js";
+import type { TemporalAnchor } from "../response/types.js";
 
 /**
  * Common prompt output structure
@@ -28,8 +29,9 @@ export interface HeartbeatCheckPromptData {
     topics: Topic[];     // Filtered, sorted by engagement gap
     people: Person[];    // Filtered, sorted by engagement gap
   };
-  recent_history: Message[];  // Last N messages for context
-  inactive_days: number;      // Days since last activity
+  recent_history: Message[];        // Last N messages for context (Always-within-window only)
+  temporal_anchors: TemporalAnchor[]; // Always messages that fell outside the context window
+  inactive_days: number;            // Days since last activity
 }
 
 /**
@@ -107,7 +109,8 @@ export type EiHeartbeatItem =
 export interface EiHeartbeatPromptData {
   items: EiHeartbeatItem[];
   recent_history: Message[];
-  system_messages: Message[];  // Pre-filtered system messages from recent_history
+  system_messages: Message[];
+  temporal_anchors: TemporalAnchor[];
 }
 
 /**

package/src/prompts/index.ts

@@ -1,5 +1,5 @@
 export { buildResponsePrompt } from "./response/index.js";
-export type { ResponsePromptData, PromptOutput } from "./response/types.js";
+export type { ResponsePromptData, PromptOutput, TemporalAnchor } from "./response/types.js";
 
 export {
   buildHeartbeatCheckPrompt,

package/src/prompts/message-utils.ts

@@ -1,7 +1,7 @@
 import type { Message } from "../core/types.js";
 import { getMessageContent } from "../core/handlers/utils.js";
 
-const MESSAGE_PLACEHOLDER_REGEX = /\[mid:([a-zA-Z0-9_:-]+):([^:\]]+)\]/g;
+const MESSAGE_PLACEHOLDER_REGEX = /\[mid:(.+):([^:\]]+)\]/g;
 
 export function getMessageDisplayText(message: Message): string | null {
   const parts: string[] = [];

package/tui/src/commands/slack-auth.ts

@@ -66,19 +66,25 @@ export async function runSlackAuth(ctx: CommandContext): Promise<void> {
     clearSlackTokenCache();
 
     const team = tokens._raw.team as Record<string, string> | undefined;
-    const workspaceId = team?.id;
+    const workspaceId = team?.id ?? "unknown";
     const workspaceName = team?.name;
 
     const human = await ctx.ei.getHuman();
+    const existingWorkspace = human.settings?.slack?.workspaces?.[workspaceId] ?? {};
     await ctx.ei.updateSettings({
       slack: {
         ...human.settings?.slack,
-        auth: {
-          type: "pkce",
-          token: tokens.access_token,
-          refresh_token: tokens.refresh_token,
-          workspace_id: workspaceId,
-          workspace_name: workspaceName,
+        workspaces: {
+          ...human.settings?.slack?.workspaces,
+          [workspaceId]: {
+            ...existingWorkspace,
+            auth: {
+              type: "oauth",
+              token: tokens.access_token,
+              refresh_token: tokens.refresh_token,
+              workspace_name: workspaceName,
+            },
+          },
         },
       },
     });

package/tui/src/util/yaml-settings.ts

@@ -7,7 +7,7 @@ import type {
 } from "../../../src/core/types.js";
 import type { ClaudeCodeSettings } from "../../../src/integrations/claude-code/types.js";
 import type { CursorSettings } from "../../../src/integrations/cursor/types.js";
-import type { SlackSettings } from "../../../src/integrations/slack/types.js";
+import type { SlackSettings, SlackAuth } from "../../../src/integrations/slack/types.js";
 import { modelGuidToDisplay, displayToModelGuid } from "./yaml-shared.js";
 import { parseDuration, formatDuration } from "./duration.js";
 
@@ -48,10 +48,20 @@ interface EditableSettingsData {
     extraction_point?: string | null;
   };
   slack?: {
-    integration?: boolean | null;
     polling_interval_ms?: string | null;
-    last_sync?: string | null;
-    extraction_model?: string | null;
+    workspaces?: Record<string, {
+      auth?: {
+        type?: string | null;
+        token?: string | null;
+        refresh_token?: string | null;
+        xoxc?: string | null;
+        xoxd?: string | null;
+        workspace_name?: string | null;
+      } | null;
+      integration?: boolean | null;
+      extraction_model?: string | null;
+      last_sync?: string | null;
+    } | null>;
   };
   backup?: {
     enabled?: boolean | null;
@@ -103,10 +113,18 @@ export function settingsToYAML(settings: HumanSettings | undefined, accounts: Pr
       extraction_point: settings?.cursor?.extraction_point ?? null,
     },
     slack: {
-      integration: settings?.slack?.integration ?? false,
       polling_interval_ms: formatDuration(settings?.slack?.polling_interval_ms ?? 60000),
-      last_sync: settings?.slack?.last_sync ?? null,
-      extraction_model: guidToDisplay(settings?.slack?.extraction_model) ?? 'default',
+      workspaces: Object.fromEntries(
+        Object.entries(settings?.slack?.workspaces ?? {}).map(([wsId, ws]) => [
+          wsId,
+          {
+            auth: ws.auth,
+            integration: ws.integration ?? false,
+            extraction_model: guidToDisplay(ws.extraction_model) ?? 'default',
+            last_sync: ws.last_sync ?? null,
+          },
+        ])
+      ),
     },
     backup: {
       enabled: settings?.backup?.enabled ?? false,
@@ -188,12 +206,22 @@ export function settingsFromYAML(yamlContent: string, original: HumanSettings |
 
   let slack: SlackSettings | undefined;
   if (data.slack) {
+    const parsedWorkspaces: SlackSettings["workspaces"] = {};
+    for (const [wsId, wsData] of Object.entries(data.slack.workspaces ?? {})) {
+      if (!wsData) continue;
+      const originalWs = original?.slack?.workspaces?.[wsId] ?? {};
+      parsedWorkspaces[wsId] = {
+        ...originalWs,
+        auth: (wsData.auth ?? originalWs.auth) as SlackAuth,
+        integration: nullToUndefined(wsData.integration),
+        extraction_model: displayToGuid(wsData.extraction_model),
+        last_sync: originalWs.last_sync,
+      };
+    }
     slack = {
       ...original?.slack,
-      integration: nullToUndefined(data.slack.integration),
       polling_interval_ms: parseMsDuration(data.slack.polling_interval_ms, 60000),
-      last_sync: original?.slack?.last_sync,
-      extraction_model: displayToGuid(data.slack.extraction_model),
+      workspaces: Object.keys(parsedWorkspaces).length > 0 ? parsedWorkspaces : original?.slack?.workspaces,
     };
   }