@tiflis-io/tiflis-code-workstation 0.3.4 → 0.3.6

package/dist/main.js

@@ -5,7 +5,7 @@ import {
 } from "./chunk-JSN52PLR.js";
 
 // src/main.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 
 // src/app.ts
 import Fastify from "fastify";
@@ -129,7 +129,14 @@ var EnvSchema = z.object({
   /** Terminal output buffer size (number of messages, in-memory only, does not survive restarts) */
   TERMINAL_OUTPUT_BUFFER_SIZE: z.coerce.number().default(100),
   // Legacy (fallback for STT/TTS if specific keys not set)
-  OPENAI_API_KEY: z.string().optional()
+  OPENAI_API_KEY: z.string().optional(),
+  // ─────────────────────────────────────────────────────────────
+  // Mock Mode Configuration (for screenshot automation)
+  // ─────────────────────────────────────────────────────────────
+  /** Enable mock mode for screenshot automation tests */
+  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()
 });
 function parseAgentAliases() {
   const aliases = /* @__PURE__ */ new Map();
@@ -433,14 +440,21 @@ function getAgentConfig(agentName) {
 }
 function getWorkstationVersion() {
   try {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const packageJsonPath = join2(__dirname, "../../package.json");
-    const packageJsonContent = readFileSync(packageJsonPath, "utf-8");
-    const packageJson = JSON.parse(packageJsonContent);
-    const version = packageJson.version;
-    if (typeof version === "string" && version.length > 0) {
-      return version;
+    const __filename2 = fileURLToPath(import.meta.url);
+    const __dirname2 = dirname(__filename2);
+    const possiblePaths = [
+      join2(__dirname2, "../package.json"),
+      join2(__dirname2, "../../package.json")
+    ];
+    for (const packageJsonPath of possiblePaths) {
+      try {
+        const packageJsonContent = readFileSync(packageJsonPath, "utf-8");
+        const packageJson = JSON.parse(packageJsonContent);
+        if (packageJson.name === "@tiflis-io/tiflis-code-workstation" && typeof packageJson.version === "string" && packageJson.version.length > 0) {
+          return packageJson.version;
+        }
+      } catch {
+      }
     }
     return "0.0.0";
   } catch {
@@ -1124,8 +1138,21 @@ var HeartbeatSchema = z2.object({
 var SyncMessageSchema = z2.object({
   type: z2.literal("sync"),
   id: z2.string(),
-  device_id: z2.string().optional()
+  device_id: z2.string().optional(),
+  // Injected by tunnel for tunnel connections
+  lightweight: z2.boolean().optional()
+  // If true, excludes message histories (for watchOS)
+});
+var HistoryRequestPayloadSchema = z2.object({
+  session_id: z2.string().optional()
+  // If omitted, returns supervisor history
+});
+var HistoryRequestSchema = z2.object({
+  type: z2.literal("history.request"),
+  id: z2.string(),
+  device_id: z2.string().optional(),
   // Injected by tunnel for tunnel connections
+  payload: HistoryRequestPayloadSchema.optional()
 });
 var ListSessionsSchema = z2.object({
   type: z2.literal("supervisor.list_sessions"),
@@ -1282,6 +1309,7 @@ var IncomingClientMessageSchema = z2.discriminatedUnion("type", [
   PingSchema,
   HeartbeatSchema,
   SyncMessageSchema,
+  HistoryRequestSchema,
   ListSessionsSchema,
   CreateSessionSchema,
   TerminateSessionSchema,
@@ -2181,6 +2209,186 @@ var FileSystemWorkspaceDiscovery = class {
       worktrees: []
     };
   }
+  /**
+   * Gets current branch and uncommitted changes status for a project.
+   */
+  async getBranchStatus(workspace, project) {
+    const projectPath = join4(this.workspacesRoot, workspace, project);
+    if (!await this.isGitRepository(projectPath)) {
+      throw new Error(`Project "${project}" is not a git repository`);
+    }
+    try {
+      const currentBranch = execSync("git rev-parse --abbrev-ref HEAD", {
+        cwd: projectPath,
+        encoding: "utf-8"
+      }).trim();
+      const statusOutput = execSync("git status --porcelain", {
+        cwd: projectPath,
+        encoding: "utf-8"
+      });
+      const uncommittedChanges = statusOutput.trim().split("\n").filter((line) => line.length > 0);
+      let aheadCommits = 0;
+      const mainBranches = ["main", "master"];
+      for (const mainBranch of mainBranches) {
+        try {
+          aheadCommits = parseInt(execSync(`git rev-list --count ${mainBranch}..${currentBranch}`, {
+            cwd: projectPath,
+            encoding: "utf-8"
+          }).trim(), 10);
+          break;
+        } catch {
+          continue;
+        }
+      }
+      return {
+        currentBranch,
+        uncommittedChanges,
+        aheadCommits,
+        isClean: uncommittedChanges.length === 0
+      };
+    } catch {
+      throw new Error("Failed to get branch status");
+    }
+  }
+  /**
+   * Merges source branch into target branch with safety checks.
+   */
+  async mergeBranch(workspace, project, sourceBranch, targetBranch = "main", options = {}) {
+    const projectPath = join4(this.workspacesRoot, workspace, project);
+    if (!await this.isGitRepository(projectPath)) {
+      throw new Error(`Project "${project}" is not a git repository`);
+    }
+    try {
+      if (!options.skipPreCheck) {
+        const status = await this.getBranchStatus(workspace, project);
+        if (!status.isClean) {
+          return {
+            success: false,
+            message: `Cannot merge: uncommitted changes exist in ${status.currentBranch}`
+          };
+        }
+      }
+      execSync(`git checkout "${targetBranch}"`, { cwd: projectPath });
+      try {
+        execSync(`git pull origin "${targetBranch}"`, { cwd: projectPath });
+      } catch {
+        console.warn(`Failed to pull ${targetBranch} from remote, continuing with local merge`);
+      }
+      try {
+        execSync(`git merge "${sourceBranch}"`, { cwd: projectPath });
+      } catch (error) {
+        const conflicts = execSync("git diff --name-only --diff-filter=U", {
+          cwd: projectPath,
+          encoding: "utf-8"
+        }).trim().split("\n").filter((f) => f.length > 0);
+        return {
+          success: false,
+          message: `Merge conflicts in files: ${conflicts.join(", ")}`,
+          conflicts
+        };
+      }
+      if (options.pushAfter) {
+        try {
+          execSync(`git push origin "${targetBranch}"`, { cwd: projectPath });
+        } catch {
+          console.warn(`Failed to push ${targetBranch} to remote`);
+        }
+      }
+      return {
+        success: true,
+        message: `Successfully merged "${sourceBranch}" into "${targetBranch}"`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Merge failed: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Checks if branch is merged into target branch.
+   */
+  async isBranchMerged(workspace, project, branch, targetBranch) {
+    const projectPath = join4(this.workspacesRoot, workspace, project);
+    if (!await this.isGitRepository(projectPath)) {
+      return false;
+    }
+    try {
+      const mergeBase = execSync(`git merge-base "${targetBranch}" "${branch}"`, {
+        cwd: projectPath,
+        encoding: "utf-8"
+      }).trim();
+      const branchHead = execSync(`git rev-parse "${branch}"`, {
+        cwd: projectPath,
+        encoding: "utf-8"
+      }).trim();
+      return mergeBase === branchHead;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Cleans up worktree and safely deletes the branch if merged.
+   */
+  async cleanupWorktreeAndBranch(workspace, project, branch) {
+    const projectPath = join4(this.workspacesRoot, workspace, project);
+    try {
+      let branchDeleted = false;
+      await this.removeWorktree(workspace, project, branch);
+      const mainBranches = ["main", "master"];
+      for (const mainBranch of mainBranches) {
+        try {
+          const isMerged = await this.isBranchMerged(workspace, project, branch, mainBranch);
+          if (isMerged) {
+            execSync(`git branch -d "${branch}"`, { cwd: projectPath });
+            branchDeleted = true;
+            break;
+          }
+        } catch {
+          continue;
+        }
+      }
+      return {
+        success: true,
+        message: `Cleaned up worktree for "${branch}"${branchDeleted ? " and deleted merged branch" : ""}`,
+        branchDeleted
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Cleanup failed: ${error instanceof Error ? error.message : String(error)}`,
+        branchDeleted: false
+      };
+    }
+  }
+  /**
+   * Lists mergeable branches with their status.
+   */
+  async listMergeableBranches(workspace, project) {
+    const worktrees = await this.listWorktrees(workspace, project);
+    const mergeableBranches = [];
+    for (const worktree of worktrees) {
+      if (worktree.branch === "main" || worktree.branch === "master") continue;
+      try {
+        const [isMerged, hasChanges, aheadCommits] = await Promise.all([
+          this.isBranchMerged(workspace, project, worktree.branch, "main"),
+          this.getBranchStatus(workspace, project).then((status) => !status.isClean),
+          this.getBranchStatus(workspace, project).then((status) => status.aheadCommits)
+        ]);
+        mergeableBranches.push({
+          branch: worktree.branch,
+          path: worktree.path,
+          isMerged: await this.isBranchMerged(workspace, project, worktree.branch, "main"),
+          hasUncommittedChanges: hasChanges,
+          canCleanup: isMerged && !hasChanges,
+          aheadCommits
+        });
+      } catch {
+        continue;
+      }
+    }
+    return mergeableBranches;
+  }
 };
 
 // src/infrastructure/terminal/pty-manager.ts
@@ -3593,6 +3801,87 @@ var AgentSessionManager = class extends EventEmitter2 {
       this.terminateSession(id);
     }
   }
+  /**
+   * Terminates sessions that are running in a specific worktree.
+   * Returns the list of terminated session IDs.
+   */
+  terminateWorktreeSessions(workspace, project, branch) {
+    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}`);
+      if (isInWorktree) {
+        try {
+          if (state.isExecuting) {
+            this.cancelCommand(sessionId);
+          }
+          this.terminateSession(sessionId);
+          terminatedSessions.push(sessionId);
+          this.logger.info({ sessionId, workspace, project, branch }, "Terminated worktree session");
+        } catch (error) {
+          this.logger.error({ sessionId, error }, "Failed to terminate worktree session");
+        }
+      }
+    }
+    return terminatedSessions;
+  }
+  /**
+   * Gets session summary for a specific worktree.
+   */
+  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}`)
+    );
+    const sessionTypes = [...new Set(activeSessions.map((s) => s.agentType))];
+    const executingCount = activeSessions.filter((s) => s.isExecuting).length;
+    return {
+      activeSessions,
+      sessionCount: activeSessions.length,
+      sessionTypes,
+      executingCount
+    };
+  }
+  /**
+   * Lists all sessions with their worktree information.
+   */
+  listSessionsWithWorktreeInfo() {
+    return Array.from(this.sessions.values()).map((session) => {
+      const worktreeInfo = this.parseWorktreeInfo(session.workingDir);
+      return {
+        sessionId: session.sessionId,
+        agentType: session.agentType,
+        agentName: session.agentName,
+        workingDir: session.workingDir,
+        isExecuting: session.isExecuting,
+        worktreeInfo
+      };
+    });
+  }
+  /**
+   * Parse worktree information from a working directory path.
+   */
+  parseWorktreeInfo(workingDir) {
+    const parts = workingDir.split("/");
+    if (parts.length < 3) {
+      return { isWorktree: false };
+    }
+    const workspacesIndex = parts.findIndex((part) => part === "workspaces" || part.includes("workspace"));
+    if (workspacesIndex === -1 || workspacesIndex + 2 >= parts.length) {
+      return { isWorktree: false };
+    }
+    const workspace = parts[workspacesIndex + 1];
+    const projectPart = parts[workspacesIndex + 2];
+    if (!projectPart) {
+      return { isWorktree: false };
+    }
+    if (projectPart.includes("--")) {
+      const [project, branch] = projectPart.split("--");
+      return { workspace, project, branch, isWorktree: true };
+    } else {
+      return { workspace, project: projectPart, isWorktree: false };
+    }
+  }
   /**
    * Setup event handlers for an executor.
    */
@@ -4279,7 +4568,14 @@ var SubscriptionService = class {
     }
     const isNew = client.subscribe(session);
     if (isNew) {
-      this.deps.subscriptionRepository.subscribe(deviceId, sessionId);
+      try {
+        this.deps.subscriptionRepository.subscribe(deviceId, sessionId);
+      } catch (error) {
+        this.logger.debug(
+          { deviceId, sessionId, error },
+          "Failed to persist subscription (may be expected in mock mode)"
+        );
+      }
     }
     let isMaster = false;
     let cols;
@@ -5400,6 +5696,274 @@ var ChatHistoryService = class _ChatHistoryService {
     );
     return agentSessions;
   }
+  // ============================================================================
+  // Mock Data Seeding (for Screenshot Automation)
+  // ============================================================================
+  /**
+   * Seeds mock chat history for screenshot automation.
+   * Creates realistic conversation history with voice messages, code blocks, etc.
+   *
+   * @param agentSessions - Object with agent session IDs and their working directories
+   */
+  seedMockData(agentSessions) {
+    this.logger.info("Seeding mock chat history for screenshots...");
+    this.seedSupervisorHistory();
+    if (agentSessions.claude) {
+      this.ensureAgentSession(agentSessions.claude.id, "claude", agentSessions.claude.workingDir);
+      this.seedClaudeAgentHistory(agentSessions.claude.id);
+    }
+    if (agentSessions.cursor) {
+      this.ensureAgentSession(agentSessions.cursor.id, "cursor", agentSessions.cursor.workingDir);
+      this.seedCursorAgentHistory(agentSessions.cursor.id);
+    }
+    if (agentSessions.opencode) {
+      this.ensureAgentSession(agentSessions.opencode.id, "opencode", agentSessions.opencode.workingDir);
+      this.seedOpenCodeAgentHistory(agentSessions.opencode.id);
+    }
+    this.logger.info("Mock chat history seeded successfully");
+  }
+  /**
+   * Ensures an agent session exists in the database.
+   * Creates it if it doesn't exist.
+   */
+  ensureAgentSession(sessionId, sessionType, workingDir) {
+    try {
+      const existing = this.sessionRepo.getById(sessionId);
+      if (!existing) {
+        this.sessionRepo.create({
+          id: sessionId,
+          type: sessionType,
+          workingDir
+        });
+        this.logger.debug({ sessionId, sessionType }, "Created agent session in database for seeding");
+      }
+    } catch {
+    }
+  }
+  /**
+   * Seeds Supervisor chat with a realistic voice conversation.
+   */
+  seedSupervisorHistory() {
+    this.ensureSupervisorSession();
+    const sessionId = _ChatHistoryService.SUPERVISOR_SESSION_ID;
+    this.messageRepo.deleteBySession(sessionId);
+    const voiceInput1 = {
+      id: "vi-1",
+      block_type: "voice_input",
+      content: "Show me the available workspaces",
+      metadata: { duration: 2.1, has_audio: true }
+    };
+    this.messageRepo.create({
+      sessionId,
+      role: "user",
+      contentType: "transcription",
+      content: "Show me the available workspaces",
+      contentBlocks: JSON.stringify([voiceInput1]),
+      isComplete: true
+    });
+    const textBlock1 = {
+      id: "tb-1",
+      block_type: "text",
+      content: "I found 2 workspaces with several projects. The **work** workspace contains my-app and api-service. The **personal** workspace has your blog project. Would you like to start an agent session in any of these?"
+    };
+    const voiceOutput1 = {
+      id: "vo-1",
+      block_type: "voice_output",
+      content: "I found 2 workspaces with several projects.",
+      metadata: { duration: 4.2, has_audio: true }
+    };
+    this.messageRepo.create({
+      sessionId,
+      role: "assistant",
+      contentType: "text",
+      content: "I found 2 workspaces with several projects. The work workspace contains my-app and api-service. The personal workspace has your blog project. Would you like to start an agent session in any of these?",
+      contentBlocks: JSON.stringify([textBlock1, voiceOutput1]),
+      isComplete: true
+    });
+    const voiceInput2 = {
+      id: "vi-2",
+      block_type: "voice_input",
+      content: "Start Claude on my-app",
+      metadata: { duration: 1.8, has_audio: true }
+    };
+    this.messageRepo.create({
+      sessionId,
+      role: "user",
+      contentType: "transcription",
+      content: "Start Claude on my-app",
+      contentBlocks: JSON.stringify([voiceInput2]),
+      isComplete: true
+    });
+    const textBlock2 = {
+      id: "tb-2",
+      block_type: "text",
+      content: "I've started a new Claude Code session in **work/my-app**. You can find it in the sidebar under Agent Sessions. The session is ready for your commands!"
+    };
+    const voiceOutput2 = {
+      id: "vo-2",
+      block_type: "voice_output",
+      content: "I've started a new Claude Code session in work/my-app.",
+      metadata: { duration: 3.5, has_audio: true }
+    };
+    this.messageRepo.create({
+      sessionId,
+      role: "assistant",
+      contentType: "text",
+      content: "I've started a new Claude Code session in work/my-app. You can find it in the sidebar under Agent Sessions. The session is ready for your commands!",
+      contentBlocks: JSON.stringify([textBlock2, voiceOutput2]),
+      isComplete: true
+    });
+    this.logger.debug("Seeded Supervisor history with voice conversation");
+  }
+  /**
+   * Seeds Claude agent chat with code examples and tool use.
+   */
+  seedClaudeAgentHistory(sessionId) {
+    this.messageRepo.deleteBySession(sessionId);
+    const userVoiceBlock = {
+      id: "vi-claude-1",
+      block_type: "voice_input",
+      content: "Add a health check endpoint to the API",
+      metadata: {
+        duration: 2.3,
+        has_audio: true
+      }
+    };
+    this.messageRepo.create({
+      sessionId,
+      role: "user",
+      contentType: "audio",
+      content: "Add a health check endpoint to the API",
+      contentBlocks: JSON.stringify([userVoiceBlock]),
+      isComplete: true
+    });
+    const thinkingBlock = {
+      id: "think-1",
+      block_type: "thinking",
+      content: "I'll add a simple health check endpoint that returns the server status and version information."
+    };
+    const toolBlock = {
+      id: "tool-1",
+      block_type: "tool",
+      content: "Edit",
+      metadata: {
+        tool_name: "Edit",
+        tool_status: "completed",
+        tool_input: JSON.stringify({ file: "src/routes/health.ts" })
+      }
+    };
+    const codeBlock = {
+      id: "code-1",
+      block_type: "code",
+      content: `import { Router } from 'express';
+
+const router = Router();
+
+router.get('/health', (req, res) => {
+  res.json({
+    status: 'healthy',
+    version: process.env.npm_package_version,
+    uptime: process.uptime()
+  });
+});
+
+export default router;`,
+      metadata: { language: "typescript" }
+    };
+    const textBlock = {
+      id: "text-1",
+      block_type: "text",
+      content: "I've added a health check endpoint at `/health` that returns the server status, version, and uptime. You can test it with `curl http://localhost:3000/health`."
+    };
+    this.messageRepo.create({
+      sessionId,
+      role: "assistant",
+      contentType: "text",
+      content: "I've added a health check endpoint at /health that returns the server status, version, and uptime.",
+      contentBlocks: JSON.stringify([thinkingBlock, toolBlock, codeBlock, textBlock]),
+      isComplete: true
+    });
+    this.logger.debug({ sessionId }, "Seeded Claude agent history with code example");
+  }
+  /**
+   * Seeds Cursor agent chat.
+   */
+  seedCursorAgentHistory(sessionId) {
+    this.messageRepo.deleteBySession(sessionId);
+    this.messageRepo.create({
+      sessionId,
+      role: "user",
+      contentType: "text",
+      content: "Explain the project structure",
+      isComplete: true
+    });
+    const textBlock = {
+      id: "text-cursor-1",
+      block_type: "text",
+      content: `This is a **Next.js portfolio site** with the following structure:
+
+- \`/app\` - App router pages and layouts
+- \`/components\` - Reusable React components
+- \`/lib\` - Utility functions and helpers
+- \`/public\` - Static assets (images, fonts)
+- \`/styles\` - Global CSS and Tailwind config
+
+The site uses **Tailwind CSS** for styling and **Framer Motion** for animations. Would you like me to explain any specific part in more detail?`
+    };
+    this.messageRepo.create({
+      sessionId,
+      role: "assistant",
+      contentType: "text",
+      content: "This is a Next.js portfolio site with app router, components, lib, public, and styles directories.",
+      contentBlocks: JSON.stringify([textBlock]),
+      isComplete: true
+    });
+    this.logger.debug({ sessionId }, "Seeded Cursor agent history");
+  }
+  /**
+   * Seeds OpenCode agent chat.
+   */
+  seedOpenCodeAgentHistory(sessionId) {
+    this.messageRepo.deleteBySession(sessionId);
+    this.messageRepo.create({
+      sessionId,
+      role: "user",
+      contentType: "text",
+      content: "Run the tests",
+      isComplete: true
+    });
+    const statusBlock = {
+      id: "status-1",
+      block_type: "status",
+      content: "Running tests..."
+    };
+    const codeBlock = {
+      id: "code-oc-1",
+      block_type: "code",
+      content: `\u2713 auth.test.ts (3 tests) 120ms
+\u2713 api.test.ts (8 tests) 340ms
+\u2713 utils.test.ts (5 tests) 45ms
+
+Test Files  3 passed (3)
+     Tests  16 passed (16)
+      Time  0.51s`,
+      metadata: { language: "shell" }
+    };
+    const textBlock = {
+      id: "text-oc-1",
+      block_type: "text",
+      content: "All 16 tests passed across 3 test files. The test suite completed in 0.51 seconds."
+    };
+    this.messageRepo.create({
+      sessionId,
+      role: "assistant",
+      contentType: "text",
+      content: "All 16 tests passed across 3 test files.",
+      contentBlocks: JSON.stringify([statusBlock, codeBlock, textBlock]),
+      isComplete: true
+    });
+    this.logger.debug({ sessionId }, "Seeded OpenCode agent history");
+  }
 };
 
 // src/infrastructure/persistence/in-memory-session-manager.ts
@@ -5457,6 +6021,21 @@ var InMemorySessionManager = class extends EventEmitter3 {
    * Sets up event listeners to sync agent session state.
    */
   setupAgentSessionSync() {
+    this.agentSessionManager.on("sessionCreated", (state) => {
+      if (!this.sessions.has(state.sessionId)) {
+        const session = new AgentSession({
+          id: new SessionId(state.sessionId),
+          type: state.agentType,
+          agentName: state.agentName,
+          workingDir: state.workingDir
+        });
+        this.sessions.set(state.sessionId, session);
+        this.logger.debug(
+          { sessionId: state.sessionId, agentType: state.agentType },
+          "Agent session registered from external creation"
+        );
+      }
+    });
     this.agentSessionManager.on("sessionTerminated", (sessionId) => {
       const session = this.sessions.get(sessionId);
       if (session && isAgentType(session.type)) {
@@ -5763,7 +6342,7 @@ Path: ${project.path}`;
 // src/infrastructure/agents/supervisor/tools/worktree-tools.ts
 import { tool as tool2 } from "@langchain/core/tools";
 import { z as z4 } from "zod";
-function createWorktreeTools(workspaceDiscovery) {
+function createWorktreeTools(workspaceDiscovery, _agentSessionManager) {
   const listWorktrees = tool2(
     async ({ workspace, project }) => {
       try {
@@ -5843,8 +6422,224 @@ ${worktrees.map((w) => `- ${w.name}: ${w.branch} (${w.path})`).join("\n")}`;
       })
     }
   );
-  return [listWorktrees, createWorktree, removeWorktree];
-}
+  const branchStatus = tool2(
+    async ({ workspace, project }) => {
+      try {
+        const status = await workspaceDiscovery.getBranchStatus(workspace, project);
+        return {
+          currentBranch: status.currentBranch,
+          uncommittedChanges: status.uncommittedChanges,
+          aheadCommits: status.aheadCommits,
+          isClean: status.isClean,
+          summary: status.isClean ? `Branch "${status.currentBranch}" is clean with ${status.aheadCommits} commits ahead of main` : `Branch "${status.currentBranch}" has ${status.uncommittedChanges.length} uncommitted changes:
+${status.uncommittedChanges.map((c) => `  ${c}`).join("\n")}`
+        };
+      } catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) };
+      }
+    },
+    {
+      name: "branch_status",
+      description: "Get current branch status including uncommitted changes and commit count ahead of main",
+      schema: z4.object({
+        workspace: z4.string().describe("Workspace name containing the project"),
+        project: z4.string().describe("Project name to get branch status for")
+      })
+    }
+  );
+  const mergeBranch = tool2(
+    async ({ workspace, project, sourceBranch, targetBranch, pushAfter, skipPreCheck }) => {
+      try {
+        const result = await workspaceDiscovery.mergeBranch(
+          workspace,
+          project,
+          sourceBranch,
+          targetBranch ?? "main",
+          { pushAfter, skipPreCheck }
+        );
+        return result;
+      } catch (error) {
+        return {
+          success: false,
+          message: `Merge operation failed: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    },
+    {
+      name: "merge_branch",
+      description: "Merge source branch into target branch with safety checks and optional push to remote",
+      schema: z4.object({
+        workspace: z4.string().describe("Workspace name"),
+        project: z4.string().describe("Project name"),
+        sourceBranch: z4.string().describe("Source branch to merge from"),
+        targetBranch: z4.string().optional().describe("Target branch (defaults to main)"),
+        pushAfter: z4.boolean().optional().describe("Push to remote after successful merge"),
+        skipPreCheck: z4.boolean().optional().describe("Skip pre-merge safety checks (not recommended)")
+      })
+    }
+  );
+  const listMergeableBranches = tool2(
+    async ({ workspace, project }) => {
+      try {
+        const branches = await workspaceDiscovery.listMergeableBranches(workspace, project);
+        if (branches.length === 0) {
+          return "No feature branches found.";
+        }
+        const statusLines = branches.map((b) => {
+          const status = [
+            `Branch: ${b.branch}`,
+            `Path: ${b.path}`,
+            `Merged: ${b.isMerged ? "\u2713" : "\u2717"}`,
+            `Clean: ${b.hasUncommittedChanges ? "\u2717 (has changes)" : "\u2713"}`,
+            `Cleanup ready: ${b.canCleanup ? "\u2713" : "\u2717"}`,
+            `Ahead commits: ${b.aheadCommits}`
+          ].join(" | ");
+          return `- ${status}`;
+        });
+        const summary = `Found ${branches.length} branches. ${branches.filter((b) => b.canCleanup).length} are ready for cleanup.`;
+        return `${summary}
+
+${statusLines.join("\n")}`;
+      } catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) };
+      }
+    },
+    {
+      name: "list_mergeable_branches",
+      description: "List all feature branches and their merge/cleanup status",
+      schema: z4.object({
+        workspace: z4.string().describe("Workspace name"),
+        project: z4.string().describe("Project name")
+      })
+    }
+  );
+  const cleanupWorktree = tool2(
+    async ({ workspace, project, branch, force }) => {
+      try {
+        if (!force) {
+          const status = await workspaceDiscovery.getBranchStatus(workspace, project);
+          if (!status.isClean && status.currentBranch === branch) {
+            return {
+              success: false,
+              message: `Cannot cleanup: uncommitted changes exist in "${branch}". Use force=true to override.`,
+              uncommittedChanges: status.uncommittedChanges
+            };
+          }
+        }
+        const result = await workspaceDiscovery.cleanupWorktreeAndBranch(
+          workspace,
+          project,
+          branch
+        );
+        return result;
+      } catch (error) {
+        return {
+          success: false,
+          message: `Cleanup failed: ${error instanceof Error ? error.message : String(error)}`,
+          branchDeleted: false
+        };
+      }
+    },
+    {
+      name: "cleanup_worktree",
+      description: "Remove worktree and optionally delete the branch if merged",
+      schema: z4.object({
+        workspace: z4.string().describe("Workspace name"),
+        project: z4.string().describe("Project name"),
+        branch: z4.string().describe("Branch/worktree name to cleanup"),
+        force: z4.boolean().optional().describe("Force cleanup even with uncommitted changes")
+      })
+    }
+  );
+  const completeFeature = tool2(
+    async ({ workspace, project, featureBranch, targetBranch, skipConfirmation }) => {
+      try {
+        const results = [];
+        const status = await workspaceDiscovery.getBranchStatus(workspace, project);
+        results.push({
+          step: "status_check",
+          data: {
+            currentBranch: status.currentBranch,
+            isClean: status.isClean,
+            uncommittedChanges: status.uncommittedChanges,
+            aheadCommits: status.aheadCommits
+          }
+        });
+        if (!status.isClean && status.currentBranch === featureBranch && !skipConfirmation) {
+          return {
+            success: false,
+            message: `Cannot complete feature: uncommitted changes exist in "${featureBranch}". Commit or stash changes first.`,
+            results
+          };
+        }
+        const mergeResult = await workspaceDiscovery.mergeBranch(
+          workspace,
+          project,
+          featureBranch,
+          targetBranch ?? "main",
+          { pushAfter: true }
+        );
+        results.push({
+          step: "merge",
+          data: mergeResult
+        });
+        if (!mergeResult.success) {
+          return {
+            success: false,
+            message: `Merge failed: ${mergeResult.message}`,
+            results
+          };
+        }
+        const cleanupResult = await workspaceDiscovery.cleanupWorktreeAndBranch(
+          workspace,
+          project,
+          featureBranch
+        );
+        results.push({
+          step: "cleanup",
+          data: cleanupResult
+        });
+        return {
+          success: true,
+          message: `\u2705 Feature "${featureBranch}" completed successfully!
+
+Steps executed:
+1. \u2705 Branch validated
+2. \u2705 Merged into ${targetBranch ?? "main"} and pushed
+3. \u2705 Worktree cleaned up${cleanupResult.branchDeleted ? " and branch deleted" : ""}`,
+          results
+        };
+      } catch (error) {
+        return {
+          success: false,
+          message: `Feature completion failed: ${error instanceof Error ? error.message : String(error)}`,
+          results: []
+        };
+      }
+    },
+    {
+      name: "complete_feature",
+      description: "Complete workflow: merge feature branch into main and cleanup worktree/branch",
+      schema: z4.object({
+        workspace: z4.string().describe("Workspace name"),
+        project: z4.string().describe("Project name"),
+        featureBranch: z4.string().describe("Feature branch name to complete"),
+        targetBranch: z4.string().optional().describe("Target branch (defaults to main)"),
+        skipConfirmation: z4.boolean().optional().describe("Skip safety checks (not recommended)")
+      })
+    }
+  );
+  return [
+    listWorktrees,
+    createWorktree,
+    removeWorktree,
+    branchStatus,
+    mergeBranch,
+    listMergeableBranches,
+    cleanupWorktree,
+    completeFeature
+  ];
+}
 
 // src/infrastructure/agents/supervisor/tools/session-tools.ts
 import { tool as tool3 } from "@langchain/core/tools";
@@ -6134,7 +6929,96 @@ Messages: ${agentState.messages.length}`;
       })
     }
   );
-  return [listSessions, listAvailableAgents, createAgentSession, createTerminalSession, terminateSession, terminateAllSessions, getSessionInfo];
+  const listSessionsWithWorktrees = tool3(
+    () => {
+      try {
+        const sessions2 = agentSessionManager.listSessionsWithWorktreeInfo();
+        if (sessions2.length === 0) {
+          return "No active sessions.";
+        }
+        const sessionLines = sessions2.map((s) => {
+          const worktreeInfo = s.worktreeInfo ? s.worktreeInfo.isWorktree ? ` (worktree: ${s.worktreeInfo.workspace}/${s.worktreeInfo.project}--${s.worktreeInfo.branch})` : ` (main: ${s.worktreeInfo.workspace}/${s.worktreeInfo.project})` : "";
+          const executing = s.isExecuting ? " [executing]" : "";
+          return `- [${s.agentType}] ${s.sessionId}${executing}${worktreeInfo}
+  Working dir: ${s.workingDir}`;
+        });
+        return `Active sessions:
+${sessionLines.join("\n")}`;
+      } catch (error) {
+        return `Error listing sessions: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    {
+      name: "list_sessions_with_worktrees",
+      description: "Lists all active sessions with worktree information for branch management",
+      schema: z5.object({})
+    }
+  );
+  const getWorktreeSessionSummary = tool3(
+    ({ workspace, project, branch }) => {
+      try {
+        const summary = agentSessionManager.getWorktreeSessionSummary(workspace, project, branch);
+        if (summary.sessionCount === 0) {
+          return `No active sessions in worktree "${workspace}/${project}--${branch}".`;
+        }
+        const sessionDetails = summary.activeSessions.map(
+          (s) => `- [${s.agentType}] ${s.sessionId} (${s.isExecuting ? "executing" : "idle"})
+  Created: ${new Date(s.createdAt).toISOString()}`
+        ).join("\n");
+        return `Worktree "${workspace}/${project}--${branch}" has ${summary.sessionCount} active session(s):
+${sessionDetails}
+
+Session types: ${summary.sessionTypes.join(", ")}
+Executing: ${summary.executingCount}`;
+      } catch (error) {
+        return `Error getting worktree session summary: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    {
+      name: "get_worktree_session_summary",
+      description: "Gets detailed session information for a specific worktree",
+      schema: z5.object({
+        workspace: z5.string().describe("Workspace name"),
+        project: z5.string().describe("Project name"),
+        branch: z5.string().describe("Branch/worktree name")
+      })
+    }
+  );
+  const terminateWorktreeSessions = tool3(
+    ({ workspace, project, branch }) => {
+      try {
+        const terminatedSessions = agentSessionManager.terminateWorktreeSessions(workspace, project, branch);
+        if (terminatedSessions.length === 0) {
+          return `No active sessions to terminate in worktree "${workspace}/${project}--${branch}".`;
+        }
+        return `Terminated ${terminatedSessions.length} session(s) in worktree "${workspace}/${project}--${branch}":
+${terminatedSessions.map((id) => `  - ${id}`).join("\n")}`;
+      } catch (error) {
+        return `Error terminating worktree sessions: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    {
+      name: "terminate_worktree_sessions",
+      description: "Terminates all active sessions in a specific worktree",
+      schema: z5.object({
+        workspace: z5.string().describe("Workspace name"),
+        project: z5.string().describe("Project name"),
+        branch: z5.string().describe("Branch/worktree name")
+      })
+    }
+  );
+  return [
+    listSessions,
+    listAvailableAgents,
+    createAgentSession,
+    createTerminalSession,
+    terminateSession,
+    terminateAllSessions,
+    getSessionInfo,
+    listSessionsWithWorktrees,
+    getWorktreeSessionSummary,
+    terminateWorktreeSessions
+  ];
 }
 
 // src/infrastructure/agents/supervisor/tools/filesystem-tools.ts
@@ -6266,7 +7150,7 @@ var SupervisorAgent = class extends EventEmitter4 {
     const llm = this.createLLM(env);
     const tools = [
       ...createWorkspaceTools(config2.workspaceDiscovery),
-      ...createWorktreeTools(config2.workspaceDiscovery),
+      ...createWorktreeTools(config2.workspaceDiscovery, config2.agentSessionManager),
       ...createSessionTools(
         config2.sessionManager,
         config2.agentSessionManager,
@@ -6518,142 +7402,682 @@ var SupervisorAgent = class extends EventEmitter4 {
     return this.isProcessingCommand || this.isExecuting;
   }
   /**
-   * Ends command processing (called after completion or error, not after cancel).
+   * Ends command processing (called after completion or error, not after cancel).
+   */
+  endProcessing() {
+    this.isProcessingCommand = false;
+    this.logger.debug("Ended command processing");
+  }
+  /**
+   * Clears global conversation history.
+   * Also resets cancellation state to allow new commands.
+   */
+  clearHistory() {
+    this.conversationHistory = [];
+    this.isCancelled = false;
+    this.logger.info("Global conversation history cleared");
+  }
+  /**
+   * Resets the cancellation state.
+   * Call this before starting a new command to ensure previous cancellation doesn't affect it.
+   */
+  resetCancellationState() {
+    this.isCancelled = false;
+  }
+  /**
+   * Restores global conversation history from persistent storage.
+   * Called on startup to sync in-memory cache with database.
+   */
+  restoreHistory(history) {
+    if (history.length === 0) return;
+    this.conversationHistory = history.slice(-20);
+    this.logger.debug({ messageCount: this.conversationHistory.length }, "Global conversation history restored");
+  }
+  /**
+   * Builds the system message for the agent.
+   */
+  buildSystemMessage() {
+    const systemPrompt = `You are the Supervisor Agent for Tiflis Code, a workstation management system.
+
+Your role is to help users:
+1. **Discover workspaces and projects** - List available workspaces and projects
+2. **Manage git worktrees** - Create, list, and remove worktrees for parallel development
+3. **Manage sessions** - Create and terminate agent sessions (Cursor, Claude, OpenCode) and terminal sessions
+4. **Navigate the file system** - List directories and read files
+5. **Complete feature workflows** - Merge branches, clean up worktrees, and manage related sessions
+
+## CRITICAL: Always Use Tools - Never Be Lazy
+
+**YOU MUST ALWAYS call tools to execute user requests. NEVER be lazy or skip actions based on memory or previous context.**
+
+### Mandatory Tool Usage Rules:
+
+1. **ALWAYS call tools for fresh data** - When user asks about workspaces, projects, sessions, or any system state:
+   - ALWAYS call the appropriate tool (list_workspaces, list_projects, list_sessions, etc.)
+   - NEVER respond from memory or previous conversation context
+   - System state changes constantly - what was true before may not be true now
+
+2. **ALWAYS execute requested actions** - When user asks to create, terminate, or modify something:
+   - ALWAYS call the tool to perform the action, even if you think it was done before
+   - If user asks to create a session and one already exists, CREATE ANOTHER ONE (user knows what they want)
+   - If user asks to list projects, LIST THEM NOW with a tool call (don't say "I already showed you")
+   - NEVER refuse a direct request because "it was already done" or "nothing changed"
+
+3. **User intent is paramount** - When user explicitly requests an action:
+   - Execute it immediately without questioning or suggesting alternatives
+   - Don't assume user made a mistake - they know what they need
+   - Multiple sessions in the same project is a valid use case
+   - Refreshing information is always valid
+
+4. **No shortcuts** - You must:
+   - Call list_workspaces/list_projects EVERY time user asks what workspaces/projects exist
+   - Call list_sessions EVERY time user asks about active sessions
+   - Call create_agent_session/create_terminal_session EVERY time user asks to create a session
+   - Never say "based on our previous conversation" or "as I mentioned earlier" for factual data
+
+## Feature Completion & Merge Workflows
+
+When users ask to "complete the feature", "finish the work", "merge and clean up", or similar requests:
+
+### Safety Checks First:
+1. **Check branch status** with \`branch_status\` - Look for uncommitted changes
+2. **List active sessions** with \`get_worktree_session_summary\` - Find sessions in the worktree
+3. **Ask for confirmation** if there are uncommitted changes or active sessions
+
+### Complete Workflow with \`complete_feature\`:
+- Merges feature branch into main with automatic push
+- Cleans up the worktree and removes the branch if merged
+- One-command solution for feature completion
+
+### Step-by-Step Alternative:
+1. **Handle uncommitted changes**: Commit, stash, or get user confirmation
+2. **Terminate sessions**: Use \`terminate_worktree_sessions\` to clean up active sessions
+3. **Merge branch**: Use \`merge_branch\` with pushAfter=true
+4. **Cleanup worktree**: Use \`cleanup_worktree\` to remove worktree directory
+
+### Available Merge Tools:
+- **branch_status** - Check current branch state and uncommitted changes
+- **merge_branch** - Safe merge with conflict detection and push
+- **complete_feature** - Full workflow (merge + cleanup + push)
+- **cleanup_worktree** - Remove worktree and delete merged branch
+- **list_mergeable_branches** - Show all branches and their cleanup eligibility
+- **get_worktree_session_summary** - List sessions in a specific worktree
+- **terminate_worktree_sessions** - End all sessions in a worktree
+
+### Error Handling:
+- **Merge conflicts**: Report conflicting files and suggest manual resolution
+- **Uncommitted changes**: Offer to commit, stash, or force cleanup
+- **Active sessions**: List sessions and ask for termination confirmation
+- **Failed pushes**: Continue with local merge, warn about remote sync
+
+## Guidelines:
+- Be concise and helpful
+- Use tools to gather information before responding
+- When creating sessions, always confirm the workspace and project first
+- For ambiguous requests, ask clarifying questions
+- Format responses for terminal display (avoid markdown links)
+- ALWAYS prioritize safety - check before deleting/merging
+
+## Session Types:
+- **cursor** - Cursor AI agent for code assistance
+- **claude** - Claude Code CLI for AI coding
+- **opencode** - OpenCode AI agent
+- **terminal** - Shell terminal for direct commands
+
+## Creating Agent Sessions:
+When creating agent sessions, by default use the main project directory (main or master branch) unless the user explicitly requests a specific worktree or branch:
+- **Default behavior**: Omit the \`worktree\` parameter to create session on the main/master branch (project root directory)
+- **Specific worktree**: Only specify \`worktree\` when the user explicitly asks for a feature branch worktree (NOT the main branch)
+- **IMPORTANT**: When \`list_worktrees\` shows a worktree named "main" with \`isMain: true\`, this represents the project root directory. Do NOT pass \`worktree: "main"\` - instead, omit the worktree parameter entirely to use the project root.
+
+## Worktree Management:
+Worktrees allow working on multiple branches simultaneously in separate directories.
+- **Branch naming**: Use conventional format \`<type>/<name>\` where \`<name>\` is lower-kebab-case. Types: \`feature\`, \`fix\`, \`refactor\`, \`docs\`, \`chore\`. Examples: \`feature/user-auth\`, \`fix/keyboard-layout\`, \`refactor/websocket-handler\`
+- **Directory pattern**: \`project--branch-name\` (slashes replaced with dashes, e.g., \`my-app--feature-user-auth\`)
+- **Creating worktrees**: Use \`create_worktree\` tool with:
+  - \`createNewBranch: true\` \u2014 Creates a NEW branch and worktree (most common for new features)
+  - \`createNewBranch: false\` \u2014 Checks out an EXISTING branch into a worktree
+  - \`baseBranch\` \u2014 Optional starting point for new branches (defaults to HEAD, commonly "main")`;
+    return [new HumanMessage(`[System Instructions]
+${systemPrompt}
+[End Instructions]`)];
+  }
+  /**
+   * Builds messages from conversation history.
+   */
+  buildHistoryMessages(history) {
+    return history.map(
+      (entry) => entry.role === "user" ? new HumanMessage(entry.content) : new AIMessage(entry.content)
+    );
+  }
+  /**
+   * Gets global conversation history.
+   */
+  getConversationHistory() {
+    return this.conversationHistory;
+  }
+  /**
+   * Adds an entry to global conversation history.
+   */
+  addToHistory(role, content) {
+    this.conversationHistory.push({ role, content });
+    if (this.conversationHistory.length > 20) {
+      this.conversationHistory.splice(0, this.conversationHistory.length - 20);
+    }
+  }
+};
+
+// src/infrastructure/mock/mock-supervisor-agent.ts
+import { EventEmitter as EventEmitter5 } from "events";
+
+// src/infrastructure/mock/fixture-loader.ts
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { join as join7, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename = fileURLToPath2(import.meta.url);
+var __dirname = dirname2(__filename);
+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 fixturesDir = customPath ?? DEFAULT_FIXTURES_PATH;
+  const filePath = join7(fixturesDir, `${name}.json`);
+  if (!existsSync3(filePath)) {
+    console.warn(`[MockMode] Fixture not found: ${filePath}`);
+    return null;
+  }
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    const fixture = JSON.parse(content);
+    fixtureCache.set(cacheKey, fixture);
+    return fixture;
+  } catch (error) {
+    console.error(`[MockMode] Failed to load fixture ${filePath}:`, error);
+    return null;
+  }
+}
+function findMatchingResponse(fixture, input) {
+  const normalizedInput = input.toLowerCase().trim();
+  for (const scenario of Object.values(fixture.scenarios)) {
+    for (const trigger of scenario.triggers) {
+      if (normalizedInput.includes(trigger.toLowerCase())) {
+        return scenario.response;
+      }
+    }
+  }
+  return fixture.default_response;
+}
+
+// src/infrastructure/mock/streaming-simulator.ts
+var DEFAULT_TOKEN_DELAY_MS = 30;
+async function simulateStreaming(text2, delayMs = DEFAULT_TOKEN_DELAY_MS, onBlock, onComplete) {
+  const tokens = tokenize(text2);
+  let accumulated = "";
+  for (let i = 0; i < tokens.length; i++) {
+    accumulated += tokens[i];
+    const block = {
+      type: "text",
+      text: accumulated
+    };
+    onBlock([block], false);
+    if (i < tokens.length - 1) {
+      await sleep(delayMs);
+    }
+  }
+  const finalBlock = {
+    type: "text",
+    text: accumulated
+  };
+  onBlock([finalBlock], true);
+  onComplete();
+}
+function tokenize(text2) {
+  const tokens = [];
+  let current = "";
+  for (const char of text2) {
+    if (char === " ") {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      tokens.push(" ");
+    } else if (/[.,!?;:\n]/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      tokens.push(char);
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/infrastructure/mock/mock-supervisor-agent.ts
+var MockSupervisorAgent = class extends EventEmitter5 {
+  logger;
+  fixturesPath;
+  fixture;
+  conversationHistory = [];
+  isExecuting = false;
+  isProcessingCommand = false;
+  isCancelled = false;
+  abortController = null;
+  constructor(config2) {
+    super();
+    this.logger = config2.logger.child({ component: "MockSupervisorAgent" });
+    this.fixturesPath = config2.fixturesPath;
+    this.fixture = loadFixture("supervisor", this.fixturesPath);
+    if (this.fixture) {
+      this.logger.info(
+        { scenarios: Object.keys(this.fixture.scenarios).length },
+        "Mock Supervisor Agent initialized with fixtures"
+      );
+    } else {
+      this.logger.warn(
+        "Mock Supervisor Agent initialized without fixtures - will return default responses"
+      );
+    }
+  }
+  /**
+   * Executes a command (non-streaming).
+   */
+  async execute(command, deviceId, _currentSessionId) {
+    this.logger.info({ command, deviceId }, "Mock supervisor execute");
+    const response = this.getResponse(command);
+    this.conversationHistory.push({ role: "user", content: command });
+    this.conversationHistory.push({ role: "assistant", content: response.text });
+    return {
+      output: response.text
+    };
+  }
+  /**
+   * Executes a command with simulated streaming.
+   */
+  async executeWithStream(command, deviceId) {
+    this.logger.info({ command, deviceId }, "Mock supervisor executeWithStream");
+    this.abortController = new AbortController();
+    this.isExecuting = true;
+    this.isCancelled = false;
+    try {
+      const response = this.getResponse(command);
+      if (this.isExecuting && !this.isCancelled) {
+        const statusBlock = createStatusBlock("Processing...");
+        this.emit("blocks", deviceId, [statusBlock], false);
+      }
+      await this.sleep(100);
+      const allBlocks = [];
+      await simulateStreaming(
+        response.text,
+        response.delay_ms ?? 30,
+        (blocks, isComplete) => {
+          if (this.isExecuting && !this.isCancelled) {
+            this.emit("blocks", deviceId, blocks, false);
+            if (isComplete) {
+              allBlocks.push(...blocks);
+            }
+          }
+        },
+        () => {
+        }
+      );
+      if (this.isExecuting && !this.isCancelled) {
+        this.conversationHistory.push({ role: "user", content: command });
+        this.conversationHistory.push({
+          role: "assistant",
+          content: response.text
+        });
+        const completionBlock = createStatusBlock("Complete");
+        this.emit(
+          "blocks",
+          deviceId,
+          [completionBlock],
+          true,
+          response.text,
+          allBlocks
+        );
+      }
+    } catch (error) {
+      if (this.isCancelled) {
+        this.logger.info({ deviceId }, "Mock supervisor cancelled");
+        return;
+      }
+      this.logger.error({ error, command }, "Mock supervisor error");
+      const errorBlock = createTextBlock(
+        error instanceof Error ? error.message : "An error occurred"
+      );
+      this.emit("blocks", deviceId, [errorBlock], true);
+    } finally {
+      this.isExecuting = false;
+      this.abortController = null;
+    }
+  }
+  /**
+   * Gets the response for a command from fixtures.
+   */
+  getResponse(command) {
+    if (!this.fixture) {
+      return {
+        text: "I'm the Supervisor agent. I can help you manage workspaces, sessions, and more. What would you like to do?",
+        delay_ms: 30
+      };
+    }
+    return findMatchingResponse(this.fixture, command);
+  }
+  /**
+   * Cancels current execution.
+   */
+  cancel() {
+    if (!this.isProcessingCommand && !this.isExecuting) {
+      return false;
+    }
+    this.logger.info("Cancelling mock supervisor execution");
+    this.isCancelled = true;
+    this.isExecuting = false;
+    this.isProcessingCommand = false;
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+    return true;
+  }
+  /**
+   * Check if execution was cancelled.
+   */
+  wasCancelled() {
+    return this.isCancelled;
+  }
+  /**
+   * Starts command processing.
+   */
+  startProcessing() {
+    this.abortController = new AbortController();
+    this.isProcessingCommand = true;
+    this.isCancelled = false;
+    return this.abortController;
+  }
+  /**
+   * Checks if processing is active.
+   */
+  isProcessing() {
+    return this.isProcessingCommand || this.isExecuting;
+  }
+  /**
+   * Ends command processing.
+   */
+  endProcessing() {
+    this.isProcessingCommand = false;
+  }
+  /**
+   * Clears conversation history.
+   */
+  clearHistory() {
+    this.conversationHistory = [];
+    this.isCancelled = false;
+    this.logger.info("Mock conversation history cleared");
+  }
+  /**
+   * Resets cancellation state.
+   */
+  resetCancellationState() {
+    this.isCancelled = false;
+  }
+  /**
+   * Restores conversation history.
+   */
+  restoreHistory(history) {
+    this.conversationHistory = history.slice(-20);
+  }
+  /**
+   * Gets conversation history.
+   */
+  getConversationHistory() {
+    return [...this.conversationHistory];
+  }
+  /**
+   * Sleep utility.
+   */
+  sleep(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+};
+
+// src/infrastructure/mock/mock-agent-session-manager.ts
+import { EventEmitter as EventEmitter6 } from "events";
+import { randomUUID as randomUUID3 } from "crypto";
+var MockAgentSessionManager = class extends EventEmitter6 {
+  sessions = /* @__PURE__ */ new Map();
+  fixtures = /* @__PURE__ */ new Map();
+  logger;
+  fixturesPath;
+  constructor(config2) {
+    super();
+    this.logger = config2.logger.child({ component: "MockAgentSessionManager" });
+    this.fixturesPath = config2.fixturesPath;
+    this.loadAgentFixtures();
+    this.logger.info("Mock Agent Session Manager initialized");
+  }
+  /**
+   * Pre-load fixtures for all agent types.
+   */
+  loadAgentFixtures() {
+    const agentTypes = ["cursor", "claude", "opencode"];
+    for (const agentType of agentTypes) {
+      const fixture = loadFixture(agentType, this.fixturesPath);
+      this.fixtures.set(agentType, fixture);
+      if (fixture) {
+        this.logger.debug(
+          { agentType, scenarios: Object.keys(fixture.scenarios).length },
+          "Loaded fixture for agent type"
+        );
+      }
+    }
+  }
+  /**
+   * Create a new mock agent session.
+   */
+  createSession(agentType, workingDir, sessionId, agentName) {
+    const id = sessionId ?? `agent-${randomUUID3()}`;
+    const resolvedAgentName = agentName ?? agentType;
+    const state = {
+      sessionId: id,
+      agentType,
+      agentName: resolvedAgentName,
+      workingDir,
+      cliSessionId: `mock-cli-${randomUUID3().slice(0, 8)}`,
+      isExecuting: false,
+      isCancelled: false,
+      messages: [],
+      createdAt: Date.now(),
+      lastActivityAt: Date.now()
+    };
+    this.sessions.set(id, state);
+    this.logger.info(
+      { sessionId: id, agentType, agentName: resolvedAgentName, workingDir },
+      "Mock agent session created"
+    );
+    this.emit("sessionCreated", state);
+    this.emit("cliSessionIdDiscovered", id, state.cliSessionId);
+    return state;
+  }
+  /**
+   * Execute a command in a mock agent session with simulated streaming.
+   */
+  async executeCommand(sessionId, prompt) {
+    const state = this.sessions.get(sessionId);
+    if (!state) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    if (state.isExecuting) {
+      this.cancelCommand(sessionId);
+    }
+    state.isExecuting = true;
+    state.isCancelled = false;
+    state.lastActivityAt = Date.now();
+    const userMessage = {
+      id: randomUUID3(),
+      timestamp: Date.now(),
+      role: "user",
+      blocks: [createTextBlock(prompt)]
+    };
+    state.messages.push(userMessage);
+    try {
+      const fixture = this.fixtures.get(state.agentType);
+      const response = fixture ? findMatchingResponse(fixture, prompt) : this.getDefaultResponse(state.agentType);
+      await this.sleep(150);
+      const allBlocks = [];
+      await simulateStreaming(
+        response.text,
+        response.delay_ms ?? 30,
+        (blocks, _isComplete) => {
+          if (state.isExecuting && !state.isCancelled) {
+            this.emit("blocks", sessionId, blocks, false);
+          }
+        },
+        () => {
+        }
+      );
+      if (state.isExecuting && !state.isCancelled) {
+        const assistantMessage = {
+          id: randomUUID3(),
+          timestamp: Date.now(),
+          role: "assistant",
+          blocks: [createTextBlock(response.text)]
+        };
+        state.messages.push(assistantMessage);
+        allBlocks.push(createTextBlock(response.text));
+        const completionBlocks = [createStatusBlock("Command completed")];
+        const completionMsg = {
+          id: randomUUID3(),
+          timestamp: Date.now(),
+          role: "system",
+          blocks: completionBlocks
+        };
+        state.messages.push(completionMsg);
+        this.emit("blocks", sessionId, completionBlocks, true);
+      }
+    } catch (error) {
+      if (!state.isCancelled) {
+        this.logger.error({ sessionId, error }, "Mock command execution error");
+        const errorBlocks = [
+          createTextBlock(
+            error instanceof Error ? error.message : "An error occurred"
+          )
+        ];
+        this.emit("blocks", sessionId, errorBlocks, true);
+      }
+    } finally {
+      state.isExecuting = false;
+      state.lastActivityAt = Date.now();
+    }
+  }
+  /**
+   * Get default response when no fixture is available.
+   */
+  getDefaultResponse(agentType) {
+    const responses = {
+      claude: "I'm Claude, an AI assistant. I can help you with coding tasks, answer questions, and assist with various development workflows. What would you like me to help you with?",
+      cursor: "I'm Cursor AI, ready to help you write and edit code. I can assist with code completion, refactoring, and explaining complex code. What can I help you with today?",
+      opencode: "I'm OpenCode, an open-source AI coding assistant. I can help with code generation, debugging, and documentation. How can I assist you?"
+    };
+    return {
+      text: responses[agentType],
+      delay_ms: 30
+    };
+  }
+  /**
+   * Cancel current command execution.
+   */
+  cancelCommand(sessionId) {
+    const state = this.sessions.get(sessionId);
+    if (!state?.isExecuting) {
+      return;
+    }
+    this.logger.info({ sessionId }, "Cancelling mock command execution");
+    state.isExecuting = false;
+    state.isCancelled = true;
+    state.lastActivityAt = Date.now();
+  }
+  /**
+   * Clear chat history for a session.
+   */
+  clearHistory(sessionId) {
+    const state = this.sessions.get(sessionId);
+    if (!state) {
+      return;
+    }
+    state.messages = [];
+    this.logger.info({ sessionId }, "Mock session history cleared");
+  }
+  /**
+   * Terminate an agent session.
    */
-  endProcessing() {
-    this.isProcessingCommand = false;
-    this.logger.debug("Ended command processing");
+  terminateSession(sessionId) {
+    this.sessions.delete(sessionId);
+    this.logger.info({ sessionId }, "Mock agent session terminated");
+    this.emit("sessionTerminated", sessionId);
   }
   /**
-   * Clears global conversation history.
-   * Also resets cancellation state to allow new commands.
+   * Get session state.
    */
-  clearHistory() {
-    this.conversationHistory = [];
-    this.isCancelled = false;
-    this.logger.info("Global conversation history cleared");
+  getSession(sessionId) {
+    return this.sessions.get(sessionId);
   }
   /**
-   * Resets the cancellation state.
-   * Call this before starting a new command to ensure previous cancellation doesn't affect it.
+   * List all active sessions.
    */
-  resetCancellationState() {
-    this.isCancelled = false;
+  listSessions() {
+    return Array.from(this.sessions.values());
   }
   /**
-   * Restores global conversation history from persistent storage.
-   * Called on startup to sync in-memory cache with database.
+   * Get chat history for a session.
    */
-  restoreHistory(history) {
-    if (history.length === 0) return;
-    this.conversationHistory = history.slice(-20);
-    this.logger.debug({ messageCount: this.conversationHistory.length }, "Global conversation history restored");
+  getMessages(sessionId) {
+    return this.sessions.get(sessionId)?.messages ?? [];
   }
   /**
-   * Builds the system message for the agent.
+   * Check if a session is executing.
    */
-  buildSystemMessage() {
-    const systemPrompt = `You are the Supervisor Agent for Tiflis Code, a workstation management system.
-
-Your role is to help users:
-1. **Discover workspaces and projects** - List available workspaces and projects
-2. **Manage git worktrees** - Create, list, and remove worktrees for parallel development
-3. **Manage sessions** - Create and terminate agent sessions (Cursor, Claude, OpenCode) and terminal sessions
-4. **Navigate the file system** - List directories and read files
-
-## CRITICAL: Always Use Tools - Never Be Lazy
-
-**YOU MUST ALWAYS call tools to execute user requests. NEVER be lazy or skip actions based on memory or previous context.**
-
-### Mandatory Tool Usage Rules:
-
-1. **ALWAYS call tools for fresh data** - When user asks about workspaces, projects, sessions, or any system state:
-   - ALWAYS call the appropriate tool (list_workspaces, list_projects, list_sessions, etc.)
-   - NEVER respond from memory or previous conversation context
-   - System state changes constantly - what was true before may not be true now
-
-2. **ALWAYS execute requested actions** - When user asks to create, terminate, or modify something:
-   - ALWAYS call the tool to perform the action, even if you think it was done before
-   - If user asks to create a session and one already exists, CREATE ANOTHER ONE (user knows what they want)
-   - If user asks to list projects, LIST THEM NOW with a tool call (don't say "I already showed you")
-   - NEVER refuse a direct request because "it was already done" or "nothing changed"
-
-3. **User intent is paramount** - When user explicitly requests an action:
-   - Execute it immediately without questioning or suggesting alternatives
-   - Don't assume user made a mistake - they know what they need
-   - Multiple sessions in the same project is a valid use case
-   - Refreshing information is always valid
-
-4. **No shortcuts** - You must:
-   - Call list_workspaces/list_projects EVERY time user asks what workspaces/projects exist
-   - Call list_sessions EVERY time user asks about active sessions
-   - Call create_agent_session/create_terminal_session EVERY time user asks to create a session
-   - Never say "based on our previous conversation" or "as I mentioned earlier" for factual data
-
-## Guidelines:
-- Be concise and helpful
-- Use tools to gather information before responding
-- When creating sessions, always confirm the workspace and project first
-- For ambiguous requests, ask clarifying questions
-- Format responses for terminal display (avoid markdown links)
-
-## Session Types:
-- **cursor** - Cursor AI agent for code assistance
-- **claude** - Claude Code CLI for AI coding
-- **opencode** - OpenCode AI agent
-- **terminal** - Shell terminal for direct commands
-
-## Creating Agent Sessions:
-When creating agent sessions, by default use the main project directory (main or master branch) unless the user explicitly requests a specific worktree or branch:
-- **Default behavior**: Omit the \`worktree\` parameter to create session on the main/master branch (project root directory)
-- **Specific worktree**: Only specify \`worktree\` when the user explicitly asks for a feature branch worktree (NOT the main branch)
-- **IMPORTANT**: When \`list_worktrees\` shows a worktree named "main" with \`isMain: true\`, this represents the project root directory. Do NOT pass \`worktree: "main"\` - instead, omit the worktree parameter entirely to use the project root.
-- **Example**: If user says "start claude on tiflis-code", create session WITHOUT worktree parameter (uses project root on main branch)
-- **Example**: If user says "start claude on tiflis-code feature/auth branch", list worktrees, find the feature worktree name (e.g., "feature-auth"), and pass that as worktree
-
-## Worktree Management:
-Worktrees allow working on multiple branches simultaneously in separate directories.
-- **Branch naming**: Use conventional format \`<type>/<name>\` where \`<name>\` is lower-kebab-case. Types: \`feature\`, \`fix\`, \`refactor\`, \`docs\`, \`chore\`. Examples: \`feature/user-auth\`, \`fix/keyboard-layout\`, \`refactor/websocket-handler\`
-- **Directory pattern**: \`project--branch-name\` (slashes replaced with dashes, e.g., \`my-app--feature-user-auth\`)
-- **Creating worktrees**: Use \`create_worktree\` tool with:
-  - \`createNewBranch: true\` \u2014 Creates a NEW branch and worktree (most common for new features)
-  - \`createNewBranch: false\` \u2014 Checks out an EXISTING branch into a worktree
-  - \`baseBranch\` \u2014 Optional starting point for new branches (defaults to HEAD, commonly "main")
-- **Example**: To start work on a new feature, create worktree with \`createNewBranch: true\`, \`branch: "feature/new-keyboard"\`, \`baseBranch: "main"\``;
-    return [new HumanMessage(`[System Instructions]
-${systemPrompt}
-[End Instructions]`)];
+  isExecuting(sessionId) {
+    return this.sessions.get(sessionId)?.isExecuting ?? false;
   }
   /**
-   * Builds messages from conversation history.
+   * Check if a session was cancelled.
    */
-  buildHistoryMessages(history) {
-    return history.map(
-      (entry) => entry.role === "user" ? new HumanMessage(entry.content) : new AIMessage(entry.content)
-    );
+  wasCancelled(sessionId) {
+    return this.sessions.get(sessionId)?.isCancelled ?? false;
   }
   /**
-   * Gets global conversation history.
+   * Cleanup all sessions.
    */
-  getConversationHistory() {
-    return this.conversationHistory;
+  cleanup() {
+    const sessionIds = Array.from(this.sessions.keys());
+    for (const id of sessionIds) {
+      this.terminateSession(id);
+    }
   }
   /**
-   * Adds an entry to global conversation history.
+   * Sleep utility.
    */
-  addToHistory(role, content) {
-    this.conversationHistory.push({ role, content });
-    if (this.conversationHistory.length > 20) {
-      this.conversationHistory.splice(0, this.conversationHistory.length - 20);
-    }
+  sleep(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
 };
 
 // src/infrastructure/speech/stt-service.ts
 import { writeFile as writeFile2, unlink as unlink2 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { tmpdir } from "os";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 var STTService = class {
   config;
   logger;
@@ -6694,7 +8118,7 @@ var STTService = class {
   async transcribeOpenAI(audioBuffer, format, signal) {
     const baseUrl = this.config.baseUrl ?? "https://api.openai.com/v1";
     const endpoint = `${baseUrl}/audio/transcriptions`;
-    const tempPath = join7(tmpdir(), `stt-${randomUUID3()}.${format}`);
+    const tempPath = join8(tmpdir(), `stt-${randomUUID4()}.${format}`);
     try {
       if (signal?.aborted) {
         throw new Error("Transcription cancelled");
@@ -6742,7 +8166,7 @@ var STTService = class {
   async transcribeElevenLabs(audioBuffer, format, signal) {
     const baseUrl = this.config.baseUrl ?? "https://api.elevenlabs.io/v1";
     const endpoint = `${baseUrl}/speech-to-text`;
-    const tempPath = join7(tmpdir(), `stt-${randomUUID3()}.${format}`);
+    const tempPath = join8(tmpdir(), `stt-${randomUUID4()}.${format}`);
     try {
       if (signal?.aborted) {
         throw new Error("Transcription cancelled");
@@ -7255,13 +8679,60 @@ async function bootstrap() {
     workspacesRoot: env.WORKSPACES_ROOT
   });
   const ptyManager = new PtyManager({ logger });
-  const agentSessionManager = new AgentSessionManager(logger);
+  const agentSessionManager = env.MOCK_MODE ? new MockAgentSessionManager({ logger, fixturesPath: env.MOCK_FIXTURES_PATH }) : new AgentSessionManager(logger);
+  if (env.MOCK_MODE) {
+    logger.info(
+      { fixturesPath: env.MOCK_FIXTURES_PATH ?? "built-in" },
+      "Mock mode enabled - using mock agent session manager"
+    );
+  }
   const sessionManager = new InMemorySessionManager({
     ptyManager,
     agentSessionManager,
     workspacesRoot: env.WORKSPACES_ROOT,
     logger
   });
+  if (env.MOCK_MODE) {
+    const mockAgentManager = agentSessionManager;
+    await sessionManager.createSession({
+      sessionType: "supervisor",
+      workingDir: env.WORKSPACES_ROOT
+    });
+    logger.info("Pre-created supervisor session for screenshots");
+    mockAgentManager.createSession(
+      "claude",
+      `${env.WORKSPACES_ROOT}/work/my-app`,
+      "claude-my-app",
+      "claude"
+    );
+    mockAgentManager.createSession(
+      "cursor",
+      `${env.WORKSPACES_ROOT}/personal/blog`,
+      "cursor-blog",
+      "cursor"
+    );
+    mockAgentManager.createSession(
+      "opencode",
+      `${env.WORKSPACES_ROOT}/work/api-service`,
+      "opencode-api",
+      "opencode"
+    );
+    logger.info("Pre-created 3 mock agent sessions for screenshots");
+    chatHistoryService.seedMockData({
+      claude: {
+        id: "claude-my-app",
+        workingDir: `${env.WORKSPACES_ROOT}/work/my-app`
+      },
+      cursor: {
+        id: "cursor-blog",
+        workingDir: `${env.WORKSPACES_ROOT}/personal/blog`
+      },
+      opencode: {
+        id: "opencode-api",
+        workingDir: `${env.WORKSPACES_ROOT}/work/api-service`
+      }
+    });
+  }
   const sttService = createSTTService(env, logger);
   if (sttService) {
     logger.info(
@@ -7295,7 +8766,10 @@ async function bootstrap() {
   const cancelledDuringTranscription = /* @__PURE__ */ new Set();
   const expectedAuthKey = new AuthKey(env.WORKSTATION_AUTH_KEY);
   let messageBroadcaster = null;
-  const supervisorAgent = new SupervisorAgent({
+  const supervisorAgent = env.MOCK_MODE ? new MockSupervisorAgent({
+    logger,
+    fixturesPath: env.MOCK_FIXTURES_PATH
+  }) : new SupervisorAgent({
     sessionManager,
     agentSessionManager,
     workspaceDiscovery,
@@ -7304,7 +8778,11 @@ async function bootstrap() {
     getMessageBroadcaster: () => messageBroadcaster,
     getChatHistoryService: () => chatHistoryService
   });
-  logger.info("Supervisor Agent initialized with LangGraph");
+  if (env.MOCK_MODE) {
+    logger.info("Mock Supervisor Agent initialized for screenshot automation");
+  } else {
+    logger.info("Supervisor Agent initialized with LangGraph");
+  }
   const authenticateClient = new AuthenticateClientUseCase({
     clientRegistry,
     expectedAuthKey,
@@ -7377,10 +8855,11 @@ 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 },
+        { persistedAgentSessions, inMemoryCount: inMemorySessions.length, isLightweight },
         "Sync: fetched sessions"
       );
       const inMemorySessionIds = new Set(
@@ -7405,6 +8884,67 @@ 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) => ({
@@ -7775,7 +9315,7 @@ async function bootstrap() {
         logger.info({ wasCancelled }, "supervisorAgent.cancel() returned");
         if (messageBroadcaster) {
           const cancelBlock = {
-            id: randomUUID4(),
+            id: randomUUID5(),
             block_type: "cancel",
             content: "Cancelled by user"
           };
@@ -8010,6 +9550,22 @@ async function bootstrap() {
             subscribeMessage.device_id,
             JSON.stringify(result)
           );
+          if (env.MOCK_MODE) {
+            const session = sessionManager.getSession(new SessionId(sessionId));
+            if (session?.type === "terminal") {
+              setTimeout(() => {
+                const clearAndBanner = `clear && printf '\\033[1;36m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\\033[0m\\n\\033[1;32m  Tiflis Code - Remote Development Workstation\\033[0m\\n\\033[1;36m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\\033[0m\\n\\n\\033[1;33m  System Information:\\033[0m\\n  \u251C\u2500 OS:       macOS Sequoia 15.1\\n  \u251C\u2500 Shell:    zsh 5.9\\n  \u251C\u2500 Node:     v22.11.0\\n  \u2514\u2500 Uptime:   2 days, 14 hours\\n\\n\\033[1;33m  Active Sessions:\\033[0m\\n  \u251C\u2500 Claude Code  \u2500  tiflis/tiflis-code\\n  \u251C\u2500 Cursor       \u2500  personal/portfolio\\n  \u2514\u2500 OpenCode     \u2500  tiflis/tiflis-api\\n\\n\\033[1;36m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\\033[0m\\n\\n'\r`;
+                ptyManager.write(
+                  session,
+                  clearAndBanner
+                );
+                logger.info(
+                  { sessionId },
+                  "Mock mode: Generated terminal banner on subscribe"
+                );
+              }, 100);
+            }
+          }
         }
       }
       return Promise.resolve();
@@ -8307,7 +9863,7 @@ async function bootstrap() {
         }
         if (messageBroadcaster) {
           const cancelBlock = {
-            id: randomUUID4(),
+            id: randomUUID5(),
             block_type: "cancel",
             content: "Cancelled by user"
           };
@@ -8511,6 +10067,107 @@ async function bootstrap() {
       }
       return Promise.resolve();
     },
+    "history.request": async (socket, message) => {
+      const historyRequest = message;
+      const sessionId = historyRequest.payload?.session_id;
+      const isSupervisor = !sessionId;
+      logger.debug(
+        { sessionId, isSupervisor, requestId: historyRequest.id },
+        "History request received"
+      );
+      try {
+        if (isSupervisor) {
+          const supervisorHistoryRaw = chatHistoryService.getSupervisorHistory();
+          const supervisorHistory = await Promise.all(
+            supervisorHistoryRaw.map(async (msg) => ({
+              message_id: msg.id,
+              // Include message ID for audio.request
+              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 history response
+              ),
+              createdAt: msg.createdAt.toISOString()
+            }))
+          );
+          const isExecuting = supervisorAgent.isProcessing();
+          socket.send(
+            JSON.stringify({
+              type: "history.response",
+              id: historyRequest.id,
+              payload: {
+                session_id: null,
+                // Indicates supervisor
+                history: supervisorHistory,
+                is_executing: isExecuting
+              }
+            })
+          );
+          logger.debug(
+            { messageCount: supervisorHistory.length, isExecuting },
+            "Supervisor history sent"
+          );
+        } else {
+          const history = chatHistoryService.getAgentHistory(sessionId);
+          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 history response
+              ),
+              createdAt: msg.createdAt.toISOString()
+            }))
+          );
+          const isExecuting = agentSessionManager.isExecuting(sessionId);
+          let currentStreamingBlocks;
+          if (isExecuting) {
+            const blocks = agentMessageAccumulator.get(sessionId);
+            if (blocks && blocks.length > 0) {
+              currentStreamingBlocks = blocks;
+            }
+          }
+          socket.send(
+            JSON.stringify({
+              type: "history.response",
+              id: historyRequest.id,
+              payload: {
+                session_id: sessionId,
+                history: enrichedHistory,
+                is_executing: isExecuting,
+                current_streaming_blocks: currentStreamingBlocks
+              }
+            })
+          );
+          logger.debug(
+            { sessionId, messageCount: enrichedHistory.length, isExecuting },
+            "Agent session history sent"
+          );
+        }
+      } catch (error) {
+        logger.error({ error, sessionId }, "Failed to get history");
+        socket.send(
+          JSON.stringify({
+            type: "history.response",
+            id: historyRequest.id,
+            payload: {
+              session_id: sessionId ?? null,
+              error: error instanceof Error ? error.message : "Failed to get history"
+            }
+          })
+        );
+      }
+    },
     "audio.request": async (socket, message) => {
       const audioRequest = message;
       const { message_id, type = "output" } = audioRequest.payload;
@@ -9016,6 +10673,40 @@ async function bootstrap() {
       );
     });
   });
+  if (env.MOCK_MODE) {
+    const terminalSession = await sessionManager.createSession({
+      sessionType: "terminal",
+      workingDir: env.WORKSPACES_ROOT,
+      terminalSize: { cols: 80, rows: 24 }
+    });
+    logger.info(
+      { sessionId: terminalSession.id.value },
+      "Pre-created terminal session for screenshots"
+    );
+    if (terminalSession.type === "terminal") {
+      setTimeout(() => {
+        try {
+          const command = `printf $'\\033[1;36m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\\033[0m\\n\\033[1;32m  Tiflis Code - Remote Development Workstation\\033[0m\\n\\033[1;36m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\\033[0m\\n\\n\\033[1;33m  System Information:\\033[0m\\n  \u251C\u2500 OS:       macOS Sequoia 15.1\\n  \u251C\u2500 Shell:    zsh 5.9\\n  \u251C\u2500 Node:     v22.11.0\\n  \u2514\u2500 Uptime:   2 days, 14 hours\\n\\n\\033[1;33m  Active Sessions:\\033[0m\\n  \u251C\u2500 Claude Code  \u2500  tiflis/tiflis-code\\n  \u251C\u2500 Cursor       \u2500  personal/portfolio\\n  \u2514\u2500 OpenCode     \u2500  tiflis/tiflis-api\\n\\n\\033[1;36m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\\033[0m\\n\\n'`;
+          ptyManager.write(terminalSession, command + "\r");
+          logger.info("Ran terminal commands for screenshots");
+          setTimeout(() => {
+            const ts = terminalSession;
+            const history = ts.getOutputHistory();
+            logger.info(
+              {
+                sessionId: ts.id.value,
+                bufferSize: history.length,
+                currentSequence: ts.currentSequence
+              },
+              "Terminal output buffer status after command"
+            );
+          }, 500);
+        } catch (error) {
+          logger.warn({ error }, "Failed to run terminal commands");
+        }
+      }, 100);
+    }
+  }
   const app = createApp({ env, logger });
   registerHealthRoute(
     app,
@@ -9328,6 +11019,36 @@ bootstrap().catch((error) => {
  *
  * LangGraph-based Supervisor Agent for managing workstation resources.
  */
+/**
+ * @file fixture-loader.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ *
+ * Loads and parses JSON fixture files for mock mode.
+ */
+/**
+ * @file streaming-simulator.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ *
+ * Simulates realistic streaming output for mock responses.
+ */
+/**
+ * @file mock-supervisor-agent.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ *
+ * Mock Supervisor Agent for screenshot automation tests.
+ * Returns fixture-based responses with simulated streaming.
+ */
+/**
+ * @file mock-agent-session-manager.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ *
+ * Mock Agent Session Manager for screenshot automation tests.
+ * Simulates agent sessions with fixture-based responses and streaming.
+ */
 /**
  * @file stt-service.ts
  * @copyright 2025 Roman Barinov <rbarinov@gmail.com>