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

package/dist/main.js

@@ -118,11 +118,11 @@ var EnvSchema = z.object({
   // Hide base agent options in mobile apps (only show aliases)
   // ─────────────────────────────────────────────────────────────
   /** Hide base Cursor agent option (only show aliases) */
-  HIDE_BASE_CURSOR: z.string().transform((val) => val?.toLowerCase() === "true").default("false"),
+  HIDE_BASE_CURSOR: z.string().transform((val) => val.toLowerCase() === "true").default("false"),
   /** Hide base Claude agent option (only show aliases) */
-  HIDE_BASE_CLAUDE: z.string().transform((val) => val?.toLowerCase() === "true").default("false"),
+  HIDE_BASE_CLAUDE: z.string().transform((val) => val.toLowerCase() === "true").default("false"),
   /** Hide base OpenCode agent option (only show aliases) */
-  HIDE_BASE_OPENCODE: z.string().transform((val) => val?.toLowerCase() === "true").default("false"),
+  HIDE_BASE_OPENCODE: z.string().transform((val) => val.toLowerCase() === "true").default("false"),
   // ─────────────────────────────────────────────────────────────
   // Terminal Configuration
   // ─────────────────────────────────────────────────────────────
@@ -134,7 +134,7 @@ var EnvSchema = z.object({
   // Mock Mode Configuration (for screenshot automation)
   // ─────────────────────────────────────────────────────────────
   /** Enable mock mode for screenshot automation tests */
-  MOCK_MODE: z.string().transform((val) => val?.toLowerCase() === "true").default("false"),
+  MOCK_MODE: z.string().transform((val) => val.toLowerCase() === "true").default("false"),
   /** Path to mock fixtures directory (defaults to built-in fixtures) */
   MOCK_FIXTURES_PATH: z.string().optional()
 });
@@ -155,6 +155,7 @@ function parseAgentAliases() {
     let commandStartIndex = 0;
     for (let i = 0; i < parts.length; i++) {
       const part = parts[i];
+      if (!part) break;
       const eqIndex = part.indexOf("=");
       if (eqIndex > 0 && !part.startsWith("-")) {
         const varName = part.slice(0, eqIndex);
@@ -173,6 +174,10 @@ function parseAgentAliases() {
       continue;
     }
     const baseCommand = commandParts[0];
+    if (!baseCommand) {
+      console.warn(`Invalid agent alias ${key}: empty base command`);
+      continue;
+    }
     const additionalArgs = commandParts.slice(1);
     aliases.set(aliasName, {
       name: aliasName,
@@ -1144,8 +1149,9 @@ var SyncMessageSchema = z2.object({
   // If true, excludes message histories (for watchOS)
 });
 var HistoryRequestPayloadSchema = z2.object({
-  session_id: z2.string().optional()
-  // If omitted, returns supervisor history
+  session_id: z2.string().nullable().optional(),
+  before_sequence: z2.number().int().optional(),
+  limit: z2.number().int().min(1).max(50).optional()
 });
 var HistoryRequestSchema = z2.object({
   type: z2.literal("history.request"),
@@ -1188,7 +1194,7 @@ var TerminateSessionSchema = z2.object({
 var SupervisorCommandPayloadSchema = z2.object({
   command: z2.string().optional(),
   audio: z2.string().optional(),
-  audio_format: z2.enum(["m4a", "wav", "mp3"]).optional(),
+  audio_format: z2.enum(["m4a", "wav", "mp3", "webm", "opus"]).optional(),
   message_id: z2.string().optional(),
   language: z2.string().optional()
 }).refine(
@@ -1232,7 +1238,7 @@ var SessionExecutePayloadSchema = z2.object({
   text: z2.string().optional(),
   // Alias for content (backward compat)
   audio: z2.string().optional(),
-  audio_format: z2.enum(["m4a", "wav", "mp3"]).optional(),
+  audio_format: z2.enum(["m4a", "wav", "mp3", "webm", "opus"]).optional(),
   message_id: z2.string().optional(),
   // For linking transcription back to voice message
   language: z2.string().optional(),
@@ -1365,6 +1371,13 @@ function parseClientMessage(data) {
   }
   return void 0;
 }
+function parseClientMessageWithErrors(data) {
+  const result = IncomingClientMessageSchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, errors: result.error.issues };
+}
 function parseTunnelMessage(data) {
   const result = IncomingTunnelMessageSchema.safeParse(data);
   if (result.success) {
@@ -2315,7 +2328,7 @@ var FileSystemWorkspaceDiscovery = class {
       }
       try {
         execSync(`git merge "${sourceBranch}"`, { cwd: projectPath });
-      } catch (error) {
+      } catch {
         const conflicts = execSync("git diff --name-only --diff-filter=U", {
           cwd: projectPath,
           encoding: "utf-8"
@@ -3283,8 +3296,8 @@ function mergeToolBlocks(blocks) {
           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_input: block.metadata.tool_input ?? existing.metadata.tool_input,
+            tool_output: block.metadata.tool_output ?? existing.metadata.tool_output,
             tool_status: mergedStatus
           }
         };
@@ -3341,8 +3354,8 @@ function accumulateBlocks(existing, newBlocks) {
           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_input: block.metadata.tool_input ?? existingBlock.metadata.tool_input,
+            tool_output: block.metadata.tool_output ?? existingBlock.metadata.tool_output,
             tool_status: mergedStatus
           }
         };
@@ -4022,7 +4035,7 @@ var AgentSessionManager = class extends EventEmitter2 {
     const worktreePath = `/${workspace}/${project}--${branch}`;
     const terminatedSessions = [];
     for (const [sessionId, state] of this.sessions) {
-      const isInWorktree = state.workingDir.includes(worktreePath) || state.cliSessionId?.includes(`${project}--${branch}`) || state.workingDir.endsWith(`${project}--${branch}`);
+      const isInWorktree = state.workingDir.includes(worktreePath) || (state.cliSessionId?.includes(`${project}--${branch}`) ?? false) || state.workingDir.endsWith(`${project}--${branch}`);
       if (isInWorktree) {
         try {
           if (state.isExecuting) {
@@ -4044,7 +4057,7 @@ var AgentSessionManager = class extends EventEmitter2 {
   getWorktreeSessionSummary(workspace, project, branch) {
     const worktreePath = `/${workspace}/${project}--${branch}`;
     const activeSessions = Array.from(this.sessions.values()).filter(
-      (session) => session.workingDir.includes(worktreePath) || session.cliSessionId?.includes(`${project}--${branch}`) || session.workingDir.endsWith(`${project}--${branch}`)
+      (session) => session.workingDir.includes(worktreePath) || (session.cliSessionId?.includes(`${project}--${branch}`) ?? false) || session.workingDir.endsWith(`${project}--${branch}`)
     );
     const sessionTypes = [...new Set(activeSessions.map((s) => s.agentType))];
     const executingCount = activeSessions.filter((s) => s.isExecuting).length;
@@ -4640,8 +4653,8 @@ var CreateSessionUseCase = class {
    */
   checkSessionLimits(sessionType) {
     if (sessionType === "terminal") {
-      const count = this.deps.sessionManager.countByType("terminal");
-      if (count >= SESSION_CONFIG.MAX_TERMINAL_SESSIONS) {
+      const count2 = this.deps.sessionManager.countByType("terminal");
+      if (count2 >= SESSION_CONFIG.MAX_TERMINAL_SESSIONS) {
         throw new SessionLimitReachedError("terminal", SESSION_CONFIG.MAX_TERMINAL_SESSIONS);
       }
     } else if (sessionType !== "supervisor") {
@@ -4691,6 +4704,9 @@ var TerminateSessionUseCase = class {
     let terminatedInMemory = false;
     let terminatedInDb = false;
     if (session) {
+      if (isAgentType(session.type)) {
+        this.deps.agentSessionManager.terminateSession(sessionId);
+      }
       await this.deps.sessionManager.terminateSession(id);
       terminatedInMemory = true;
       this.logger.info(
@@ -4729,6 +4745,42 @@ var TerminateSessionUseCase = class {
     };
     return { response, broadcast };
   }
+  /**
+   * Terminates a session and broadcasts the termination to all clients.
+   * Use this for internal calls (e.g., from supervisor tools) where no request/response is needed.
+   * Returns true if session was found and terminated, false otherwise.
+   */
+  async terminateAndBroadcast(sessionId) {
+    const id = new SessionId(sessionId);
+    this.logger.info({ sessionId }, "Attempting to terminate session (internal)");
+    const session = this.deps.sessionManager.getSession(id);
+    if (session?.type === "supervisor") {
+      throw new Error("Cannot terminate supervisor session");
+    }
+    let terminatedInMemory = false;
+    let terminatedInDb = false;
+    if (session) {
+      if (isAgentType(session.type)) {
+        this.deps.agentSessionManager.terminateSession(sessionId);
+      }
+      await this.deps.sessionManager.terminateSession(id);
+      terminatedInMemory = true;
+    }
+    terminatedInDb = this.deps.chatHistoryService.terminateSession(sessionId);
+    if (!terminatedInMemory && !terminatedInDb) {
+      return false;
+    }
+    const broadcast = {
+      type: "session.terminated",
+      session_id: sessionId
+    };
+    this.deps.messageBroadcaster.broadcastToAll(JSON.stringify(broadcast));
+    this.logger.info(
+      { sessionId, terminatedInMemory, terminatedInDb },
+      "Session terminated and broadcast sent"
+    );
+    return true;
+  }
 };
 
 // src/application/queries/list-sessions.ts
@@ -5040,7 +5092,7 @@ var MessageBroadcasterImpl = class {
 };
 
 // src/infrastructure/persistence/repositories/message-repository.ts
-import { eq as eq3, desc, gt, and as and2, max } from "drizzle-orm";
+import { eq as eq3, desc, gt, lt, and as and2, max, count } from "drizzle-orm";
 import { nanoid as nanoid2 } from "nanoid";
 var MessageRepository = class {
   /**
@@ -5066,17 +5118,24 @@ var MessageRepository = class {
     db2.insert(messages).values(newMessage).run();
     return { ...newMessage, createdAt: newMessage.createdAt };
   }
-  /**
-   * Gets messages for a session with pagination.
-   * Returns messages ordered by sequence descending (newest first).
-   */
   getBySession(sessionId, limit = 100) {
     const db2 = getDatabase();
     return db2.select().from(messages).where(eq3(messages.sessionId, sessionId)).orderBy(desc(messages.sequence)).limit(limit).all();
   }
-  /**
-   * Gets messages after a specific timestamp.
-   */
+  getBySessionPaginated(sessionId, options = {}) {
+    const db2 = getDatabase();
+    const limit = Math.min(options.limit ?? 20, 50);
+    const totalResult = db2.select({ count: count() }).from(messages).where(eq3(messages.sessionId, sessionId)).get();
+    const totalCount = totalResult?.count ?? 0;
+    const whereClause = options.beforeSequence ? and2(
+      eq3(messages.sessionId, sessionId),
+      lt(messages.sequence, options.beforeSequence)
+    ) : eq3(messages.sessionId, sessionId);
+    const rows = db2.select().from(messages).where(whereClause).orderBy(desc(messages.sequence)).limit(limit + 1).all();
+    const hasMore = rows.length > limit;
+    const resultMessages = hasMore ? rows.slice(0, limit) : rows;
+    return { messages: resultMessages, hasMore, totalCount };
+  }
   getAfterTimestamp(sessionId, timestamp, limit = 100) {
     const db2 = getDatabase();
     return db2.select().from(messages).where(and2(eq3(messages.sessionId, sessionId), gt(messages.createdAt, timestamp))).orderBy(messages.createdAt).limit(limit).all();
@@ -5766,9 +5825,40 @@ var ChatHistoryService = class _ChatHistoryService {
       };
     });
   }
-  /**
-   * Clears supervisor chat history (global).
-   */
+  getSupervisorHistoryPaginated(options = {}) {
+    const sessionId = _ChatHistoryService.SUPERVISOR_SESSION_ID;
+    const result = this.messageRepo.getBySessionPaginated(sessionId, options);
+    const messages2 = result.messages.reverse().map((row) => {
+      let contentBlocks;
+      if (row.contentBlocks) {
+        try {
+          contentBlocks = JSON.parse(row.contentBlocks);
+        } catch {
+        }
+      }
+      return {
+        id: row.id,
+        sessionId: row.sessionId,
+        sequence: row.sequence,
+        role: row.role,
+        contentType: row.contentType,
+        content: row.content,
+        contentBlocks,
+        audioInputPath: row.audioInputPath,
+        audioOutputPath: row.audioOutputPath,
+        isComplete: row.isComplete ?? false,
+        createdAt: row.createdAt
+      };
+    });
+    const firstMsg = messages2[0];
+    const lastMsg = messages2[messages2.length - 1];
+    return {
+      messages: messages2,
+      hasMore: result.hasMore,
+      oldestSequence: firstMsg?.sequence,
+      newestSequence: lastMsg?.sequence
+    };
+  }
   clearSupervisorHistory() {
     const sessionId = _ChatHistoryService.SUPERVISOR_SESSION_ID;
     this.messageRepo.deleteBySession(sessionId);
@@ -5851,9 +5941,43 @@ var ChatHistoryService = class _ChatHistoryService {
       };
     });
   }
-  /**
-   * Clears agent session chat history.
-   */
+  getAgentHistoryPaginated(sessionId, options = {}) {
+    const result = this.messageRepo.getBySessionPaginated(sessionId, options);
+    const storedMessages = result.messages.reverse().map((row) => {
+      let contentBlocks;
+      if (row.contentBlocks) {
+        try {
+          contentBlocks = JSON.parse(row.contentBlocks);
+        } catch (error) {
+          this.logger.error(
+            { sessionId, messageId: row.id, error },
+            "Failed to parse contentBlocks JSON"
+          );
+        }
+      }
+      return {
+        id: row.id,
+        sessionId: row.sessionId,
+        sequence: row.sequence,
+        role: row.role,
+        contentType: row.contentType,
+        content: row.content,
+        contentBlocks,
+        audioInputPath: row.audioInputPath,
+        audioOutputPath: row.audioOutputPath,
+        isComplete: row.isComplete ?? false,
+        createdAt: row.createdAt
+      };
+    });
+    const firstMsg = storedMessages[0];
+    const lastMsg = storedMessages[storedMessages.length - 1];
+    return {
+      messages: storedMessages,
+      hasMore: result.hasMore,
+      oldestSequence: firstMsg?.sequence,
+      newestSequence: lastMsg?.sequence
+    };
+  }
   clearAgentHistory(sessionId) {
     this.messageRepo.deleteBySession(sessionId);
     this.logger.info({ sessionId }, "Agent session history cleared");
@@ -6387,18 +6511,35 @@ var InMemorySessionManager = class extends EventEmitter3 {
     this.logger.info({ sessionId: sessionId.value }, "Session terminated");
   }
   /**
-   * Terminates all sessions.
+   * Terminates all sessions with individual timeouts.
+   * Each session has a 3-second timeout to prevent hanging.
    */
   async terminateAll() {
     this.agentSessionManager.cleanup();
     const sessions2 = Array.from(this.sessions.values());
+    const sessionCount = sessions2.length;
+    if (sessionCount === 0) {
+      this.logger.info("No sessions to terminate");
+      return;
+    }
+    this.logger.info({ count: sessionCount }, "Terminating all sessions...");
+    const INDIVIDUAL_TIMEOUT_MS = 3e3;
     await Promise.all(
       sessions2.map(async (session) => {
+        const sessionId = session.id.value;
         try {
-          await session.terminate();
+          const terminatePromise = session.terminate();
+          const timeoutPromise = new Promise((resolve2) => {
+            setTimeout(() => {
+              this.logger.warn({ sessionId }, "Session termination timed out, skipping");
+              resolve2();
+            }, INDIVIDUAL_TIMEOUT_MS);
+          });
+          await Promise.race([terminatePromise, timeoutPromise]);
+          this.logger.debug({ sessionId }, "Session terminated");
         } catch (error) {
           this.logger.error(
-            { sessionId: session.id.value, error },
+            { sessionId, error },
             "Error terminating session"
           );
         }
@@ -6406,7 +6547,7 @@ var InMemorySessionManager = class extends EventEmitter3 {
     );
     this.sessions.clear();
     this.supervisorSession = null;
-    this.logger.info({ count: sessions2.length }, "All sessions terminated");
+    this.logger.info({ count: sessionCount }, "All sessions terminated");
   }
   /**
    * Gets the count of active sessions by type.
@@ -6857,16 +6998,7 @@ Steps executed:
 // src/infrastructure/agents/supervisor/tools/session-tools.ts
 import { tool as tool3 } from "@langchain/core/tools";
 import { z as z5 } from "zod";
-function createSessionTools(sessionManager, agentSessionManager, workspaceDiscovery, workspacesRoot, getMessageBroadcaster, getChatHistoryService) {
-  const broadcastTermination = (sessionId) => {
-    const broadcaster = getMessageBroadcaster?.();
-    if (!broadcaster) return;
-    const message = {
-      type: "session.terminated",
-      session_id: sessionId
-    };
-    broadcaster.broadcastToAll(JSON.stringify(message));
-  };
+function createSessionTools(sessionManager, agentSessionManager, workspaceDiscovery, workspacesRoot, _getMessageBroadcaster, getChatHistoryService, clearSupervisorContext, terminateSessionCallback) {
   const listSessions = tool3(
     () => {
       const chatHistoryService = getChatHistoryService?.();
@@ -7008,26 +7140,13 @@ Use this tool when user asks to "open terminal", "create terminal", or similar r
   const terminateSession = tool3(
     async ({ sessionId }) => {
       try {
-        const { SessionId: SessionId2 } = await import("./session-id-VKOYWZAK.js");
-        const id = new SessionId2(sessionId);
-        const session = sessionManager.getSession(id);
-        let terminatedInMemory = false;
-        let terminatedInDb = false;
-        if (session) {
-          if (isAgentType(session.type)) {
-            agentSessionManager.terminateSession(sessionId);
-          }
-          await sessionManager.terminateSession(id);
-          terminatedInMemory = true;
-        }
-        const chatHistoryService = getChatHistoryService?.();
-        if (chatHistoryService) {
-          terminatedInDb = chatHistoryService.terminateSession(sessionId);
+        if (!terminateSessionCallback) {
+          return "Error: Terminate session callback not configured.";
         }
-        if (!terminatedInMemory && !terminatedInDb) {
+        const terminated = await terminateSessionCallback(sessionId);
+        if (!terminated) {
           return `Session "${sessionId}" not found.`;
         }
-        broadcastTermination(sessionId);
         return `Session "${sessionId}" terminated.`;
       } catch (error) {
         return `Error terminating session: ${error instanceof Error ? error.message : String(error)}`;
@@ -7044,6 +7163,9 @@ Use this tool when user asks to "open terminal", "create terminal", or similar r
   const terminateAllSessions = tool3(
     async ({ sessionType }) => {
       try {
+        if (!terminateSessionCallback) {
+          return "Error: Terminate session callback not configured.";
+        }
         const typeFilter = sessionType === "all" || !sessionType ? null : sessionType;
         const chatHistoryService = getChatHistoryService?.();
         const inMemorySessions = sessionManager.getAllSessions();
@@ -7051,31 +7173,25 @@ Use this tool when user asks to "open terminal", "create terminal", or similar r
         const persistedSessions = chatHistoryService?.getActiveAgentSessions() ?? [];
         const inMemoryIds = new Set(inMemorySessions.map((s) => s.id.value));
         const persistedToTerminate = persistedSessions.filter((s) => !inMemoryIds.has(s.sessionId)).filter((s) => !typeFilter || s.sessionType === typeFilter);
-        if (inMemoryToTerminate.length === 0 && persistedToTerminate.length === 0) {
+        const sessionsToTerminate = [
+          ...inMemoryToTerminate.map((s) => ({ id: s.id.value, type: s.type })),
+          ...persistedToTerminate.map((s) => ({ id: s.sessionId, type: s.sessionType }))
+        ];
+        if (sessionsToTerminate.length === 0) {
           return typeFilter ? `No active ${typeFilter} sessions to terminate.` : "No active sessions to terminate.";
         }
         const terminated = [];
         const errors = [];
-        for (const session of inMemoryToTerminate) {
+        for (const session of sessionsToTerminate) {
           try {
-            if (isAgentType(session.type)) {
-              agentSessionManager.terminateSession(session.id.value);
+            const success = await terminateSessionCallback(session.id);
+            if (success) {
+              terminated.push(`${session.type}:${session.id}`);
+            } else {
+              errors.push(`${session.id}: Session not found`);
             }
-            await sessionManager.terminateSession(session.id);
-            chatHistoryService?.terminateSession(session.id.value);
-            broadcastTermination(session.id.value);
-            terminated.push(`${session.type}:${session.id.value}`);
-          } catch (error) {
-            errors.push(`${session.id.value}: ${error instanceof Error ? error.message : String(error)}`);
-          }
-        }
-        for (const session of persistedToTerminate) {
-          try {
-            chatHistoryService?.terminateSession(session.sessionId);
-            broadcastTermination(session.sessionId);
-            terminated.push(`${session.sessionType}:${session.sessionId}`);
           } catch (error) {
-            errors.push(`${session.sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+            errors.push(`${session.id}: ${error instanceof Error ? error.message : String(error)}`);
           }
         }
         let result = `Terminated ${terminated.length} session(s)`;
@@ -7220,6 +7336,23 @@ ${terminatedSessions.map((id) => `  - ${id}`).join("\n")}`;
       })
     }
   );
+  const clearContext = tool3(
+    () => {
+      try {
+        if (clearSupervisorContext) {
+          clearSupervisorContext();
+        }
+        return "Supervisor context cleared successfully. Conversation history has been reset.";
+      } catch (error) {
+        return `Error clearing context: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    {
+      name: "clear_supervisor_context",
+      description: 'Clears the supervisor agent conversation context and history. Use when user asks to "clear context", "reset conversation", "start fresh", or similar requests.',
+      schema: z5.object({})
+    }
+  );
   return [
     listSessions,
     listAvailableAgents,
@@ -7230,7 +7363,8 @@ ${terminatedSessions.map((id) => `  - ${id}`).join("\n")}`;
     getSessionInfo,
     listSessionsWithWorktrees,
     getWorktreeSessionSummary,
-    terminateWorktreeSessions
+    terminateWorktreeSessions,
+    clearContext
   ];
 }
 
@@ -7348,6 +7482,8 @@ function formatSize(bytes) {
 var SupervisorAgent = class extends EventEmitter4 {
   logger;
   agent;
+  getMessageBroadcaster;
+  getChatHistoryService;
   conversationHistory = [];
   abortController = null;
   isExecuting = false;
@@ -7359,8 +7495,18 @@ var SupervisorAgent = class extends EventEmitter4 {
   constructor(config2) {
     super();
     this.logger = config2.logger.child({ component: "SupervisorAgent" });
+    this.getMessageBroadcaster = config2.getMessageBroadcaster;
+    this.getChatHistoryService = config2.getChatHistoryService;
     const env = getEnv();
     const llm = this.createLLM(env);
+    const terminateSessionCallback = async (sessionId) => {
+      const terminate = config2.getTerminateSession?.();
+      if (!terminate) {
+        this.logger.warn("Terminate session callback not available");
+        return false;
+      }
+      return terminate(sessionId);
+    };
     const tools = [
       ...createWorkspaceTools(config2.workspaceDiscovery),
       ...createWorktreeTools(config2.workspaceDiscovery, config2.agentSessionManager),
@@ -7370,7 +7516,9 @@ var SupervisorAgent = class extends EventEmitter4 {
         config2.workspaceDiscovery,
         config2.workspacesRoot,
         config2.getMessageBroadcaster,
-        config2.getChatHistoryService
+        config2.getChatHistoryService,
+        () => this.clearContext(),
+        terminateSessionCallback
       ),
       ...createFilesystemTools(config2.workspacesRoot)
     ];
@@ -7621,14 +7769,38 @@ var SupervisorAgent = class extends EventEmitter4 {
     this.logger.debug("Ended command processing");
   }
   /**
-   * Clears global conversation history.
+   * Clears global conversation history (in-memory only).
    * Also resets cancellation state to allow new commands.
+   * @deprecated Use clearContext() for full context clearing with persistence and broadcast.
    */
   clearHistory() {
     this.conversationHistory = [];
     this.isCancelled = false;
     this.logger.info("Global conversation history cleared");
   }
+  /**
+   * Clears supervisor context completely:
+   * - In-memory conversation history
+   * - Persistent history in database
+   * - Notifies all connected clients
+   */
+  clearContext() {
+    this.conversationHistory = [];
+    this.isCancelled = false;
+    const chatHistoryService = this.getChatHistoryService?.();
+    if (chatHistoryService) {
+      chatHistoryService.clearSupervisorHistory();
+    }
+    const broadcaster = this.getMessageBroadcaster?.();
+    if (broadcaster) {
+      const clearNotification = JSON.stringify({
+        type: "supervisor.context_cleared",
+        payload: { timestamp: Date.now() }
+      });
+      broadcaster.broadcastToAll(clearNotification);
+    }
+    this.logger.info("Supervisor context cleared (in-memory, persistent, and clients notified)");
+  }
   /**
    * Resets the cancellation state.
    * Call this before starting a new command to ensure previous cancellation doesn't affect it.
@@ -7864,8 +8036,9 @@ var DEFAULT_FIXTURES_PATH = join7(__dirname, "fixtures");
 var fixtureCache = /* @__PURE__ */ new Map();
 function loadFixture(name, customPath) {
   const cacheKey = `${customPath ?? "default"}:${name}`;
-  if (fixtureCache.has(cacheKey)) {
-    return fixtureCache.get(cacheKey);
+  const cached = fixtureCache.get(cacheKey);
+  if (cached) {
+    return cached;
   }
   const fixturesDir = customPath ?? DEFAULT_FIXTURES_PATH;
   const filePath = join7(fixturesDir, `${name}.json`);
@@ -7901,20 +8074,14 @@ async function simulateStreaming(text2, delayMs = DEFAULT_TOKEN_DELAY_MS, onBloc
   const tokens = tokenize(text2);
   let accumulated = "";
   for (let i = 0; i < tokens.length; i++) {
-    accumulated += tokens[i];
-    const block = {
-      type: "text",
-      text: accumulated
-    };
+    accumulated += tokens[i] ?? "";
+    const block = createTextBlock(accumulated);
     onBlock([block], false);
     if (i < tokens.length - 1) {
       await sleep(delayMs);
     }
   }
-  const finalBlock = {
-    type: "text",
-    text: accumulated
-  };
+  const finalBlock = createTextBlock(accumulated);
   onBlock([finalBlock], true);
   onComplete();
 }
@@ -7976,7 +8143,7 @@ var MockSupervisorAgent = class extends EventEmitter5 {
   /**
    * Executes a command (non-streaming).
    */
-  async execute(command, deviceId, _currentSessionId) {
+  execute(command, deviceId, _currentSessionId) {
     this.logger.info({ command, deviceId }, "Mock supervisor execute");
     const response = this.getResponse(command);
     this.conversationHistory.push({ role: "user", content: command });
@@ -8571,8 +8738,10 @@ var TTSService = class {
         case "elevenlabs":
           result = await this.synthesizeElevenLabs(text2);
           break;
-        default:
-          throw new Error(`Unsupported TTS provider: ${this.config.provider}`);
+        default: {
+          const exhaustiveCheck = this.config.provider;
+          throw new Error(`Unsupported TTS provider: ${exhaustiveCheck}`);
+        }
       }
       const elapsed = Date.now() - startTime;
       this.logger.info(
@@ -8905,11 +9074,19 @@ function handleTunnelMessage(rawMessage, tunnelClient, messageBroadcaster, creat
       return;
     }
     const handler = handlers[messageType];
-    const parsedMessage = parseClientMessage(data);
-    if (!parsedMessage) {
-      logger.warn({ type: messageType }, "Failed to parse tunnel message");
+    const parseResult = parseClientMessageWithErrors(data);
+    if (!parseResult.success) {
+      logger.warn(
+        {
+          type: messageType,
+          errors: parseResult.errors,
+          rawMessage: JSON.stringify(data).slice(0, 500)
+        },
+        "Failed to parse tunnel message - Zod validation failed"
+      );
       return;
     }
+    const parsedMessage = parseResult.data;
     handler(virtualSocket, parsedMessage).catch((error) => {
       logger.error(
         { error, type: messageType },
@@ -9097,6 +9274,29 @@ async function bootstrap() {
   const pendingSupervisorVoiceCommands = /* @__PURE__ */ new Map();
   const pendingAgentVoiceCommands = /* @__PURE__ */ new Map();
   const cancelledDuringTranscription = /* @__PURE__ */ new Set();
+  const supervisorMessageAccumulator = {
+    blocks: [],
+    streamingMessageId: null,
+    get() {
+      return this.blocks;
+    },
+    getStreamingMessageId() {
+      return this.streamingMessageId;
+    },
+    set(blocks) {
+      this.blocks = blocks;
+    },
+    clear() {
+      this.blocks = [];
+      this.streamingMessageId = null;
+    },
+    accumulate(newBlocks) {
+      if (this.blocks.length === 0 && newBlocks.length > 0) {
+        this.streamingMessageId = randomUUID5();
+      }
+      accumulateBlocks(this.blocks, newBlocks);
+    }
+  };
   const expectedAuthKey = new AuthKey(env.WORKSTATION_AUTH_KEY);
   let messageBroadcaster = null;
   const supervisorAgent = env.MOCK_MODE ? new MockSupervisorAgent({
@@ -9109,7 +9309,8 @@ async function bootstrap() {
     workspacesRoot: env.WORKSPACES_ROOT,
     logger,
     getMessageBroadcaster: () => messageBroadcaster,
-    getChatHistoryService: () => chatHistoryService
+    getChatHistoryService: () => chatHistoryService,
+    getTerminateSession: () => terminateSession?.terminateAndBroadcast.bind(terminateSession) ?? null
   });
   if (env.MOCK_MODE) {
     logger.info("Mock Supervisor Agent initialized for screenshot automation");
@@ -9188,11 +9389,10 @@ async function bootstrap() {
       const syncMessage = message;
       const client = clientRegistry.getBySocket(socket) ?? (syncMessage.device_id ? clientRegistry.getByDeviceId(new DeviceId(syncMessage.device_id)) : void 0);
       const subscriptions2 = client ? client.getSubscriptions() : [];
-      const isLightweight = syncMessage.lightweight === true;
       const inMemorySessions = sessionManager.getSessionInfos();
       const persistedAgentSessions = chatHistoryService.getActiveAgentSessions();
       logger.debug(
-        { persistedAgentSessions, inMemoryCount: inMemorySessions.length, isLightweight },
+        { persistedAgentSessions, inMemoryCount: inMemorySessions.length },
         "Sync: fetched sessions"
       );
       const inMemorySessionIds = new Set(
@@ -9217,119 +9417,14 @@ async function bootstrap() {
         };
       });
       const sessions2 = [...inMemorySessions, ...restoredAgentSessions];
-      if (isLightweight) {
-        const availableAgentsMap2 = getAvailableAgents();
-        const availableAgents2 = Array.from(availableAgentsMap2.values()).map(
-          (agent) => ({
-            name: agent.name,
-            base_type: agent.baseType,
-            description: agent.description,
-            is_alias: agent.isAlias
-          })
-        );
-        const hiddenBaseTypes2 = getDisabledBaseAgents();
-        const workspacesList2 = await workspaceDiscovery.listWorkspaces();
-        const workspaces2 = await Promise.all(
-          workspacesList2.map(async (ws) => {
-            const projects = await workspaceDiscovery.listProjects(ws.name);
-            return {
-              name: ws.name,
-              projects: projects.map((p) => ({
-                name: p.name,
-                is_git_repo: p.isGitRepo,
-                default_branch: p.defaultBranch
-              }))
-            };
-          })
-        );
-        const executingStates2 = {};
-        for (const session of sessions2) {
-          if (session.session_type === "cursor" || session.session_type === "claude" || session.session_type === "opencode") {
-            executingStates2[session.session_id] = agentSessionManager.isExecuting(
-              session.session_id
-            );
-          }
-        }
-        const supervisorIsExecuting2 = supervisorAgent.isProcessing();
-        logger.info(
-          {
-            totalSessions: sessions2.length,
-            isLightweight: true,
-            availableAgentsCount: availableAgents2.length,
-            workspacesCount: workspaces2.length,
-            supervisorIsExecuting: supervisorIsExecuting2
-          },
-          "Sync: sending lightweight state to client (no histories)"
-        );
-        const syncStateMessage2 = JSON.stringify({
-          type: "sync.state",
-          id: syncMessage.id,
-          payload: {
-            sessions: sessions2,
-            subscriptions: subscriptions2,
-            availableAgents: availableAgents2,
-            hiddenBaseTypes: hiddenBaseTypes2,
-            workspaces: workspaces2,
-            supervisorIsExecuting: supervisorIsExecuting2,
-            executingStates: executingStates2
-            // Omit: supervisorHistory, agentHistories, currentStreamingBlocks
-          }
-        });
-        sendToDevice(socket, syncMessage.device_id, syncStateMessage2);
-        return Promise.resolve();
-      }
       const supervisorHistoryRaw = chatHistoryService.getSupervisorHistory();
-      const supervisorHistory = await Promise.all(
-        supervisorHistoryRaw.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()
-        }))
-      );
-      if (supervisorHistory.length > 0) {
-        const historyForAgent = supervisorHistory.filter((msg) => msg.role === "user" || msg.role === "assistant").map((msg) => ({
+      if (supervisorHistoryRaw.length > 0) {
+        const historyForAgent = supervisorHistoryRaw.filter((msg) => msg.role === "user" || msg.role === "assistant").map((msg) => ({
           role: msg.role,
           content: msg.content
         }));
         supervisorAgent.restoreHistory(historyForAgent);
       }
-      const agentSessionIds = sessions2.filter(
-        (s) => s.session_type === "cursor" || s.session_type === "claude" || s.session_type === "opencode"
-      ).map((s) => s.session_id);
-      const agentHistoriesMap = chatHistoryService.getAllAgentHistories(agentSessionIds);
-      const agentHistories = {};
-      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(
         (agent) => ({
@@ -9362,31 +9457,23 @@ async function bootstrap() {
           );
         }
       }
-      const currentStreamingBlocks = {};
-      for (const [sessionId, isExecuting] of Object.entries(executingStates)) {
-        if (isExecuting) {
-          const blocks = agentMessageAccumulator.get(sessionId);
-          if (blocks && blocks.length > 0) {
-            currentStreamingBlocks[sessionId] = blocks;
-          }
+      const supervisorIsExecuting = supervisorAgent.isProcessing();
+      let currentStreamingBlocks;
+      if (supervisorIsExecuting) {
+        const blocks = supervisorMessageAccumulator.get();
+        if (blocks && blocks.length > 0) {
+          currentStreamingBlocks = blocks;
         }
       }
-      const supervisorIsExecuting = supervisorAgent.isProcessing();
       logger.info(
         {
           totalSessions: sessions2.length,
-          sessionTypes: sessions2.map((s) => ({
-            id: s.session_id,
-            type: s.session_type
-          })),
-          agentHistoriesCount: Object.keys(agentHistories).length,
           availableAgentsCount: availableAgents.length,
           workspacesCount: workspaces.length,
           supervisorIsExecuting,
-          executingStates,
-          streamingBlocksCount: Object.keys(currentStreamingBlocks).length
+          hasStreamingBlocks: !!currentStreamingBlocks
         },
-        "Sync: sending state to client"
+        "Sync: sending state to client (v1.13 - no histories)"
       );
       const syncStateMessage = JSON.stringify({
         type: "sync.state",
@@ -9394,14 +9481,15 @@ async function bootstrap() {
         payload: {
           sessions: sessions2,
           subscriptions: subscriptions2,
-          supervisorHistory,
-          agentHistories,
           availableAgents,
           hiddenBaseTypes,
           workspaces,
           supervisorIsExecuting,
           executingStates,
-          currentStreamingBlocks: Object.keys(currentStreamingBlocks).length > 0 ? currentStreamingBlocks : void 0
+          // Only include supervisor streaming blocks for mid-stream join
+          currentStreamingBlocks
+          // Protocol v1.13: No supervisorHistory, agentHistories
+          // Clients use history.request for on-demand loading
         }
       });
       sendToDevice(socket, syncMessage.device_id, syncStateMessage);
@@ -9463,7 +9551,7 @@ async function bootstrap() {
       let commandText;
       const messageId = commandMessage.payload.message_id;
       if (messageBroadcaster) {
-        const ackMessageId = messageId || commandMessage.id;
+        const ackMessageId = messageId ?? commandMessage.id;
         const ackMessage = {
           type: "message.ack",
           payload: {
@@ -9496,7 +9584,7 @@ async function bootstrap() {
             const errorEvent = {
               type: "supervisor.transcription",
               payload: {
-                text: "",
+                transcription: "",
                 error: "Voice transcription not available - STT service not configured",
                 message_id: messageId,
                 timestamp: Date.now()
@@ -9546,7 +9634,7 @@ async function bootstrap() {
             const transcriptionEvent = {
               type: "supervisor.transcription",
               payload: {
-                text: commandText,
+                transcription: commandText,
                 language: transcriptionResult.language,
                 duration: transcriptionResult.duration,
                 message_id: messageId,
@@ -9575,7 +9663,7 @@ async function bootstrap() {
             const errorEvent = {
               type: "supervisor.transcription",
               payload: {
-                text: "",
+                transcription: "",
                 error: error instanceof Error ? error.message : "Transcription failed",
                 message_id: messageId,
                 timestamp: Date.now(),
@@ -9721,13 +9809,7 @@ async function bootstrap() {
       const tunnelClient2 = clearMessage.device_id ? clientRegistry.getByDeviceId(new DeviceId(clearMessage.device_id)) : void 0;
       const isAuthenticated = directClient?.isAuthenticated ?? tunnelClient2?.isAuthenticated;
       if (isAuthenticated) {
-        supervisorAgent.clearHistory();
-        chatHistoryService.clearSupervisorHistory();
-        const clearNotification = JSON.stringify({
-          type: "supervisor.context_cleared",
-          payload: { timestamp: Date.now() }
-        });
-        broadcaster.broadcastToAll(clearNotification);
+        supervisorAgent.clearContext();
         sendToDevice(
           socket,
           clearMessage.device_id,
@@ -9855,45 +9937,29 @@ async function bootstrap() {
             },
             "Client subscribed to agent session"
           );
-          const history = chatHistoryService.getAgentHistory(sessionId, 50);
-          const enrichedHistory = await Promise.all(
-            history.map(async (msg) => ({
-              id: msg.id,
-              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 subscription response
-              ),
-              createdAt: msg.createdAt.toISOString()
-            }))
-          );
           const isExecuting = agentSessionManager.isExecuting(sessionId);
           const currentStreamingBlocks = agentMessageAccumulator.get(sessionId) ?? [];
+          const streamingMessageId = currentStreamingBlocks.length > 0 ? agentStreamingMessageIds.get(sessionId) : void 0;
           sendToDevice(
             socket,
             subscribeMessage.device_id,
             JSON.stringify({
               type: "session.subscribed",
               session_id: sessionId,
-              history: enrichedHistory,
               is_executing: isExecuting,
-              current_streaming_blocks: currentStreamingBlocks.length > 0 ? currentStreamingBlocks : void 0
+              current_streaming_blocks: currentStreamingBlocks.length > 0 ? currentStreamingBlocks : void 0,
+              streaming_message_id: streamingMessageId
             })
           );
           logger.debug(
             {
               deviceId: client.deviceId.value,
               sessionId,
-              historyCount: enrichedHistory.length,
               isExecuting,
-              streamingBlocksCount: currentStreamingBlocks.length
+              streamingBlocksCount: currentStreamingBlocks.length,
+              streamingMessageId
             },
-            "Sent agent session history on subscribe"
+            "Agent session subscribed (v1.13 - use history.request for messages)"
           );
         } else {
           const result = subscriptionService.subscribe(
@@ -9950,7 +10016,7 @@ async function bootstrap() {
       const sessionId = execMessage.session_id;
       const messageId = execMessage.payload.message_id;
       if (deviceId && messageBroadcaster) {
-        const ackMessageId = messageId || execMessage.id;
+        const ackMessageId = messageId ?? execMessage.id;
         const ackMessage = {
           type: "message.ack",
           payload: {
@@ -10022,7 +10088,7 @@ async function bootstrap() {
               type: "session.transcription",
               session_id: sessionId,
               payload: {
-                text: transcribedText,
+                transcription: transcribedText,
                 language: transcriptionResult.language,
                 duration: transcriptionResult.duration,
                 message_id: messageId,
@@ -10115,7 +10181,7 @@ async function bootstrap() {
               type: "session.transcription",
               session_id: sessionId,
               payload: {
-                text: "",
+                transcription: "",
                 error: error instanceof Error ? error.message : "Transcription failed",
                 message_id: messageId,
                 timestamp: Date.now()
@@ -10441,18 +10507,22 @@ async function bootstrap() {
     "history.request": async (socket, message) => {
       const historyRequest = message;
       const sessionId = historyRequest.payload?.session_id;
+      const beforeSequence = historyRequest.payload?.before_sequence;
+      const limit = historyRequest.payload?.limit;
       const isSupervisor = !sessionId;
       logger.debug(
-        { sessionId, isSupervisor, requestId: historyRequest.id },
-        "History request received"
+        { sessionId, isSupervisor, beforeSequence, limit, requestId: historyRequest.id },
+        "Paginated history request received"
       );
       try {
         if (isSupervisor) {
-          const supervisorHistoryRaw = chatHistoryService.getSupervisorHistory();
+          const result = chatHistoryService.getSupervisorHistoryPaginated({
+            beforeSequence,
+            limit
+          });
           const supervisorHistory = await Promise.all(
-            supervisorHistoryRaw.map(async (msg) => ({
+            result.messages.map(async (msg) => ({
               message_id: msg.id,
-              // Include message ID for audio.request
               sequence: msg.sequence,
               role: msg.role,
               content: msg.content,
@@ -10461,32 +10531,54 @@ async function bootstrap() {
                 msg.audioOutputPath,
                 msg.audioInputPath,
                 false
-                // Don't include audio in history response
               ),
               createdAt: msg.createdAt.toISOString()
             }))
           );
           const isExecuting = supervisorAgent.isProcessing();
+          let currentStreamingBlocks;
+          let streamingMessageId;
+          if (isExecuting && !beforeSequence) {
+            const blocks = supervisorMessageAccumulator.get();
+            if (blocks && blocks.length > 0) {
+              currentStreamingBlocks = blocks;
+              streamingMessageId = supervisorMessageAccumulator.getStreamingMessageId() ?? void 0;
+            }
+          }
           socket.send(
             JSON.stringify({
               type: "history.response",
               id: historyRequest.id,
               payload: {
                 session_id: null,
-                // Indicates supervisor
                 history: supervisorHistory,
-                is_executing: isExecuting
+                has_more: result.hasMore,
+                oldest_sequence: result.oldestSequence,
+                newest_sequence: result.newestSequence,
+                is_executing: isExecuting,
+                current_streaming_blocks: currentStreamingBlocks,
+                streaming_message_id: streamingMessageId
               }
             })
           );
           logger.debug(
-            { messageCount: supervisorHistory.length, isExecuting },
-            "Supervisor history sent"
+            {
+              messageCount: supervisorHistory.length,
+              hasMore: result.hasMore,
+              oldestSeq: result.oldestSequence,
+              newestSeq: result.newestSequence,
+              isExecuting
+            },
+            "Paginated supervisor history sent"
           );
         } else {
-          const history = chatHistoryService.getAgentHistory(sessionId);
+          const result = chatHistoryService.getAgentHistoryPaginated(sessionId, {
+            beforeSequence,
+            limit
+          });
           const enrichedHistory = await Promise.all(
-            history.map(async (msg) => ({
+            result.messages.map(async (msg) => ({
+              message_id: msg.id,
               sequence: msg.sequence,
               role: msg.role,
               content: msg.content,
@@ -10495,17 +10587,18 @@ async function bootstrap() {
                 msg.audioOutputPath,
                 msg.audioInputPath,
                 false
-                // Don't include audio in history response
               ),
               createdAt: msg.createdAt.toISOString()
             }))
           );
           const isExecuting = agentSessionManager.isExecuting(sessionId);
           let currentStreamingBlocks;
-          if (isExecuting) {
+          let streamingMessageId;
+          if (isExecuting && !beforeSequence) {
             const blocks = agentMessageAccumulator.get(sessionId);
             if (blocks && blocks.length > 0) {
               currentStreamingBlocks = blocks;
+              streamingMessageId = agentStreamingMessageIds.get(sessionId);
             }
           }
           socket.send(
@@ -10515,13 +10608,17 @@ async function bootstrap() {
               payload: {
                 session_id: sessionId,
                 history: enrichedHistory,
+                has_more: result.hasMore,
+                oldest_sequence: result.oldestSequence,
+                newest_sequence: result.newestSequence,
                 is_executing: isExecuting,
-                current_streaming_blocks: currentStreamingBlocks
+                current_streaming_blocks: currentStreamingBlocks,
+                streaming_message_id: streamingMessageId
               }
             })
           );
           logger.debug(
-            { sessionId, messageCount: enrichedHistory.length, isExecuting },
+            { sessionId, messageCount: enrichedHistory.length, isExecuting, streamingMessageId },
             "Agent session history sent"
           );
         }
@@ -10555,7 +10652,7 @@ async function bootstrap() {
               id: audioRequest.id,
               payload: {
                 message_id,
-                audio: audioBase64
+                audio_base64: audioBase64
               }
             })
           );
@@ -10700,6 +10797,7 @@ async function bootstrap() {
   });
   terminateSession = new TerminateSessionUseCase({
     sessionManager,
+    agentSessionManager,
     messageBroadcaster,
     chatHistoryService,
     logger
@@ -10712,6 +10810,18 @@ async function bootstrap() {
   });
   const broadcaster = messageBroadcaster;
   const agentMessageAccumulator = /* @__PURE__ */ new Map();
+  const agentStreamingMessageIds = /* @__PURE__ */ new Map();
+  const getOrCreateAgentStreamingMessageId = (sessionId) => {
+    let messageId = agentStreamingMessageIds.get(sessionId);
+    if (!messageId) {
+      messageId = randomUUID5();
+      agentStreamingMessageIds.set(sessionId, messageId);
+    }
+    return messageId;
+  };
+  const clearAgentStreamingMessageId = (sessionId) => {
+    agentStreamingMessageIds.delete(sessionId);
+  };
   agentSessionManager.on(
     "blocks",
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
@@ -10784,9 +10894,11 @@ async function bootstrap() {
       const accumulatedBlocks = agentMessageAccumulator.get(sessionId) ?? [];
       const mergedBlocks = mergeToolBlocks(accumulatedBlocks);
       const fullAccumulatedText = mergedBlocks.filter((b) => b.block_type === "text").map((b) => b.content).join("\n");
+      const streamingMessageId = getOrCreateAgentStreamingMessageId(sessionId);
       const outputEvent = {
         type: "session.output",
         session_id: sessionId,
+        streaming_message_id: streamingMessageId,
         payload: {
           content_type: "agent",
           content: fullAccumulatedText,
@@ -10801,6 +10913,9 @@ async function bootstrap() {
         sessionId,
         JSON.stringify(outputEvent)
       );
+      if (isComplete) {
+        clearAgentStreamingMessageId(sessionId);
+      }
       if (isComplete && fullTextContent.length > 0) {
         const pendingVoiceCommand = pendingAgentVoiceCommands.get(sessionId);
         if (pendingVoiceCommand && ttsService) {
@@ -10850,7 +10965,7 @@ async function bootstrap() {
               session_id: sessionId,
               payload: {
                 text: textForTTS,
-                audio: audioBase64,
+                audio_base64: audioBase64,
                 audio_format: "mp3",
                 duration: ttsResult.duration,
                 message_id: pendingMessageId,
@@ -10876,7 +10991,6 @@ async function bootstrap() {
       }
     }
   );
-  let supervisorBlockAccumulator = [];
   supervisorAgent.on(
     "blocks",
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
@@ -10891,17 +11005,19 @@ async function bootstrap() {
           { deviceId, blockCount: blocks.length, isComplete },
           "Ignoring supervisor blocks - execution was cancelled"
         );
-        supervisorBlockAccumulator = [];
+        supervisorMessageAccumulator.clear();
         return;
       }
       const persistableBlocks = blocks.filter((b) => b.block_type !== "status");
       if (persistableBlocks.length > 0) {
-        accumulateBlocks(supervisorBlockAccumulator, persistableBlocks);
+        supervisorMessageAccumulator.accumulate(persistableBlocks);
       }
-      const mergedBlocks = mergeToolBlocks(supervisorBlockAccumulator);
+      const mergedBlocks = mergeToolBlocks(supervisorMessageAccumulator.get());
       const textContent = mergedBlocks.filter((b) => b.block_type === "text").map((b) => b.content).join("\n");
+      const streamingMessageId = supervisorMessageAccumulator.getStreamingMessageId();
       const outputEvent = {
         type: "supervisor.output",
+        streaming_message_id: streamingMessageId,
         payload: {
           content_type: "supervisor",
           content: textContent,
@@ -10913,7 +11029,7 @@ async function bootstrap() {
       const message = JSON.stringify(outputEvent);
       broadcaster.broadcastToAll(message);
       if (isComplete) {
-        supervisorBlockAccumulator = [];
+        supervisorMessageAccumulator.clear();
       }
       if (isComplete && finalOutput && finalOutput.length > 0) {
         chatHistoryService.saveSupervisorMessage(
@@ -10963,7 +11079,7 @@ async function bootstrap() {
               type: "supervisor.voice_output",
               payload: {
                 text: textForTTS,
-                audio: audioBase64,
+                audio_base64: audioBase64,
                 audio_format: "mp3",
                 duration: ttsResult.duration,
                 message_id: pendingMessageId,
@@ -11123,23 +11239,52 @@ async function bootstrap() {
   } catch (error) {
     logger.error({ error }, "Failed to connect to tunnel (will retry)");
   }
+  const SHUTDOWN_TIMEOUT_MS = 1e4;
+  let isShuttingDown = false;
   const shutdown = async (signal) => {
+    if (isShuttingDown) {
+      logger.warn({ signal }, "Shutdown already in progress, forcing exit");
+      process.exit(1);
+    }
+    isShuttingDown = true;
     logger.info({ signal }, "Shutdown signal received");
+    const forceExitTimeout = setTimeout(() => {
+      logger.error("Graceful shutdown timeout exceeded, forcing exit");
+      process.exit(1);
+    }, SHUTDOWN_TIMEOUT_MS);
     try {
       logger.info("Disconnecting from tunnel...");
       tunnelClient.disconnect();
       logger.info("Cleaning up agent sessions...");
       agentSessionManager.cleanup();
       logger.info("Terminating all sessions...");
-      await sessionManager.terminateAll();
-      logger.info("All sessions terminated");
+      const terminatePromise = sessionManager.terminateAll();
+      const sessionTimeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error("Session termination timeout")), 5e3);
+      });
+      try {
+        await Promise.race([terminatePromise, sessionTimeoutPromise]);
+        logger.info("All sessions terminated");
+      } catch (error) {
+        logger.warn({ error }, "Session termination timed out, continuing shutdown");
+      }
       logger.info("Closing HTTP server...");
-      await app.close();
+      const closePromise = app.close();
+      const closeTimeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error("HTTP server close timeout")), 2e3);
+      });
+      try {
+        await Promise.race([closePromise, closeTimeoutPromise]);
+      } catch (error) {
+        logger.warn({ error }, "HTTP server close timed out, continuing shutdown");
+      }
       logger.info("Closing database...");
       closeDatabase();
+      clearTimeout(forceExitTimeout);
       logger.info("Shutdown complete");
       process.exit(0);
     } catch (error) {
+      clearTimeout(forceExitTimeout);
       logger.error({ error }, "Error during shutdown");
       process.exit(1);
     }

package/package.json

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