@tiflis-io/tiflis-code-workstation 0.3.11 → 0.3.13

package/dist/main.js

@@ -127,7 +127,11 @@ var EnvSchema = z.object({
   // Terminal Configuration
   // ─────────────────────────────────────────────────────────────
   /** Terminal output buffer size (number of messages, in-memory only, does not survive restarts) */
-  TERMINAL_OUTPUT_BUFFER_SIZE: z.coerce.number().default(100),
+  TERMINAL_OUTPUT_BUFFER_SIZE: z.coerce.number().default(1e4),
+  /** Terminal output batch interval in milliseconds (how long to wait before flushing) */
+  TERMINAL_BATCH_INTERVAL_MS: z.coerce.number().default(64),
+  /** Terminal output batch max size in bytes (flush immediately when exceeded) */
+  TERMINAL_BATCH_MAX_SIZE: z.coerce.number().default(4096),
   // Legacy (fallback for STT/TTS if specific keys not set)
   OPENAI_API_KEY: z.string().optional(),
   // ─────────────────────────────────────────────────────────────
@@ -283,7 +287,7 @@ var SESSION_CONFIG = {
   /** Data retention period for terminated sessions (30 days in ms) */
   DATA_RETENTION_MS: 30 * 24 * 60 * 60 * 1e3,
   /** Default terminal output buffer size (number of messages) */
-  DEFAULT_TERMINAL_OUTPUT_BUFFER_SIZE: 100
+  DEFAULT_TERMINAL_OUTPUT_BUFFER_SIZE: 1e4
 };
 var AGENT_COMMANDS = {
   cursor: {
@@ -1149,8 +1153,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"),
@@ -1193,7 +1198,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(
@@ -1237,7 +1242,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(),
@@ -1370,6 +1375,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) {
@@ -2580,15 +2592,12 @@ var TerminalSession = class extends Session {
     return this._masterDeviceId;
   }
   /**
-   * Sets the master device ID. Only sets if not already set (first subscriber wins).
-   * @returns true if this device became master, false if master was already set
+   * Sets the master device ID. Always overrides the current master (new subscriber wins).
+   * @returns true (new subscriber always becomes master)
    */
   setMaster(deviceId) {
-    if (this._masterDeviceId === null) {
-      this._masterDeviceId = deviceId;
-      return true;
-    }
-    return this._masterDeviceId === deviceId;
+    this._masterDeviceId = deviceId;
+    return true;
   }
   /**
    * Checks if the given device is the master for this session.
@@ -2909,6 +2918,75 @@ var PtyManager = class {
   }
 };
 
+// src/infrastructure/terminal/terminal-output-batcher.ts
+var TerminalOutputBatcher = class {
+  buffer = "";
+  timeout = null;
+  lastActivityTime = Date.now();
+  outputRate = 0;
+  // Bytes/second estimate (exponential moving average)
+  batchIntervalMs;
+  maxBatchSize;
+  onFlush;
+  constructor(config2) {
+    this.batchIntervalMs = config2.batchIntervalMs;
+    this.maxBatchSize = config2.maxBatchSize;
+    this.onFlush = config2.onFlush;
+  }
+  /**
+   * Appends data to the batch buffer.
+   * Triggers flush based on size threshold or adaptive timeout.
+   */
+  append(chunk) {
+    this.buffer += chunk;
+    const now = Date.now();
+    const elapsed = Math.max(now - this.lastActivityTime, 1);
+    const instantRate = chunk.length / elapsed * 1e3;
+    this.outputRate = this.outputRate * 0.7 + instantRate * 0.3;
+    this.lastActivityTime = now;
+    if (this.buffer.length >= this.maxBatchSize) {
+      this.flush();
+      return;
+    }
+    if (this.timeout === null) {
+      const adaptiveInterval = this.outputRate > 1e3 ? this.batchIntervalMs : Math.min(8, this.batchIntervalMs);
+      this.timeout = setTimeout(() => this.flush(), adaptiveInterval);
+    }
+  }
+  /**
+   * Immediately flushes the buffer, invoking the onFlush callback.
+   */
+  flush() {
+    if (this.timeout !== null) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+    if (this.buffer.length > 0) {
+      const data = this.buffer;
+      this.buffer = "";
+      this.onFlush(data);
+    }
+  }
+  /**
+   * Disposes the batcher, flushing any pending data.
+   */
+  dispose() {
+    this.flush();
+  }
+  /**
+   * Returns current buffer size (for debugging/monitoring).
+   */
+  get pendingSize() {
+    return this.buffer.length;
+  }
+  /**
+   * Returns estimated output rate in bytes/second.
+   */
+  get currentOutputRate() {
+    return this.outputRate;
+  }
+};
+
 // src/infrastructure/agents/agent-session-manager.ts
 import { EventEmitter as EventEmitter2 } from "events";
 import { randomUUID as randomUUID2 } from "crypto";
@@ -4645,8 +4723,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") {
@@ -5084,7 +5162,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 {
   /**
@@ -5110,17 +5188,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();
@@ -5810,9 +5895,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);
@@ -5895,9 +6011,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");
@@ -6431,18 +6581,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"
           );
         }
@@ -6450,7 +6617,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.
@@ -8977,11 +9144,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 },
@@ -9169,6 +9344,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({
@@ -9261,11 +9459,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(
@@ -9290,119 +9487,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) => ({
@@ -9435,31 +9527,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.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",
@@ -9467,14 +9551,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);
@@ -9569,7 +9654,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()
@@ -9619,7 +9704,7 @@ async function bootstrap() {
             const transcriptionEvent = {
               type: "supervisor.transcription",
               payload: {
-                text: commandText,
+                transcription: commandText,
                 language: transcriptionResult.language,
                 duration: transcriptionResult.duration,
                 message_id: messageId,
@@ -9648,7 +9733,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(),
@@ -9922,45 +10007,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(
@@ -10089,7 +10158,7 @@ async function bootstrap() {
               type: "session.transcription",
               session_id: sessionId,
               payload: {
-                text: transcribedText,
+                transcription: transcribedText,
                 language: transcriptionResult.language,
                 duration: transcriptionResult.duration,
                 message_id: messageId,
@@ -10182,7 +10251,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()
@@ -10508,18 +10577,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,
@@ -10528,32 +10601,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.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,
@@ -10562,17 +10657,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(
@@ -10582,13 +10678,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"
           );
         }
@@ -10622,7 +10722,7 @@ async function bootstrap() {
               id: audioRequest.id,
               payload: {
                 message_id,
-                audio: audioBase64
+                audio_base64: audioBase64
               }
             })
           );
@@ -10780,6 +10880,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
@@ -10852,9 +10964,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,
@@ -10869,6 +10983,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) {
@@ -10918,7 +11035,7 @@ async function bootstrap() {
               session_id: sessionId,
               payload: {
                 text: textForTTS,
-                audio: audioBase64,
+                audio_base64: audioBase64,
                 audio_format: "mp3",
                 duration: ttsResult.duration,
                 message_id: pendingMessageId,
@@ -10944,7 +11061,6 @@ async function bootstrap() {
       }
     }
   );
-  let supervisorBlockAccumulator = [];
   supervisorAgent.on(
     "blocks",
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
@@ -10959,17 +11075,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,
@@ -10981,7 +11099,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(
@@ -11031,7 +11149,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,
@@ -11105,23 +11223,35 @@ async function bootstrap() {
       }
     };
     broadcaster.broadcastToAll(JSON.stringify(broadcastMessage));
+    const batcher = new TerminalOutputBatcher({
+      batchIntervalMs: env.TERMINAL_BATCH_INTERVAL_MS,
+      maxBatchSize: env.TERMINAL_BATCH_MAX_SIZE,
+      onFlush: (batchedData) => {
+        const outputMessage = session.addOutputToBuffer(batchedData);
+        const outputEvent = {
+          type: "session.output",
+          session_id: sessionId.value,
+          payload: {
+            content_type: "terminal",
+            content: batchedData,
+            timestamp: outputMessage.timestamp,
+            sequence: outputMessage.sequence
+          }
+        };
+        broadcaster.broadcastToSubscribers(
+          sessionId.value,
+          JSON.stringify(outputEvent)
+        );
+      }
+    });
     session.onOutput((data) => {
-      const outputMessage = session.addOutputToBuffer(data);
-      const outputEvent = {
-        type: "session.output",
-        session_id: sessionId.value,
-        payload: {
-          content_type: "terminal",
-          content: data,
-          timestamp: outputMessage.timestamp,
-          sequence: outputMessage.sequence
-        }
-      };
-      broadcaster.broadcastToSubscribers(
-        sessionId.value,
-        JSON.stringify(outputEvent)
-      );
+      batcher.append(data);
     });
+    const originalTerminate = session.terminate.bind(session);
+    session.terminate = async () => {
+      batcher.dispose();
+      return originalTerminate();
+    };
   });
   if (env.MOCK_MODE) {
     const terminalSession = await sessionManager.createSession({
@@ -11191,23 +11321,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);
     }
@@ -11324,6 +11483,14 @@ bootstrap().catch((error) => {
  * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
  * @license FSL-1.1-NC
  */
+/**
+ * @file terminal-output-batcher.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ *
+ * Batches terminal output chunks to reduce message frequency and improve performance.
+ * Uses adaptive batching based on output rate for optimal responsiveness.
+ */
 /**
  * @file headless-agent-executor.ts
  * @copyright 2025 Roman Barinov <rbarinov@gmail.com>

package/package.json

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