tide-commander 1.89.0 → 1.91.0

package/dist/assets/{web-BrBkKQlr.js → web-Cx_ySRHK.js}

@@ -1 +1 @@
-import{ck as s}from"./main-D-YFCprA.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class l extends s{constructor(){super(...arguments),this.pending=[],this.deliveredNotifications=[],this.hasNotificationSupport=()=>{if(!("Notification"in window)||!Notification.requestPermission)return!1;if(Notification.permission!=="granted")try{new Notification("")}catch(i){if(i instanceof Error&&i.name==="TypeError")return!1}return!0}}async getDeliveredNotifications(){const i=[];for(const t of this.deliveredNotifications){const e={title:t.title,id:parseInt(t.tag),body:t.body};i.push(e)}return{notifications:i}}async removeDeliveredNotifications(i){for(const t of i.notifications){const e=this.deliveredNotifications.find(n=>n.tag===String(t.id));e==null||e.close(),this.deliveredNotifications=this.deliveredNotifications.filter(()=>!e)}}async removeAllDeliveredNotifications(){for(const i of this.deliveredNotifications)i.close();this.deliveredNotifications=[]}async createChannel(){throw this.unimplemented("Not implemented on web.")}async deleteChannel(){throw this.unimplemented("Not implemented on web.")}async listChannels(){throw this.unimplemented("Not implemented on web.")}async schedule(i){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");for(const t of i.notifications)this.sendNotification(t);return{notifications:i.notifications.map(t=>({id:t.id}))}}async getPending(){return{notifications:this.pending}}async registerActionTypes(){throw this.unimplemented("Not implemented on web.")}async cancel(i){this.pending=this.pending.filter(t=>!i.notifications.find(e=>e.id===t.id))}async areEnabled(){const{display:i}=await this.checkPermissions();return{value:i==="granted"}}async changeExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async checkExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async requestPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(await Notification.requestPermission())}}async checkPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(Notification.permission)}}transformNotificationPermission(i){switch(i){case"granted":return"granted";case"denied":return"denied";default:return"prompt"}}sendPending(){var i;const t=[],e=new Date().getTime();for(const n of this.pending)!((i=n.schedule)===null||i===void 0)&&i.at&&n.schedule.at.getTime()<=e&&(this.buildNotification(n),t.push(n));this.pending=this.pending.filter(n=>!t.find(o=>o===n))}sendNotification(i){var t;if(!((t=i.schedule)===null||t===void 0)&&t.at){const e=i.schedule.at.getTime()-new Date().getTime();this.pending.push(i),setTimeout(()=>{this.sendPending()},e);return}this.buildNotification(i)}buildNotification(i){const t=new Notification(i.title,{body:i.body,tag:String(i.id)});return t.addEventListener("click",this.onClick.bind(this,i),!1),t.addEventListener("show",this.onShow.bind(this,i),!1),t.addEventListener("close",()=>{this.deliveredNotifications=this.deliveredNotifications.filter(()=>!this)},!1),this.deliveredNotifications.push(t),t}onClick(i){const t={actionId:"tap",notification:i};this.notifyListeners("localNotificationActionPerformed",t)}onShow(i){this.notifyListeners("localNotificationReceived",i)}}export{l as LocalNotificationsWeb};
+import{ck as s}from"./main-5eyR3isL.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class l extends s{constructor(){super(...arguments),this.pending=[],this.deliveredNotifications=[],this.hasNotificationSupport=()=>{if(!("Notification"in window)||!Notification.requestPermission)return!1;if(Notification.permission!=="granted")try{new Notification("")}catch(i){if(i instanceof Error&&i.name==="TypeError")return!1}return!0}}async getDeliveredNotifications(){const i=[];for(const t of this.deliveredNotifications){const e={title:t.title,id:parseInt(t.tag),body:t.body};i.push(e)}return{notifications:i}}async removeDeliveredNotifications(i){for(const t of i.notifications){const e=this.deliveredNotifications.find(n=>n.tag===String(t.id));e==null||e.close(),this.deliveredNotifications=this.deliveredNotifications.filter(()=>!e)}}async removeAllDeliveredNotifications(){for(const i of this.deliveredNotifications)i.close();this.deliveredNotifications=[]}async createChannel(){throw this.unimplemented("Not implemented on web.")}async deleteChannel(){throw this.unimplemented("Not implemented on web.")}async listChannels(){throw this.unimplemented("Not implemented on web.")}async schedule(i){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");for(const t of i.notifications)this.sendNotification(t);return{notifications:i.notifications.map(t=>({id:t.id}))}}async getPending(){return{notifications:this.pending}}async registerActionTypes(){throw this.unimplemented("Not implemented on web.")}async cancel(i){this.pending=this.pending.filter(t=>!i.notifications.find(e=>e.id===t.id))}async areEnabled(){const{display:i}=await this.checkPermissions();return{value:i==="granted"}}async changeExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async checkExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async requestPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(await Notification.requestPermission())}}async checkPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(Notification.permission)}}transformNotificationPermission(i){switch(i){case"granted":return"granted";case"denied":return"denied";default:return"prompt"}}sendPending(){var i;const t=[],e=new Date().getTime();for(const n of this.pending)!((i=n.schedule)===null||i===void 0)&&i.at&&n.schedule.at.getTime()<=e&&(this.buildNotification(n),t.push(n));this.pending=this.pending.filter(n=>!t.find(o=>o===n))}sendNotification(i){var t;if(!((t=i.schedule)===null||t===void 0)&&t.at){const e=i.schedule.at.getTime()-new Date().getTime();this.pending.push(i),setTimeout(()=>{this.sendPending()},e);return}this.buildNotification(i)}buildNotification(i){const t=new Notification(i.title,{body:i.body,tag:String(i.id)});return t.addEventListener("click",this.onClick.bind(this,i),!1),t.addEventListener("show",this.onShow.bind(this,i),!1),t.addEventListener("close",()=>{this.deliveredNotifications=this.deliveredNotifications.filter(()=>!this)},!1),this.deliveredNotifications.push(t),t}onClick(i){const t={actionId:"tap",notification:i};this.notifyListeners("localNotificationActionPerformed",t)}onShow(i){this.notifyListeners("localNotificationReceived",i)}}export{l as LocalNotificationsWeb};

