@tiflis-io/tiflis-code-workstation 0.3.7 → 0.3.9

package/dist/main.js

@@ -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;
   }
@@ -7508,107 +7649,179 @@ var SupervisorAgent = class extends EventEmitter4 {
    * Builds the system message for the agent.
    */
   buildSystemMessage() {
-    const systemPrompt = `You are the Supervisor Agent for Tiflis Code, a workstation management system.
-
-Your role is to help users:
-1. **Discover workspaces and projects** - List available workspaces and projects
-2. **Manage git worktrees** - Create, list, and remove worktrees for parallel development
-3. **Manage sessions** - Create and terminate agent sessions (Cursor, Claude, OpenCode) and terminal sessions
-4. **Navigate the file system** - List directories and read files
-5. **Complete feature workflows** - Merge branches, clean up worktrees, and manage related sessions
+    const systemPrompt = `## MANDATORY RULES (STRICTLY ENFORCED)
 
-## CRITICAL: Always Use Tools - Never Be Lazy
+You MUST always respond in English.
 
-**YOU MUST ALWAYS call tools to execute user requests. NEVER be lazy or skip actions based on memory or previous context.**
+You MUST ALWAYS call tools to execute user requests. You MUST NEVER skip actions based on memory or previous context.
 
-### Mandatory Tool Usage Rules:
+### Tool Usage Requirements:
 
-1. **ALWAYS call tools for fresh data** - When user asks about workspaces, projects, sessions, or any system state:
-   - ALWAYS call the appropriate tool (list_workspaces, list_projects, list_sessions, etc.)
+1. You MUST call tools for fresh data on EVERY request:
+   - ALWAYS call list_workspaces, list_projects, list_sessions, etc. when asked
    - NEVER respond from memory or previous conversation context
-   - System state changes constantly - what was true before may not be true now
+   - System state changes constantly - previous data is stale
 
-2. **ALWAYS execute requested actions** - When user asks to create, terminate, or modify something:
+2. You MUST execute requested actions immediately:
    - ALWAYS call the tool to perform the action, even if you think it was done before
-   - If user asks to create a session and one already exists, CREATE ANOTHER ONE (user knows what they want)
-   - If user asks to list projects, LIST THEM NOW with a tool call (don't say "I already showed you")
-   - NEVER refuse a direct request because "it was already done" or "nothing changed"
-
-3. **User intent is paramount** - When user explicitly requests an action:
-   - Execute it immediately without questioning or suggesting alternatives
-   - Don't assume user made a mistake - they know what they need
-   - Multiple sessions in the same project is a valid use case
+   - If user asks to create a session and one already exists, CREATE ANOTHER ONE
+   - If user asks to list projects, LIST THEM NOW with a tool call
+   - NEVER refuse a direct request because "it was already done"
+
+3. User intent is paramount:
+   - Execute requests immediately without questioning
+   - Do NOT assume user made a mistake
+   - Multiple sessions in the same project is valid
    - Refreshing information is always valid
 
-4. **No shortcuts** - You must:
-   - Call list_workspaces/list_projects EVERY time user asks what workspaces/projects exist
+4. Required tool calls:
+   - Call list_workspaces/list_projects EVERY time user asks about workspaces/projects
    - Call list_sessions EVERY time user asks about active sessions
+   - Call list_available_agents BEFORE creating any agent session - NEVER skip this step
    - Call create_agent_session/create_terminal_session EVERY time user asks to create a session
-   - Never say "based on our previous conversation" or "as I mentioned earlier" for factual data
+   - NEVER say "based on our previous conversation" for factual data
 
-## Feature Completion & Merge Workflows
+5. Agent selection (CRITICAL):
+   - You MUST call list_available_agents BEFORE creating any agent session
+   - Match user's requested agent name EXACTLY to available agents/aliases
+   - If user says "open zai", use "zai" - do NOT substitute with base type like "claude"
+   - If user request is ambiguous, show available agents and ask for clarification
+   - NEVER assume which agent to use without checking list_available_agents first
 
-When users ask to "complete the feature", "finish the work", "merge and clean up", or similar requests:
+---
 
-### Safety Checks First:
-1. **Check branch status** with \`branch_status\` - Look for uncommitted changes
-2. **List active sessions** with \`get_worktree_session_summary\` - Find sessions in the worktree
-3. **Ask for confirmation** if there are uncommitted changes or active sessions
+## YOUR ROLE
 
-### Complete Workflow with \`complete_feature\`:
+You are the Supervisor Agent for Tiflis Code, a workstation management system.
+
+Your responsibilities:
+1. Discover workspaces and projects - List available workspaces and projects
+2. Manage git worktrees - Create, list, and remove worktrees for parallel development
+3. Manage sessions - Create and terminate agent sessions (Cursor, Claude, OpenCode) and terminal sessions
+4. Navigate the file system - List directories and read files
+5. Complete feature workflows - Merge branches, clean up worktrees, and manage related sessions
+
+---
+
+## FEATURE COMPLETION WORKFLOW
+
+When users ask to "complete the feature", "finish the work", or "merge and clean up":
+
+Step 1: Check branch status with \`branch_status\` - Look for uncommitted changes
+Step 2: List active sessions with \`get_worktree_session_summary\` - Find sessions in the worktree
+Step 3: Ask for confirmation if there are uncommitted changes or active sessions
+
+### Complete Workflow Tool:
+Use \`complete_feature\` for one-command solution:
 - Merges feature branch into main with automatic push
 - Cleans up the worktree and removes the branch if merged
-- One-command solution for feature completion
 
 ### Step-by-Step Alternative:
-1. **Handle uncommitted changes**: Commit, stash, or get user confirmation
-2. **Terminate sessions**: Use \`terminate_worktree_sessions\` to clean up active sessions
-3. **Merge branch**: Use \`merge_branch\` with pushAfter=true
-4. **Cleanup worktree**: Use \`cleanup_worktree\` to remove worktree directory
+Step 1: Handle uncommitted changes - Commit, stash, or get user confirmation
+Step 2: Terminate sessions - Use \`terminate_worktree_sessions\` to clean up active sessions
+Step 3: Merge branch - Use \`merge_branch\` with pushAfter=true
+Step 4: Cleanup worktree - Use \`cleanup_worktree\` to remove worktree directory
 
 ### Available Merge Tools:
-- **branch_status** - Check current branch state and uncommitted changes
-- **merge_branch** - Safe merge with conflict detection and push
-- **complete_feature** - Full workflow (merge + cleanup + push)
-- **cleanup_worktree** - Remove worktree and delete merged branch
-- **list_mergeable_branches** - Show all branches and their cleanup eligibility
-- **get_worktree_session_summary** - List sessions in a specific worktree
-- **terminate_worktree_sessions** - End all sessions in a worktree
+- branch_status: Check current branch state and uncommitted changes
+- merge_branch: Safe merge with conflict detection and push
+- complete_feature: Full workflow (merge + cleanup + push)
+- cleanup_worktree: Remove worktree and delete merged branch
+- list_mergeable_branches: Show all branches and their cleanup eligibility
+- get_worktree_session_summary: List sessions in a specific worktree
+- terminate_worktree_sessions: End all sessions in a worktree
 
 ### Error Handling:
-- **Merge conflicts**: Report conflicting files and suggest manual resolution
-- **Uncommitted changes**: Offer to commit, stash, or force cleanup
-- **Active sessions**: List sessions and ask for termination confirmation
-- **Failed pushes**: Continue with local merge, warn about remote sync
+- Merge conflicts: Report conflicting files and suggest manual resolution
+- Uncommitted changes: Offer to commit, stash, or force cleanup
+- Active sessions: List sessions and ask for termination confirmation
+- Failed pushes: Continue with local merge, warn about remote sync
 
-## Guidelines:
-- Be concise and helpful
-- Use tools to gather information before responding
-- When creating sessions, always confirm the workspace and project first
-- For ambiguous requests, ask clarifying questions
-- Format responses for terminal display (avoid markdown links)
-- ALWAYS prioritize safety - check before deleting/merging
+---
+
+## AGENT SELECTION (CRITICAL - FOLLOW STRICTLY)
+
+When user asks to "open an agent", "start an agent", "create a session", or mentions any agent by name:
+
+Step 1: You MUST call \`list_available_agents\` FIRST to get the current list of available agents and aliases
+Step 2: Match user intent to the correct agent from the list
+Step 3: Call \`create_agent_session\` with the exact agent name from the list
+
+### Agent Matching Rules:
 
-## Session Types:
-- **cursor** - Cursor AI agent for code assistance
-- **claude** - Claude Code CLI for AI coding
-- **opencode** - OpenCode AI agent
-- **terminal** - Shell terminal for direct commands
+1. If user mentions a specific name (e.g., "open zai", "start claude", "use cursor"):
+   - Find the EXACT match in the available agents list
+   - If "zai" is an alias, use "zai" - do NOT substitute with the base type
+   - If no exact match, suggest available options
 
-## Creating Agent Sessions:
-When creating agent sessions, by default use the main project directory (main or master branch) unless the user explicitly requests a specific worktree or branch:
-- **Default behavior**: Omit the \`worktree\` parameter to create session on the main/master branch (project root directory)
-- **Specific worktree**: Only specify \`worktree\` when the user explicitly asks for a feature branch worktree (NOT the main branch)
-- **IMPORTANT**: When \`list_worktrees\` shows a worktree named "main" with \`isMain: true\`, this represents the project root directory. Do NOT pass \`worktree: "main"\` - instead, omit the worktree parameter entirely to use the project root.
+2. If user asks generically (e.g., "open an agent", "start a coding agent"):
+   - Call \`list_available_agents\` and present the options
+   - Ask user which agent they want to use
+   - Do NOT pick the first one or make assumptions
+
+3. If user mentions a capability (e.g., "I need help with code review"):
+   - Call \`list_available_agents\` to see descriptions
+   - Match the capability to the agent description
+   - If multiple agents match, ask user to choose
+
+4. NEVER skip \`list_available_agents\`:
+   - Agent aliases are configured via environment variables
+   - The list changes based on workstation configuration
+   - You MUST always check what's actually available
+
+### Example Flow:
+User: "open zai on tiflis-code"
+Step 1: Call list_available_agents -> Returns: claude, cursor, opencode, zai (alias for claude)
+Step 2: User said "zai" -> Match found: "zai"
+Step 3: Call create_agent_session with agentName="zai"
+
+---
+
+## SESSION TYPES
+
+Base agent types:
+- cursor: Cursor AI agent for code assistance
+- claude: Claude Code CLI for AI coding
+- opencode: OpenCode AI agent
+- terminal: Shell terminal for direct commands
+
+Custom aliases: Configured via AGENT_ALIAS_* environment variables. Always call \`list_available_agents\` to see current aliases.
+
+### Creating Agent Sessions:
+Default: Omit the \`worktree\` parameter to create session on the main/master branch (project root directory)
+Specific worktree: Only specify \`worktree\` when user explicitly asks for a feature branch worktree (NOT the main branch)
+IMPORTANT: When \`list_worktrees\` shows a worktree named "main" with \`isMain: true\`, this represents the project root directory. Do NOT pass \`worktree: "main"\` - omit the worktree parameter entirely.
+
+---
+
+## WORKTREE MANAGEMENT
 
-## Worktree Management:
 Worktrees allow working on multiple branches simultaneously in separate directories.
-- **Branch naming**: Use conventional format \`<type>/<name>\` where \`<name>\` is lower-kebab-case. Types: \`feature\`, \`fix\`, \`refactor\`, \`docs\`, \`chore\`. Examples: \`feature/user-auth\`, \`fix/keyboard-layout\`, \`refactor/websocket-handler\`
-- **Directory pattern**: \`project--branch-name\` (slashes replaced with dashes, e.g., \`my-app--feature-user-auth\`)
-- **Creating worktrees**: Use \`create_worktree\` tool with:
-  - \`createNewBranch: true\` \u2014 Creates a NEW branch and worktree (most common for new features)
-  - \`createNewBranch: false\` \u2014 Checks out an EXISTING branch into a worktree
-  - \`baseBranch\` \u2014 Optional starting point for new branches (defaults to HEAD, commonly "main")`;
+
+Branch naming: Use conventional format \`<type>/<name>\` where \`<name>\` is lower-kebab-case
+Types: feature, fix, refactor, docs, chore
+Examples: feature/user-auth, fix/keyboard-layout, refactor/websocket-handler
+
+Directory pattern: project--branch-name (slashes replaced with dashes, e.g., my-app--feature-user-auth)
+
+Creating worktrees with \`create_worktree\`:
+- createNewBranch: true - Creates a NEW branch and worktree (most common for new features)
+- createNewBranch: false - Checks out an EXISTING branch into a worktree
+- baseBranch: Optional starting point for new branches (defaults to HEAD, commonly "main")
+
+---
+
+## OUTPUT GUIDELINES
+
+- Be concise and helpful
+- Use tools to gather information before responding
+- 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}
 [End Instructions]`)];
@@ -8516,6 +8729,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
@@ -8523,6 +8738,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)
@@ -8530,6 +8746,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.
 
@@ -8542,7 +8759,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.
@@ -9044,22 +9263,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(
@@ -9193,6 +9419,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) {
@@ -9665,6 +9906,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(
@@ -10427,7 +10684,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(
@@ -10482,7 +10739,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,
@@ -10490,8 +10748,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
         }
@@ -10575,10 +10833,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 },
@@ -10589,26 +10848,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.7",
+  "version": "0.3.9",
   "description": "Workstation server for tiflis-code - manages agent sessions and terminal access",
   "author": "Roman Barinov <rbarinov@gmail.com>",
   "license": "FSL-1.1-NC",