@tiflis-io/tiflis-code-workstation 0.3.8 → 0.3.10

package/dist/main.js

@@ -94,7 +94,7 @@ var EnvSchema = z.object({
   // ─────────────────────────────────────────────────────────────
   // Speech-to-Text (STT) Configuration
   // ─────────────────────────────────────────────────────────────
-  STT_PROVIDER: z.enum(["openai", "elevenlabs", "deepgram"]).default("openai"),
+  STT_PROVIDER: z.enum(["openai", "elevenlabs", "deepgram", "local"]).default("openai"),
   STT_API_KEY: z.string().optional(),
   STT_MODEL: z.string().default("whisper-1"),
   STT_BASE_URL: z.string().url().optional(),
@@ -102,7 +102,7 @@ var EnvSchema = z.object({
   // ─────────────────────────────────────────────────────────────
   // Text-to-Speech (TTS) Configuration
   // ─────────────────────────────────────────────────────────────
-  TTS_PROVIDER: z.enum(["openai", "elevenlabs"]).default("openai"),
+  TTS_PROVIDER: z.enum(["openai", "elevenlabs", "local"]).default("openai"),
   TTS_API_KEY: z.string().optional(),
   TTS_MODEL: z.string().default("tts-1"),
   TTS_VOICE: z.string().default("alloy"),
@@ -247,18 +247,18 @@ function getProtocolVersion() {
   return `${PROTOCOL_VERSION.major}.${PROTOCOL_VERSION.minor}.${PROTOCOL_VERSION.patch}`;
 }
 var CONNECTION_TIMING = {
-  /** How often to send ping to tunnel (15 seconds - keeps connection alive through proxies) */
-  PING_INTERVAL_MS: 15e3,
-  /** Max time to wait for pong before considering connection stale (30 seconds) */
-  PONG_TIMEOUT_MS: 3e4,
-  /** Max time to wait for registration response (15 seconds) */
-  REGISTRATION_TIMEOUT_MS: 15e3,
-  /** Minimum reconnect delay (1 second) */
-  RECONNECT_DELAY_MIN_MS: 1e3,
-  /** Maximum reconnect delay (30 seconds) */
-  RECONNECT_DELAY_MAX_MS: 3e4,
-  /** Interval for checking timed-out client connections (10 seconds) */
-  CLIENT_TIMEOUT_CHECK_INTERVAL_MS: 1e4
+  /** How often to send ping to tunnel (5 seconds - fast liveness detection) */
+  PING_INTERVAL_MS: 5e3,
+  /** Max time to wait for pong before considering connection stale (10 seconds) */
+  PONG_TIMEOUT_MS: 1e4,
+  /** Max time to wait for registration response (10 seconds) */
+  REGISTRATION_TIMEOUT_MS: 1e4,
+  /** Minimum reconnect delay (500ms - fast first retry) */
+  RECONNECT_DELAY_MIN_MS: 500,
+  /** Maximum reconnect delay (5 seconds - don't wait too long) */
+  RECONNECT_DELAY_MAX_MS: 5e3,
+  /** Interval for checking timed-out client connections (5 seconds - faster cleanup) */
+  CLIENT_TIMEOUT_CHECK_INTERVAL_MS: 5e3
 };
 var SESSION_CONFIG = {
   /** Maximum number of concurrent agent sessions */
@@ -1895,13 +1895,37 @@ import { join as join4 } from "path";
 import { execSync } from "child_process";
 var FileSystemWorkspaceDiscovery = class {
   workspacesRoot;
+  cacheTtlMs;
+  /** Cache for workspace list */
+  workspacesCache = null;
+  /** Cache for projects by workspace name */
+  projectsCache = /* @__PURE__ */ new Map();
   constructor(config2) {
     this.workspacesRoot = config2.workspacesRoot;
+    this.cacheTtlMs = config2.cacheTtlMs ?? 3e4;
+  }
+  /**
+   * Checks if a cache entry is still valid.
+   */
+  isCacheValid(entry) {
+    if (!entry) return false;
+    return Date.now() - entry.timestamp < this.cacheTtlMs;
+  }
+  /**
+   * Invalidates all caches. Call when workspace structure changes.
+   */
+  invalidateCache() {
+    this.workspacesCache = null;
+    this.projectsCache.clear();
   }
   /**
    * Lists all workspaces in the workspaces root.
+   * Results are cached for faster subsequent calls.
    */
   async listWorkspaces() {
+    if (this.isCacheValid(this.workspacesCache)) {
+      return this.workspacesCache.data;
+    }
     const entries = await readdir(this.workspacesRoot, { withFileTypes: true });
     const workspaces = [];
     for (const entry of entries) {
@@ -1915,12 +1939,22 @@ var FileSystemWorkspaceDiscovery = class {
         });
       }
     }
-    return workspaces.sort((a, b) => a.name.localeCompare(b.name));
+    const result = workspaces.sort((a, b) => a.name.localeCompare(b.name));
+    this.workspacesCache = {
+      data: result,
+      timestamp: Date.now()
+    };
+    return result;
   }
   /**
    * Lists all projects in a workspace.
+   * Results are cached for faster subsequent calls.
    */
   async listProjects(workspace) {
+    const cached = this.projectsCache.get(workspace);
+    if (this.isCacheValid(cached)) {
+      return cached.data;
+    }
     const workspacePath = join4(this.workspacesRoot, workspace);
     if (!await this.pathExists(workspacePath)) {
       return [];
@@ -1949,7 +1983,12 @@ var FileSystemWorkspaceDiscovery = class {
         });
       }
     }
-    return projects.sort((a, b) => a.name.localeCompare(b.name));
+    const result = projects.sort((a, b) => a.name.localeCompare(b.name));
+    this.projectsCache.set(workspace, {
+      data: result,
+      timestamp: Date.now()
+    });
+    return result;
   }
   /**
    * Gets information about a specific project.
@@ -3141,6 +3180,12 @@ var HeadlessAgentExecutor = class extends EventEmitter {
 
 // src/domain/value-objects/content-block.ts
 import { randomUUID } from "crypto";
+function isTextBlock(block) {
+  return block.block_type === "text";
+}
+function isToolBlock(block) {
+  return block.block_type === "tool";
+}
 function createTextBlock(content) {
   return {
     id: randomUUID(),
@@ -3219,6 +3264,103 @@ function createVoiceOutputBlock(text2, options) {
     }
   };
 }
+function mergeToolBlocks(blocks) {
+  const toolBlocksByUseId = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    if (isToolBlock(block) && block.metadata.tool_use_id) {
+      const toolUseId = block.metadata.tool_use_id;
+      const existing = toolBlocksByUseId.get(toolUseId);
+      if (existing) {
+        const mergedStatus = getMergedToolStatus(
+          existing.metadata.tool_status,
+          block.metadata.tool_status
+        );
+        const mergedBlock = {
+          id: existing.id,
+          // Keep original ID
+          block_type: "tool",
+          content: block.metadata.tool_name || existing.content,
+          metadata: {
+            tool_name: block.metadata.tool_name || existing.metadata.tool_name,
+            tool_use_id: toolUseId,
+            tool_input: block.metadata.tool_input || existing.metadata.tool_input,
+            tool_output: block.metadata.tool_output || existing.metadata.tool_output,
+            tool_status: mergedStatus
+          }
+        };
+        toolBlocksByUseId.set(toolUseId, mergedBlock);
+      } else {
+        toolBlocksByUseId.set(toolUseId, block);
+      }
+    }
+  }
+  const seenToolUseIds = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const block of blocks) {
+    if (isToolBlock(block) && block.metadata.tool_use_id) {
+      const toolUseId = block.metadata.tool_use_id;
+      if (!seenToolUseIds.has(toolUseId)) {
+        seenToolUseIds.add(toolUseId);
+        const mergedBlock = toolBlocksByUseId.get(toolUseId);
+        if (mergedBlock) {
+          result.push(mergedBlock);
+        }
+      }
+    } else {
+      result.push(block);
+    }
+  }
+  return result;
+}
+function getMergedToolStatus(status1, status2) {
+  if (status1 === "completed" || status2 === "completed") {
+    return "completed";
+  }
+  if (status1 === "failed" || status2 === "failed") {
+    return "failed";
+  }
+  return "running";
+}
+function accumulateBlocks(existing, newBlocks) {
+  for (const block of newBlocks) {
+    if (isToolBlock(block) && block.metadata.tool_use_id) {
+      const toolUseId = block.metadata.tool_use_id;
+      const existingIndex = existing.findIndex(
+        (b) => isToolBlock(b) && b.metadata.tool_use_id === toolUseId
+      );
+      if (existingIndex >= 0) {
+        const existingBlock = existing[existingIndex];
+        const mergedStatus = getMergedToolStatus(
+          existingBlock.metadata.tool_status,
+          block.metadata.tool_status
+        );
+        existing[existingIndex] = {
+          id: existingBlock.id,
+          block_type: "tool",
+          content: block.metadata.tool_name || existingBlock.content,
+          metadata: {
+            tool_name: block.metadata.tool_name || existingBlock.metadata.tool_name,
+            tool_use_id: toolUseId,
+            tool_input: block.metadata.tool_input || existingBlock.metadata.tool_input,
+            tool_output: block.metadata.tool_output || existingBlock.metadata.tool_output,
+            tool_status: mergedStatus
+          }
+        };
+      } else {
+        existing.push(block);
+      }
+    } else if (isTextBlock(block)) {
+      const lastBlock = existing[existing.length - 1];
+      if (lastBlock && isTextBlock(lastBlock)) {
+        existing[existing.length - 1] = block;
+      } else {
+        existing.push(block);
+      }
+    } else {
+      existing.push(block);
+    }
+  }
+}
 
 // src/infrastructure/agents/agent-output-parser.ts
 var AgentOutputParser = class _AgentOutputParser {
@@ -5598,7 +5740,7 @@ var ChatHistoryService = class _ChatHistoryService {
    * Gets supervisor chat history (global, shared across all devices).
    * Returns messages sorted by sequence (oldest first) for chronological display.
    */
-  getSupervisorHistory(limit = 50) {
+  getSupervisorHistory(limit = 20) {
     const sessionId = _ChatHistoryService.SUPERVISOR_SESSION_ID;
     const rows = this.messageRepo.getBySession(sessionId, limit);
     return rows.reverse().map((row) => {
@@ -5663,7 +5805,7 @@ var ChatHistoryService = class _ChatHistoryService {
    * Gets agent session chat history.
    * Returns messages sorted chronologically (oldest first).
    */
-  getAgentHistory(sessionId, limit = 100) {
+  getAgentHistory(sessionId, limit = 20) {
     const rows = this.messageRepo.getBySession(sessionId, limit);
     return rows.reverse().map((row) => {
       let contentBlocks;
@@ -5721,7 +5863,7 @@ var ChatHistoryService = class _ChatHistoryService {
    * @param sessionIds - List of active agent session IDs
    * @param limit - Max messages per session
    */
-  getAllAgentHistories(sessionIds, limit = 50) {
+  getAllAgentHistories(sessionIds, limit = 20) {
     const histories = /* @__PURE__ */ new Map();
     for (const sessionId of sessionIds) {
       const history = this.getAgentHistory(sessionId, limit);
@@ -7346,12 +7488,7 @@ var SupervisorAgent = class extends EventEmitter4 {
             if (this.isExecuting && !this.isCancelled) {
               const textBlock = createTextBlock(content);
               this.emit("blocks", deviceId, [textBlock], false);
-              const lastTextIndex = allBlocks.findLastIndex((b) => b.block_type === "text");
-              if (lastTextIndex >= 0) {
-                allBlocks[lastTextIndex] = textBlock;
-              } else {
-                allBlocks.push(textBlock);
-              }
+              accumulateBlocks(allBlocks, [textBlock]);
             }
           } else if (Array.isArray(content)) {
             for (const item of content) {
@@ -7359,7 +7496,7 @@ var SupervisorAgent = class extends EventEmitter4 {
                 const block = this.parseContentItem(item);
                 if (block) {
                   this.emit("blocks", deviceId, [block], false);
-                  allBlocks.push(block);
+                  accumulateBlocks(allBlocks, [block]);
                 }
               }
             }
@@ -7368,21 +7505,24 @@ var SupervisorAgent = class extends EventEmitter4 {
         if (lastMessage.getType() === "tool" && this.isExecuting && !this.isCancelled) {
           const toolContent = lastMessage.content;
           const toolName = lastMessage.name ?? "tool";
+          const toolCallId = lastMessage.tool_call_id;
           const toolBlock = createToolBlock(
             toolName,
             "completed",
             void 0,
-            typeof toolContent === "string" ? toolContent : JSON.stringify(toolContent)
+            typeof toolContent === "string" ? toolContent : JSON.stringify(toolContent),
+            toolCallId
           );
           this.emit("blocks", deviceId, [toolBlock], false);
-          allBlocks.push(toolBlock);
+          accumulateBlocks(allBlocks, [toolBlock]);
         }
       }
       if (this.isExecuting && !this.isCancelled) {
         this.addToHistory("user", command);
         this.addToHistory("assistant", finalOutput);
+        const finalBlocks = mergeToolBlocks(allBlocks);
         const completionBlock = createStatusBlock("Complete");
-        this.emit("blocks", deviceId, [completionBlock], true, finalOutput, allBlocks);
+        this.emit("blocks", deviceId, [completionBlock], true, finalOutput, finalBlocks);
         this.logger.debug({ output: finalOutput.slice(0, 200) }, "Supervisor streaming completed");
       } else {
         this.logger.info({ deviceId, isCancelled: this.isCancelled, isExecuting: this.isExecuting }, "Supervisor streaming ended due to cancellation");
@@ -7412,7 +7552,8 @@ var SupervisorAgent = class extends EventEmitter4 {
     if (type === "tool_use") {
       const name = typeof item.name === "string" ? item.name : "tool";
       const input = item.input;
-      return createToolBlock(name, "running", input);
+      const toolUseId = typeof item.id === "string" ? item.id : void 0;
+      return createToolBlock(name, "running", input, void 0, toolUseId);
     }
     return null;
   }
@@ -7677,6 +7818,9 @@ Creating worktrees with \`create_worktree\`:
 - When creating sessions, confirm the workspace and project first
 - For ambiguous requests, ask clarifying questions
 - Format responses for terminal display (avoid markdown links)
+- NEVER use tables - they display poorly on mobile devices
+- ALWAYS use bullet lists or numbered lists instead of tables
+- Keep list items short and scannable for mobile reading
 - ALWAYS prioritize safety - check before deleting/merging`;
     return [new HumanMessage(`[System Instructions]
 ${systemPrompt}
@@ -8235,7 +8379,18 @@ var STTService = class {
     this.logger.debug({ audioSize: audioBuffer.length, format }, "Transcribing audio");
     const startTime = Date.now();
     try {
-      const result = this.config.provider === "openai" ? await this.transcribeOpenAI(audioBuffer, format, signal) : await this.transcribeElevenLabs(audioBuffer, format, signal);
+      let result;
+      switch (this.config.provider) {
+        case "openai":
+        case "local":
+          result = await this.transcribeOpenAI(audioBuffer, format, signal);
+          break;
+        case "elevenlabs":
+          result = await this.transcribeElevenLabs(audioBuffer, format, signal);
+          break;
+        default:
+          throw new Error(`Unsupported STT provider: ${this.config.provider}`);
+      }
       const elapsed = Date.now() - startTime;
       this.logger.info(
         {
@@ -8347,6 +8502,9 @@ var STTService = class {
    * Check if the service is configured and ready.
    */
   isConfigured() {
+    if (this.config.provider === "local") {
+      return Boolean(this.config.baseUrl && this.config.model);
+    }
     return Boolean(this.config.apiKey && this.config.model);
   }
   /**
@@ -8363,20 +8521,28 @@ var STTService = class {
 function createSTTService(env, logger) {
   const provider = (env.STT_PROVIDER ?? "openai").toLowerCase();
   const apiKey = env.STT_API_KEY;
-  if (!apiKey) {
+  const baseUrl = env.STT_BASE_URL;
+  if (provider === "local") {
+    if (!baseUrl) {
+      logger.warn("STT_BASE_URL not configured for local provider, STT service disabled");
+      return null;
+    }
+  } else if (!apiKey) {
     logger.warn("STT_API_KEY not configured, STT service disabled");
     return null;
   }
   const defaults = {
     openai: { model: "whisper-1" },
-    elevenlabs: { model: "scribe_v1" }
+    elevenlabs: { model: "scribe_v1" },
+    deepgram: { model: "nova-2" },
+    local: { model: "large-v3" }
   };
   const config2 = {
     provider,
-    apiKey,
+    apiKey: apiKey ?? "",
     model: env.STT_MODEL ?? defaults[provider].model,
     language: env.STT_LANGUAGE,
-    baseUrl: env.STT_BASE_URL
+    baseUrl
   };
   return new STTService(config2, logger);
 }
@@ -8396,7 +8562,18 @@ var TTSService = class {
     this.logger.debug({ textLength: text2.length }, "Synthesizing speech");
     const startTime = Date.now();
     try {
-      const result = this.config.provider === "openai" ? await this.synthesizeOpenAI(text2) : await this.synthesizeElevenLabs(text2);
+      let result;
+      switch (this.config.provider) {
+        case "openai":
+        case "local":
+          result = await this.synthesizeOpenAI(text2);
+          break;
+        case "elevenlabs":
+          result = await this.synthesizeElevenLabs(text2);
+          break;
+        default:
+          throw new Error(`Unsupported TTS provider: ${this.config.provider}`);
+      }
       const elapsed = Date.now() - startTime;
       this.logger.info(
         { textLength: text2.length, audioSize: result.audio.length, elapsedMs: elapsed },
@@ -8473,6 +8650,9 @@ var TTSService = class {
    * Check if the service is configured and ready.
    */
   isConfigured() {
+    if (this.config.provider === "local") {
+      return Boolean(this.config.baseUrl && this.config.voice);
+    }
     return Boolean(this.config.apiKey && this.config.model && this.config.voice);
   }
   /**
@@ -8489,20 +8669,27 @@ var TTSService = class {
 function createTTSService(env, logger) {
   const provider = (env.TTS_PROVIDER ?? "openai").toLowerCase();
   const apiKey = env.TTS_API_KEY;
-  if (!apiKey) {
+  const baseUrl = env.TTS_BASE_URL;
+  if (provider === "local") {
+    if (!baseUrl) {
+      logger.warn("TTS_BASE_URL not configured for local provider, TTS service disabled");
+      return null;
+    }
+  } else if (!apiKey) {
     logger.warn("TTS_API_KEY not configured, TTS service disabled");
     return null;
   }
   const defaults = {
     openai: { model: "tts-1", voice: "alloy" },
-    elevenlabs: { model: "eleven_flash_v2_5", voice: "21m00Tcm4TlvDq8ikWAM" }
+    elevenlabs: { model: "eleven_flash_v2_5", voice: "21m00Tcm4TlvDq8ikWAM" },
+    local: { model: "kokoro", voice: "af_heart" }
   };
   const config2 = {
     provider,
-    apiKey,
+    apiKey: apiKey ?? "",
     model: env.TTS_MODEL ?? defaults[provider].model,
     voice: env.TTS_VOICE ?? defaults[provider].voice,
-    baseUrl: env.TTS_BASE_URL
+    baseUrl
   };
   return new TTSService(config2, logger);
 }
@@ -8585,6 +8772,8 @@ var SummarizationService = class {
   buildSystemPrompt() {
     return `You are a concise summarizer for voice output. Summarize AI assistant responses into 1-${this.maxSentences} SHORT sentences.
 
+CRITICAL: ALWAYS OUTPUT IN ENGLISH. Translate any non-English content to English.
+
 STRICT RULES:
 - Maximum 20 words total (hard limit)
 - Prefer 1 sentence when possible, 2 only if essential
@@ -8592,6 +8781,7 @@ STRICT RULES:
 - Natural spoken language only
 - Never use markdown, bullets, or formatting
 - Never start with "I" - use passive voice or action verbs
+- ALWAYS translate to English regardless of input language
 
 ABSOLUTELY FORBIDDEN (never include these in output):
 - Session IDs or any alphanumeric identifiers (e.g., "session-abc123", "id: 7f3a2b", UUIDs)
@@ -8599,6 +8789,7 @@ ABSOLUTELY FORBIDDEN (never include these in output):
 - Any string that looks like a technical identifier, hash, or token
 - Code snippets, variable names, or technical jargon
 - Long lists or enumerations
+- Non-English output (always translate to English)
 
 If the original text contains session IDs or paths, OMIT them entirely. Just describe what happened.
 
@@ -8611,7 +8802,9 @@ GOOD examples:
 BAD examples (never do this):
 - "Created session abc-123-def in /Users/roman/work/project" \u274C
 - "Session ID is 7f3a2b1c" \u274C
-- "Working in /home/user/documents/code" \u274C`;
+- "Working in /home/user/documents/code" \u274C
+- "\u0421\u043E\u0437\u0434\u0430\u043D\u0430 \u043D\u043E\u0432\u0430\u044F \u0441\u0435\u0441\u0441\u0438\u044F Claude." \u274C (non-English)
+- "Sesi\xF3n creada exitosamente." \u274C (non-English)`;
   }
   /**
    * Builds the user prompt with the text to summarize and optional context.
@@ -9113,22 +9306,29 @@ async function bootstrap() {
       ).map((s) => s.session_id);
       const agentHistoriesMap = chatHistoryService.getAllAgentHistories(agentSessionIds);
       const agentHistories = {};
-      for (const [sessionId, history] of agentHistoriesMap) {
-        agentHistories[sessionId] = await Promise.all(
-          history.map(async (msg) => ({
-            sequence: msg.sequence,
-            role: msg.role,
-            content: msg.content,
-            content_blocks: await chatHistoryService.enrichBlocksWithAudio(
-              msg.contentBlocks,
-              msg.audioOutputPath,
-              msg.audioInputPath,
-              false
-              // Don't include audio in sync.state
-            ),
-            createdAt: msg.createdAt.toISOString()
-          }))
-        );
+      const historyEntries = Array.from(agentHistoriesMap.entries());
+      const processedHistories = await Promise.all(
+        historyEntries.map(async ([sessionId, history]) => {
+          const enrichedHistory = await Promise.all(
+            history.map(async (msg) => ({
+              sequence: msg.sequence,
+              role: msg.role,
+              content: msg.content,
+              content_blocks: await chatHistoryService.enrichBlocksWithAudio(
+                msg.contentBlocks,
+                msg.audioOutputPath,
+                msg.audioInputPath,
+                false
+                // Don't include audio in sync.state
+              ),
+              createdAt: msg.createdAt.toISOString()
+            }))
+          );
+          return { sessionId, history: enrichedHistory };
+        })
+      );
+      for (const { sessionId, history } of processedHistories) {
+        agentHistories[sessionId] = history;
       }
       const availableAgentsMap = getAvailableAgents();
       const availableAgents = Array.from(availableAgentsMap.values()).map(
@@ -9262,6 +9462,21 @@ async function bootstrap() {
       }
       let commandText;
       const messageId = commandMessage.payload.message_id;
+      if (messageBroadcaster) {
+        const ackMessageId = messageId || commandMessage.id;
+        const ackMessage = {
+          type: "message.ack",
+          payload: {
+            message_id: ackMessageId,
+            status: "received"
+          }
+        };
+        messageBroadcaster.sendToClient(deviceId, JSON.stringify(ackMessage));
+        logger.debug(
+          { messageId: ackMessageId, deviceId },
+          "Sent message.ack for supervisor.command"
+        );
+      }
       supervisorAgent.resetCancellationState();
       let abortController;
       if (commandMessage.payload.audio) {
@@ -9734,6 +9949,22 @@ async function bootstrap() {
       const deviceId = execMessage.device_id;
       const sessionId = execMessage.session_id;
       const messageId = execMessage.payload.message_id;
+      if (deviceId && messageBroadcaster) {
+        const ackMessageId = messageId || execMessage.id;
+        const ackMessage = {
+          type: "message.ack",
+          payload: {
+            message_id: ackMessageId,
+            session_id: sessionId,
+            status: "received"
+          }
+        };
+        messageBroadcaster.sendToClient(deviceId, JSON.stringify(ackMessage));
+        logger.debug(
+          { messageId: ackMessageId, sessionId, deviceId },
+          "Sent message.ack for session.execute"
+        );
+      }
       cancelledDuringTranscription.delete(sessionId);
       if (execMessage.payload.audio) {
         logger.info(
@@ -10496,7 +10727,7 @@ async function bootstrap() {
       if (persistableBlocks.length > 0) {
         const accumulated = agentMessageAccumulator.get(sessionId) ?? [];
         const wasEmpty = accumulated.length === 0;
-        accumulated.push(...persistableBlocks);
+        accumulateBlocks(accumulated, persistableBlocks);
         agentMessageAccumulator.set(sessionId, accumulated);
         if (wasEmpty) {
           logger.debug(
@@ -10551,7 +10782,8 @@ async function bootstrap() {
         }
       }
       const accumulatedBlocks = agentMessageAccumulator.get(sessionId) ?? [];
-      const fullAccumulatedText = accumulatedBlocks.filter((b) => b.block_type === "text").map((b) => b.content).join("\n");
+      const mergedBlocks = mergeToolBlocks(accumulatedBlocks);
+      const fullAccumulatedText = mergedBlocks.filter((b) => b.block_type === "text").map((b) => b.content).join("\n");
       const outputEvent = {
         type: "session.output",
         session_id: sessionId,
@@ -10559,8 +10791,8 @@ async function bootstrap() {
           content_type: "agent",
           content: fullAccumulatedText,
           // Full accumulated text for backward compat
-          content_blocks: accumulatedBlocks,
-          // Full accumulated blocks for rich UI
+          content_blocks: mergedBlocks,
+          // Full accumulated blocks for rich UI (merged)
           timestamp: Date.now(),
           is_complete: isComplete
         }
@@ -10644,10 +10876,11 @@ async function bootstrap() {
       }
     }
   );
+  let supervisorBlockAccumulator = [];
   supervisorAgent.on(
     "blocks",
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    async (deviceId, blocks, isComplete, finalOutput, allBlocks) => {
+    async (deviceId, blocks, isComplete, finalOutput, _allBlocks) => {
       const wasCancelled = supervisorAgent.wasCancelled();
       logger.debug(
         { deviceId, blockCount: blocks.length, isComplete, wasCancelled },
@@ -10658,26 +10891,35 @@ async function bootstrap() {
           { deviceId, blockCount: blocks.length, isComplete },
           "Ignoring supervisor blocks - execution was cancelled"
         );
+        supervisorBlockAccumulator = [];
         return;
       }
-      const textContent = blocks.filter((b) => b.block_type === "text").map((b) => b.content).join("\n");
+      const persistableBlocks = blocks.filter((b) => b.block_type !== "status");
+      if (persistableBlocks.length > 0) {
+        accumulateBlocks(supervisorBlockAccumulator, persistableBlocks);
+      }
+      const mergedBlocks = mergeToolBlocks(supervisorBlockAccumulator);
+      const textContent = mergedBlocks.filter((b) => b.block_type === "text").map((b) => b.content).join("\n");
       const outputEvent = {
         type: "supervisor.output",
         payload: {
           content_type: "supervisor",
           content: textContent,
-          content_blocks: blocks,
+          content_blocks: mergedBlocks,
           timestamp: Date.now(),
           is_complete: isComplete
         }
       };
       const message = JSON.stringify(outputEvent);
       broadcaster.broadcastToAll(message);
+      if (isComplete) {
+        supervisorBlockAccumulator = [];
+      }
       if (isComplete && finalOutput && finalOutput.length > 0) {
         chatHistoryService.saveSupervisorMessage(
           "assistant",
           finalOutput,
-          allBlocks
+          mergedBlocks
         );
         const pendingVoiceCommand = pendingSupervisorVoiceCommands.get(deviceId);
         if (pendingVoiceCommand && ttsService) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiflis-io/tiflis-code-workstation",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "description": "Workstation server for tiflis-code - manages agent sessions and terminal access",
   "author": "Roman Barinov <rbarinov@gmail.com>",
   "license": "FSL-1.1-NC",