package/dist/assets/{web-DCu3NTho.js → web-DGO1VHbi.js}

@@ -1 +1 @@
-import{ck as a}from"./main-D-YFCprA.js";import{ImpactStyle as i,NotificationType as r}from"./index-BiAZinYH.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class h extends a{constructor(){super(...arguments),this.selectionStarted=!1}async impact(t){const e=this.patternForImpact(t==null?void 0:t.style);this.vibrateWithPattern(e)}async notification(t){const e=this.patternForNotification(t==null?void 0:t.type);this.vibrateWithPattern(e)}async vibrate(t){const e=(t==null?void 0:t.duration)||300;this.vibrateWithPattern([e])}async selectionStart(){this.selectionStarted=!0}async selectionChanged(){this.selectionStarted&&this.vibrateWithPattern([70])}async selectionEnd(){this.selectionStarted=!1}patternForImpact(t=i.Heavy){return t===i.Medium?[43]:t===i.Light?[20]:[61]}patternForNotification(t=r.Success){return t===r.Warning?[30,40,30,50,60]:t===r.Error?[27,45,50]:[35,65,21]}vibrateWithPattern(t){if(navigator.vibrate)navigator.vibrate(t);else throw this.unavailable("Browser does not support the vibrate API")}}export{h as HapticsWeb};
+import{ck as a}from"./main-5eyR3isL.js";import{ImpactStyle as i,NotificationType as r}from"./index-B4JdUiAe.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class h extends a{constructor(){super(...arguments),this.selectionStarted=!1}async impact(t){const e=this.patternForImpact(t==null?void 0:t.style);this.vibrateWithPattern(e)}async notification(t){const e=this.patternForNotification(t==null?void 0:t.type);this.vibrateWithPattern(e)}async vibrate(t){const e=(t==null?void 0:t.duration)||300;this.vibrateWithPattern([e])}async selectionStart(){this.selectionStarted=!0}async selectionChanged(){this.selectionStarted&&this.vibrateWithPattern([70])}async selectionEnd(){this.selectionStarted=!1}patternForImpact(t=i.Heavy){return t===i.Medium?[43]:t===i.Light?[20]:[61]}patternForNotification(t=r.Success){return t===r.Warning?[30,40,30,50,60]:t===r.Error?[27,45,50]:[35,65,21]}vibrateWithPattern(t){if(navigator.vibrate)navigator.vibrate(t);else throw this.unavailable("Browser does not support the vibrate API")}}export{h as HapticsWeb};

package/dist/assets/{web-DX588C-g.js → web-DMjkVCWy.js}

