alvin-bot 4.11.0 → 4.12.0

package/CHANGELOG.md

@@ -2,6 +2,111 @@
 
 All notable changes to Alvin Bot are documented here.
 
+## [4.12.0] — 2026-04-13
+
+### 🧭 Multi-Session + Slack Interface — parallel contexts, per-channel workspaces
+
+A colleague's feature request the same day v4.11.0 shipped: *"Multiple Session und Interface über Slack — wie bei OpenClaw. Du hast mehrere parallele Sessions, die den jeweiligen Kontext voneinander nicht kennen aber in sich einen bestimmten Kontext und Zweck haben. Sie hatten dabei Zugriff auf das gesamte Knowledge (Skills + Memory). Und konnten bei Bedarf eigene agents starten."*
+
+The ultra-analysis revealed Alvin was already ~80% built for this: the Slack adapter existed (355 LOC with `@slack/bolt@4.6.0`), the platform abstraction was clean, `buildSessionKey()` already supported `per-channel` mode, `session.workingDir` was already per-session, sub-agents were already async and session-isolated (v4.10.0), and memory/skills were already globally shared. **The single blocker: one line in `platform-message.ts` that bypassed `buildSessionKey` with a naive `hashUserId(userId)`, collapsing every non-Telegram channel from the same user into one session.**
+
+This release adds a thin workspace layer on top plus Slack polish. **No breaking changes** — if no workspaces are configured, pre-v4.12 behavior is preserved exactly.
+
+#### P0 #1 — Session-Key Fix (`src/handlers/platform-message.ts`)
+
+`handlePlatformMessage` now routes through `buildSessionKey(msg.platform, msg.chatId, msg.userId)` instead of `hashUserId(msg.userId)`. On Slack with `SESSION_MODE=per-channel`, each channel gets its own session. Cross-channel isolation is automatic.
+
+`buildSessionKey` signature widened from `userId: number` to `userId: string | number` so Slack user IDs (`U01ABC...`) pass through unchanged.
+
+**6 unit tests** covering per-channel / per-channel-peer / per-user modes, cross-channel isolation, cross-platform isolation, and backwards compat with numeric Telegram user IDs.
+
+#### P0 #2 — Workspace Registry (`src/services/workspaces.ts`, NEW)
+
+Loads `~/.alvin-bot/workspaces/*.md` markdown files with YAML frontmatter. Each workspace has: `name`, `purpose`, `cwd`, optional `color`/`emoji`, explicit `channels: []` array for ID-based mapping, and a markdown body that becomes the system prompt override.
+
+Hot-reload via `fs.watch()` with 500 ms debounce — same pattern as `src/services/skills.ts`. Changes to workspace files are picked up without a bot restart.
+
+Public API: `loadWorkspaces`, `reloadWorkspaces`, `listWorkspaces`, `getWorkspace`, `getDefaultWorkspace`, `matchWorkspaceForChannel`, `resolveWorkspaceOrDefault`, `initWorkspaces`, `startWorkspaceWatcher`, `stopWorkspaceWatcher`.
+
+**13 unit tests** covering default fallback, single/multi-workspace load, `~` expansion in cwd, channel-ID match, channel-name match, hot-reload, non-`.md` file skipping, malformed frontmatter resilience, missing directory graceful handling.
+
+#### P0 #3 — Workspace Resolver Integration (`src/handlers/platform-message.ts`, `src/handlers/message.ts`)
+
+Both the platform handler (Slack/Discord/WhatsApp) and the Telegram main handler now resolve the incoming message to a workspace before building the system prompt. If the session's `workspaceName` changed vs. the previous turn, `workingDir` is updated and persisted via `session-persistence` (v4.11.0).
+
+`buildSystemPrompt` and `buildSmartSystemPrompt` gained a new optional `workspacePersona` parameter that injects a `## Workspace Persona` section into the system prompt. Empty string = no-op (default workspace).
+
+`UserSession` gained a new `workspaceName: string | null` field. Persisted across restarts via the new v2 envelope format in `sessions.json` (backwards compatible with v4.11 flat format — the loader auto-detects).
+
+#### P0 #4 — Slack Setup Documentation (`docs/install/slack-setup.md`, `docs/install/slack-manifest.json`)
+
+Step-by-step guide: create Slack App from manifest → Socket Mode → App-Level Token → Bot Token → `~/.alvin-bot/.env` → restart → invite bot → create workspace files. Covers troubleshooting for common issues. The `slack-manifest.json` is copy-paste-ready: pre-configured bot user, all required scopes, event subscriptions, Socket Mode enabled. Both files are gitignored (Ali's docs/install/ convention) and ship via GitHub Release assets.
+
+#### P1 #1 — Slack Progress Ticker (`src/platforms/slack.ts`)
+
+`SlackAdapter.sendText()` now returns the message `ts` so callers can hold on to it. New `SlackAdapter.editMessage(chatId, messageId, newText)` wraps `chat.update`. Fail-silent: if Slack API errors, the ticker degrades gracefully and the full message still arrives at query end.
+
+`PlatformAdapter` interface: `sendText` return type widened from `void` to `string | void`, optional `editMessage` method added. Existing adapters (Telegram, WhatsApp, Discord, Signal) that don't implement `editMessage` are unaffected.
+
+**3 unit tests** with mocked `@slack/bolt` covering `chat.update` call, `sendText` ts return, and graceful failure handling.
+
+#### P1 #2 — Slack Typing Status + Channel Name Resolution (`src/platforms/slack.ts`)
+
+`SlackAdapter.setTyping()` now calls `assistant.threads.setStatus` so Slack shows "Alvin is thinking…" under the message during long queries. Silently no-ops in channels where the assistant scope isn't granted.
+
+New `SlackAdapter.getChannelName(channelId)` resolves + caches channel names via `conversations.info`. `platform-message.ts` detects this helper via duck-typing on the adapter and passes the resolved name to `resolveWorkspaceOrDefault` — enabling channel-name matching (`#alev-b` → `workspaces/alev-b.md`) without hardcoding the Slack type in the platform handler.
+
+#### P1 #3 — Telegram `/workspace` + `/workspaces` Commands
+
+Feature parity for Telegram. `/workspaces` lists all configured workspaces with emojis, purposes, and the active one marked ✅. `/workspace <name>` switches the active workspace for the Telegram user; next message uses the new persona and cwd. `/workspace default` resets.
+
+New `session.ts` exports: `getTelegramWorkspace(userId)` / `setTelegramWorkspace(userId, name)` + a module-level `telegramWorkspaces` map persisted via a new v2 envelope format in `sessions.json` (backwards compatible with v4.11 flat format).
+
+**5 new unit tests** covering getter/setter/null-clear, persistence roundtrip, and v4.11 flat-format backwards compat.
+
+#### P1 #4 — Per-Workspace Cost Aggregation (`src/services/session.ts`)
+
+New `getCostByWorkspace()` helper aggregates `session.totalCost` by `session.workspaceName` across all active sessions in memory. Returns per-workspace totals for cost, session count, message count, and tool use count. Used by the Web UI workspace cards.
+
+Sessions with `workspaceName === null` aggregate under `"default"` in the breakdown.
+
+#### P1 #5 — Web UI Workspace Cards (`src/web/server.ts`, `web/public/index.html`, `web/public/js/app.js`)
+
+New `GET /api/workspaces` endpoint returns the workspace registry merged with `getCostByWorkspace()`. Dashboard SPA gains a "🧭 Workspaces" page in the Data section of the sidebar (between Sessions and Files). Cards show emoji, name, purpose, cwd, channel mappings, session count, message count, and cumulative cost — color-coded via workspace frontmatter `color` field.
+
+Default workspace is always included even when no user configs exist, so the UI always shows at least one card.
+
+#### Architecture Decisions
+
+- **Workspace is channel-scoped, not thread-scoped.** Slack channel = workspace. Threads within a channel are continuations of the same session.
+- **Memory stays global.** All workspaces share `MEMORY.md`, the Hub memory, and the embeddings index.
+- **Provider stays global.** Per-workspace provider override deferred to v4.13.
+- **`@slack/bolt@^4.6.0`** is a regular dep, already in `package.json` from a previous branch.
+- **Backwards compat is absolute.** If no workspaces exist, `resolveWorkspaceOrDefault` returns the default workspace with empty persona + global cwd. v4.11 flat-format `sessions.json` files still load without migration.
+- **v2 envelope format**: `sessions.json` is now `{ version: 2, sessions: {...}, telegramWorkspaces: {...} }`. Loader auto-detects and handles both legacy flat format and new envelope.
+
+#### Testing
+
+**330 tests total** (292 baseline from v4.11 + 38 new). All green. TSC clean.
+
+- 6 platform-session-key unit tests
+- 14 workspaces unit + integration tests
+- 3 slack-progress-ticker tests (mocked @slack/bolt)
+- 5 telegram-workspace-command tests
+- 10 multi-session end-to-end stress tests
+
+**Live verified** via `tmp/live-multi-session.mjs` probe against the real `dist/`: 5 parallel workspaces, 5 simulated Slack channels, full persistence roundtrip with v2 envelope, cost aggregation, hot-reload picking up new workspace files, channel-name fallback, telegramWorkspaces map persistence. **All 7 phases passed.**
+
+#### Files changed
+
+- **NEW code:** `src/services/workspaces.ts`
+- **NEW tests:** `test/platform-session-key.test.ts`, `test/workspaces.test.ts`, `test/slack-progress-ticker.test.ts`, `test/telegram-workspace-command.test.ts`, `test/multi-session-stress.test.ts`
+- **NEW docs (gitignored, in Release assets):** `docs/install/slack-setup.md`, `docs/install/slack-manifest.json`
+- **Modified:** `src/handlers/platform-message.ts`, `src/handlers/message.ts`, `src/handlers/commands.ts`, `src/platforms/slack.ts`, `src/platforms/types.ts`, `src/services/session.ts`, `src/services/session-persistence.ts`, `src/services/personality.ts`, `src/paths.ts`, `src/index.ts`, `src/web/server.ts`, `web/public/index.html`, `web/public/js/app.js`
+- **Plan:** `docs/superpowers/plans/2026-04-13-multi-session-slack.md`
+
+---
+
 ## [4.11.0] — 2026-04-13
 
 ### 🧠 Memory Persistence + Smart Loading — sessions survive restart, memory is layered

package/dist/handlers/commands.js

@@ -2,7 +2,8 @@ import { InlineKeyboard, InputFile } from "grammy";
 import fs from "fs";
 import path, { resolve } from "path";
 import os from "os";
-import { getSession, resetSession, markSessionDirty } from "../services/session.js";
+import { getSession, resetSession, markSessionDirty, getTelegramWorkspace, setTelegramWorkspace } from "../services/session.js";
+import { listWorkspaces, getWorkspace } from "../services/workspaces.js";
 import { getRegistry } from "../engine.js";
 import { reloadSoul } from "../services/personality.js";
 import { parseDuration, createReminder, listReminders, cancelReminder } from "../services/reminders.js";
@@ -425,6 +426,50 @@ export function registerCommands(bot) {
         markSessionDirty(userId);
         await ctx.reply(`✅ Effort: ${EFFORT_LABELS[session.effort]}`);
     });
