alaska-ai 0.1.30 → 0.1.32

package/dist/adapters/slack.d.ts

@@ -96,6 +96,9 @@ export declare class SlackAdapter {
     private trackPermissionAck;
     /** Remove :eyes: from all tracked permission ack messages for a thread. */
     private cleanupPermissionAcks;
+    private stripAssistantTexts;
+    private logSuppressedError;
+    private logSuppressedCommandFailure;
     private detectGmailToolDrift;
     private withGmailRecoveryHint;
     private hasGmailMutationClaim;

package/dist/adapters/slack.js

@@ -11,7 +11,7 @@ import { spawnSync } from 'node:child_process';
 import { App } from '@slack/bolt';
 import { splitText, downloadAndStageFile, markdownToSlackMrkdwn } from '../utils.js';
 import { resolvePermission, resolveUserQuestion, hasPendingQuestion, resolveQuestionByThread } from '../mcp/ipc-server.js';
-import { clearPostMessageFlag, wasPostMessageCalled, clearScheduleFlag, wasScheduleCreated, clearGmailActionFlag, wasGmailActionCalled, getGmailActions, getGmailActionReceipts, } from '../mcp/callbacks.js';
+import { clearPostMessageFlag, getPostMessageTexts, wasPostMessageCalled, clearScheduleFlag, wasScheduleCreated, clearGmailActionFlag, wasGmailActionCalled, getGmailActions, getGmailActionReceipts, } from '../mcp/callbacks.js';
 import { requireSandboxRoot, resolveWithinSandbox, validateSandboxRoot } from '../sandbox-policy.js';
 import { defaultAsyncErrorSink, withAsyncErrorPropagation, } from '../async-callback.js';
 import { buildThreadDeployUrl, isValidThreadId, normalizeThreadId, THREAD_DEPLOY_BASE_URL, THREAD_WEB_MODE_MARKER, } from '../lib/thread-id.js';
@@ -781,6 +781,18 @@ export class SlackAdapter {
             await this.removeReactSeen(ack.channel, ack.ts, client);
         }
     }
+    stripAssistantTexts(events, predicate) {
+        return events.filter((event) => event.type !== 'assistant_text' || !predicate(event.text));
+    }
+    logSuppressedError(threadTs, message) {
+        console.warn(`[slack] internal error for thread ${threadTs}: ${message}`);
+    }
+    logSuppressedCommandFailure(threadTs, event) {
+        const command = event.command.trim() || '(unknown command)';
+        const output = event.output.trim() || '(no output captured)';
+        const clipped = output.length > 1200 ? `${output.slice(0, 1200)}\n... (truncated)` : output;
+        console.warn(`[slack] internal command failure for thread ${threadTs}: exit=${event.exitCode} command=${command}\n${clipped}`);
+    }
     detectGmailToolDrift(events) {
         for (const event of events) {
             const raw = event.type === 'assistant_text'
@@ -808,7 +820,12 @@ export class SlackAdapter {
             ...result,
             events: [
                 ...result.events,
-                { type: 'error', message: GMAIL_RECOVERY_HINT },
+                {
+                    type: 'error',
+                    message: GMAIL_RECOVERY_HINT,
+                    visibility: 'blocking',
+                    userMessage: GMAIL_RECOVERY_HINT,
+                },
             ],
         };
     }
@@ -839,14 +856,27 @@ export class SlackAdapter {
         }
         const actions = getGmailActions(threadTs);
         const actionLabel = actions.length > 0 ? actions.join(', ') : '(none)';
+        const sanitizedEvents = this.stripAssistantTexts(result.events, (text) => {
+            const normalized = text.replace(/\s+/g, ' ').trim();
+            if (!normalized)
+                return false;
+            if (!GMAIL_MUTATION_CLAIM_RE.test(normalized))
+                return false;
+            return !GMAIL_NEGATION_RE.test(normalized);
+        });
         return {
             ...result,
             events: [
-                ...result.events,
+                ...sanitizedEvents,
+                {
+                    type: 'assistant_text',
+                    text: 'No mailbox changes were applied in this turn because no gmail_* tool executed.',
+                },
                 {
                     type: 'error',
                     message: 'No gmail_* tool was executed in this turn, so no mailbox changes were applied. ' +
                         `Observed actions: ${actionLabel}. Ask me to run gmail_prepare_delete/gmail_confirm_action or gmail_prepare_delete_query/gmail_confirm_action explicitly.`,
+                    visibility: 'debug',
                 },
             ],
         };
@@ -870,7 +900,7 @@ export class SlackAdapter {
             ...result,
             events: [
                 ...result.events,
-                { type: 'error', message },
+                { type: 'assistant_text', text: message },
             ],
         };
     }