@@ -1 +1 @@
-import{ck as t}from"./main-D-YFCprA.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class o extends t{constructor(){super(),this.handleVisibilityChange=()=>{const e={isActive:document.hidden!==!0};this.notifyListeners("appStateChange",e),document.hidden?this.notifyListeners("pause",null):this.notifyListeners("resume",null)},document.addEventListener("visibilitychange",this.handleVisibilityChange,!1)}exitApp(){throw this.unimplemented("Not implemented on web.")}async getInfo(){throw this.unimplemented("Not implemented on web.")}async getLaunchUrl(){return{url:""}}async getState(){return{isActive:document.hidden!==!0}}async minimizeApp(){throw this.unimplemented("Not implemented on web.")}async toggleBackButtonHandler(){throw this.unimplemented("Not implemented on web.")}async getAppLanguage(){return{value:navigator.language.split("-")[0].toLowerCase()}}}export{o as AppWeb};
+import{ck as t}from"./main-5eyR3isL.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class o extends t{constructor(){super(),this.handleVisibilityChange=()=>{const e={isActive:document.hidden!==!0};this.notifyListeners("appStateChange",e),document.hidden?this.notifyListeners("pause",null):this.notifyListeners("resume",null)},document.addEventListener("visibilitychange",this.handleVisibilityChange,!1)}exitApp(){throw this.unimplemented("Not implemented on web.")}async getInfo(){throw this.unimplemented("Not implemented on web.")}async getLaunchUrl(){return{url:""}}async getState(){return{isActive:document.hidden!==!0}}async minimizeApp(){throw this.unimplemented("Not implemented on web.")}async toggleBackButtonHandler(){throw this.unimplemented("Not implemented on web.")}async getAppLanguage(){return{value:navigator.language.split("-")[0].toLowerCase()}}}export{o as AppWeb};

package/dist/index.html

@@ -22,10 +22,10 @@
     <link rel="icon" type="image/png" sizes="16x16" href="/assets/icons/favicon-16x16.png" />
     <link rel="apple-touch-icon" sizes="180x180" href="/assets/icons/apple-touch-icon.png" />
     <title>Tide Commander</title>
-    <script type="module" crossorigin src="/assets/main-D-YFCprA.js"></script>
+    <script type="module" crossorigin src="/assets/main-5eyR3isL.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-react--Eh9ivFN.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-three-Chj50gSY.js">
-    <link rel="stylesheet" crossorigin href="/assets/main-Bw5ZddEN.css">
+    <link rel="stylesheet" crossorigin href="/assets/main-CrGeO0Sc.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/src/packages/server/claude/backend.js

@@ -9,6 +9,7 @@ import { createLogger, sanitizeUnicode } from '../utils/index.js';
 import { TIDE_COMMANDER_APPENDED_PROMPT } from '../prompts/tide-commander.js';
 import { getSystemPrompt, isEchoPromptEnabled } from '../services/system-prompt-service.js';
 import { loadAreas } from '../data/index.js';
+import { getAgent } from '../services/agent-service.js';
 const log = createLogger('Backend');
 // Track tool_use_id to tool_name mapping for matching tool_result events
 // This is a module-level map that persists across parseEvent calls
@@ -46,6 +47,16 @@ export function buildAppendedProjectInstructions(config) {
             sections.push(`## Area-Level Prompt (${agentArea.name})`, areaPrompt);
         }
     }