+    // v4.12.0 P1 #3 — Multi-workspace support on Telegram
+    bot.command("workspaces", async (ctx) => {
+        const userId = ctx.from.id;
+        const active = getTelegramWorkspace(userId) ?? "default";
+        const all = listWorkspaces();
+        if (all.length === 0) {
+            await ctx.reply("🧭 No workspaces configured.\n\n" +
+                "Create one by adding a file at `~/.alvin-bot/workspaces/<name>.md` " +
+                "with YAML frontmatter. See docs/install/slack-setup.md for the format.", { parse_mode: "Markdown" });
+            return;
+        }
+        const lines = [`🧭 *Workspaces* (active: \`${active}\`)`, ""];
+        for (const ws of all) {
+            const marker = ws.name === active ? "✅" : (ws.emoji ?? "▪️");
+            const purpose = ws.purpose || "(no purpose)";
+            lines.push(`${marker} \`${ws.name}\` — ${purpose}`);
+        }
+        lines.push("");
+        lines.push("Switch with: `/workspace <name>` · Reset: `/workspace default`");
+        await ctx.reply(lines.join("\n"), { parse_mode: "Markdown" });
+    });
+    bot.command("workspace", async (ctx) => {
+        const userId = ctx.from.id;
+        const arg = ctx.match?.trim();
+        if (!arg) {
+            const active = getTelegramWorkspace(userId) ?? "default";
+            const ws = active === "default" ? null : getWorkspace(active);
+            const purpose = ws?.purpose || "global default — no persona, global cwd";
+            await ctx.reply(`🧭 Active workspace: *${active}*\n_${purpose}_\n\nUse \`/workspaces\` to see all available.`, { parse_mode: "Markdown" });
+            return;
+        }
+        if (arg === "default" || arg === "reset") {
+            setTelegramWorkspace(userId, null);
+            await ctx.reply("✅ Switched to the default workspace.");
+            return;
+        }
+        const ws = getWorkspace(arg);
+        if (!ws) {
+            await ctx.reply(`❌ Workspace \`${arg}\` not found.\nUse \`/workspaces\` to list available ones.`, { parse_mode: "Markdown" });
+            return;
+        }
+        setTelegramWorkspace(userId, arg);
+        await ctx.reply(`✅ Switched to workspace *${ws.emoji ?? "🧭"} ${ws.name}*\n_${ws.purpose || "(no purpose set)"}_\n\nNext message will use this workspace's persona and cwd (\`${ws.cwd}\`).`, { parse_mode: "Markdown" });
+    });
     // Inline keyboard callback for effort switching
     bot.callbackQuery(/^effort:(.+)$/, async (ctx) => {
         const level = ctx.match[1];

package/dist/handlers/message.js

@@ -1,6 +1,7 @@
 import { InputFile } from "grammy";
 import fs from "fs";
-import { getSession, addToHistory, trackProviderUsage, buildSessionKey } from "../services/session.js";
+import { getSession, addToHistory, trackProviderUsage, buildSessionKey, getTelegramWorkspace } from "../services/session.js";
+import { resolveWorkspaceOrDefault, getWorkspace } from "../services/workspaces.js";
 import { TelegramStreamer } from "../services/telegram.js";
 import { getRegistry } from "../engine.js";
 import { textToSpeech } from "../services/voice.js";
@@ -226,10 +227,22 @@ export async function handleMessage(ctx) {
         // and rehydrated sessions where the persisted snapshot lacked a sessionId.
         // After the first SDK turn, Claude resumes via SDK session_id and already
         // carries the recalled context — no need for another search per turn.
+        //
+        // v4.12.0 — Resolve the user's active Telegram workspace (if any) and
+        // forward the persona to buildSmartSystemPrompt. If the workspace
+        // changed since last turn, update session's workingDir + workspaceName.
+        const activeWsName = getTelegramWorkspace(userId);
+        const workspace = activeWsName
+            ? (getWorkspace(activeWsName) ?? resolveWorkspaceOrDefault("telegram", String(userId), undefined))
+            : resolveWorkspaceOrDefault("telegram", String(userId), undefined);
+        if (session.workspaceName !== workspace.name) {
+            session.workspaceName = workspace.name;
+            session.workingDir = workspace.cwd;
+        }
         const chatIdStr = String(ctx.chat.id);
         const skillContext = buildSkillContext(text);
         const isFirstSDKTurn = isSDK && session.sessionId === null;
-        const systemPrompt = (await buildSmartSystemPrompt(isSDK, session.language, text, chatIdStr, isFirstSDKTurn)) + skillContext;
+        const systemPrompt = (await buildSmartSystemPrompt(isSDK, session.language, text, chatIdStr, isFirstSDKTurn, workspace.systemPromptOverride)) + skillContext;
         // Track the user turn in history regardless of provider type. This keeps
         // the fallback path (Ollama etc.) aware of what was said on SDK turns.
         addToHistory(userId, { role: "user", content: text });

package/dist/handlers/platform-message.js

@@ -7,7 +7,8 @@
  * This is the platform-agnostic equivalent of message.ts (which is Telegram-specific).
  */
 import fs from "fs";
-import { getSession, addToHistory, trackProviderUsage } from "../services/session.js";
+import { getSession, addToHistory, trackProviderUsage, buildSessionKey } from "../services/session.js";
+import { resolveWorkspaceOrDefault } from "../services/workspaces.js";
 import { getRegistry } from "../engine.js";
 import { buildSmartSystemPrompt } from "../services/personality.js";
 import { buildSkillContext } from "../services/skills.js";
@@ -87,9 +88,38 @@ export async function handlePlatformMessage(msg, adapter) {
     const cmdHandled = await handlePlatformCommand(text, msg, adapter);
     if (cmdHandled)
         return;
-    const userId = hashUserId(msg.userId);
-    const session = getSession(userId);
-    touchProfile(userId, msg.userName, msg.userHandle, msg.platform, text);
+    // v4.12.0 — Use buildSessionKey so each channel on Slack/Discord/WhatsApp
+    // gets its own session. Before v4.12.0 we hashed just userId, which
+    // collapsed every channel from the same user into one session and broke
+    // multi-session completely on non-Telegram platforms.
+    const sessionKey = buildSessionKey(msg.platform, msg.chatId, msg.userId);
+    const session = getSession(sessionKey);
+    // touchProfile still uses a stable userId-based numeric hash for the
+    // user profile store — profiles are about *people*, not sessions.
+    const profileKey = hashUserId(msg.userId);
+    touchProfile(profileKey, msg.userName, msg.userHandle, msg.platform, text);
+    // v4.12.0 — Workspace resolution: channel → workspace → persona + cwd.
+    // P1 #2 — If the platform has a getChannelName helper (Slack does), use
+    // it to enable channel-name-based workspace matching (e.g. #alev-b →
+    // workspaces/alev-b.md). Cached in the adapter, so no extra API call
+    // after the first hit per channel.
+    let channelName;
+    const getChannelName = adapter.getChannelName;
+    if (typeof getChannelName === "function") {
+        try {
+            channelName = await getChannelName.call(adapter, msg.chatId);
+        }
+        catch {
+            channelName = undefined;
+        }
+    }
+    const workspace = resolveWorkspaceOrDefault(msg.platform, msg.chatId, channelName);
+    // If the workspace changed since last turn, update the session's cwd +
+    // workspaceName. This is debounced via session-persistence (v4.11.0).
+    if (session.workspaceName !== workspace.name) {
+        session.workspaceName = workspace.name;
+        session.workingDir = workspace.cwd;
+    }
     // Skip if already processing (queue up to 3)
     if (session.isProcessing) {
         if (session.messageQueue.length < 3) {
@@ -130,8 +160,10 @@ export async function handlePlatformMessage(msg, adapter) {
         const isSDK = activeProvider.config.type === "claude-sdk";
         const skillContext = buildSkillContext(fullText);
         // v4.11.0 P0 #3 — SDK gets semantic recall on first turn (when no resume token yet).
+        // v4.12.0 P0 #3 — Workspace persona is forwarded so per-channel personas land
+        // in the system prompt for this query.
         const isFirstSDKTurn = isSDK && session.sessionId === null;
-        const systemPrompt = (await buildSmartSystemPrompt(isSDK, session.language, fullText, msg.chatId, isFirstSDKTurn)) + skillContext;
+        const systemPrompt = (await buildSmartSystemPrompt(isSDK, session.language, fullText, msg.chatId, isFirstSDKTurn, workspace.systemPromptOverride)) + skillContext;
         const queryOpts = {
             prompt: fullText,
             systemPrompt,
@@ -141,7 +173,7 @@ export async function handlePlatformMessage(msg, adapter) {
             history: !isSDK ? session.history : undefined,
         };
         if (!isSDK) {
-            addToHistory(userId, { role: "user", content: fullText });
+            addToHistory(sessionKey, { role: "user", content: fullText });
         }
         for await (const chunk of registry.queryWithFallback(queryOpts)) {
             switch (chunk.type) {
@@ -153,7 +185,7 @@ export async function handlePlatformMessage(msg, adapter) {
                         session.sessionId = chunk.sessionId;
                     if (chunk.costUsd)
                         session.totalCost += chunk.costUsd;
-                    trackProviderUsage(userId, registry.getActiveKey(), chunk.costUsd || 0, chunk.inputTokens, chunk.outputTokens);
+                    trackProviderUsage(sessionKey, registry.getActiveKey(), chunk.costUsd || 0, chunk.inputTokens, chunk.outputTokens);
                     session.lastActivity = Date.now();
                     break;
                 case "error":
@@ -174,7 +206,7 @@ export async function handlePlatformMessage(msg, adapter) {
                 await adapter.sendText(msg.chatId, finalText);
             }
             if (!isSDK && finalText) {
-                addToHistory(userId, { role: "assistant", content: finalText });
+                addToHistory(sessionKey, { role: "assistant", content: finalText });
             }
         }
     }
@@ -198,12 +230,14 @@ async function handlePlatformCommand(text, msg, adapter) {
         return false;
     const parts = text.split(/\s+/);
     const cmd = parts[0].toLowerCase();
-    const userId = hashUserId(msg.userId);
-    const session = getSession(userId);
+    // v4.12.0 — Same buildSessionKey routing as the main handler so /new and
+    // /status etc operate on the per-channel session, not the per-user one.
+    const sessionKey = buildSessionKey(msg.platform, msg.chatId, msg.userId);
+    const session = getSession(sessionKey);
     switch (cmd) {
         case "/new": {
             const { resetSession } = await import("../services/session.js");
-            resetSession(userId);
+            resetSession(sessionKey);
             await adapter.sendText(msg.chatId, "🔄 New chat started.");
             return true;
         }

package/dist/index.js

@@ -101,6 +101,10 @@ if (assetScanResult.assets.length > 0) {
 discoverTools();
 // Load skill files
 loadSkills();
+// v4.12.0 — Workspace registry: load per-channel configs and start the
+// hot-reload watcher. Safe no-op if no workspaces are configured.
+import { initWorkspaces, stopWorkspaceWatcher } from "./services/workspaces.js";
+initWorkspaces();
 // Load user-defined lifecycle hooks from ~/.alvin-bot/hooks/
 const hookCount = loadHooks();
 if (hookCount > 0)
@@ -258,6 +262,7 @@ const shutdown = async () => {
     stopScheduler();
     stopAsyncAgentWatcher();
     stopSessionCleanup();
+    stopWorkspaceWatcher();
     // v4.11.0 — Final immediate flush of in-memory sessions to disk before exit.
     // The debounced timer might be pending; flushSessions() cancels it and writes
     // synchronously so the next boot can rehydrate the latest state.

package/dist/paths.js

@@ -50,6 +50,11 @@ export const IDENTITY_FILE = resolve(DATA_DIR, "memory", "identity.md");
 export const PREFERENCES_FILE = resolve(DATA_DIR, "memory", "preferences.md");
 /** memory/projects/ — L2 layer (v4.11.0): per-project context loaded on topic match. */
 export const PROJECTS_MEMORY_DIR = resolve(DATA_DIR, "memory", "projects");
+/** workspaces/ — Per-workspace configuration (v4.12.0).
+ *  Each file is a markdown doc with YAML frontmatter defining the workspace's
+ *  name, purpose, cwd, color, emoji, and an optional system prompt body.
+ *  See src/services/workspaces.ts for the loader and matcher. */
+export const WORKSPACES_DIR = resolve(DATA_DIR, "workspaces");
 /** memory/.embeddings.json — Vector index */
 export const EMBEDDINGS_IDX = resolve(DATA_DIR, "memory", ".embeddings.json");
 /** users/ — User profiles and per-user memory */

package/dist/platforms/slack.js

@@ -36,6 +36,8 @@ export class SlackAdapter {
     botUserId = "";
     botToken;
     appToken;
+    /** v4.12.0 — channelId → channelName cache, refreshed on miss via conversations.info */
+    channelNameCache = new Map();
     constructor(botToken, appToken) {
         this.botToken = botToken;
         this.appToken = appToken;
@@ -221,8 +223,9 @@ export class SlackAdapter {
         const chunks = text.length > 3800
             ? text.match(/.{1,3800}/gs) || [text]
             : [text];
+        let lastTs;
         for (const chunk of chunks) {
-            await this.app.client.chat.postMessage({
+            const result = await this.app.client.chat.postMessage({
                 token: this.botToken,
                 channel: chatId,
                 text: chunk,
@@ -231,7 +234,30 @@ export class SlackAdapter {
                 // Convert markdown bold/italic to Slack mrkdwn
                 mrkdwn: true,
             });
+            if (result?.ts)
+                lastTs = result.ts;
         }
+        return lastTs;
+    }
+    /** Edit a previously-sent message (for progress tickers on long queries).
+     *  Fail-silent: ticker UX shouldn't crash the query. */
+    async editMessage(chatId, messageId, newText) {
+        if (!this.app)
+            return messageId;
+        try {
+            const safeText = newText.length > 3800 ? newText.slice(0, 3800) + "..." : newText;
+            await this.app.client.chat.update({
+                token: this.botToken,
+                channel: chatId,
+                ts: messageId,
+                text: safeText,
+                mrkdwn: true,
+            });
+        }
+        catch {
+            // Silent failure — ticker UX shouldn't crash the query
+        }
+        return messageId;
     }
     async sendPhoto(chatId, photo, caption) {
         if (!this.app)
@@ -299,8 +325,46 @@ export class SlackAdapter {
         catch { /* ignore — emoji might not exist */ }
     }
     async setTyping(chatId) {
-        // Slack doesn't have a public typing indicator API for bots
-        // The closest is the "is typing" shown during Web API calls
+        if (!this.app)
+            return;
+        // v4.12.0 — Slack's official "is thinking" API for bots is
+        // assistant.threads.setStatus which shows "Alvin is thinking…" under
+        // the message. Only works in assistant-enabled channels (scope:
+        // assistant:write) — silently no-ops in channels where the bot
+        // isn't enabled as an assistant.
+        try {
+            await this.app.client.apiCall("assistant.threads.setStatus", {
+                channel_id: chatId,
+                status: "is thinking…",
+            });
+        }
+        catch {
+            // Not every channel supports assistant threads — that's fine
+        }
+    }
+    /** v4.12.0 — Look up a Slack channel's name by ID, using a small in-memory
+     *  cache. Used by platform-message.ts for workspace resolution. */
+    async getChannelName(channelId) {
+        if (!this.app)
+            return undefined;
+        const cached = this.channelNameCache.get(channelId);
+        if (cached)
+            return cached;
+        try {
+            const result = await this.app.client.conversations.info({
+                token: this.botToken,
+                channel: channelId,
+            });
+            const name = result?.channel?.name;
+            if (name) {
+                this.channelNameCache.set(channelId, name);
+                return name;
+            }
+        }
+        catch {
+            // IM channels return channel_not_found here — that's expected
+        }
+        return undefined;
     }
     async stop() {
         if (this.app) {

package/dist/services/personality.js

@@ -186,7 +186,7 @@ Always ask yourself first: "Can I solve this with my own intelligence?" If yes
  * @param isSDK Whether the active provider is the Claude SDK (has tool use)
  * @param language Preferred language ('de' or 'en')
  */
-export function buildSystemPrompt(isSDK, language = "en", chatId, query) {
+export function buildSystemPrompt(isSDK, language = "en", chatId, query, workspacePersona) {
     // The deep base prompt has only de/en variants (writing four full
     // personality templates is out of scope). For es/fr we fall back to
     // the English base — the LLM mirrors the user's conversational language
@@ -214,6 +214,12 @@ export function buildSystemPrompt(isSDK, language = "en", chatId, query) {
     if (standingOrders) {
         parts.push("## Standing Orders\n\n" + standingOrders);
     }
+    // v4.12.0 — Workspace persona: per-channel system prompt override from
+    // ~/.alvin-bot/workspaces/<name>.md body. Only injected when a workspace
+    // is resolved for the channel; default workspace passes empty string.
+    if (workspacePersona && workspacePersona.trim().length > 0) {
+        parts.push("## Workspace Persona\n\n" + workspacePersona.trim());
+    }
     if (isSDK) {
         parts.push(SDK_ADDON);
         // Stage 1 — teach Claude to use run_in_background for long-running
@@ -266,10 +272,11 @@ export function buildSystemPrompt(isSDK, language = "en", chatId, query) {
  *                      context in its conversation history. Non-SDK providers
  *                      run the search on every turn (cheap, no resume).
  */
-export async function buildSmartSystemPrompt(isSDK, language = "en", userMessage, chatId, isFirstTurn = false) {
+export async function buildSmartSystemPrompt(isSDK, language = "en", userMessage, chatId, isFirstTurn = false, workspacePersona) {
     // Pass userMessage as query so L2 project memories matching the topic
-    // get loaded into the base prompt automatically.
-    const base = buildSystemPrompt(isSDK, language, chatId, userMessage);
+    // get loaded into the base prompt automatically. Workspace persona (v4.12.0)
+    // is also threaded through so per-channel personas land in the system prompt.
+    const base = buildSystemPrompt(isSDK, language, chatId, userMessage, workspacePersona);
     if (!userMessage)
         return base;
     // Decide whether to run the semantic search:

package/dist/services/session-persistence.js

@@ -21,7 +21,7 @@
 import fs from "fs";
 import { dirname } from "path";
 import { SESSIONS_STATE_FILE } from "../paths.js";
-import { getAllSessions, } from "./session.js";
+import { getAllSessions, getTelegramWorkspacesMap, } from "./session.js";
 /** History entries to keep in the persisted snapshot (per session). */
 const MAX_PERSISTED_HISTORY = 50;
 /** Debounce window for grouped mutations. */
@@ -32,6 +32,7 @@ function snapshot(session) {
     return {
         sessionId: session.sessionId,
         workingDir: session.workingDir,
+        workspaceName: session.workspaceName,
         language: session.language,
         effort: session.effort,
         voiceReply: session.voiceReply,
@@ -72,9 +73,21 @@ export async function flushSessions() {
         }
         // Ensure the state directory exists
         fs.mkdirSync(dirname(SESSIONS_STATE_FILE), { recursive: true });
+        // v4.12.0 — Persist Telegram active-workspace map alongside sessions.
+        // Wrapped in a versioned envelope so we can add more state later without
+        // breaking loadPersistedSessions' backwards-compat path for older files.
+        const tgWorkspaces = {};
+        for (const [userId, ws] of getTelegramWorkspacesMap()) {
+            tgWorkspaces[userId] = ws;
+        }
+        const envelope = {
+            version: 2,
+            sessions: out,
+            telegramWorkspaces: tgWorkspaces,
+        };
         // Atomic write: tmp + rename
         const tmpFile = `${SESSIONS_STATE_FILE}.tmp`;
-        fs.writeFileSync(tmpFile, JSON.stringify(out, null, 2), "utf-8");
+        fs.writeFileSync(tmpFile, JSON.stringify(envelope, null, 2), "utf-8");
         fs.renameSync(tmpFile, SESSIONS_STATE_FILE);
     }
     catch (err) {
@@ -106,16 +119,37 @@ export function loadPersistedSessions() {
     catch {
         return 0; // no file = nothing to do
     }
-    let parsed;
+    let raw_parsed;
     try {
-        parsed = JSON.parse(raw);
+        raw_parsed = JSON.parse(raw);
     }
     catch (err) {
         console.warn("⚠️ session-persistence: corrupt sessions.json, starting fresh —", err instanceof Error ? err.message : String(err));
         return 0;
     }
-    if (!parsed || typeof parsed !== "object")
+    if (!raw_parsed || typeof raw_parsed !== "object")
         return 0;
+    // v4.12.0 — Detect envelope format vs legacy v4.11.0 flat format
+    let parsed;
+    let tgWorkspaces = {};
+    if (raw_parsed &&
+        typeof raw_parsed === "object" &&
+        "version" in raw_parsed &&
+        "sessions" in raw_parsed) {
+        const env = raw_parsed;
+        parsed = env.sessions ?? {};
+        tgWorkspaces = env.telegramWorkspaces ?? {};
+    }
+    else {
+        // Legacy flat format (v4.11.0)
+        parsed = raw_parsed;
+    }
+    // Rehydrate Telegram workspace map
+    const tgMap = getTelegramWorkspacesMap();
+    for (const [userId, name] of Object.entries(tgWorkspaces)) {
+        if (typeof name === "string")
+            tgMap.set(userId, name);
+    }
     // Use the same getAllSessions Map that session.ts exports
     const all = getAllSessions();
     let count = 0;
@@ -127,6 +161,7 @@ export function loadPersistedSessions() {
         const restored = {
             sessionId: persisted.sessionId ?? null,
             workingDir: persisted.workingDir ?? process.cwd(),
+            workspaceName: persisted.workspaceName ?? null,
             isProcessing: false,
             abortController: null,
             lastActivity: persisted.lastActivity ?? Date.now(),

package/dist/services/session.js

@@ -2,6 +2,35 @@ import { config } from "../config.js";
 /** Max history entries to keep (to avoid token overflow) */
 const MAX_HISTORY = 100;
 const sessions = new Map();
+// v4.12.0 P1 #3 — Telegram active-workspace map: userId → workspaceName.
+// Separate from the sessions Map because a user's ACTIVE workspace is an
+// index, not a session itself. Persisted via session-persistence snapshots.
+const telegramWorkspaces = new Map();
+/** Get the user's currently active Telegram workspace. null = default. */
+export function getTelegramWorkspace(userId) {
+    return telegramWorkspaces.get(String(userId)) ?? null;
+}
+/** Set the user's currently active Telegram workspace. */
+export function setTelegramWorkspace(userId, name) {
+    const key = String(userId);
+    if (name === null) {
+        telegramWorkspaces.delete(key);
+    }
+    else {
+        telegramWorkspaces.set(key, name);
+    }
+    // Defer persist() until after it's defined below
+    if (_persistHook) {
+        try {
+            _persistHook();
+        }
+        catch { /* ignore */ }
+    }
+}
+/** For session-persistence.ts — expose the raw map for snapshotting. */
+export function getTelegramWorkspacesMap() {
+    return telegramWorkspaces;
+}
 // ── Persistence Hook (v4.11.0) ─────────────────────────────────────
 //
 // session-persistence.ts is wired in via attachPersistHook() at bot startup.
@@ -47,6 +76,7 @@ export function getSession(key) {
         session = {
             sessionId: null,
             workingDir: config.defaultWorkingDir,
+            workspaceName: null,
             isProcessing: false,
             abortController: null,
             lastActivity: Date.now(),
@@ -199,6 +229,24 @@ export function addToHistory(key, message) {
 export function getAllSessions() {
     return sessions;
 }
+/** v4.12.0 — Aggregate session.totalCost by workspaceName across all
+ *  active sessions. Returns an object keyed by workspace name (null →
+ *  "default") with cumulative cost, session count, message count, and
+ *  tool use count. Used by the Web UI's workspace overview. */
+export function getCostByWorkspace() {
+    const out = {};
+    for (const s of sessions.values()) {
+        const name = s.workspaceName ?? "default";
+        if (!out[name]) {
+            out[name] = { totalCost: 0, sessionCount: 0, messageCount: 0, toolUseCount: 0 };
+        }
+        out[name].totalCost += s.totalCost;
+        out[name].sessionCount += 1;
+        out[name].messageCount += s.messageCount;
+        out[name].toolUseCount += s.toolUseCount;
+    }
+    return out;
+}
 /** Kill a user session completely — abort running query, clear history, remove from map. */
 export function killSession(key) {
     const k = String(key);