@@ -904,16 +934,29 @@ export class SlackAdapter {
             return result;
         if (!this.hasThreadWebCompletionClaim(result.events))
             return result;
+        const withoutCompletionClaims = this.stripAssistantTexts(result.events, (text) => {
+            const normalized = text.replace(/\s+/g, ' ').trim();
+            if (!normalized)
+                return false;
+            if (THREAD_WEB_COMPLETION_CLAIM_RE.test(normalized))
+                return true;
+            return normalized.includes(THREAD_DEPLOY_BASE_URL);
+        });
         const deployUrl = buildThreadDeployUrl(threadTs);
         if (!deployUrl) {
             return {
                 ...result,
                 events: [
-                    ...result.events,
+                    ...withoutCompletionClaims,
+                    {
+                        type: 'assistant_text',
+                        text: 'Thread web publish could not be verified as complete.',
+                    },
                     {
                         type: 'error',
                         message: 'Thread deploy validation failed: invalid thread ID format. ' +
                             'Use Slack thread_ts normalized by "." -> "-", and verify through lib/thread-id.ts.',
+                        visibility: 'debug',
                     },
                 ],
             };
@@ -931,12 +974,17 @@ export class SlackAdapter {
         return {
             ...result,
             events: [
-                ...result.events,
+                ...withoutCompletionClaims,
+                {
+                    type: 'assistant_text',
+                    text: 'Thread web publish is not complete yet.',
+                },
                 {
                     type: 'error',
                     message: 'Thread web publish is not complete: missing ' +
                         `${missing.join(' and ')}. ` +
                         'Finish the publish flow before declaring deployment complete.',
+                    visibility: 'debug',
                 },
             ],
         };
@@ -1489,19 +1537,30 @@ export class SlackAdapter {
             }
             return true;
         });
-        // If Claude used post_message during this turn, suppress assistant_text
-        // (Claude already communicated directly). Otherwise, render only the last
-        // assistant_text block as a fallback summary.
+        // If post_message was used during this turn, suppress only duplicate
+        // assistant_text content. This preserves explicit progress updates while
+        // still delivering a distinct final answer.
         const postMessageUsed = wasPostMessageCalled(threadTs);
+        const postMessageTexts = postMessageUsed
+            ? new Set(getPostMessageTexts(threadTs)
+                .map((text) => text.trim())
+                .filter(Boolean))
+            : new Set();
         const assistantTexts = deduped.filter(e => e.type === 'assistant_text');
         const lastAssistantText = assistantTexts.length > 0
             ? assistantTexts[assistantTexts.length - 1]
             : null;
+        let renderedUserMessage = false;
+        let sawSuppressedCommandFailure = false;
+        let sawSuppressedDiagnostic = false;
+        const summaryMessages = new Set();
         for (const event of deduped) {
             switch (event.type) {
                 case 'assistant_text':
-                    if (!postMessageUsed && event === lastAssistantText) {
+                    if (event === lastAssistantText &&
+                        (!postMessageUsed || !postMessageTexts.has(event.text.trim()))) {
                         await this.postText(channelId, threadTs, event.text, client);
+                        renderedUserMessage = true;
                     }
                     break;
                 case 'permission_denied':
@@ -1514,13 +1573,26 @@ export class SlackAdapter {
                     else {
                         await this.postPermissionPrompt(channelId, threadTs, event, client);
                     }
+                    renderedUserMessage = true;
                     break;
                 case 'error':
-                    await this.postError(channelId, threadTs, event.message, client);
+                    this.logSuppressedError(threadTs, event.message);
+                    if (event.visibility === 'blocking') {
+                        await this.postError(channelId, threadTs, event.userMessage ?? event.message, client);
+                        renderedUserMessage = true;
+                    }
+                    else if (event.visibility === 'summary') {
+                        summaryMessages.add(event.userMessage ?? 'The task did not complete. Details were recorded in the debug logs.');
+                        sawSuppressedDiagnostic = true;
+                    }
+                    else {
+                        sawSuppressedDiagnostic = true;
+                    }
                     break;
                 case 'command_execution':
                     if (event.exitCode !== 0) {
-                        await this.postCommandFailure(channelId, threadTs, event, client);
+                        this.logSuppressedCommandFailure(threadTs, event);
+                        sawSuppressedCommandFailure = true;
                     }
                     break;
                 // Other event types (tool_use, tool_result, etc.)
@@ -1529,6 +1601,20 @@ export class SlackAdapter {
                     break;
             }
         }
+        if (renderedUserMessage) {
+            return;
+        }
+        if (summaryMessages.size > 0) {
+            const summaries = [...summaryMessages];
+            const message = summaries.length === 1
+                ? summaries[0]
+                : summaries.map((item) => `- ${item}`).join('\n');
+            await this.postText(channelId, threadTs, message, client);
+            return;
+        }
+        if (sawSuppressedCommandFailure || sawSuppressedDiagnostic) {
+            await this.postText(channelId, threadTs, 'The task hit internal errors and did not produce a user-facing resolution. Details were recorded in the debug logs.', client);
+        }
     }
     /** Post text response, splitting if it exceeds Slack's limit. */
     async postText(channelId, threadTs, text, client) {