+    // Per-agent persistent memory — the agent's own notes/lessons accumulated
+    // over time. Injected between the global system prompt and class instructions
+    // so the agent's self-curated context is visible before class-level rules.
+    if (config.agentId) {
+        const agent = getAgent(config.agentId);
+        const agentMemory = agent?.memory?.trim();
+        if (agentMemory) {
+            sections.push('## Agent Memory (Your Notes To Yourself)', 'The following are notes you have saved to your own persistent memory across conversations — past lessons, user preferences, project context, and references you have chosen to retain. Use them as authoritative context but verify before acting on stale-sounding facts. Update them via the `agent-memory` skill when you learn something worth keeping.', agentMemory);
+        }
+    }
     const customPrompt = config.customAgent?.definition?.prompt?.trim();
     if (customPrompt) {
         sections.push('## Agent Class Instructions', 'The following instructions are mandatory unless the user explicitly overrides them.', customPrompt);

package/dist/src/packages/server/data/builtin-skills/agent-memory.js

@@ -0,0 +1,126 @@
+export const agentMemory = {
+    slug: 'agent-memory',
+    name: 'Agent Memory',
+    description: 'Save important notes, lessons, preferences, and context to your persistent agent memory. Use proactively whenever you learn something worth remembering across conversations.',
+    allowedTools: ['Bash(curl:*)'],
+    assignedAgentClasses: ['*'],
+    content: `# Agent Memory (Your Own Persistent Notes)
+
+You have a **per-agent persistent memory string** that is automatically injected into your system prompt on every turn under the section \`## Agent Memory (Your Notes To Yourself)\`. It survives across conversations, restarts, and context resets. It is yours — only you (and the user via UI) edit it.
+
+Use it to remember things that would otherwise be lost the next time your context is cleared.
+
+## Endpoints
+
+All endpoints are authenticated with the shared \`X-Auth-Token: abcd\` header (same as every other Tide Commander API).
+
+\`\`\`bash
+# Read your current memory
+curl -s -H "X-Auth-Token: abcd" \\
+  http://localhost:5174/api/agents/YOUR_AGENT_ID/memory
+
+# Replace your memory (FULL REPLACE — see read-modify-write below)
+curl -s -X PATCH -H "X-Auth-Token: abcd" \\
+  http://localhost:5174/api/agents/YOUR_AGENT_ID/memory \\
+  -H "Content-Type: application/json" \\
+  -d @- <<'EOF'
+{"memory": "## Project context\\n- foo\\n- bar\\n"}
+EOF
+
+# Clear your memory completely
+curl -s -X DELETE -H "X-Auth-Token: abcd" \\
+  http://localhost:5174/api/agents/YOUR_AGENT_ID/memory
+\`\`\`
+
+Substitute \`YOUR_AGENT_ID\` with the real agent ID from your identity block.
+
+## When to write to memory
+
+Save things that will still be useful **next conversation**, especially when they're not obvious from reading the code:
+
+- **User preferences:** "User prefers terse responses with no trailing summaries"
+- **Project facts:** "Backend uses Bun, not Node — \`npm run build\` is wrong, use \`bun run build\`"
+- **Lessons from corrections:** "User got annoyed when I created new files for one-off scripts — prefer inline edits"
+- **Useful debugging recipes:** "When tsc fails with TS2307 on .js extension, the file is in /src not /dist; build first"
+- **External system references:** "Bugs tracked in Linear project 'INGEST'; deploy logs at grafana.internal/d/deploys"
+- **Architectural decisions:** "Auth middleware was rewritten in v1.85 for compliance — do NOT re-introduce the old session-token pattern"
+
+## When NOT to write to memory
+
+- Code patterns / structure / file paths — re-derive with Grep
+- Git history or recent diffs — \`git log\` is authoritative
+- Things already in CLAUDE.md
+- Temporary in-conversation state (current task, current todo list)
+- Debug output, build errors, scratch logs
+
+If removing a memory entry wouldn't confuse future-you, don't write it.
+
+## CRITICAL: PATCH is a full replace — use read-modify-write
+
+The PATCH endpoint overwrites your entire memory. You must:
+
+1. **GET** the current memory first
+2. **Merge** your new note into the existing content (don't blow it away)
+3. **PATCH** the merged result back
+
+Example flow:
+
+\`\`\`bash
+# 1. Read current memory
+current=$(curl -s -H "X-Auth-Token: abcd" \\
+  http://localhost:5174/api/agents/YOUR_AGENT_ID/memory | \\
+  jq -r '.memory')
+
+# 2. (You merge \$current with your new note in your head, then write it.)
+
+# 3. Write merged result back
+curl -s -X PATCH -H "X-Auth-Token: abcd" \\
+  http://localhost:5174/api/agents/YOUR_AGENT_ID/memory \\
+  -H "Content-Type: application/json" \\
+  -d @- <<'EOF'
+{"memory": "<the merged content here>"}
+EOF
+\`\`\`
+
+If your memory is empty (first time), skip step 1 and just PATCH the new content.
+
+## Suggested format — keep memory organized
+
+Use a small set of markdown sections so the file stays scannable as it grows. A good starting structure:
+
+\`\`\`markdown
+## Project context
+- The backend uses Bun, not Node.
+- Frontend lives in src/packages/client.
+
+## User preferences
+- Terse responses, no trailing summaries.
+- Always full project-relative paths.
+
+## Lessons learned
+- Don't run npm install — use bun install.
+- The pre-commit hook will reject Co-Authored-By trailers.
+
+## External references
+- Linear project "INGEST" for pipeline bugs.
+- Grafana board grafana.internal/d/api-latency for oncall.
+\`\`\`
+
+Add, rewrite, or prune sections as your understanding evolves. Outdated entries are worse than no entries — delete them when they no longer apply.
+
+## Size limit
+
+Keep total memory under **~10KB**. Memory is injected into every system prompt for this agent, so bloat = wasted context window on every turn. If you're approaching that, prune the least useful entries before adding new ones.
+
+## When to use this skill proactively
+
+You do **not** need the user to ask. If you observe:
+
+- The user **corrects** you ("no, use X instead") — save the correction.
+- The user **confirms** a non-obvious approach ("yes that was right") — save the validated approach.
+- You discover a **project-specific fact** the codebase doesn't make obvious — save it.
+- You learn an **external resource** location — save the pointer.
+
+Read your memory at the start of any task where remembered context would change your approach — but trust **current code** over memory if the two conflict (memory can go stale; update or remove stale entries when you spot them).
+`,
+};

package/dist/src/packages/server/data/builtin-skills/index.js

@@ -17,6 +17,7 @@ import { exploreDatabase } from './explore-database.js';
 import { releasePipeline } from './release-pipeline.js';
 import { taskLabel } from './task-label.js';
 import { agentTracking } from './agent-tracking.js';
+import { agentMemory } from './agent-memory.js';
 import { reportTaskToBoss } from './report-task-to-boss.js';
 import { bossInstructions } from './boss-instructions.js';
 import { workflowDesigner } from './workflow-designer.js';
@@ -39,6 +40,7 @@ export const BUILTIN_SKILLS = [
     releasePipeline,
     taskLabel,
     agentTracking,
+    agentMemory,
     reportTaskToBoss,
     bossInstructions,
     workflowDesigner,

package/dist/src/packages/server/integrations/slack/slack-instance.js

@@ -17,6 +17,7 @@ import { SocketModeClient } from '@slack/socket-mode';
 import { instanceSecretKey, loadConfig, resolveAuthMode, updateConfig } from './slack-config.js';
 import { SlackPollingClient, asPollingWebClient } from './slack-polling-client.js';
 import { SlackWatermarkStore } from './slack-watermark-store.js';
+import { SlackNameCache } from './slack-name-cache.js';
 // Subtypes we never want to trigger on. Modern file-share has NO subtype, legacy uses `file_share` — both must pass.
 const SKIP_MESSAGE_SUBTYPES = new Set([
     'bot_message',
@@ -51,6 +52,13 @@ export class SlackInstance {
     ctx = null;
     userCache = new Map();
     channelNameCache = new Map();
+    /**
+     * TTL+LRU cache of resolved labels for the trigger template (separate from
+     * the unbounded `userCache` / `channelNameCache` above which back the
+     * SlackUser objects + raw conversation names). Lives per-instance, so the
+     * `default` and `personal` instances never share resolved names.
+     */
+    nameCache = new SlackNameCache();
     messageListeners = new Set();
     replyWaiters = new Set();
     constructor(id) {
@@ -265,11 +273,17 @@ export class SlackInstance {
             try {
                 const user = await this.resolveUser(userId);
                 userName = user?.displayName || user?.name || userId;
+                // Prime the lightweight cache so the trigger pipeline + future
+                // resolveChannelLabel calls can hit it synchronously.
+                this.nameCache.primeUser(userId, userName);
             }
             catch {
                 // Use userId as fallback
             }
         }
+        // Best-effort channel-label resolve. Empty string fallback lets consumers
+        // see the raw id when name metadata is unavailable.
+        const channelName = await this.resolveChannelLabel(event.channel).catch(() => '');
         const files = hasFiles
             ? event.files.map((f) => normalizeSlackFile(f))
             : undefined;
@@ -277,6 +291,7 @@ export class SlackInstance {
             ts: event.ts,
             threadTs: event.thread_ts,
             channel: event.channel,
+            channelName: channelName ?? '',
             userId,
             userName,
             text,
@@ -286,8 +301,10 @@ export class SlackInstance {
         };
         const direction = isOwnMessage ? 'outbound' : 'inbound';
         // Heartbeat: one line per dispatched message. PII-safe — only ids, ts,
-        // direction, file count. No message text, no usernames, no emails.
-        this.ctx?.log.info(`Slack[${this.id}] dispatch: channel=${event.channel} user=${userId || '-'} ts=${event.ts} direction=${direction} files=${files?.length ?? 0}${event.thread_ts && event.thread_ts !== event.ts ? ` thread=${event.thread_ts}` : ''}`);
+        // direction, file count, and resolved-flag for name lookups (Y/N), no
+        // names/emails/text.
+        const resolvedFlag = `userResolved=${userName && userName !== userId ? 'Y' : 'N'} channelResolved=${channelName ? 'Y' : 'N'}`;
+        this.ctx?.log.info(`Slack[${this.id}] dispatch: channel=${event.channel} user=${userId || '-'} ts=${event.ts} direction=${direction} files=${files?.length ?? 0}${event.thread_ts && event.thread_ts !== event.ts ? ` thread=${event.thread_ts}` : ''} ${resolvedFlag}`);
         this.ctx?.eventDb.logSlackMessage({
             ts: event.ts,
             threadTs: event.thread_ts,
@@ -488,6 +505,81 @@ export class SlackInstance {
         this.userCache.set(userId, user);
         return user;
     }
+    /**
+     * Resolve a channel id to a human-readable label for trigger templates and
+     * the Guake bubble. Cached via SlackNameCache (10 min TTL, LRU 500).
+     *   - public/private channels: `#name`
+     *   - 1:1 DM (im): `DM con @counterparty`
+     *   - multi-party DM (mpim): `Grupo: @user1, @user2, +N more`
+     * Returns the empty string when metadata can't be fetched — caller should
+     * fall back to the raw id.
+     */
+    async resolveChannelLabel(channelId) {
+        if (!channelId)
+            return '';
+        const cached = this.nameCache.peekChannel(channelId);
+        if (cached !== undefined)
+            return cached ?? '';
+        const label = await this.nameCache.lookupChannel(channelId, async () => {
+            if (!this.webClient)
+                return null;
+            const info = await this.webClient.conversations.info({
+                channel: channelId,
+                include_num_members: false,
+            });
+            const ch = info.channel;
+            if (!ch)
+                return null;
+            // Public/private channel → `#name`. Slack stores both kinds with `is_channel`
+            // / `is_group` flags + a `name` field.
+            const name = typeof ch.name === 'string' ? ch.name : undefined;
+            if (ch.is_im) {
+                const counterpartyId = typeof ch.user === 'string' ? ch.user : '';
+                if (!counterpartyId)
+                    return 'DM';
+                const counterparty = await this.resolveUserNameSafe(counterpartyId);
+                return counterparty ? `DM con @${counterparty}` : `DM con @${counterpartyId}`;
+            }
+            if (ch.is_mpim) {
+                // members may be returned via include_num_members or via a follow-up
+                // conversations.members call; mpim usually returns it inline.
+                const members = Array.isArray(ch.members) ? ch.members : [];
+                if (members.length === 0 && name)
+                    return `Grupo: ${name}`;
+                const labels = await Promise.all(members.slice(0, 3).map(async (uid) => {
+                    const n = await this.resolveUserNameSafe(uid);
+                    return n ? `@${n}` : `@${uid}`;
+                }));
+                const more = members.length > 3 ? `, +${members.length - 3} more` : '';
+                return labels.length > 0 ? `Grupo: ${labels.join(', ')}${more}` : (name ? `Grupo: ${name}` : 'Grupo');
+            }
+            if (name)
+                return `#${name}`;
+            return null;
+        });
+        return label ?? '';
+    }
+    /**
+     * Resolve a userId to its preferred display string (display_name → name →
+     * real_name) without throwing. Returns null when the lookup fails. Cached.
+     */
+    async resolveUserNameSafe(userId) {
+        if (!userId)
+            return null;
+        return this.nameCache.lookupUser(userId, async () => {
+            try {
+                const user = await this.resolveUser(userId);
+                return user?.displayName || user?.name || user?.realName || null;
+            }
+            catch {
+                return null;
+            }
+        });
+    }
+    /** Test/diagnostic accessor for the per-instance name cache. */
+    getNameCache() {
+        return this.nameCache;
+    }
     async findUserByEmail(email) {
         if (!this.webClient)
             throw new Error('Slack not connected');
@@ -725,10 +817,16 @@ export class SlackInstance {
         }
         const rawFiles = msg.files;
         const files = rawFiles?.length ? rawFiles.map(normalizeSlackFile) : undefined;
+        // Best-effort channel-name lookup. This path is the historical
+        // getChannelMessages / getThreadReplies API surface, used by skills not
+        // by the trigger pipeline; if the resolver fails we leave channelName
+        // empty and the caller falls back to `channel` (the raw id).
+        const channelName = await this.resolveChannelLabel(channel).catch(() => '');
         return {
             ts: msg.ts,
             threadTs: msg.thread_ts,
             channel,
+            channelName: channelName ?? '',
             userId,
             userName,
             text: msg.text || '',

package/dist/src/packages/server/integrations/slack/slack-name-cache.js

@@ -0,0 +1,153 @@
+/**
+ * SlackNameCache — caches resolved display names for Slack user IDs and
+ * channel IDs so the trigger template can render `@David` / `#navi` instead
+ * of cryptic `U078UV85AEM` / `C02JE0A23BJ`.
+ *
+ * One instance is owned by each `SlackInstance`, giving free per-instance
+ * isolation: the `default` (xoxb- bot) and `personal` (xoxp- user token) caches
+ * never bleed into each other even when the same user/channel id is visible
+ * to both tokens.
+ *
+ * The `users.info` / `conversations.info` Slack endpoints are Tier 4
+ * (~100 req/min) so we don't bother routing through the polling pacer; with
+ * cache hit-rate ≈100% after warm-up the additional traffic is negligible.
+ */
+/**
+ * Insertion-ordered Map gives free LRU when we evict the oldest on overflow,
+ * same trick used by message-dedupe.ts in the WhatsApp integration.
+ */
+class TtlLruCache {
+    ttlMs;
+    maxEntries;
+    now;
+    map = new Map();
+    constructor(ttlMs, maxEntries, now) {
+        this.ttlMs = ttlMs;
+        this.maxEntries = maxEntries;
+        this.now = now;
+    }
+    get(key) {
+        const entry = this.map.get(key);
+        if (!entry)
+            return undefined;
+        if (this.now() - entry.storedAt > this.ttlMs) {
+            this.map.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value) {
+        if (this.map.has(key))
+            this.map.delete(key);
+        this.map.set(key, { value, storedAt: this.now() });
+        if (this.map.size > this.maxEntries) {
+            // Drop the oldest (insertion order) to bound memory.
+            const oldest = this.map.keys().next();
+            if (!oldest.done)
+                this.map.delete(oldest.value);
+        }
+    }
+    size() {
+        return this.map.size;
+    }
+    clear() {
+        this.map.clear();
+    }
+}
+export class SlackNameCache {
+    users;
+    channels;
+    userInflight = new Map();
+    channelInflight = new Map();
+    constructor(opts = {}) {
+        const ttl = opts.ttlMs ?? 10 * 60_000;
+        const max = opts.maxEntries ?? 500;
+        const now = opts.now ?? Date.now;
+        this.users = new TtlLruCache(ttl, max, now);
+        this.channels = new TtlLruCache(ttl, max, now);
+    }
+    /** Synchronous read — returns the cached value or undefined when stale/absent. */
+    peekUser(userId) {
+        return this.users.get(userId);
+    }
+    peekChannel(channelId) {
+        return this.channels.get(channelId);
+    }
+    /**
+     * Resolve a userId to a display name with cache + in-flight coalescing. The
+     * fetcher is provided by `SlackInstance` so this module stays decoupled from
+     * the WebClient. Returns null when the name can't be resolved — callers
+     * fall back to the bare userId.
+     */
+    async lookupUser(userId, fetcher) {
+        if (!userId)
+            return null;
+        const cached = this.users.get(userId);
+        if (cached !== undefined)
+            return cached;
+        const pending = this.userInflight.get(userId);
+        if (pending)
+            return pending;
+        const promise = (async () => {
+            try {
+                const name = await fetcher();
+                this.users.set(userId, name ?? null);
+                return name ?? null;
+            }
+            catch {
+                // Don't poison the cache on transient errors — a future call retries.
+                return null;
+            }
+            finally {
+                this.userInflight.delete(userId);
+            }
+        })();
+        this.userInflight.set(userId, promise);
+        return promise;
+    }
+    async lookupChannel(channelId, fetcher) {
+        if (!channelId)
+            return null;
+        const cached = this.channels.get(channelId);
+        if (cached !== undefined)
+            return cached;
+        const pending = this.channelInflight.get(channelId);
+        if (pending)
+            return pending;
+        const promise = (async () => {
+            try {
+                const name = await fetcher();
+                this.channels.set(channelId, name ?? null);
+                return name ?? null;
+            }
+            catch {
+                return null;
+            }
+            finally {
+                this.channelInflight.delete(channelId);
+            }
+        })();
+        this.channelInflight.set(channelId, promise);
+        return promise;
+    }
+    /** Force-prime an entry — used when other code paths already know the name. */
+    primeUser(userId, name) {
+        if (!userId)
+            return;
+        this.users.set(userId, name);
+    }
+    primeChannel(channelId, name) {
+        if (!channelId)
+            return;
+        this.channels.set(channelId, name);
+    }
+    size() {
+        return { users: this.users.size(), channels: this.channels.size() };
+    }
+    clear() {
+        this.users.clear();
+        this.channels.clear();
+        this.userInflight.clear();
+        this.channelInflight.clear();
+    }
+}

package/dist/src/packages/server/integrations/slack/slack-trigger-handler.js

@@ -90,16 +90,31 @@ export const slackTriggerHandler = {
         const msg = event.data;
         void trigger;
         const files = msg.files ?? [];
+        // Resolved channel label: `#name` / `DM con @user` / `Grupo: @a, @b…`.
+        // Falls back to the raw id when the resolver couldn't fetch metadata
+        // (network blip, missing scope, deleted channel).
+        const channelLabel = msg.channelName || msg.channel;
         return {
             'slack.user': msg.userName,
+            // fromName/fromId are the boss-canonical names mirroring the Slack
+            // template the trigger renderer uses. Aliases for slack.user/userId so
+            // user-authored templates can pick whichever reads better.
+            'slack.fromName': msg.userName,
             'slack.userId': msg.userId,
+            'slack.fromId': msg.userId,
             'slack.message': msg.text,
+            'slack.body': msg.text,
             'slack.channel': msg.channel,
+            'slack.channelId': msg.channel,
+            'slack.channelName': channelLabel,
             'slack.threadTs': msg.threadTs || msg.ts,
             'slack.fileCount': String(files.length),
+            'slack.attachmentsCount': String(files.length),
             'slack.fileIds': files.map((f) => f.id).join(','),
             'slack.fileNames': files.map((f) => f.name ?? '').filter(Boolean).join(','),
+            'slack.attachmentsList': files.map((f) => f.name ?? '').filter(Boolean).join(','),
             'slack.instanceId': msg.instanceId,
+            'slack.instanceName': msg.instanceId,
         };
     },
     formatEventForLLM(event) {
@@ -109,7 +124,8 @@ export const slackTriggerHandler = {
             ? `\nAttachments (${files.length}): ${files.map((f) => `${f.name ?? f.id} [${f.mimetype ?? 'unknown'}]`).join(', ')}`
             : '';
         const instanceLine = msg.instanceId !== 'default' ? ` [Slack instance: ${msg.instanceId}]` : '';
-        return `Slack message from @${msg.userName} (${msg.userId}) in #${msg.channel}${instanceLine}:\n"${msg.text}"${filesLine}`;
+        const channelDisplay = msg.channelName || msg.channel;
+        return `Slack message from @${msg.userName} (${msg.userId}) in ${channelDisplay} (${msg.channel})${instanceLine}:\n"${msg.text}"${filesLine}`;
     },
 };
 // `slackClient` import kept (re-exports SlackMessage type used above).

package/dist/src/packages/server/integrations/whatsapp/group-name-cache.js

@@ -0,0 +1,91 @@
+/**
+ * GroupNameCache — resolves a Baileys group JID (`*@g.us`) to its current
+ * subject via the upstream `GET /api/sessions/:id/groups` endpoint.
+ *
+ * Why this exists: per-message webhook payloads from the upstream WA service
+ * do not carry the group subject (verified against trigger_events for the
+ * Bolba group: `groupName` was always NULL). The upstream DOES expose the
+ * subject through the groups list endpoint — one call warms many JIDs at
+ * once. Without this cache, the bridge would always fall back to
+ * `humanizeGroupJid()` and bubbles would render `Grupo <last4>` instead of
+ * the real subject.
+ *
+ * Mirrors ContactNameCache deliberately — same TTL semantics, same fetch
+ * coalescing, same negative caching, same prime() escape hatch.
+ */
+export class GroupNameCache {
+    entries = new Map();
+    ttlMs;
+    now;
+    fetchGroups;
+    inflight = new Map();
+    constructor(opts) {
+        this.ttlMs = opts.ttlMs ?? 10 * 60_000;
+        this.now = opts.now ?? Date.now;
+        this.fetchGroups = opts.fetchGroups;
+    }
+    async lookup(sessionId, jid) {
+        if (!sessionId || !jid)
+            return null;
+        const key = this.cacheKey(sessionId, jid);
+        const cached = this.entries.get(key);
+        if (cached && this.now() - cached.ts < this.ttlMs) {
+            return cached.name;
+        }
+        await this.refreshSession(sessionId);
+        const after = this.entries.get(key);
+        if (after)
+            return after.name;
+        // Negative-cache so we don't refetch on every message from this group.
+        this.entries.set(key, { name: null, ts: this.now() });
+        return null;
+    }
+    peek(sessionId, jid) {
+        return this.entries.get(this.cacheKey(sessionId, jid));
+    }
+    size() {
+        return this.entries.size;
+    }
+    clear() {
+        this.entries.clear();
+        this.inflight.clear();
+    }
+    prime(sessionId, groups) {
+        const t = this.now();
+        for (const g of groups) {
+            if (!g?.id)
+                continue;
+            const key = this.cacheKey(sessionId, g.id);
+            const name = typeof g.name === 'string' && g.name ? g.name : null;
+            this.entries.set(key, { name, ts: t });
+        }
+    }
+    cacheKey(sessionId, jid) {
+        return `${sessionId}:${jid}`;
+    }
+    async refreshSession(sessionId) {
+        const pending = this.inflight.get(sessionId);
+        if (pending) {
+            await pending;
+            return;
+        }
+        const promise = (async () => {
+            try {
+                const groups = await this.fetchGroups(sessionId);
+                if (Array.isArray(groups))
+                    this.prime(sessionId, groups);
+            }
+            catch {
+                // Swallow — caller falls back to humanizeGroupJid. Don't cache an empty
+                // result on error; let the next call retry.
+            }
+        })();
+        this.inflight.set(sessionId, promise);
+        try {
+            await promise;
+        }
+        finally {
+            this.inflight.delete(sessionId);
+        }
+    }
+}