@tiflis-io/tiflis-code-workstation 0.3.29 → 0.3.31

package/dist/main.js

@@ -5,7 +5,7 @@ import {
 } from "./chunk-JSN52PLR.js";
 
 // src/main.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 
 // src/app.ts
 import Fastify from "fastify";
@@ -274,6 +274,8 @@ var SESSION_CONFIG = {
   MAX_AGENT_SESSIONS: 10,
   /** Maximum number of concurrent terminal sessions */
   MAX_TERMINAL_SESSIONS: 5,
+  /** Maximum number of concurrent backlog sessions */
+  MAX_BACKLOG_SESSIONS: 10,
   /** Default terminal columns */
   DEFAULT_TERMINAL_COLS: 80,
   /** Default terminal rows */
@@ -1116,6 +1118,67 @@ var SubscriptionRepository = class {
   }
 };
 
+// src/infrastructure/persistence/repositories/session-repository.ts
+import { eq as eq3 } from "drizzle-orm";
+var SessionRepository = class {
+  /**
+   * Creates a new session record or updates if exists.
+   */
+  create(params) {
+    const db2 = getDatabase();
+    const newSession = {
+      id: params.id,
+      type: params.type,
+      workspace: params.workspace,
+      project: params.project,
+      worktree: params.worktree,
+      workingDir: params.workingDir,
+      status: "active",
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    db2.insert(sessions).values(newSession).onConflictDoUpdate({
+      target: sessions.id,
+      set: {
+        status: "active",
+        terminatedAt: null
+      }
+    }).run();
+    return { ...newSession, terminatedAt: null, createdAt: newSession.createdAt };
+  }
+  /**
+   * Gets a session by ID.
+   */
+  getById(sessionId) {
+    const db2 = getDatabase();
+    return db2.select().from(sessions).where(eq3(sessions.id, sessionId)).get();
+  }
+  /**
+   * Gets all active sessions.
+   */
+  getActive() {
+    const db2 = getDatabase();
+    return db2.select().from(sessions).where(eq3(sessions.status, "active")).all();
+  }
+  /**
+   * Marks a session as terminated.
+   */
+  terminate(sessionId) {
+    const db2 = getDatabase();
+    db2.update(sessions).set({
+      status: "terminated",
+      terminatedAt: /* @__PURE__ */ new Date()
+    }).where(eq3(sessions.id, sessionId)).run();
+  }
+  /**
+   * Deletes old terminated sessions (for cleanup).
+   */
+  deleteOldTerminated(_olderThan) {
+    const db2 = getDatabase();
+    const result = db2.delete(sessions).where(eq3(sessions.status, "terminated")).run();
+    return result.changes;
+  }
+};
+
 // src/infrastructure/websocket/tunnel-client.ts
 import WebSocket from "ws";
 
@@ -1171,7 +1234,7 @@ var ListSessionsSchema = z2.object({
   // Injected by tunnel for tunnel connections
 });
 var CreateSessionPayloadSchema = z2.object({
-  session_type: z2.enum(["cursor", "claude", "opencode", "terminal"]),
+  session_type: z2.enum(["cursor", "claude", "opencode", "terminal", "backlog-agent"]),
   agent_name: z2.string().optional(),
   // Custom alias name (e.g., 'zai' for claude with custom config)
   workspace: z2.string().min(1, "Workspace is required"),
@@ -1398,7 +1461,7 @@ function getMessageType(data) {
 }
 
 // src/infrastructure/websocket/tunnel-client.ts
-var TunnelClient = class {
+var TunnelClient = class _TunnelClient {
   config;
   callbacks;
   logger;
@@ -1412,6 +1475,8 @@ var TunnelClient = class {
   reconnectTimeout = null;
   registrationTimeout = null;
   messageBuffer = [];
+  static MAX_SEND_RETRIES = 3;
+  static SEND_RETRY_DELAY_MS = 100;
   constructor(config2, callbacks) {
     this.config = config2;
     this.callbacks = callbacks;
@@ -1514,8 +1579,9 @@ var TunnelClient = class {
     this.messageBuffer = [];
   }
   /**
-   * Sends a message to the tunnel (for forwarding to clients).
-   * Detects send failures and triggers reconnection.
+   * Sends a message to the tunnel (for forwarding to clients) with retry logic (FIX #3).
+   * Buffers during reconnection, retries on transient failures with exponential backoff.
+   * Returns true if send was successful or queued for retry.
    */
   send(message) {
     if (this.state !== "registered" || !this.ws) {
@@ -1528,18 +1594,55 @@ var TunnelClient = class {
     if (this.ws.readyState !== WebSocket.OPEN) {
       this.logger.warn(
         { readyState: this.ws.readyState },
-        "Socket not open, triggering reconnection"
+        "Socket not open, buffering message and triggering reconnection"
       );
+      this.messageBuffer.push(message);
       this.handleSendFailure();
+      return true;
+    }
+    return this.sendWithRetry(message, 0);
+  }
+  /**
+   * FIX #3: Send with exponential backoff retry.
+   * On failure, schedules retry with exponential delay (100ms, 200ms, 400ms).
+   */
+  sendWithRetry(message, attempt) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      if (attempt === 0) {
+        this.messageBuffer.push(message);
+      }
       return false;
     }
-    this.ws.send(message, (error) => {
-      if (error) {
-        this.logger.error({ error }, "Send failed, triggering reconnection");
-        this.handleSendFailure();
+    try {
+      this.ws.send(message, (error) => {
+        if (error) {
+          if (attempt < _TunnelClient.MAX_SEND_RETRIES) {
+            const delay = _TunnelClient.SEND_RETRY_DELAY_MS * Math.pow(2, attempt);
+            this.logger.debug(
+              { attempt: attempt + 1, delay, errorType: error.name },
+              "Send failed, scheduling retry with exponential backoff"
+            );
+            setTimeout(() => {
+              this.sendWithRetry(message, attempt + 1);
+            }, delay);
+          } else {
+            this.logger.error(
+              { error: error.message, attempts: attempt + 1 },
+              "Send failed after all retries, buffering message"
+            );
+            this.messageBuffer.push(message);
+            this.handleSendFailure();
+          }
+        }
+      });
+      return true;
+    } catch (error) {
+      this.logger.error({ error: error.message }, "Unexpected error in send");
+      if (attempt === 0) {
+        this.messageBuffer.push(message);
       }
-    });
-    return true;
+      return false;
+    }
   }
   /**
    * Handles send failure by disconnecting and scheduling reconnection.
@@ -2457,6 +2560,8 @@ var FileSystemWorkspaceDiscovery = class {
 // src/infrastructure/terminal/pty-manager.ts
 import * as pty from "node-pty";
 import { nanoid } from "nanoid";
+import { existsSync as existsSync3 } from "fs";
+import { execSync as execSync3 } from "child_process";
 
 // src/domain/entities/session.ts
 var Session = class {
@@ -2779,15 +2884,26 @@ function isTerminalSession(session) {
 
 // src/infrastructure/shell/shell-env.ts
 import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
 var cachedShellEnv = null;
-function getDefaultShell() {
-  return process.env.SHELL ?? "/bin/bash";
+function resolveShell() {
+  const primaryShell = process.env.SHELL;
+  if (primaryShell && existsSync2(primaryShell)) {
+    return primaryShell;
+  }
+  const fallbackShells = ["/bin/zsh", "/bin/bash", "/bin/sh"];
+  for (const shell of fallbackShells) {
+    if (existsSync2(shell)) {
+      return shell;
+    }
+  }
+  return "/bin/bash";
 }
 function getShellEnv() {
   if (cachedShellEnv) {
     return cachedShellEnv;
   }
-  const shell = getDefaultShell();
+  const shell = resolveShell();
   const isZsh = shell.includes("zsh");
   const isBash = shell.includes("bash");
   let envOutput;
@@ -2838,17 +2954,49 @@ function getShellEnv() {
     return cachedShellEnv;
   } catch (error) {
     console.warn(
-      "Failed to retrieve shell environment, using process.env:",
-      error instanceof Error ? error.message : String(error)
+      "Failed to retrieve shell environment from shell",
+      {
+        shell,
+        error: error instanceof Error ? error.message : String(error)
+      }
     );
+    console.warn("Using process.env as fallback");
     cachedShellEnv = { ...process.env };
     return cachedShellEnv;
   }
 }
 
 // src/infrastructure/terminal/pty-manager.ts
-function getDefaultShell2() {
-  return process.env.SHELL ?? "/bin/bash";
+function resolveShell2(logger) {
+  const primaryShell = process.env.SHELL;
+  if (primaryShell && existsSync3(primaryShell)) {
+    logger.debug({ shell: primaryShell }, "Using primary shell from SHELL environment");
+    return primaryShell;
+  }
+  if (primaryShell) {
+    logger.warn(
+      { primaryShell, exists: false },
+      "Primary shell from SHELL env does not exist, trying alternatives"
+    );
+  }
+  const fallbackShells = ["/bin/zsh", "/bin/bash", "/bin/sh"];
+  for (const shell of fallbackShells) {
+    if (existsSync3(shell)) {
+      logger.debug({ shell }, "Using fallback shell");
+      return shell;
+    }
+  }
+  try {
+    const whichSh = execSync3("which sh", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (whichSh && existsSync3(whichSh)) {
+      logger.debug({ shell: whichSh }, "Found sh in PATH as last resort");
+      return whichSh;
+    }
+  } catch {
+    logger.warn("Failed to find sh in PATH");
+  }
+  logger.error("No usable shell found, defaulting to /bin/bash");
+  return "/bin/bash";
 }
 var PtyManager = class {
   logger;
@@ -2860,40 +3008,59 @@ var PtyManager = class {
   }
   /**
    * Creates a new terminal session.
+   * Resolves shell with fallbacks and includes detailed error logging for debugging M1 issues.
    */
   create(workingDir, cols, rows) {
     const sessionId = new SessionId(nanoid(12));
-    const shell = getDefaultShell2();
+    const shell = resolveShell2(this.logger);
     this.logger.debug(
       { sessionId: sessionId.value, workingDir, shell, cols, rows },
       "Creating terminal session"
     );
-    const shellEnv = getShellEnv();
-    const ptyProcess = pty.spawn(shell, [], {
-      name: "xterm-256color",
-      cols,
-      rows,
-      cwd: workingDir,
-      env: {
-        ...shellEnv,
-        TERM: "xterm-256color",
-        // Disable zsh partial line marker (inverse % sign on startup)
-        PROMPT_EOL_MARK: ""
-      }
-    });
-    const session = new TerminalSession({
-      id: sessionId,
-      pty: ptyProcess,
-      cols,
-      rows,
-      workingDir,
-      bufferSize: this.bufferSize
-    });
-    this.logger.info(
-      { sessionId: sessionId.value, pid: ptyProcess.pid },
-      "Terminal session created"
-    );
-    return Promise.resolve(session);
+    try {
+      const shellEnv = getShellEnv();
+      const ptyProcess = pty.spawn(shell, [], {
+        name: "xterm-256color",
+        cols,
+        rows,
+        cwd: workingDir,
+        env: {
+          ...shellEnv,
+          TERM: "xterm-256color",
+          // Disable zsh partial line marker (inverse % sign on startup)
+          PROMPT_EOL_MARK: ""
+        }
+      });
+      const session = new TerminalSession({
+        id: sessionId,
+        pty: ptyProcess,
+        cols,
+        rows,
+        workingDir,
+        bufferSize: this.bufferSize
+      });
+      this.logger.info(
+        { sessionId: sessionId.value, pid: ptyProcess.pid, shell },
+        "Terminal session created"
+      );
+      return Promise.resolve(session);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.logger.error(
+        {
+          sessionId: sessionId.value,
+          shell,
+          workingDir,
+          cols,
+          rows,
+          error: errorMsg,
+          stack: error instanceof Error ? error.stack : void 0
+        },
+        "Failed to create terminal session"
+      );
+      const message = `Terminal creation failed: ${errorMsg}. Shell: ${shell}, Working dir: ${workingDir}`;
+      throw new Error(message);
+    }
   }
   /**
    * Writes data to a terminal session.
@@ -3055,39 +3222,32 @@ var HeadlessAgentExecutor = class extends EventEmitter {
       cwd: this.workingDir,
       env: {
         ...shellEnv,
-        // Apply alias env vars (e.g., CLAUDE_CONFIG_DIR)
         ...aliasEnvVars,
-        // Ensure proper terminal environment
         TERM: "xterm-256color",
-        // Disable interactive prompts
         CI: "true"
       },
       stdio: ["ignore", "pipe", "pipe"],
-      // stdin ignored, stdout/stderr piped
-      detached: true,
-      // Create new process group for clean termination
-      // Ensure child doesn't interfere with parent's signal handling
-      // @ts-expect-error - Node.js 16+ option
-      ignoreParentSignals: true
+      detached: true
     });
-    this.subprocess.stdout?.on("data", (data) => {
+    const proc = this.subprocess;
+    proc.stdout?.on("data", (data) => {
       if (this.isKilled) return;
       const text2 = data.toString();
       this.emit("stdout", text2);
     });
-    this.subprocess.stderr?.on("data", (data) => {
+    proc.stderr?.on("data", (data) => {
       if (this.isKilled) return;
       const text2 = data.toString();
       this.emit("stderr", text2);
     });
-    this.subprocess.on("exit", (code) => {
+    proc.on("exit", (code) => {
       this.clearExecutionTimeout();
       if (!this.isKilled) {
         this.emit("exit", code);
       }
       this.subprocess = null;
     });
-    this.subprocess.on("error", (error) => {
+    proc.on("error", (error) => {
       this.clearExecutionTimeout();
       if (!this.isKilled) {
         this.emit("error", error);
@@ -4638,11 +4798,15 @@ var CreateSessionUseCase = class {
    * Creates a new session.
    */
   async execute(params) {
-    const { requestId, sessionType, agentName, workspace, project, worktree } = params;
-    this.logger.info({ requestId, sessionType, agentName, workspace, project, worktree }, "CreateSession execute called");
+    const { requestId, sessionType, agentName, workspace, project, worktree: rawWorktree, backlogAgent, backlogId } = params;
+    let worktree = rawWorktree;
+    if (worktree && (worktree.toLowerCase() === "main" || worktree.toLowerCase() === "master")) {
+      worktree = void 0;
+    }
+    this.logger.info({ requestId, sessionType, agentName, workspace, project, worktree, backlogAgent, backlogId }, "CreateSession execute called");
     let workingDir;
     let workspacePath = null;
-    if (sessionType === "terminal") {
+    if (sessionType === "terminal" || sessionType === "backlog-agent") {
       const hasRealWorkspace = workspace && workspace !== "home";
       const hasRealProject = project && project !== "default";
       this.logger.info({ hasRealWorkspace, hasRealProject, workspace, project }, "Terminal session path logic");
@@ -4754,6 +4918,11 @@ var CreateSessionUseCase = class {
       if (count2 >= SESSION_CONFIG.MAX_TERMINAL_SESSIONS) {
         throw new SessionLimitReachedError("terminal", SESSION_CONFIG.MAX_TERMINAL_SESSIONS);
       }
+    } else if (sessionType === "backlog-agent") {
+      const count2 = this.deps.sessionManager.countByType("backlog-agent");
+      if (count2 >= SESSION_CONFIG.MAX_BACKLOG_SESSIONS) {
+        throw new SessionLimitReachedError("backlog", SESSION_CONFIG.MAX_BACKLOG_SESSIONS);
+      }
     } else if (sessionType !== "supervisor") {
       const agentCount = this.deps.sessionManager.countByType("cursor") + this.deps.sessionManager.countByType("claude") + this.deps.sessionManager.countByType("opencode");
       if (agentCount >= SESSION_CONFIG.MAX_AGENT_SESSIONS) {
@@ -5067,13 +5236,58 @@ var SubscriptionService = class {
 };
 
 // src/application/services/message-broadcaster-impl.ts
-var MessageBroadcasterImpl = class {
+var MessageBroadcasterImpl = class _MessageBroadcasterImpl {
   deps;
   logger;
+  /** FIX #4: Buffer messages for devices during auth flow */
+  authBuffers = /* @__PURE__ */ new Map();
+  static AUTH_BUFFER_TTL_MS = 5e3;
+  // 5 second buffer TTL
   constructor(deps) {
     this.deps = deps;
     this.logger = deps.logger.child({ service: "broadcaster" });
   }
+  /**
+   * FIX #4: Buffers a message for a device during auth flow.
+   * Called when subscribing clients are not yet authenticated.
+   * Messages are buffered with TTL and flushed when auth completes.
+   */
+  bufferMessageForAuth(deviceId, sessionId, message) {
+    if (!this.authBuffers.has(deviceId)) {
+      this.authBuffers.set(deviceId, []);
+    }
+    const buffer = this.authBuffers.get(deviceId) ?? [];
+    buffer.push({ sessionId, message, timestamp: Date.now() });
+    const now = Date.now();
+    const filtered = buffer.filter(
+      (item) => now - item.timestamp < _MessageBroadcasterImpl.AUTH_BUFFER_TTL_MS
+    );
+    this.authBuffers.set(deviceId, filtered);
+    this.logger.debug(
+      { deviceId, bufferSize: filtered.length },
+      "Buffered message for authenticating device"
+    );
+  }
+  /**
+   * FIX #4: Flushes buffered messages for a device after authentication.
+   * Called from main.ts after subscription restore completes.
+   * Returns buffered messages so they can be sent to subscribed sessions.
+   */
+  flushAuthBuffer(deviceId) {
+    const buffer = this.authBuffers.get(deviceId) ?? [];
+    this.authBuffers.delete(deviceId);
+    const now = Date.now();
+    const validMessages = buffer.filter(
+      (item) => now - item.timestamp < _MessageBroadcasterImpl.AUTH_BUFFER_TTL_MS
+    );
+    if (validMessages.length > 0) {
+      this.logger.info(
+        { deviceId, messageCount: validMessages.length },
+        "Flushing auth buffer - delivering buffered messages"
+      );
+    }
+    return validMessages;
+  }
   /**
    * Broadcasts a message to all connected clients via tunnel.
    * The tunnel handles client filtering and delivery.
@@ -5115,6 +5329,8 @@ var MessageBroadcasterImpl = class {
    * Broadcasts a message to all clients subscribed to a session (by session ID string).
    * Sends targeted messages to each subscriber in parallel with timeout.
    * Prevents slow clients from blocking others.
+   *
+   * FIX #4: Also buffers messages for unauthenticated subscribers during auth flow.
    */
   async broadcastToSubscribers(sessionId, message) {
     const session = new SessionId(sessionId);
@@ -5123,9 +5339,36 @@ var MessageBroadcasterImpl = class {
       (c) => c.isAuthenticated
     );
     if (authenticatedSubscribers.length === 0) {
+      const unauthenticatedCount = subscribers.length - authenticatedSubscribers.length;
+      if (unauthenticatedCount > 0) {
+        this.logger.debug(
+          { sessionId, unauthenticatedCount },
+          "Subscribers are authenticating - buffering message for delivery after auth"
+        );
+        for (const client of subscribers) {
+          if (!client.isAuthenticated) {
+            this.bufferMessageForAuth(client.deviceId.value, sessionId, message);
+          }
+        }
+      } else {
+        let messageType = "unknown";
+        try {
+          const parsed = JSON.parse(message);
+          messageType = parsed.type ?? "unknown";
+        } catch {
+        }
+        this.logger.debug(
+          { sessionId, messageType },
+          "No subscribers found for session"
+        );
+      }
       return;
     }
     const SEND_TIMEOUT_MS = 2e3;
+    this.logger.debug(
+      { sessionId, subscriberCount: authenticatedSubscribers.length },
+      "Broadcasting message to subscribers"
+    );
     const sendPromises = authenticatedSubscribers.map(async (client) => {
       try {
         await Promise.race([
@@ -5162,12 +5405,23 @@ var MessageBroadcasterImpl = class {
         );
       }
     });
-    await Promise.allSettled(sendPromises);
+    const results = await Promise.allSettled(sendPromises);
+    const failedCount = results.filter((r) => r.status === "rejected").length;
+    if (failedCount > 0) {
+      this.logger.warn(
+        { sessionId, totalSubscribers: authenticatedSubscribers.length, failedCount },
+        "Some subscribers failed to receive message"
+      );
+    }
+  }
+  getAuthenticatedDeviceIds() {
+    const clients = this.deps.clientRegistry.getAll();
+    return clients.filter((c) => c.isAuthenticated).map((c) => c.deviceId.value);
   }
 };
 
 // src/infrastructure/persistence/repositories/message-repository.ts
-import { eq as eq3, desc, gt, lt, and as and2, max, count } from "drizzle-orm";
+import { eq as eq4, desc, gt, lt, and as and2, max, count } from "drizzle-orm";
 import { nanoid as nanoid2 } from "nanoid";
 var MessageRepository = class {
   /**
@@ -5175,7 +5429,7 @@ var MessageRepository = class {
    */
   create(params) {
     const db2 = getDatabase();
-    const result = db2.select({ maxSeq: max(messages.sequence) }).from(messages).where(eq3(messages.sessionId, params.sessionId)).get();
+    const result = db2.select({ maxSeq: max(messages.sequence) }).from(messages).where(eq4(messages.sessionId, params.sessionId)).get();
     const nextSequence = (result?.maxSeq ?? 0) + 1;
     const newMessage = {
       id: params.messageId ?? nanoid2(16),
@@ -5196,17 +5450,17 @@ var MessageRepository = class {
   }
   getBySession(sessionId, limit = 100) {
     const db2 = getDatabase();
-    return db2.select().from(messages).where(eq3(messages.sessionId, sessionId)).orderBy(desc(messages.sequence)).limit(limit).all();
+    return db2.select().from(messages).where(eq4(messages.sessionId, sessionId)).orderBy(desc(messages.sequence)).limit(limit).all();
   }
   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 totalResult = db2.select({ count: count() }).from(messages).where(eq4(messages.sessionId, sessionId)).get();
     const totalCount = totalResult?.count ?? 0;
     const whereClause = options.beforeSequence ? and2(
-      eq3(messages.sessionId, sessionId),
+      eq4(messages.sessionId, sessionId),
       lt(messages.sequence, options.beforeSequence)
-    ) : eq3(messages.sessionId, sessionId);
+    ) : eq4(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;
@@ -5214,117 +5468,56 @@ var MessageRepository = class {
   }
   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();
+    return db2.select().from(messages).where(and2(eq4(messages.sessionId, sessionId), gt(messages.createdAt, timestamp))).orderBy(messages.createdAt).limit(limit).all();
   }
   /**
    * Updates message completion status.
    */
   markComplete(messageId) {
     const db2 = getDatabase();
-    db2.update(messages).set({ isComplete: true }).where(eq3(messages.id, messageId)).run();
+    db2.update(messages).set({ isComplete: true }).where(eq4(messages.id, messageId)).run();
   }
   /**
    * Updates message audio output path.
    */
   setAudioOutput(messageId, audioPath) {
     const db2 = getDatabase();
-    db2.update(messages).set({ audioOutputPath: audioPath }).where(eq3(messages.id, messageId)).run();
+    db2.update(messages).set({ audioOutputPath: audioPath }).where(eq4(messages.id, messageId)).run();
   }
   /**
    * Updates message content blocks (JSON string).
    */
   updateContentBlocks(messageId, contentBlocks) {
     const db2 = getDatabase();
-    db2.update(messages).set({ contentBlocks }).where(eq3(messages.id, messageId)).run();
+    db2.update(messages).set({ contentBlocks }).where(eq4(messages.id, messageId)).run();
   }
   /**
    * Gets the last message for a session.
    */
   getLastBySession(sessionId) {
     const db2 = getDatabase();
-    return db2.select().from(messages).where(eq3(messages.sessionId, sessionId)).orderBy(desc(messages.sequence)).limit(1).get();
+    return db2.select().from(messages).where(eq4(messages.sessionId, sessionId)).orderBy(desc(messages.sequence)).limit(1).get();
   }
   /**
    * Gets a message by ID.
    */
   getById(messageId) {
     const db2 = getDatabase();
-    return db2.select().from(messages).where(eq3(messages.id, messageId)).get();
+    return db2.select().from(messages).where(eq4(messages.id, messageId)).get();
   }
   /**
    * Deletes all messages for a session.
    */
   deleteBySession(sessionId) {
     const db2 = getDatabase();
-    db2.delete(messages).where(eq3(messages.sessionId, sessionId)).run();
-  }
-};
-
-// src/infrastructure/persistence/repositories/session-repository.ts
-import { eq as eq4 } from "drizzle-orm";
-var SessionRepository = class {
-  /**
-   * Creates a new session record or updates if exists.
-   */
-  create(params) {
-    const db2 = getDatabase();
-    const newSession = {
-      id: params.id,
-      type: params.type,
-      workspace: params.workspace,
-      project: params.project,
-      worktree: params.worktree,
-      workingDir: params.workingDir,
-      status: "active",
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    db2.insert(sessions).values(newSession).onConflictDoUpdate({
-      target: sessions.id,
-      set: {
-        status: "active",
-        terminatedAt: null
-      }
-    }).run();
-    return { ...newSession, terminatedAt: null, createdAt: newSession.createdAt };
-  }
-  /**
-   * Gets a session by ID.
-   */
-  getById(sessionId) {
-    const db2 = getDatabase();
-    return db2.select().from(sessions).where(eq4(sessions.id, sessionId)).get();
-  }
-  /**
-   * Gets all active sessions.
-   */
-  getActive() {
-    const db2 = getDatabase();
-    return db2.select().from(sessions).where(eq4(sessions.status, "active")).all();
-  }
-  /**
-   * Marks a session as terminated.
-   */
-  terminate(sessionId) {
-    const db2 = getDatabase();
-    db2.update(sessions).set({
-      status: "terminated",
-      terminatedAt: /* @__PURE__ */ new Date()
-    }).where(eq4(sessions.id, sessionId)).run();
-  }
-  /**
-   * Deletes old terminated sessions (for cleanup).
-   */
-  deleteOldTerminated(_olderThan) {
-    const db2 = getDatabase();
-    const result = db2.delete(sessions).where(eq4(sessions.status, "terminated")).run();
-    return result.changes;
+    db2.delete(messages).where(eq4(messages.sessionId, sessionId)).run();
   }
 };
 
 // src/infrastructure/persistence/storage/audio-storage.ts
 import { mkdir as mkdir2, writeFile, readFile, unlink, rm, readdir as readdir2 } from "fs/promises";
 import { join as join5 } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 var AudioStorage = class {
   baseDir;
   constructor(dataDir) {
@@ -5367,7 +5560,7 @@ var AudioStorage = class {
    * Deletes a specific audio file.
    */
   async deleteAudio(path) {
-    if (existsSync2(path)) {
+    if (existsSync4(path)) {
       await unlink(path);
     }
   }
@@ -5377,10 +5570,10 @@ var AudioStorage = class {
   async deleteSessionAudio(sessionId) {
     const inputDir = join5(this.baseDir, "input", sessionId);
     const outputDir = join5(this.baseDir, "output", sessionId);
-    if (existsSync2(inputDir)) {
+    if (existsSync4(inputDir)) {
       await rm(inputDir, { recursive: true, force: true });
     }
-    if (existsSync2(outputDir)) {
+    if (existsSync4(outputDir)) {
       await rm(outputDir, { recursive: true, force: true });
     }
   }
@@ -5388,7 +5581,7 @@ var AudioStorage = class {
    * Checks if an audio file exists.
    */
   exists(path) {
-    return existsSync2(path);
+    return existsSync4(path);
   }
   /**
    * Finds audio file by message ID across all sessions.
@@ -5400,7 +5593,7 @@ var AudioStorage = class {
    */
   async findAudioByMessageId(messageId, type) {
     const typeDir = join5(this.baseDir, type);
-    if (!existsSync2(typeDir)) {
+    if (!existsSync4(typeDir)) {
       return null;
     }
     try {
@@ -6385,7 +6578,9 @@ Test Files  3 passed (3)
 };
 
 // src/infrastructure/persistence/in-memory-session-manager.ts
-import { EventEmitter as EventEmitter3 } from "events";
+import { EventEmitter as EventEmitter6 } from "events";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+import { join as join9 } from "path";
 import { nanoid as nanoid3 } from "nanoid";
 
 // src/domain/entities/supervisor-session.ts
@@ -6421,35 +6616,1830 @@ var SupervisorSession = class extends Session {
   }
 };
 
-// src/infrastructure/persistence/in-memory-session-manager.ts
-var InMemorySessionManager = class extends EventEmitter3 {
-  sessions = /* @__PURE__ */ new Map();
-  ptyManager;
-  agentSessionManager;
-  logger;
-  supervisorSession = null;
-  constructor(config2) {
-    super();
-    this.ptyManager = config2.ptyManager;
-    this.agentSessionManager = config2.agentSessionManager;
-    this.logger = config2.logger.child({ component: "session-manager" });
-    this.setupAgentSessionSync();
+// src/domain/entities/backlog-agent-session.ts
+var BacklogAgentSession = class extends Session {
+  _agentName;
+  _backlogId;
+  _harnessRunning = false;
+  constructor(props) {
+    super({
+      ...props,
+      type: "backlog-agent"
+    });
+    this._agentName = props.agentName;
+    this._backlogId = props.backlogId;
   }
-  /**
-   * 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 },
+  get agentName() {
+    return this._agentName;
+  }
+  get backlogId() {
+    return this._backlogId;
+  }
+  get harnessRunning() {
+    return this._harnessRunning;
+  }
+  setHarnessRunning(running) {
+    this._harnessRunning = running;
+    if (running) {
+      this.markBusy();
+    } else {
+      this.markIdle();
+    }
+  }
+  terminate() {
+    this._harnessRunning = false;
+    this.markTerminated();
+    return Promise.resolve();
+  }
+  toInfo() {
+    const info = super.toInfo();
+    return {
+      ...info,
+      agent_name: this._agentName,
+      backlog_id: this._backlogId,
+      harness_running: this._harnessRunning
+      // backlog_summary will be populated by BacklogAgentManager if needed
+    };
+  }
+};
+
+// src/infrastructure/agents/backlog-agent-manager.ts
+import { EventEmitter as EventEmitter5 } from "events";
+import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join8 } from "path";
+
+// src/domain/value-objects/backlog.ts
+import { z as z3 } from "zod";
+var TaskSchema = z3.object({
+  id: z3.number().describe("Internal task ID (sequential)"),
+  external_id: z3.string().optional().describe("External system ID (e.g., AUTH-123)"),
+  external_url: z3.string().optional().describe("Link to external issue"),
+  title: z3.string().describe("Task title"),
+  description: z3.string().describe("Detailed description"),
+  acceptance_criteria: z3.array(z3.string()).describe("Acceptance criteria"),
+  dependencies: z3.array(z3.number()).describe("Task IDs this task depends on"),
+  priority: z3.enum(["low", "medium", "high"]).describe("Priority level"),
+  complexity: z3.enum(["simple", "moderate", "complex"]).describe("Estimated complexity"),
+  status: z3.enum(["pending", "in_progress", "completed", "failed", "skipped"]).describe("Current status"),
+  started_at: z3.string().datetime().optional().describe("When task execution started"),
+  completed_at: z3.string().datetime().optional().describe("When task was completed"),
+  error: z3.string().optional().describe("Error message if task failed"),
+  commit_hash: z3.string().optional().describe("Git commit hash if code was written"),
+  retry_count: z3.number().default(0).describe("Number of times task was retried")
+});
+var TaskSourceSchema = z3.object({
+  type: z3.enum(["jira", "github", "gitlab", "linear", "notion", "manual"]).describe("Source system"),
+  system: z3.string().optional().describe("Human-friendly system name"),
+  issue_id: z3.string().optional().describe("Single issue/epic ID"),
+  sprint_id: z3.number().optional().describe("Jira sprint ID"),
+  project_key: z3.string().optional().describe("Jira project key"),
+  repository: z3.string().optional().describe("GitHub repo (owner/repo)"),
+  labels: z3.array(z3.string()).optional().describe("GitHub/GitLab labels"),
+  url: z3.string().optional().describe("URL for custom sources")
+});
+var BacklogSchema = z3.object({
+  id: z3.string().describe("Unique backlog identifier"),
+  project: z3.string().describe("Project name"),
+  worktree: z3.string().optional().describe("Git worktree/branch name (omitted for main/master)"),
+  agent: z3.enum(["claude", "cursor", "opencode"]).describe("Agent to use for execution"),
+  source: TaskSourceSchema.describe("Where tasks came from"),
+  created_at: z3.string().datetime().describe("When backlog was created"),
+  updated_at: z3.string().datetime().optional().describe("Last update time"),
+  tasks: z3.array(TaskSchema).describe("List of tasks"),
+  completed_at: z3.string().datetime().optional().describe("When all tasks completed"),
+  summary: z3.object({
+    total: z3.number(),
+    completed: z3.number(),
+    failed: z3.number(),
+    in_progress: z3.number(),
+    pending: z3.number()
+  }).optional().describe("Task count summary")
+});
+function recalculateSummary(backlog) {
+  const summary = {
+    total: backlog.tasks.length,
+    completed: 0,
+    failed: 0,
+    in_progress: 0,
+    pending: 0
+  };
+  for (const task of backlog.tasks) {
+    if (task.status === "completed") summary.completed++;
+    else if (task.status === "failed") summary.failed++;
+    else if (task.status === "in_progress") summary.in_progress++;
+    else if (task.status === "pending") summary.pending++;
+  }
+  return {
+    ...backlog,
+    summary,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/infrastructure/agents/backlog-harness.ts
+import { EventEmitter as EventEmitter3 } from "events";
+import { readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join6 } from "path";
+var BacklogHarness = class _BacklogHarness extends EventEmitter3 {
+  backlog;
+  isRunning = false;
+  isPaused = false;
+  workingDir;
+  agentSessionManager;
+  logger;
+  startTime = 0;
+  selectedAgent;
+  constructor(backlog, workingDir, selectedAgent, agentSessionManager, logger) {
+    super();
+    this.backlog = backlog;
+    this.workingDir = workingDir;
+    this.selectedAgent = selectedAgent;
+    this.agentSessionManager = agentSessionManager;
+    this.logger = logger;
+  }
+  /**
+   * Start autonomous execution of tasks.
+   */
+  async start() {
+    if (this.isRunning) {
+      this.logger.warn("Harness already running");
+      return;
+    }
+    this.isRunning = true;
+    this.isPaused = false;
+    this.startTime = Date.now();
+    this.emit("harness-started", {
+      totalTasks: this.backlog.tasks.length
+    });
+    this.broadcastOutput({
+      id: "harness-start",
+      block_type: "status",
+      content: `\u{1F680} Starting Harness. Total tasks: ${this.backlog.tasks.length}`
+    });
+    try {
+      await this.executeLoop();
+    } catch (error) {
+      this.logger.error({ error }, "Harness error");
+      this.broadcastOutput({
+        id: "harness-error",
+        block_type: "error",
+        content: `Harness error: ${error instanceof Error ? error.message : "Unknown error"}`
+      });
+    } finally {
+      this.isRunning = false;
+    }
+  }
+  /**
+   * Pause execution (current task finishes, then pauses).
+   */
+  pause() {
+    if (!this.isRunning) {
+      this.logger.warn("Harness not running");
+      return;
+    }
+    this.isPaused = true;
+    this.emit("harness-paused", void 0);
+    this.broadcastOutput({
+      id: "harness-pause",
+      block_type: "status",
+      content: "\u23F8\uFE0F Harness paused"
+    });
+  }
+  /**
+   * Resume paused execution.
+   */
+  resume() {
+    if (!this.isRunning || !this.isPaused) {
+      this.logger.warn("Cannot resume harness");
+      return;
+    }
+    this.isPaused = false;
+    this.emit("harness-resumed", void 0);
+    this.broadcastOutput({
+      id: "harness-resume",
+      block_type: "status",
+      content: "\u25B6\uFE0F Harness resumed"
+    });
+  }
+  /**
+   * Stop execution immediately.
+   */
+  stop() {
+    this.isRunning = false;
+    this.isPaused = false;
+    this.emit("harness-stopped", void 0);
+    this.broadcastOutput({
+      id: "harness-stop",
+      block_type: "status",
+      content: "\u23F9\uFE0F Harness stopped"
+    });
+  }
+  /**
+   * Main execution loop.
+   */
+  async executeLoop() {
+    let completedCount = 0;
+    let failedCount = 0;
+    while (this.isRunning) {
+      while (this.isPaused && this.isRunning) {
+        await this.sleep(1e3);
+      }
+      if (!this.isRunning) break;
+      const task = this.findNextPendingTask();
+      if (!task) {
+        break;
+      }
+      if (!this.canExecuteTask(task)) {
+        this.logger.debug(`Task ${task.id} dependencies not ready, skipping`);
+        continue;
+      }
+      try {
+        await this.executeTask(task);
+        completedCount++;
+      } catch (error) {
+        this.logger.error({ error, taskId: task.id }, `Task ${task.id} failed`);
+        failedCount++;
+        this.emit("task-failed", {
+          taskId: task.id,
+          title: task.title,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+        this.updateTaskStatus(task.id, "failed", {
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+      this.saveBacklog();
+    }
+    const duration = Date.now() - this.startTime;
+    const summary = this.backlog.summary ?? {
+      total: this.backlog.tasks.length,
+      completed: completedCount,
+      failed: failedCount,
+      in_progress: 0,
+      pending: this.backlog.tasks.filter((t) => t.status === "pending").length
+    };
+    this.emit("harness-completed", {
+      completed: summary.completed,
+      failed: summary.failed,
+      total: summary.total,
+      duration
+    });
+    this.broadcastOutput({
+      id: "harness-complete",
+      block_type: "status",
+      content: `\u2705 Harness completed. Completed: ${summary.completed}/${summary.total}, Failed: ${summary.failed}`
+    });
+  }
+  /**
+   * Execute a single task.
+   */
+  async executeTask(task) {
+    const startTime = Date.now();
+    this.emit("task-started", {
+      taskId: task.id,
+      title: task.title,
+      externalId: task.external_id
+    });
+    this.updateTaskStatus(task.id, "in_progress", { started_at: (/* @__PURE__ */ new Date()).toISOString() });
+    this.broadcastOutput({
+      id: `task-${task.id}-start`,
+      block_type: "status",
+      content: `\u{1F4CC} Task ${task.id}: ${task.title}`
+    });
+    const prompt = this.buildTaskPrompt(task);
+    const taskIndex = this.backlog.tasks.findIndex((t) => t.id === task.id) + 1;
+    const totalTasks = this.backlog.tasks.length;
+    const taskSessionId = `backlog-${this.backlog.id}-task-${task.id}`;
+    const taskAgentName = `Task ${taskIndex}/${totalTasks}: ${task.title}`;
+    this.logger.info(
+      { sessionId: taskSessionId, agent: this.selectedAgent, taskIndex, totalTasks },
+      "Creating new agent session for task iteration"
+    );
+    const agentType = this.selectedAgent;
+    const newSession = this.agentSessionManager.createSession(
+      agentType,
+      this.workingDir,
+      taskSessionId,
+      taskAgentName
+    );
+    const sessionId = newSession.sessionId;
+    this.logger.info(
+      { sessionId, agent: this.selectedAgent, taskIndex, taskTitle: task.title },
+      "Created new agent session for task"
+    );
+    await new Promise((resolve2, reject) => {
+      let isResolved = false;
+      let executionTimeoutHandle;
+      const onBlocks = (emittedSessionId, blocks, isComplete) => {
+        if (emittedSessionId !== sessionId) {
+          return;
+        }
+        this.broadcastOutput(...blocks);
+        if (isResolved) {
+          return;
+        }
+        let commitHash;
+        let hasCommitDetected = false;
+        for (const block of blocks) {
+          if (block.block_type === "text") {
+            const content = block.content;
+            const commitRegex = /commit\s+([a-f0-9]{7,40})/i;
+            const commitMatch = commitRegex.exec(content);
+            if (commitMatch) {
+              commitHash = commitMatch[1];
+              hasCommitDetected = true;
+              break;
+            }
+            const headRegex = /HEAD\s+is\s+now\s+at\s+([a-f0-9]{7,40})/i;
+            const headMatch = headRegex.exec(content);
+            if (headMatch) {
+              commitHash = headMatch[1];
+              hasCommitDetected = true;
+              break;
+            }
+          }
+        }
+        if (hasCommitDetected && commitHash) {
+          isResolved = true;
+          if (executionTimeoutHandle) clearTimeout(executionTimeoutHandle);
+          this.agentSessionManager.removeListener("blocks", onBlocks);
+          const duration = Date.now() - startTime;
+          this.emit("task-completed", {
+            taskId: task.id,
+            title: task.title,
+            success: true,
+            commitHash,
+            duration
+          });
+          this.updateTaskStatus(task.id, "completed", {
+            completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+            commit_hash: commitHash
+          });
+          this.logger.info(
+            { taskId: task.id, title: task.title, commitHash, duration },
+            "Task completed with commit"
+          );
+          resolve2();
+          return;
+        }
+        if (isComplete && !isResolved) {
+          isResolved = true;
+          if (executionTimeoutHandle) clearTimeout(executionTimeoutHandle);
+          this.agentSessionManager.removeListener("blocks", onBlocks);
+          const duration = Date.now() - startTime;
+          const errorMsg = "Task execution completed but no commit was detected. The agent may not have completed the implementation.";
+          this.emit("task-completed", {
+            taskId: task.id,
+            title: task.title,
+            success: false,
+            duration
+          });
+          this.updateTaskStatus(task.id, "failed", {
+            completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+            error: errorMsg
+          });
+          this.logger.warn(
+            { taskId: task.id, title: task.title, duration },
+            errorMsg
+          );
+          reject(new Error(errorMsg));
+        }
+      };
+      this.agentSessionManager.on("blocks", onBlocks);
+      executionTimeoutHandle = setTimeout(() => {
+        if (!isResolved) {
+          isResolved = true;
+          this.agentSessionManager.removeListener("blocks", onBlocks);
+          const duration = Date.now() - startTime;
+          this.emit("task-completed", {
+            taskId: task.id,
+            title: task.title,
+            success: false,
+            duration
+          });
+          this.updateTaskStatus(task.id, "failed", {
+            completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+            error: "Task execution timeout (30 minutes exceeded)"
+          });
+          reject(new Error("Task execution timeout"));
+        }
+      }, 30 * 60 * 1e3);
+      this.agentSessionManager.executeCommand(sessionId, prompt).catch((error) => {
+        if (!isResolved) {
+          isResolved = true;
+          if (executionTimeoutHandle) clearTimeout(executionTimeoutHandle);
+          this.agentSessionManager.removeListener("blocks", onBlocks);
+          reject(error instanceof Error ? error : new Error(String(error)));
+        }
+      });
+    });
+  }
+  /**
+   * Build a prompt for the coding agent based on task.
+   */
+  buildTaskPrompt(task) {
+    return `
+You are a senior developer. Complete this task:
+
+## Task: ${task.title}
+
+${task.description}
+
+## Acceptance Criteria:
+${task.acceptance_criteria.map((c) => `- ${c}`).join("\n")}
+
+## Instructions:
+1. Implement the feature/fix according to the acceptance criteria
+2. Write/update tests to cover your changes
+3. Run all tests and make sure they pass
+4. Commit your changes with a descriptive message
+5. Ensure code follows project conventions
+
+## IMPORTANT - Completion Signal:
+When you have COMPLETED the task and committed your changes:
+- Make sure your last action is a git commit
+- Output the full commit hash in your final summary
+- Write a clear summary confirming what was implemented and that acceptance criteria are met
+
+Do NOT write "Task complete" or similar - just commit your code and include the hash in your output.
+    `.trim();
+  }
+  /**
+   * Find next pending task.
+   */
+  findNextPendingTask() {
+    return this.backlog.tasks.find((t) => t.status === "pending");
+  }
+  /**
+   * Check if task dependencies are satisfied.
+   */
+  canExecuteTask(task) {
+    if (task.dependencies.length === 0) {
+      return true;
+    }
+    return task.dependencies.every((depId) => {
+      const depTask = this.backlog.tasks.find((t) => t.id === depId);
+      return depTask?.status === "completed";
+    });
+  }
+  /**
+   * Update task status.
+   */
+  updateTaskStatus(taskId, status, updates = {}) {
+    const task = this.backlog.tasks.find((t) => t.id === taskId);
+    if (task) {
+      task.status = status;
+      Object.assign(task, updates);
+      this.backlog = recalculateSummary(this.backlog);
+    }
+  }
+  /**
+   * Save backlog to file.
+   */
+  saveBacklog() {
+    const backlogPath = join6(this.workingDir, "backlog.json");
+    try {
+      writeFileSync(backlogPath, JSON.stringify(this.backlog, null, 2));
+      this.logger.debug(`Saved backlog to ${backlogPath}`);
+    } catch (error) {
+      this.logger.error({ error }, "Failed to save backlog");
+    }
+  }
+  /**
+   * Broadcast output blocks to UI.
+   */
+  broadcastOutput(...blocks) {
+    this.emit("output", blocks);
+  }
+  /**
+   * Sleep helper.
+   */
+  sleep(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+  /**
+   * Load backlog from file.
+   * @param selectedAgent - The agent type to use for harness execution
+   */
+  static loadFromFile(path, selectedAgent, agentSessionManager, logger) {
+    const content = readFileSync2(path, "utf-8");
+    const backlog = JSON.parse(content);
+    const workingDir = path.substring(0, path.lastIndexOf("/"));
+    return new _BacklogHarness(backlog, workingDir, selectedAgent, agentSessionManager, logger);
+  }
+};
+
+// src/infrastructure/agents/base/lang-graph-agent.ts
+import { EventEmitter as EventEmitter4 } from "events";
+import { ChatOpenAI } from "@langchain/openai";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import { HumanMessage, AIMessage, isAIMessage } from "@langchain/core/messages";
+var LangGraphAgent = class extends EventEmitter4 {
+  logger;
+  agent = null;
+  conversationHistory = [];
+  abortController = null;
+  isExecuting = false;
+  isCancelled = false;
+  /** Tracks if we're processing a command (including STT, before LLM execution) */
+  isProcessingCommand = false;
+  /** Timestamp when current execution started (for race condition protection) */
+  executionStartedAt = 0;
+  constructor(logger) {
+    super();
+    this.logger = logger.child({ component: this.constructor.name });
+  }
+  /**
+   * Called after successful execution completion.
+   * Subclasses can override to perform agent-specific post-execution logic.
+   */
+  async onExecutionComplete(_blocks, _finalOutput) {
+  }
+  /**
+   * Initializes the LangGraph agent and state manager.
+   * Called by subclasses during construction.
+   */
+  initializeAgent() {
+    if (this.agent) {
+      return;
+    }
+    try {
+      const env = getEnv();
+      const llm = this.createLLM(env);
+      const tools = this.createTools();
+      this.logger.info({ toolCount: tools.length }, `Creating ${this.constructor.name} with tools`);
+      this.agent = createReactAgent({
+        llm,
+        tools
+      });
+    } catch (error) {
+      this.logger.error({ error }, `Failed to initialize ${this.constructor.name}`);
+      throw error;
+    }
+  }
+  /**
+   * Creates the LLM instance based on environment configuration.
+   */
+  createLLM(env) {
+    const provider = env.AGENT_PROVIDER;
+    const apiKey = env.AGENT_API_KEY;
+    const modelName = env.AGENT_MODEL_NAME;
+    const baseUrl = env.AGENT_BASE_URL;
+    const temperature = env.AGENT_TEMPERATURE;
+    if (!apiKey) {
+      throw new Error(`AGENT_API_KEY is required for ${this.constructor.name}`);
+    }
+    this.logger.info({ provider, model: modelName }, "Initializing LLM");
+    return new ChatOpenAI({
+      openAIApiKey: apiKey,
+      modelName,
+      temperature,
+      configuration: baseUrl ? {
+        baseURL: baseUrl
+      } : void 0
+    });
+  }
+  /**
+   * Executes a command with streaming output.
+   * Emits 'blocks' events as content is generated.
+   *
+   * This is the unified streaming method used by all agents.
+   * Subclasses should NOT override this unless they have very specific requirements.
+   */
+  async executeWithStream(command, deviceId) {
+    this.logger.info(
+      { command, deviceId, wasCancelledBefore: this.isCancelled },
+      `Executing ${this.constructor.name} with streaming`
+    );
+    this.abortController = new AbortController();
+    this.isExecuting = true;
+    this.isCancelled = false;
+    this.executionStartedAt = Date.now();
+    this.logger.debug({ isCancelled: this.isCancelled, isExecuting: this.isExecuting }, "Flags reset for new execution");
+    try {
+      const stateManager = this.createStateManager();
+      const history = await stateManager.loadHistory();
+      this.conversationHistory = history;
+      const messages2 = [
+        ...this.buildSystemMessage(),
+        ...this.buildHistoryMessages(history),
+        new HumanMessage(command)
+      ];
+      if (this.isExecuting && !this.isCancelled) {
+        const statusBlock = createStatusBlock("Processing...");
+        this.logger.debug({ deviceId, blockType: "status" }, "Emitting status block");
+        this.emit("blocks", deviceId, [statusBlock], false);
+      }
+      this.logger.info({ deviceId }, `Starting LangGraph agent stream for ${this.constructor.name}`);
+      if (!this.agent) {
+        throw new Error("Agent not initialized");
+      }
+      const stream = await this.agent.stream(
+        { messages: messages2 },
+        {
+          streamMode: "values",
+          signal: this.abortController.signal
+        }
+      );
+      let finalOutput = "";
+      const allBlocks = [];
+      for await (const chunk of stream) {
+        if (this.isCancelled || !this.isExecuting) {
+          this.logger.info(
+            { deviceId, isCancelled: this.isCancelled, isExecuting: this.isExecuting },
+            `${this.constructor.name} execution cancelled, stopping stream processing`
+          );
+          return;
+        }
+        const chunkData = chunk;
+        const chunkMessages = chunkData.messages;
+        if (!chunkMessages || chunkMessages.length === 0) continue;
+        const lastMessage = chunkMessages[chunkMessages.length - 1];
+        if (!lastMessage) continue;
+        if (isAIMessage(lastMessage)) {
+          const content = lastMessage.content;
+          if (typeof content === "string" && content.length > 0) {
+            finalOutput = content;
+            if (this.isExecuting && !this.isCancelled) {
+              const textBlock = createTextBlock(content);
+              this.emit("blocks", deviceId, [textBlock], false);
+              accumulateBlocks(allBlocks, [textBlock]);
+            }
+          } else if (Array.isArray(content)) {
+            for (const item of content) {
+              if (typeof item === "object" && this.isExecuting && !this.isCancelled) {
+                const block = this.parseContentItem(item);
+                if (block) {
+                  this.emit("blocks", deviceId, [block], false);
+                  accumulateBlocks(allBlocks, [block]);
+                }
+              }
+            }
+          }
+        }
+        if (lastMessage.getType() === "tool" && this.isExecuting && !this.isCancelled) {
+          const toolContent = lastMessage.content;
+          const toolName = lastMessage.name ?? "tool";
+          const toolCallId = lastMessage.tool_call_id;
+          const toolBlock = createToolBlock(
+            toolName,
+            "completed",
+            void 0,
+            typeof toolContent === "string" ? toolContent : JSON.stringify(toolContent),
+            toolCallId
+          );
+          this.emit("blocks", deviceId, [toolBlock], false);
+          accumulateBlocks(allBlocks, [toolBlock]);
+        }
+      }
+      if (this.isExecuting && !this.isCancelled) {
+        this.addToHistory("user", command);
+        this.addToHistory("assistant", finalOutput);
+        const finalBlocks = mergeToolBlocks(allBlocks);
+        const stateManager2 = this.createStateManager();
+        await stateManager2.saveHistory(this.conversationHistory);
+        await this.onExecutionComplete(finalBlocks, finalOutput);
+        const completionBlock = createStatusBlock("Complete");
+        this.emit("blocks", deviceId, [completionBlock], true, finalOutput, finalBlocks);
+        this.logger.debug({ output: finalOutput.slice(0, 200) }, `${this.constructor.name} streaming completed`);
+      } else {
+        this.logger.info(
+          { deviceId, isCancelled: this.isCancelled, isExecuting: this.isExecuting },
+          `${this.constructor.name} streaming ended due to cancellation`
+        );
+      }
+    } catch (error) {
+      if (this.isCancelled || !this.isExecuting) {
+        this.logger.info({ deviceId }, `${this.constructor.name} execution cancelled (caught in error handler)`);
+        return;
+      }
+      this.logger.error({ error, command }, `${this.constructor.name} streaming failed`);
+      const errorMessage = error instanceof Error ? error.message : "An unexpected error occurred";
+      const errorBlock = createErrorBlock(errorMessage);
+      this.emit("blocks", deviceId, [errorBlock], true);
+    } finally {
+      this.isExecuting = false;
+      this.abortController = null;
+    }
+  }
+  /**
+   * Parses a content item from LangGraph into a ContentBlock.
+   */
+  parseContentItem(item) {
+    const type = item.type;
+    if (type === "text" && typeof item.text === "string" && item.text.trim()) {
+      return createTextBlock(item.text);
+    }
+    if (type === "tool_use") {
+      const name = typeof item.name === "string" ? item.name : "tool";
+      const input = item.input;
+      const toolUseId = typeof item.id === "string" ? item.id : void 0;
+      return createToolBlock(name, "running", input, void 0, toolUseId);
+    }
+    return null;
+  }
+  /**
+   * Cancels the current execution if running.
+   * Returns true if cancellation was initiated.
+   */
+  cancel() {
+    if (!this.isProcessingCommand && !this.isExecuting) {
+      this.logger.debug(
+        { isProcessingCommand: this.isProcessingCommand, isExecuting: this.isExecuting },
+        "No active execution to cancel"
+      );
+      return false;
+    }
+    const timeSinceStart = Date.now() - this.executionStartedAt;
+    if (this.isExecuting && timeSinceStart < 500) {
+      this.logger.info(
+        { timeSinceStart, isProcessingCommand: this.isProcessingCommand },
+        "Ignoring cancel - execution just started (race condition protection)"
+      );
+      return false;
+    }
+    this.logger.info(
+      { isProcessingCommand: this.isProcessingCommand, isExecuting: this.isExecuting, timeSinceStart },
+      `Cancelling ${this.constructor.name} execution`
+    );
+    this.isCancelled = true;
+    this.isExecuting = false;
+    this.isProcessingCommand = false;
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+    return true;
+  }
+  /**
+   * Check if execution was cancelled.
+   * Used by clients to filter out any late-arriving blocks.
+   */
+  wasCancelled() {
+    return this.isCancelled;
+  }
+  /**
+   * Starts command processing (before STT/LLM execution).
+   * Returns an AbortController that can be used to cancel STT and other operations.
+   */
+  startProcessing() {
+    this.abortController = new AbortController();
+    this.isProcessingCommand = true;
+    this.isCancelled = false;
+    this.logger.debug("Started command processing");
+    return this.abortController;
+  }
+  /**
+   * Checks if command processing is active (STT or LLM execution).
+   */
+  isProcessing() {
+    return this.isProcessingCommand || this.isExecuting;
+  }
+  /**
+   * Ends command processing (called after completion or error, not after cancel).
+   */
+  endProcessing() {
+    this.isProcessingCommand = false;
+    this.logger.debug("Ended command processing");
+  }
+  /**
+   * Gets conversation history.
+   */
+  getConversationHistory() {
+    return this.conversationHistory;
+  }
+  /**
+   * Resets the cancellation state.
+   * Call this before starting a new command to ensure previous cancellation doesn't affect it.
+   */
+  resetCancellationState() {
+    this.isCancelled = false;
+  }
+  /**
+   * Restores 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 }, "Conversation history restored");
+  }
+  /**
+   * Builds the system message for the agent.
+   */
+  buildSystemMessage() {
+    const systemPrompt = this.buildSystemPrompt();
+    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)
+    );
+  }
+  /**
+   * Adds an entry to 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/agents/base/backlog-state-manager.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join7 } from "path";
+var BacklogStateManager = class {
+  constructor(workingDir, logger) {
+    this.workingDir = workingDir;
+    this.logger = logger;
+  }
+  getHistoryPath() {
+    return join7(this.workingDir, "conversation-history.json");
+  }
+  loadHistory() {
+    const historyPath = this.getHistoryPath();
+    if (!existsSync5(historyPath)) {
+      return Promise.resolve([]);
+    }
+    try {
+      const content = readFileSync3(historyPath, "utf-8");
+      const data = JSON.parse(content);
+      this.logger.debug({ messageCount: data.length }, "Loaded conversation history from file");
+      return Promise.resolve(data);
+    } catch (error) {
+      this.logger.error({ error }, "Failed to load conversation history from file");
+      return Promise.resolve([]);
+    }
+  }
+  saveHistory(history) {
+    const historyPath = this.getHistoryPath();
+    try {
+      writeFileSync2(historyPath, JSON.stringify(history, null, 2), "utf-8");
+      this.logger.debug({ messageCount: history.length }, "Saved conversation history to file");
+    } catch (error) {
+      this.logger.error({ error }, "Failed to save conversation history to file");
+    }
+    return Promise.resolve();
+  }
+  clearHistory() {
+    const historyPath = this.getHistoryPath();
+    try {
+      if (existsSync5(historyPath)) {
+        writeFileSync2(historyPath, JSON.stringify([], null, 2), "utf-8");
+      }
+      this.logger.info("Cleared conversation history");
+    } catch (error) {
+      this.logger.error({ error }, "Failed to clear conversation history");
+    }
+    return Promise.resolve();
+  }
+  loadAdditionalState(key) {
+    if (key !== "backlog") {
+      return Promise.resolve(null);
+    }
+    const backlogPath = join7(this.workingDir, "backlog.json");
+    if (!existsSync5(backlogPath)) {
+      return Promise.resolve(null);
+    }
+    try {
+      const content = readFileSync3(backlogPath, "utf-8");
+      const data = JSON.parse(content);
+      this.logger.debug("Loaded backlog state from file");
+      return Promise.resolve(data);
+    } catch (error) {
+      this.logger.error({ error }, "Failed to load backlog state from file");
+      return Promise.resolve(null);
+    }
+  }
+  saveAdditionalState(key, state) {
+    if (key !== "backlog") {
+      return Promise.resolve();
+    }
+    const backlogPath = join7(this.workingDir, "backlog.json");
+    try {
+      writeFileSync2(backlogPath, JSON.stringify(state, null, 2), "utf-8");
+      this.logger.debug("Saved backlog state to file");
+    } catch (error) {
+      this.logger.error({ error }, "Failed to save backlog state to file");
+    }
+    return Promise.resolve();
+  }
+  close() {
+    return Promise.resolve();
+  }
+};
+
+// src/infrastructure/agents/backlog-agent-tools.ts
+import { tool } from "@langchain/core/tools";
+import { z as z4 } from "zod";
+function createBacklogAgentTools(context) {
+  const getStatus = tool(
+    () => {
+      const blocks = context.getStatus();
+      return blocks.map((b) => b.content).join("\n");
+    },
+    {
+      name: "get_backlog_status",
+      description: "Get the current status of the backlog including task counts and progress",
+      schema: z4.object({})
+    }
+  );
+  const startHarness = tool(
+    () => {
+      const blocks = context.startHarness();
+      return blocks.map((b) => b.content).join("\n");
+    },
+    {
+      name: "start_backlog_harness",
+      description: "Start the backlog harness to begin executing tasks",
+      schema: z4.object({})
+    }
+  );
+  const stopHarness = tool(
+    () => {
+      const blocks = context.stopHarness();
+      return blocks.map((b) => b.content).join("\n");
+    },
+    {
+      name: "stop_backlog_harness",
+      description: "Stop the backlog harness execution",
+      schema: z4.object({})
+    }
+  );
+  const pauseHarness = tool(
+    () => {
+      const blocks = context.pauseHarness();
+      return blocks.map((b) => b.content).join("\n");
+    },
+    {
+      name: "pause_backlog_harness",
+      description: "Pause the backlog harness (current task will complete)",
+      schema: z4.object({})
+    }
+  );
+  const resumeHarness = tool(
+    () => {
+      const blocks = context.resumeHarness();
+      return blocks.map((b) => b.content).join("\n");
+    },
+    {
+      name: "resume_backlog_harness",
+      description: "Resume a paused backlog harness",
+      schema: z4.object({})
+    }
+  );
+  const listTasks = tool(
+    () => {
+      const blocks = context.listTasks();
+      return blocks.map((b) => b.content).join("\n");
+    },
+    {
+      name: "list_backlog_tasks",
+      description: "List all tasks in the backlog with their status",
+      schema: z4.object({})
+    }
+  );
+  const addTask = tool(
+    ({ title, description }) => {
+      const blocks = context.addTask(title, description);
+      return blocks.map((b) => b.content).join("\n");
+    },
+    {
+      name: "add_backlog_task",
+      description: "Add a new task to the backlog",
+      schema: z4.object({
+        title: z4.string().describe("Task title"),
+        description: z4.string().optional().describe("Task description")
+      })
+    }
+  );
+  const getAvailableAgents2 = tool(
+    async () => {
+      const agents = await context.getAvailableAgents();
+      const agentsList = agents.map((a) => `- ${a.name}${a.isAlias ? " (alias)" : ""}: ${a.description}`).join("\n");
+      return `Available agents:
+${agentsList}`;
+    },
+    {
+      name: "get_available_agents",
+      description: "Get list of all available coding agents (base agents and custom aliases)",
+      schema: z4.object({})
+    }
+  );
+  const parseAgentSelection = tool(
+    async ({ userResponse }) => {
+      const result = await context.parseAgentSelection(userResponse);
+      return `Agent selection result: ${result.valid ? `Selected agent: ${result.agentName}` : result.message}`;
+    },
+    {
+      name: "parse_agent_selection",
+      description: "Parse user response to extract selected agent name and validate it against available agents",
+      schema: z4.object({
+        userResponse: z4.string().describe("The user response containing agent selection")
+      })
+    }
+  );
+  return [getStatus, startHarness, stopHarness, pauseHarness, resumeHarness, listTasks, addTask, getAvailableAgents2, parseAgentSelection];
+}
+
+// src/infrastructure/agents/backlog-agent.ts
+var BACKLOG_AGENT_SYSTEM_PROMPT = `You are a Backlog Agent responsible for managing development tasks in a backlog.
+
+You have the following capabilities:
+- View backlog status and task progress
+- Start/stop/pause/resume harness execution
+- List tasks in the backlog
+- Add new tasks
+- Show available coding agents
+- Parse agent selection from user responses
+
+When the user sends a message, interpret their intent and use the appropriate tool(s) to fulfill their request.
+
+Guidelines:
+- If the user asks about progress, status, or the current state \u2192 use get_backlog_status
+- If the user wants to start execution \u2192 use start_backlog_harness
+- If the user wants to stop, pause, or resume \u2192 use the appropriate harness tool
+- If the user wants to see tasks \u2192 use list_backlog_tasks
+- If the user describes something to do or wants to add a task \u2192 use add_backlog_task
+
+SPECIAL CASE - Agent Selection for Harness Execution:
+When start_backlog_harness tool returns a message asking which agent to use:
+1. Acknowledge that we're waiting for agent selection
+2. DO NOT call any other tools until the user provides an agent selection
+3. When the user responds with an agent name (e.g., "I want to use claude" or "use cursor"):
+   - Call parse_agent_selection with their response to validate and extract the agent name
+   - Report the results to the user
+   - The agent will then proceed with harness creation
+
+You can call multiple tools in sequence if needed to fully satisfy the user's request (e.g., get status AND list tasks). After all tools have returned, provide a concise summary of what was accomplished.
+
+Be helpful and informative. Always confirm actions and provide status updates.`;
+var BacklogAgent = class extends LangGraphAgent {
+  toolsContext;
+  workingDir;
+  constructor(toolsContext, workingDir, logger) {
+    super(logger);
+    this.toolsContext = toolsContext;
+    this.workingDir = workingDir;
+    this.initializeAgent();
+  }
+  /**
+   * Implements abstract method: build system prompt for Backlog Agent.
+   */
+  buildSystemPrompt() {
+    return BACKLOG_AGENT_SYSTEM_PROMPT;
+  }
+  /**
+   * Implements abstract method: create tools for Backlog Agent.
+   */
+  createTools() {
+    return createBacklogAgentTools(this.toolsContext);
+  }
+  /**
+   * Implements abstract method: create state manager for Backlog Agent.
+   * Uses file-backed persistence for backlog state and conversation history.
+   */
+  createStateManager() {
+    return new BacklogStateManager(this.workingDir, this.logger);
+  }
+};
+
+// src/infrastructure/agents/backlog-agent-manager.ts
+var BacklogAgentManager = class _BacklogAgentManager extends EventEmitter5 {
+  session;
+  backlog;
+  harness = null;
+  conversationHistory = [];
+  workingDir;
+  agentSessionManager;
+  logger;
+  llmAgent;
+  selectedAgent = null;
+  agentSelectionInProgress = false;
+  constructor(session, backlog, workingDir, agentSessionManager, logger) {
+    super();
+    this.session = session;
+    this.backlog = backlog;
+    this.workingDir = workingDir;
+    this.agentSessionManager = agentSessionManager;
+    this.logger = logger;
+    this.llmAgent = new BacklogAgent(
+      {
+        getStatus: () => this.getStatusBlocks(),
+        startHarness: () => this.startHarnessCommand(),
+        stopHarness: () => this.stopHarnessCommand(),
+        pauseHarness: () => this.pauseHarnessCommand(),
+        resumeHarness: () => this.resumeHarnessCommand(),
+        listTasks: () => this.listTasksBlocks(),
+        addTask: (title, description) => this.addTaskCommand({ title, description }),
+        getAvailableAgents: () => this.getAvailableAgentsData(),
+        parseAgentSelection: (userResponse) => this.parseAgentSelectionData(userResponse)
+      },
+      workingDir,
+      logger
+    );
+  }
+  /**
+   * Get session info.
+   */
+  getSession() {
+    return this.session;
+  }
+  /**
+   * Get current backlog.
+   */
+  getBacklog() {
+    return this.backlog;
+  }
+  /**
+   * Update backlog from file.
+   */
+  updateBacklogFromFile() {
+    const backlogPath = join8(this.workingDir, "backlog.json");
+    if (existsSync6(backlogPath)) {
+      try {
+        const content = readFileSync4(backlogPath, "utf-8");
+        this.backlog = BacklogSchema.parse(JSON.parse(content));
+        this.logger.debug("Updated backlog from file");
+      } catch (error) {
+        this.logger.error({ error }, "Failed to load backlog from file");
+      }
+    }
+  }
+  /**
+   * Process user command using streaming LLM execution.
+   *
+   * This method now uses the unified streaming mode from LangGraphAgent
+   * which emits blocks in real-time to all connected clients.
+   *
+   * For MVP, the command processor:
+   * - Parses user intent (start_harness, add_task, get_status, etc.)
+   * - Returns appropriate response through LLM streaming
+   * - Handles agent selection if in progress
+   */
+  async executeCommand(userMessage) {
+    this.conversationHistory.push({ role: "user", content: userMessage });
+    if (this.agentSelectionInProgress && !this.selectedAgent) {
+      const selectionBlocks = this.handleAgentSelection(userMessage);
+      const responseText = selectionBlocks.map((b) => b.content).join("\n");
+      this.conversationHistory.push({ role: "assistant", content: responseText });
+      this.saveBacklog();
+      return selectionBlocks;
+    }
+    const streamedBlocks = [];
+    const blockHandler = (_deviceId, blocks, isComplete, finalOutput) => {
+      streamedBlocks.push(...blocks);
+      if (isComplete && finalOutput) {
+        this.conversationHistory.push({ role: "assistant", content: finalOutput });
+        this.saveBacklog();
+      }
+    };
+    this.llmAgent.on("blocks", blockHandler);
+    try {
+      await this.llmAgent.executeWithStream(userMessage, "backlog-manager");
+    } finally {
+      this.llmAgent.removeListener("blocks", blockHandler);
+    }
+    return streamedBlocks;
+  }
+  /**
+   * Get status blocks for current backlog.
+   */
+  getStatusBlocks() {
+    const summary = this.backlog.summary ?? {
+      total: this.backlog.tasks.length,
+      completed: 0,
+      failed: 0,
+      in_progress: 0,
+      pending: 0
+    };
+    const percentage = summary.total > 0 ? Math.round(summary.completed / summary.total * 100) : 0;
+    const worktreeDisplay = this.backlog.worktree ?? "main";
+    const statusText = `
+\u{1F4CA} **Backlog Status**: ${this.backlog.id}
+
+**Progress**: ${summary.completed}/${summary.total} tasks (${percentage}%)
+
+**Breakdown**:
+- \u2705 Completed: ${summary.completed}
+- \u23F3 In Progress: ${summary.in_progress}
+- \u23F8\uFE0F Pending: ${summary.pending}
+- \u274C Failed: ${summary.failed}
+
+**Agent**: ${this.backlog.agent}
+**Worktree**: ${worktreeDisplay}
+
+**Harness Status**: ${this.harness ? this.session.harnessRunning ? "\u{1F7E2} Running" : "\u{1F534} Stopped" : "\u274C Not started"}
+    `.trim();
+    return [
+      {
+        id: "status",
+        block_type: "text",
+        content: statusText
+      }
+    ];
+  }
+  startHarnessCommand() {
+    if (this.harness) {
+      return [
+        {
+          id: "harness-already-running",
+          block_type: "text",
+          content: '\u26A0\uFE0F Harness is already running! Use "stop" to stop it first.'
+        }
+      ];
+    }
+    const pendingCount = this.backlog.tasks.filter((t) => t.status === "pending").length;
+    const inProgressCount = this.backlog.tasks.filter((t) => t.status === "in_progress").length;
+    if (pendingCount === 0 && inProgressCount === 0) {
+      return [
+        {
+          id: "no-tasks-to-run",
+          block_type: "text",
+          content: '\u274C No pending tasks to execute. Add tasks first using "add task" command.'
+        }
+      ];
+    }
+    if (!this.selectedAgent && !this.agentSelectionInProgress) {
+      return this.askForAgentSelection();
+    }
+    if (this.agentSelectionInProgress) {
+      return [
+        {
+          id: "agent-selection-pending",
+          block_type: "status",
+          content: "\u23F3 Waiting for you to select an agent..."
+        }
+      ];
+    }
+    return this.createAndStartHarness();
+  }
+  /**
+   * Ask user which agent to use for harness execution.
+   */
+  askForAgentSelection() {
+    this.agentSelectionInProgress = true;
+    const agents = Array.from(getAvailableAgents().values());
+    const agentList = agents.map((a) => `\u2022 **${a.name}**${a.isAlias ? " (alias)" : ""}: ${a.description}`).join("\n");
+    const question = `
+\u{1F916} **Select a coding agent** to execute the harness tasks:
+
+${agentList}
+
+Please respond with the agent name you'd like to use (e.g., "claude", "cursor", or your alias name).
+    `.trim();
+    return [
+      {
+        id: "agent-selection-question",
+        block_type: "text",
+        content: question
+      }
+    ];
+  }
+  /**
+   * Handle user's agent selection response.
+   */
+  handleAgentSelection(userMessage) {
+    const availableAgents = getAvailableAgents();
+    const agentNames = Array.from(availableAgents.keys());
+    const selectedAgent = this.findBestAgentMatch(userMessage, agentNames);
+    if (!selectedAgent) {
+      const agentList = agentNames.map((name) => {
+        const config2 = availableAgents.get(name);
+        return `\u2022 **${name}**${config2?.isAlias ? " (alias)" : ""}: ${config2?.description ?? ""}`;
+      }).join("\n");
+      return [
+        {
+          id: "agent-selection-invalid",
+          block_type: "text",
+          content: `\u274C I didn't recognize that agent name. Here are the available options:
+
+${agentList}
+
+Please try again.`
+        }
+      ];
+    }
+    this.selectedAgent = selectedAgent;
+    this.agentSelectionInProgress = false;
+    const selectedConfig = availableAgents.get(selectedAgent);
+    const confirmation = `\u2705 Great! I'll use **${selectedAgent}**${selectedConfig?.isAlias ? " (alias)" : ""} to execute the tasks.
+
+Now starting the harness...`;
+    const confirmationBlocks = [
+      {
+        id: "agent-selection-confirmed",
+        block_type: "status",
+        content: confirmation
+      }
+    ];
+    const harnessBlocks = this.createAndStartHarness();
+    return [...confirmationBlocks, ...harnessBlocks];
+  }
+  /**
+   * Find best agent match from user response using improved fuzzy matching.
+   * Handles variations like "claude code", "use cursor", "my zai alias", etc.
+   */
+  findBestAgentMatch(userMessage, agentNames) {
+    const lowerMessage = userMessage.toLowerCase();
+    for (const agentName of agentNames) {
+      if (lowerMessage === agentName.toLowerCase()) {
+        return agentName;
+      }
+    }
+    for (const agentName of agentNames) {
+      const lowerAgent = agentName.toLowerCase();
+      if (lowerMessage.includes(lowerAgent)) {
+        return agentName;
+      }
+    }
+    const commonPatterns = {
+      claude: ["claude", "claude code", "claudecode", "claude-code", "claude agent"],
+      cursor: ["cursor", "cursor agent", "cursoragent", "cursor-agent"],
+      opencode: ["opencode", "open code", "opencode agent", "open-code"]
+    };
+    for (const [baseName, patterns] of Object.entries(commonPatterns)) {
+      const agentName = agentNames.find((n) => n.toLowerCase() === baseName);
+      if (agentName) {
+        for (const pattern of patterns) {
+          if (lowerMessage.includes(pattern.toLowerCase())) {
+            return agentName;
+          }
+        }
+      }
+    }
+    let bestMatch = null;
+    const threshold = 0.6;
+    for (const agentName of agentNames) {
+      const similarity = this.calculateStringSimilarity(lowerMessage, agentName.toLowerCase());
+      if (similarity > threshold && (!bestMatch || similarity > bestMatch.score)) {
+        bestMatch = { name: agentName, score: similarity };
+      }
+    }
+    return bestMatch ? bestMatch.name : null;
+  }
+  /**
+   * Calculate string similarity score (0-1) using Levenshtein distance.
+   */
+  calculateStringSimilarity(str1, str2) {
+    const maxLen = Math.max(str1.length, str2.length);
+    if (maxLen === 0) return 1;
+    const distance = this.levenshteinDistance(str1, str2);
+    return 1 - distance / maxLen;
+  }
+  /**
+   * Calculate Levenshtein distance between two strings.
+   */
+  levenshteinDistance(str1, str2) {
+    const len1 = str1.length;
+    const len2 = str2.length;
+    const matrix = Array.from(
+      { length: len1 + 1 },
+      () => Array.from({ length: len2 + 1 }, () => 0)
+    );
+    for (let i = 0; i <= len1; i++) {
+      const row = matrix[i];
+      if (row) row[0] = i;
+    }
+    for (let j = 0; j <= len2; j++) {
+      const firstRow = matrix[0];
+      if (firstRow) firstRow[j] = j;
+    }
+    for (let i = 1; i <= len1; i++) {
+      for (let j = 1; j <= len2; j++) {
+        const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
+        const row = matrix[i];
+        const prevRow = matrix[i - 1];
+        if (row && prevRow) {
+          row[j] = Math.min(
+            (prevRow[j] ?? 0) + 1,
+            (row[j - 1] ?? 0) + 1,
+            (prevRow[j - 1] ?? 0) + cost
+          );
+        }
+      }
+    }
+    return matrix[len1]?.[len2] ?? 0;
+  }
+  /**
+   * Create and start the harness with selected agent.
+   */
+  createAndStartHarness() {
+    if (!this.selectedAgent) {
+      return [
+        {
+          id: "no-agent-selected",
+          block_type: "error",
+          content: "\u274C No agent selected. Please select an agent first."
+        }
+      ];
+    }
+    this.harness = new BacklogHarness(
+      this.backlog,
+      this.workingDir,
+      this.selectedAgent,
+      this.agentSessionManager,
+      this.logger
+    );
+    this.harness.on("output", (blocks) => {
+      this.emit("output", blocks);
+    });
+    this.harness.on("harness-completed", () => {
+      this.selectedAgent = null;
+      this.agentSelectionInProgress = false;
+    });
+    this.session.setHarnessRunning(true);
+    void this.harness.start().catch((error) => {
+      this.logger.error({ error }, "Harness error");
+      this.session.setHarnessRunning(false);
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      this.emit("output", [
+        {
+          id: "harness-error",
+          block_type: "error",
+          content: `\u{1F534} Harness error: ${errorMsg}`
+        }
+      ]);
+    });
+    const worktreeDisplay = this.backlog.worktree ?? "main";
+    const pendingCount = this.backlog.tasks.filter((t) => t.status === "pending").length;
+    const inProgressCount = this.backlog.tasks.filter((t) => t.status === "in_progress").length;
+    const tasksInfo = inProgressCount > 0 ? `${inProgressCount} task(s) in progress, ${pendingCount} pending` : `${pendingCount} task(s) to execute`;
+    return [
+      {
+        id: "harness-started",
+        block_type: "status",
+        content: `\u{1F680} Harness started for ${worktreeDisplay}. ${tasksInfo}.`
+      },
+      {
+        id: "harness-notice",
+        block_type: "text",
+        content: 'The harness will execute tasks sequentially. Use "status" to check progress, "pause" to pause, or "stop" to stop.'
+      }
+    ];
+  }
+  /**
+   * Stop harness execution and reset agent selection.
+   */
+  stopHarnessCommand() {
+    if (!this.harness || !this.session.harnessRunning) {
+      return [
+        {
+          id: "harness-not-running",
+          block_type: "text",
+          content: "\u26A0\uFE0F Harness is not running."
+        }
+      ];
+    }
+    this.harness.stop();
+    this.session.setHarnessRunning(false);
+    this.selectedAgent = null;
+    this.agentSelectionInProgress = false;
+    return [
+      {
+        id: "harness-stopped",
+        block_type: "status",
+        content: "\u23F9\uFE0F Harness stopped. Agent selection reset."
+      }
+    ];
+  }
+  pauseHarnessCommand() {
+    if (!this.harness || !this.session.harnessRunning) {
+      return [
+        {
+          id: "harness-not-running",
+          block_type: "text",
+          content: "\u26A0\uFE0F Harness is not running."
+        }
+      ];
+    }
+    this.harness.pause();
+    return [
+      {
+        id: "harness-paused",
+        block_type: "status",
+        content: "\u23F8\uFE0F Harness paused (current task will complete)."
+      }
+    ];
+  }
+  resumeHarnessCommand() {
+    if (!this.harness) {
+      return [
+        {
+          id: "harness-not-running",
+          block_type: "text",
+          content: "\u26A0\uFE0F Harness is not running."
+        }
+      ];
+    }
+    this.harness.resume();
+    return [
+      {
+        id: "harness-resumed",
+        block_type: "status",
+        content: "\u25B6\uFE0F Harness resumed."
+      }
+    ];
+  }
+  /**
+   * Add a new task to backlog.
+   */
+  addTaskCommand(params) {
+    const priorityValue = params.priority;
+    const complexityValue = params.complexity;
+    const newTask = {
+      id: Math.max(0, ...this.backlog.tasks.map((t) => t.id)) + 1,
+      title: params.title ?? "Untitled",
+      description: params.description ?? "",
+      acceptance_criteria: params.criteria ? [params.criteria] : [],
+      dependencies: [],
+      priority: priorityValue ?? "medium",
+      complexity: complexityValue ?? "moderate",
+      status: "pending",
+      retry_count: 0
+    };
+    this.backlog.tasks.push(newTask);
+    return [
+      {
+        id: "task-added",
+        block_type: "text",
+        content: `\u2705 Task ${newTask.id} added: "${newTask.title}"`
+      }
+    ];
+  }
+  /**
+   * Reorder tasks by priority/dependency.
+   */
+  listTasksBlocks() {
+    const statusEmoji = {
+      pending: "\u2B1C",
+      in_progress: "\u{1F7E8}",
+      completed: "\u2705",
+      failed: "\u274C",
+      skipped: "\u23ED\uFE0F"
+    };
+    const tasksList = this.backlog.tasks.map((t) => {
+      const emoji = statusEmoji[t.status] ?? "\u2753";
+      const status = t.status.replace("_", " ").toUpperCase();
+      let line = `${emoji} **${t.id}. ${t.title}** [${status}]`;
+      if (t.description) {
+        line += `
+   ${t.description.split("\n")[0]}`;
+      }
+      if (t.error) {
+        line += `
+   \u274C Error: ${t.error}`;
+      }
+      return line;
+    }).join("\n\n");
+    const summary = this.backlog.summary ?? {
+      total: this.backlog.tasks.length,
+      completed: 0,
+      failed: 0,
+      in_progress: 0,
+      pending: this.backlog.tasks.length
+    };
+    const content = `
+\u{1F4CB} **Tasks in ${this.backlog.id}**
+
+**Progress**: ${summary.completed}/${summary.total} completed
+
+**Breakdown**:
+\u2705 Completed: ${summary.completed}
+\u{1F7E8} In Progress: ${summary.in_progress}
+\u2B1C Pending: ${summary.pending}
+\u274C Failed: ${summary.failed}
+
+**Task List**:
+${tasksList}
+    `.trim();
+    return [
+      {
+        id: "tasks-list",
+        block_type: "text",
+        content
+      }
+    ];
+  }
+  getAvailableAgentsData() {
+    const availableAgents = getAvailableAgents();
+    const agents = Array.from(availableAgents.values()).map((config2) => ({
+      name: config2.name,
+      description: config2.description,
+      isAlias: config2.isAlias
+    }));
+    return Promise.resolve(agents);
+  }
+  parseAgentSelectionData(userResponse) {
+    const availableAgents = getAvailableAgents();
+    const agentNames = Array.from(availableAgents.keys());
+    const selectedAgent = this.findBestAgentMatch(userResponse, agentNames);
+    if (!selectedAgent) {
+      const availableList = agentNames.join(", ");
+      return Promise.resolve({
+        agentName: null,
+        valid: false,
+        message: `Invalid agent. Available agents: ${availableList}`
+      });
+    }
+    return Promise.resolve({
+      agentName: selectedAgent,
+      valid: true,
+      message: `Selected agent: ${selectedAgent}`
+    });
+  }
+  saveBacklog() {
+    const backlogPath = join8(this.workingDir, "backlog.json");
+    try {
+      writeFileSync3(backlogPath, JSON.stringify(this.backlog, null, 2));
+      this.logger.debug({ backlogPath }, "Saved backlog");
+    } catch (error) {
+      this.logger.error({ error }, "Failed to save backlog");
+    }
+  }
+  /**
+   * Create a new BacklogAgentManager for manual input.
+   */
+  static createEmpty(session, workingDir, agentSessionManager, logger) {
+    const agentType = session.agentName;
+    const backlog = {
+      id: session.backlogId,
+      project: workingDir.split("/").pop() ?? "project",
+      worktree: session.workspacePath?.worktree,
+      agent: agentType,
+      source: { type: "manual" },
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      tasks: [],
+      summary: { total: 0, completed: 0, failed: 0, in_progress: 0, pending: 0 }
+    };
+    return new _BacklogAgentManager(session, backlog, workingDir, agentSessionManager, logger);
+  }
+  /**
+   * Creates a manager and attempts to load backlog from file.
+   * If backlog.json doesn't exist, starts with empty backlog.
+   * Used during session restoration to load persisted backlog state.
+   */
+  static createAndLoadFromFile(session, workingDir, agentSessionManager, logger) {
+    const manager = _BacklogAgentManager.createEmpty(session, workingDir, agentSessionManager, logger);
+    manager.updateBacklogFromFile();
+    return manager;
+  }
+};
+
+// src/infrastructure/persistence/in-memory-session-manager.ts
+var InMemorySessionManager = class extends EventEmitter6 {
+  sessions = /* @__PURE__ */ new Map();
+  ptyManager;
+  agentSessionManager;
+  logger;
+  supervisorSession = null;
+  backlogManagers;
+  sessionRepository;
+  constructor(config2) {
+    super();
+    this.ptyManager = config2.ptyManager;
+    this.agentSessionManager = config2.agentSessionManager;
+    this.logger = config2.logger.child({ component: "session-manager" });
+    this.backlogManagers = config2.backlogManagers ?? /* @__PURE__ */ new Map();
+    this.sessionRepository = config2.sessionRepository;
+    this.setupAgentSessionSync();
+  }
+  /**
+   * Restores persisted sessions from the database on startup.
+   */
+  restoreSessions() {
+    this.logger.info("restoreSessions() called");
+    if (!this.sessionRepository) {
+      this.logger.warn("No session repository - skipping session restoration");
+      return Promise.resolve();
+    }
+    let persistedSessions = [];
+    try {
+      persistedSessions = this.sessionRepository.getActive();
+      this.logger.info(
+        { count: persistedSessions.length, sessions: persistedSessions.map((s) => ({ id: s.id, type: s.type })) },
+        "Restoring persisted sessions from database"
+      );
+      if (persistedSessions.length === 0) {
+        this.logger.info("No persisted sessions found in database");
+        return Promise.resolve();
+      }
+    } catch (dbError) {
+      this.logger.error(
+        { error: dbError instanceof Error ? dbError.message : String(dbError) },
+        "Error fetching sessions from database"
+      );
+      return Promise.resolve();
+    }
+    let backlogRestoreCount = 0;
+    for (const persistedSession of persistedSessions) {
+      try {
+        if (persistedSession.type === "backlog-agent") {
+          this.logger.info(
+            { sessionId: persistedSession.id, project: persistedSession.project, workingDir: persistedSession.workingDir },
+            "Starting restoration of backlog-agent session"
+          );
+          const backlogPath = join9(persistedSession.workingDir, "backlog.json");
+          let agentName = "claude";
+          if (existsSync7(backlogPath)) {
+            try {
+              const backlogContent = readFileSync5(backlogPath, "utf-8");
+              const backlogData = JSON.parse(backlogContent);
+              if (backlogData.agent && ["claude", "cursor", "opencode"].includes(backlogData.agent)) {
+                agentName = backlogData.agent;
+              }
+              this.logger.debug(
+                { sessionId: persistedSession.id, agentName },
+                "Loaded agent type from backlog.json"
+              );
+            } catch (parseError) {
+              this.logger.warn(
+                { sessionId: persistedSession.id, error: parseError },
+                "Failed to parse backlog.json, using default agent"
+              );
+            }
+          }
+          const backlogSession = new BacklogAgentSession({
+            id: new SessionId(persistedSession.id),
+            type: "backlog-agent",
+            workspacePath: persistedSession.workspace ? new WorkspacePath(
+              persistedSession.workspace,
+              persistedSession.project ?? void 0,
+              persistedSession.worktree ?? void 0
+            ) : void 0,
+            workingDir: persistedSession.workingDir,
+            agentName,
+            backlogId: `${persistedSession.project ?? "unknown"}-${Date.now()}`
+          });
+          this.sessions.set(persistedSession.id, backlogSession);
+          try {
+            const manager = BacklogAgentManager.createAndLoadFromFile(
+              backlogSession,
+              persistedSession.workingDir,
+              this.agentSessionManager,
+              this.logger
+            );
+            this.backlogManagers.set(persistedSession.id, manager);
+            backlogRestoreCount++;
+            this.logger.info(
+              {
+                sessionId: persistedSession.id,
+                project: persistedSession.project,
+                backlogManagersCount: this.backlogManagers.size,
+                isInMap: this.backlogManagers.has(persistedSession.id)
+              },
+              "Successfully restored backlog-agent session from database"
+            );
+          } catch (managerError) {
+            this.logger.error(
+              { sessionId: persistedSession.id, error: managerError instanceof Error ? managerError.message : String(managerError), stack: managerError instanceof Error ? managerError.stack : void 0 },
+              "Failed to create backlog manager during restoration"
+            );
+            throw managerError;
+          }
+        } else if (persistedSession.type === "supervisor") {
+          this.logger.debug({ sessionId: persistedSession.id }, "Skipping supervisor session restoration (singleton)");
+        } else if (persistedSession.type === "terminal") {
+          this.logger.debug({ sessionId: persistedSession.id }, "Skipping terminal session restoration (requires PTY)");
+        }
+      } catch (error) {
+        this.logger.error(
+          { sessionId: persistedSession.id, error: error instanceof Error ? error.message : String(error), stack: error instanceof Error ? error.stack : void 0 },
+          "Error restoring session from database"
+        );
+      }
+    }
+    this.logger.info(
+      {
+        backlogManagersRestored: backlogRestoreCount,
+        totalBacklogManagers: this.backlogManagers.size,
+        backlogManagerIds: Array.from(this.backlogManagers.keys())
+      },
+      "Session restoration complete"
+    );
+    return Promise.resolve();
+  }
+  /**
+   * 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"
         );
       }
@@ -6473,7 +8463,7 @@ var InMemorySessionManager = class extends EventEmitter3 {
    * Creates a new session.
    */
   async createSession(params) {
-    const { sessionType, workingDir, terminalSize, agentName } = params;
+    const { sessionType, workingDir, terminalSize, agentName, backlogAgent, backlogId } = params;
     if (sessionType === "supervisor") {
       return this.getOrCreateSupervisor(workingDir);
     }
@@ -6482,6 +8472,16 @@ var InMemorySessionManager = class extends EventEmitter3 {
       const rows = terminalSize?.rows ?? SESSION_CONFIG.DEFAULT_TERMINAL_ROWS;
       const session = await this.ptyManager.create(workingDir, cols, rows);
       this.sessions.set(session.id.value, session);
+      if (this.sessionRepository) {
+        this.sessionRepository.create({
+          id: session.id.value,
+          type: "terminal",
+          workspace: params.workspacePath?.workspace,
+          project: params.workspacePath?.project,
+          worktree: params.workspacePath?.worktree,
+          workingDir
+        });
+      }
       this.logger.info(
         { sessionId: session.id.value, sessionType, workingDir },
         "Terminal session created"
@@ -6489,6 +8489,9 @@ var InMemorySessionManager = class extends EventEmitter3 {
       this.emit("terminalSessionCreated", session);
       return session;
     }
+    if (sessionType === "backlog-agent") {
+      return this.createBacklogSession(workingDir, backlogAgent ?? "claude", backlogId, params.workspacePath);
+    }
     if (isAgentType(sessionType)) {
       return this.createAgentSession(sessionType, workingDir, agentName, params.workspacePath);
     }
@@ -6521,6 +8524,16 @@ var InMemorySessionManager = class extends EventEmitter3 {
       cliSessionId: agentState.cliSessionId
     });
     this.sessions.set(sessionId.value, session);
+    if (this.sessionRepository) {
+      this.sessionRepository.create({
+        id: sessionId.value,
+        type: agentName ?? agentType,
+        workspace: workspacePath?.workspace,
+        project: workspacePath?.project,
+        worktree: workspacePath?.worktree,
+        workingDir
+      });
+    }
     this.logger.info(
       { sessionId: sessionId.value, agentType, agentName: resolvedAgentName, workingDir, workspacePath },
       "Agent session created"
@@ -6541,6 +8554,13 @@ var InMemorySessionManager = class extends EventEmitter3 {
       workingDir
     });
     this.sessions.set(sessionId.value, this.supervisorSession);
+    if (this.sessionRepository) {
+      this.sessionRepository.create({
+        id: sessionId.value,
+        type: "supervisor",
+        workingDir
+      });
+    }
     this.logger.info(
       { sessionId: sessionId.value },
       "Supervisor session created"
@@ -6648,19 +8668,111 @@ var InMemorySessionManager = class extends EventEmitter3 {
   getAgentSessionManager() {
     return this.agentSessionManager;
   }
+  /**
+   * Creates a backlog agent session.
+   */
+  createBacklogSession(workingDir, backlogAgent, backlogId, workspacePath) {
+    const sessionId = new SessionId(`backlog-${nanoid3(8)}`);
+    const finalBacklogId = backlogId ?? `backlog-${nanoid3(8)}`;
+    const session = new BacklogAgentSession({
+      id: sessionId,
+      type: "backlog-agent",
+      workspacePath,
+      workingDir,
+      agentName: backlogAgent,
+      backlogId: finalBacklogId
+    });
+    this.sessions.set(sessionId.value, session);
+    const manager = BacklogAgentManager.createEmpty(
+      session,
+      workingDir,
+      this.agentSessionManager,
+      this.logger
+    );
+    this.backlogManagers.set(sessionId.value, manager);
+    this.logger.debug(
+      {
+        sessionId: sessionId.value,
+        backlogManagersCount: this.backlogManagers.size
+      },
+      "BacklogAgentManager registered"
+    );
+    if (this.sessionRepository) {
+      this.sessionRepository.create({
+        id: sessionId.value,
+        type: "backlog-agent",
+        workspace: workspacePath?.workspace,
+        project: workspacePath?.project,
+        worktree: workspacePath?.worktree,
+        workingDir
+      });
+    }
+    this.logger.info(
+      {
+        sessionId: sessionId.value,
+        backlogId: finalBacklogId,
+        backlogAgent,
+        workingDir,
+        workspacePath
+      },
+      "Backlog agent session created"
+    );
+    return session;
+  }
+  /**
+   * Gets the backlog managers registry.
+   */
+  getBacklogManagers() {
+    return this.backlogManagers;
+  }
 };
 
-// src/infrastructure/agents/supervisor/supervisor-agent.ts
-import { EventEmitter as EventEmitter4 } from "events";
-import { ChatOpenAI } from "@langchain/openai";
-import { createReactAgent } from "@langchain/langgraph/prebuilt";
-import { HumanMessage, AIMessage, isAIMessage } from "@langchain/core/messages";
+// src/infrastructure/agents/supervisor/supervisor-state-manager.ts
+var SupervisorStateManager = class {
+  constructor(chatHistoryService) {
+    this.chatHistoryService = chatHistoryService;
+  }
+  loadHistory() {
+    const history = this.chatHistoryService.getSupervisorHistory();
+    const entries = history.map((entry) => ({
+      role: entry.role,
+      content: entry.content,
+      timestamp: new Date(entry.createdAt).getTime()
+    }));
+    return Promise.resolve(entries);
+  }
+  saveHistory(history) {
+    if (history.length === 0) return Promise.resolve();
+    const lastEntry = history[history.length - 1];
+    if (!lastEntry) return Promise.resolve();
+    if (lastEntry.role === "system") return Promise.resolve();
+    const storedHistory = this.chatHistoryService.getSupervisorHistory(1);
+    const mostRecentStored = storedHistory[0];
+    if (!mostRecentStored || mostRecentStored.content !== lastEntry.content) {
+      this.chatHistoryService.saveSupervisorMessage(lastEntry.role, lastEntry.content);
+    }
+    return Promise.resolve();
+  }
+  clearHistory() {
+    this.chatHistoryService.clearSupervisorHistory();
+    return Promise.resolve();
+  }
+  loadAdditionalState(_key) {
+    return Promise.resolve(null);
+  }
+  saveAdditionalState(_key, _state) {
+    return Promise.resolve();
+  }
+  close() {
+    return Promise.resolve();
+  }
+};
 
-// src/infrastructure/agents/supervisor/tools/workspace-tools.ts
-import { tool } from "@langchain/core/tools";
-import { z as z3 } from "zod";
+// src/infrastructure/agents/supervisor/tools/workspace-tools.ts
+import { tool as tool2 } from "@langchain/core/tools";
+import { z as z5 } from "zod";
 function createWorkspaceTools(workspaceDiscovery) {
-  const listWorkspaces = tool(
+  const listWorkspaces = tool2(
     async () => {
       const workspaces = await workspaceDiscovery.listWorkspaces();
       if (workspaces.length === 0) {
@@ -6672,10 +8784,10 @@ ${workspaces.map((w) => `- ${w.name} (${w.projectCount} projects)`).join("\n")}`
     {
       name: "list_workspaces",
       description: "Lists all available workspaces (top-level directories in the workspaces root). Use this to discover what workspaces exist.",
-      schema: z3.object({})
+      schema: z5.object({})
     }
   );
-  const listProjects = tool(
+  const listProjects = tool2(
     async ({ workspace }) => {
       try {
         const projects = await workspaceDiscovery.listProjects(workspace);
@@ -6691,12 +8803,12 @@ ${projects.map((p) => `- ${p.name}${p.isGitRepo ? " (git)" : ""}`).join("\n")}`;
     {
       name: "list_projects",
       description: "Lists all projects in a specific workspace. Projects are git repositories or directories.",
-      schema: z3.object({
-        workspace: z3.string().describe("Name of the workspace to list projects from")
+      schema: z5.object({
+        workspace: z5.string().describe("Name of the workspace to list projects from")
       })
     }
   );
-  const getProjectInfo = tool(
+  const getProjectInfo = tool2(
     async ({ workspace, project }) => {
       try {
         const projectInfo = await workspaceDiscovery.getProject(workspace, project);
@@ -6717,13 +8829,13 @@ Default Branch: ${projectInfo.defaultBranch}` : ""}${worktreeInfo}`;
     {
       name: "get_project_info",
       description: "Gets detailed information about a project including its path and any git worktrees.",
-      schema: z3.object({
-        workspace: z3.string().describe("Name of the workspace"),
-        project: z3.string().describe("Name of the project")
+      schema: z5.object({
+        workspace: z5.string().describe("Name of the workspace"),
+        project: z5.string().describe("Name of the project")
       })
     }
   );
-  const createWorkspace = tool(
+  const createWorkspace = tool2(
     async ({ name }) => {
       try {
         const workspace = await workspaceDiscovery.createWorkspace(name);
@@ -6735,15 +8847,15 @@ Default Branch: ${projectInfo.defaultBranch}` : ""}${worktreeInfo}`;
     {
       name: "create_workspace",
       description: 'Creates a new workspace directory. The name must be in lower-kebab-case (e.g., "my-company", "personal-projects").',
-      schema: z3.object({
-        name: z3.string().regex(
+      schema: z5.object({
+        name: z5.string().regex(
           /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/,
           'Name must be in lower-kebab-case (e.g., "my-workspace")'
         ).describe("Name for the new workspace in lower-kebab-case")
       })
     }
   );
-  const createProject = tool(
+  const createProject = tool2(
     async ({
       workspace,
       name,
@@ -6761,13 +8873,13 @@ Path: ${project.path}`;
     {
       name: "create_project",
       description: "Creates a new project directory within a workspace. The name must be in lower-kebab-case. By default, initializes a git repository.",
-      schema: z3.object({
-        workspace: z3.string().describe("Name of the workspace to create the project in"),
-        name: z3.string().regex(
+      schema: z5.object({
+        workspace: z5.string().describe("Name of the workspace to create the project in"),
+        name: z5.string().regex(
           /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/,
           'Name must be in lower-kebab-case (e.g., "my-project")'
         ).describe("Name for the new project in lower-kebab-case"),
-        init_git: z3.boolean().optional().default(true).describe("Whether to initialize a git repository (default: true)")
+        init_git: z5.boolean().optional().default(true).describe("Whether to initialize a git repository (default: true)")
       })
     }
   );
@@ -6775,10 +8887,10 @@ 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";
+import { tool as tool3 } from "@langchain/core/tools";
+import { z as z6 } from "zod";
 function createWorktreeTools(workspaceDiscovery, _agentSessionManager) {
-  const listWorktrees = tool2(
+  const listWorktrees = tool3(
     async ({ workspace, project }) => {
       try {
         const worktrees = await workspaceDiscovery.listWorktrees(workspace, project);
@@ -6794,13 +8906,13 @@ ${worktrees.map((w) => `- ${w.name}: ${w.branch} (${w.path})`).join("\n")}`;
     {
       name: "list_worktrees",
       description: "Lists all git worktrees for a specific project. Worktrees allow working on multiple branches simultaneously.",
-      schema: z4.object({
-        workspace: z4.string().describe("Name of the workspace"),
-        project: z4.string().describe("Name of the project (git repository)")
+      schema: z6.object({
+        workspace: z6.string().describe("Name of the workspace"),
+        project: z6.string().describe("Name of the project (git repository)")
       })
     }
   );
-  const createWorktree = tool2(
+  const createWorktree = tool3(
     async ({
       workspace,
       project,
@@ -6825,16 +8937,16 @@ ${worktrees.map((w) => `- ${w.name}: ${w.branch} (${w.path})`).join("\n")}`;
     {
       name: "create_worktree",
       description: "Creates a new git worktree for a project. Use this to work on a different branch without switching. Can either checkout an existing branch or create a new branch.",
-      schema: z4.object({
-        workspace: z4.string().describe("Name of the workspace"),
-        project: z4.string().describe("Name of the project (git repository)"),
-        branch: z4.string().describe("Branch name to use in the worktree"),
-        createNewBranch: z4.boolean().optional().describe("If true, creates a new branch with the given name. If false or omitted, checks out an existing branch."),
-        baseBranch: z4.string().optional().describe('When creating a new branch, specifies the starting point (e.g., "main", "develop"). Defaults to current HEAD if not specified.')
+      schema: z6.object({
+        workspace: z6.string().describe("Name of the workspace"),
+        project: z6.string().describe("Name of the project (git repository)"),
+        branch: z6.string().describe("Branch name to use in the worktree"),
+        createNewBranch: z6.boolean().optional().describe("If true, creates a new branch with the given name. If false or omitted, checks out an existing branch."),
+        baseBranch: z6.string().optional().describe('When creating a new branch, specifies the starting point (e.g., "main", "develop"). Defaults to current HEAD if not specified.')
       })
     }
   );
-  const removeWorktree = tool2(
+  const removeWorktree = tool3(
     async ({
       workspace,
       project,
@@ -6850,14 +8962,14 @@ ${worktrees.map((w) => `- ${w.name}: ${w.branch} (${w.path})`).join("\n")}`;
     {
       name: "remove_worktree",
       description: "Removes a git worktree from a project. This deletes the worktree directory.",
-      schema: z4.object({
-        workspace: z4.string().describe("Name of the workspace"),
-        project: z4.string().describe("Name of the project"),
-        worktreeName: z4.string().describe("Name of the worktree to remove")
+      schema: z6.object({
+        workspace: z6.string().describe("Name of the workspace"),
+        project: z6.string().describe("Name of the project"),
+        worktreeName: z6.string().describe("Name of the worktree to remove")
       })
     }
   );
-  const branchStatus = tool2(
+  const branchStatus = tool3(
     async ({ workspace, project }) => {
       try {
         const status = await workspaceDiscovery.getBranchStatus(workspace, project);
@@ -6876,13 +8988,13 @@ ${status.uncommittedChanges.map((c) => `  ${c}`).join("\n")}`
     {
       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")
+      schema: z6.object({
+        workspace: z6.string().describe("Workspace name containing the project"),
+        project: z6.string().describe("Project name to get branch status for")
       })
     }
   );
-  const mergeBranch = tool2(
+  const mergeBranch = tool3(
     async ({ workspace, project, sourceBranch, targetBranch, pushAfter, skipPreCheck }) => {
       try {
         const result = await workspaceDiscovery.mergeBranch(
@@ -6903,17 +9015,17 @@ ${status.uncommittedChanges.map((c) => `  ${c}`).join("\n")}`
     {
       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)")
+      schema: z6.object({
+        workspace: z6.string().describe("Workspace name"),
+        project: z6.string().describe("Project name"),
+        sourceBranch: z6.string().describe("Source branch to merge from"),
+        targetBranch: z6.string().optional().describe("Target branch (defaults to main)"),
+        pushAfter: z6.boolean().optional().describe("Push to remote after successful merge"),
+        skipPreCheck: z6.boolean().optional().describe("Skip pre-merge safety checks (not recommended)")
       })
     }
   );
-  const listMergeableBranches = tool2(
+  const listMergeableBranches = tool3(
     async ({ workspace, project }) => {
       try {
         const branches = await workspaceDiscovery.listMergeableBranches(workspace, project);
@@ -6942,13 +9054,13 @@ ${statusLines.join("\n")}`;
     {
       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")
+      schema: z6.object({
+        workspace: z6.string().describe("Workspace name"),
+        project: z6.string().describe("Project name")
       })
     }
   );
-  const cleanupWorktree = tool2(
+  const cleanupWorktree = tool3(
     async ({ workspace, project, branch, force }) => {
       try {
         if (!force) {
@@ -6978,15 +9090,15 @@ ${statusLines.join("\n")}`;
     {
       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")
+      schema: z6.object({
+        workspace: z6.string().describe("Workspace name"),
+        project: z6.string().describe("Project name"),
+        branch: z6.string().describe("Branch/worktree name to cleanup"),
+        force: z6.boolean().optional().describe("Force cleanup even with uncommitted changes")
       })
     }
   );
-  const completeFeature = tool2(
+  const completeFeature = tool3(
     async ({ workspace, project, featureBranch, targetBranch, skipConfirmation }) => {
       try {
         const results = [];
@@ -7055,12 +9167,12 @@ Steps executed:
     {
       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)")
+      schema: z6.object({
+        workspace: z6.string().describe("Workspace name"),
+        project: z6.string().describe("Project name"),
+        featureBranch: z6.string().describe("Feature branch name to complete"),
+        targetBranch: z6.string().optional().describe("Target branch (defaults to main)"),
+        skipConfirmation: z6.boolean().optional().describe("Skip safety checks (not recommended)")
       })
     }
   );
@@ -7077,10 +9189,10 @@ Steps executed:
 }
 
 // src/infrastructure/agents/supervisor/tools/session-tools.ts
-import { tool as tool3 } from "@langchain/core/tools";
-import { z as z5 } from "zod";
+import { tool as tool4 } from "@langchain/core/tools";
+import { z as z7 } from "zod";
 function createSessionTools(sessionManager, agentSessionManager, workspaceDiscovery, workspacesRoot, _getMessageBroadcaster, getChatHistoryService, clearSupervisorContext, terminateSessionCallback) {
-  const listSessions = tool3(
+  const listSessions = tool4(
     () => {
       const chatHistoryService = getChatHistoryService?.();
       const inMemorySessions = sessionManager.getAllSessions();
@@ -7108,10 +9220,10 @@ ${allSessions.map((s) => `- [${s.type}] ${s.id} (${s.status}) - ${s.workingDir}`
     {
       name: "list_sessions",
       description: "Lists all active sessions (terminals, agents). Use this to see what sessions are running.",
-      schema: z5.object({})
+      schema: z7.object({})
     }
   );
-  const listAvailableAgents = tool3(
+  const listAvailableAgents = tool4(
     () => {
       const agents = getAvailableAgents();
       if (agents.size === 0) {
@@ -7127,10 +9239,10 @@ ${allSessions.map((s) => `- [${s.type}] ${s.id} (${s.status}) - ${s.workingDir}`
     {
       name: "list_available_agents",
       description: "Lists all available AI agent types, including base agents (cursor, claude, opencode) and custom aliases configured via AGENT_ALIAS_* environment variables.",
-      schema: z5.object({})
+      schema: z7.object({})
     }
   );
-  const createAgentSession = tool3(
+  const createAgentSession = tool4(
     async ({
       agentName,
       workspace,
@@ -7143,7 +9255,10 @@ ${allSessions.map((s) => `- [${s.type}] ${s.id} (${s.status}) - ${s.workingDir}`
           const available = Array.from(getAvailableAgents().keys()).join(", ");
           return `Error: Unknown agent "${agentName}". Available agents: ${available}`;
         }
-        const normalizedWorktree = worktree === "main" ? void 0 : worktree;
+        let normalizedWorktree = worktree;
+        if (normalizedWorktree && (normalizedWorktree.toLowerCase() === "main" || normalizedWorktree.toLowerCase() === "master")) {
+          normalizedWorktree = void 0;
+        }
         const workingDir = workspaceDiscovery.resolvePath(workspace, project, normalizedWorktree);
         const exists = await workspaceDiscovery.pathExists(workingDir);
         if (!exists) {
@@ -7164,22 +9279,25 @@ Working directory: ${session.workingDir}`;
     {
       name: "create_agent_session",
       description: "Creates a new AI agent session in a specific project. Supports base agents (cursor, claude, opencode) and custom aliases configured via AGENT_ALIAS_* environment variables. Use list_available_agents to see all available options.",
-      schema: z5.object({
-        agentName: z5.string().describe('Name of the agent to start (e.g., "claude", "cursor", "opencode", or a custom alias like "zai")'),
-        workspace: z5.string().describe("Name of the workspace"),
-        project: z5.string().describe("Name of the project"),
-        worktree: z5.string().optional().describe("Optional worktree name")
+      schema: z7.object({
+        agentName: z7.string().describe('Name of the agent to start (e.g., "claude", "cursor", "opencode", or a custom alias like "zai")'),
+        workspace: z7.string().describe("Name of the workspace"),
+        project: z7.string().describe("Name of the project"),
+        worktree: z7.string().optional().describe("Optional worktree name")
       })
     }
   );
-  const createTerminalSession = tool3(
+  const createTerminalSession = tool4(
     async ({
       workspace,
       project,
       worktree
     }) => {
       try {
-        const normalizedWorktree = worktree === "main" ? void 0 : worktree;
+        let normalizedWorktree = worktree;
+        if (normalizedWorktree && (normalizedWorktree.toLowerCase() === "main" || normalizedWorktree.toLowerCase() === "master")) {
+          normalizedWorktree = void 0;
+        }
         let workingDir;
         if (workspace && project) {
           workingDir = workspaceDiscovery.resolvePath(workspace, project, normalizedWorktree);
@@ -7211,14 +9329,14 @@ Working directory: ${session.workingDir}`;
 - workspace + project + worktree: opens terminal in that worktree directory
 
 Use this tool when user asks to "open terminal", "create terminal", or similar requests.`,
-      schema: z5.object({
-        workspace: z5.string().optional().describe("Name of the workspace. Omit to open in workspaces root."),
-        project: z5.string().optional().describe("Name of the project within the workspace. Requires workspace."),
-        worktree: z5.string().optional().describe("Worktree name. Requires workspace and project.")
+      schema: z7.object({
+        workspace: z7.string().optional().describe("Name of the workspace. Omit to open in workspaces root."),
+        project: z7.string().optional().describe("Name of the project within the workspace. Requires workspace."),
+        worktree: z7.string().optional().describe("Worktree name. Requires workspace and project.")
       })
     }
   );
-  const terminateSession = tool3(
+  const terminateSession = tool4(
     async ({ sessionId }) => {
       try {
         if (!terminateSessionCallback) {
@@ -7236,12 +9354,12 @@ Use this tool when user asks to "open terminal", "create terminal", or similar r
     {
       name: "terminate_session",
       description: "Terminates an active session by its ID.",
-      schema: z5.object({
-        sessionId: z5.string().describe("ID of the session to terminate")
+      schema: z7.object({
+        sessionId: z7.string().describe("ID of the session to terminate")
       })
     }
   );
-  const terminateAllSessions = tool3(
+  const terminateAllSessions = tool4(
     async ({ sessionType }) => {
       try {
         if (!terminateSessionCallback) {
@@ -7294,12 +9412,12 @@ ${errors.map((e) => `  - ${e}`).join("\n")}`;
     {
       name: "terminate_all_sessions",
       description: "Terminates all active sessions, or all sessions of a specific type (terminal, cursor, claude, opencode).",
-      schema: z5.object({
-        sessionType: z5.enum(["terminal", "cursor", "claude", "opencode", "all"]).optional().describe('Type of sessions to terminate. Omit or use "all" to terminate all sessions.')
+      schema: z7.object({
+        sessionType: z7.enum(["terminal", "cursor", "claude", "opencode", "all"]).optional().describe('Type of sessions to terminate. Omit or use "all" to terminate all sessions.')
       })
     }
   );
-  const getSessionInfo = tool3(
+  const getSessionInfo = tool4(
     async ({ sessionId }) => {
       try {
         const { SessionId: SessionId2 } = await import("./session-id-VKOYWZAK.js");
@@ -7334,12 +9452,12 @@ Messages: ${agentState.messages.length}`;
     {
       name: "get_session_info",
       description: "Gets detailed information about a specific session.",
-      schema: z5.object({
-        sessionId: z5.string().describe("ID of the session")
+      schema: z7.object({
+        sessionId: z7.string().describe("ID of the session")
       })
     }
   );
-  const listSessionsWithWorktrees = tool3(
+  const listSessionsWithWorktrees = tool4(
     () => {
       try {
         const sessions2 = agentSessionManager.listSessionsWithWorktreeInfo();
@@ -7361,10 +9479,10 @@ ${sessionLines.join("\n")}`;
     {
       name: "list_sessions_with_worktrees",
       description: "Lists all active sessions with worktree information for branch management",
-      schema: z5.object({})
+      schema: z7.object({})
     }
   );
-  const getWorktreeSessionSummary = tool3(
+  const getWorktreeSessionSummary = tool4(
     ({ workspace, project, branch }) => {
       try {
         const summary = agentSessionManager.getWorktreeSessionSummary(workspace, project, branch);
@@ -7387,14 +9505,14 @@ Executing: ${summary.executingCount}`;
     {
       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")
+      schema: z7.object({
+        workspace: z7.string().describe("Workspace name"),
+        project: z7.string().describe("Project name"),
+        branch: z7.string().describe("Branch/worktree name")
       })
     }
   );
-  const terminateWorktreeSessions = tool3(
+  const terminateWorktreeSessions = tool4(
     ({ workspace, project, branch }) => {
       try {
         const terminatedSessions = agentSessionManager.terminateWorktreeSessions(workspace, project, branch);
@@ -7410,14 +9528,14 @@ ${terminatedSessions.map((id) => `  - ${id}`).join("\n")}`;
     {
       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")
+      schema: z7.object({
+        workspace: z7.string().describe("Workspace name"),
+        project: z7.string().describe("Project name"),
+        branch: z7.string().describe("Branch/worktree name")
       })
     }
   );
-  const clearContext = tool3(
+  const clearContext = tool4(
     () => {
       try {
         if (clearSupervisorContext) {
@@ -7431,7 +9549,7 @@ ${terminatedSessions.map((id) => `  - ${id}`).join("\n")}`;
     {
       name: "clear_supervisor_context",
       description: 'Clears the supervisor agent conversation context and history. Use when user asks to "clear context", "reset conversation", "start fresh", or similar requests.',
-      schema: z5.object({})
+      schema: z7.object({})
     }
   );
   return [
@@ -7450,12 +9568,12 @@ ${terminatedSessions.map((id) => `  - ${id}`).join("\n")}`;
 }
 
 // src/infrastructure/agents/supervisor/tools/filesystem-tools.ts
-import { tool as tool4 } from "@langchain/core/tools";
-import { z as z6 } from "zod";
+import { tool as tool5 } from "@langchain/core/tools";
+import { z as z8 } from "zod";
 import { readdir as readdir3, readFile as readFile2, stat as stat2 } from "fs/promises";
-import { join as join6, resolve } from "path";
+import { join as join10, resolve } from "path";
 function createFilesystemTools(workspacesRoot) {
-  const listDirectory = tool4(
+  const listDirectory = tool5(
     async ({ path, showHidden }) => {
       try {
         const resolvedPath = resolveSafePath(path, workspacesRoot);
@@ -7477,432 +9595,324 @@ ${formatted.join("\n")}`;
     {
       name: "list_directory",
       description: "Lists the contents of a directory. Shows files and subdirectories.",
-      schema: z6.object({
-        path: z6.string().describe("Path to the directory (relative to workspaces root or absolute)"),
-        showHidden: z6.boolean().optional().describe("Whether to show hidden files (starting with .)")
+      schema: z8.object({
+        path: z8.string().describe("Path to the directory (relative to workspaces root or absolute)"),
+        showHidden: z8.boolean().optional().describe("Whether to show hidden files (starting with .)")
       })
     }
   );
-  const readFileContent = tool4(
+  const readFileContent = tool5(
     async ({ path, maxLines }) => {
       try {
         const resolvedPath = resolveSafePath(path, workspacesRoot);
         const fileStat = await stat2(resolvedPath);
-        if (fileStat.size > 100 * 1024) {
-          return `File is too large (${Math.round(fileStat.size / 1024)}KB). Maximum is 100KB.`;
-        }
-        const content = await readFile2(resolvedPath, "utf-8");
-        const lines = content.split("\n");
-        if (maxLines && lines.length > maxLines) {
-          return `File: ${path} (showing first ${maxLines} of ${lines.length} lines)
-
-${lines.slice(0, maxLines).join("\n")}
-
-... (${lines.length - maxLines} more lines)`;
-        }
-        return `File: ${path}
-
-${content}`;
-      } catch (error) {
-        return `Error reading file: ${error instanceof Error ? error.message : String(error)}`;
-      }
-    },
-    {
-      name: "read_file",
-      description: "Reads the contents of a file. Limited to 100KB files for safety.",
-      schema: z6.object({
-        path: z6.string().describe("Path to the file"),
-        maxLines: z6.number().optional().describe("Maximum number of lines to return")
-      })
-    }
-  );
-  const getFileInfo = tool4(
-    async ({ path }) => {
-      try {
-        const resolvedPath = resolveSafePath(path, workspacesRoot);
-        const fileStat = await stat2(resolvedPath);
-        const info = [
-          `Path: ${path}`,
-          `Type: ${fileStat.isDirectory() ? "Directory" : "File"}`,
-          `Size: ${formatSize(fileStat.size)}`,
-          `Modified: ${fileStat.mtime.toISOString()}`,
-          `Created: ${fileStat.birthtime.toISOString()}`
-        ];
-        return info.join("\n");
-      } catch (error) {
-        return `Error getting file info: ${error instanceof Error ? error.message : String(error)}`;
-      }
-    },
-    {
-      name: "get_file_info",
-      description: "Gets information about a file or directory (size, modified date, etc.).",
-      schema: z6.object({
-        path: z6.string().describe("Path to the file or directory")
-      })
-    }
-  );
-  return [listDirectory, readFileContent, getFileInfo];
-}
-function resolveSafePath(path, workspacesRoot) {
-  const resolved = path.startsWith("/") ? path : join6(workspacesRoot, path);
-  const normalized = resolve(resolved);
-  const homeDir = process.env.HOME ?? "/";
-  if (!normalized.startsWith(workspacesRoot) && !normalized.startsWith(homeDir)) {
-    throw new Error(`Access denied: Path must be within ${workspacesRoot} or home directory`);
-  }
-  return normalized;
-}
-function formatSize(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
-  return `${(bytes / 1024 / 1024 / 1024).toFixed(1)} GB`;
-}
-
-// src/infrastructure/agents/supervisor/supervisor-agent.ts
-var SupervisorAgent = class extends EventEmitter4 {
-  logger;
-  agent;
-  getMessageBroadcaster;
-  getChatHistoryService;
-  conversationHistory = [];
-  abortController = null;
-  isExecuting = false;
-  isCancelled = false;
-  /** Tracks if we're processing a command (including STT, before LLM execution) */
-  isProcessingCommand = false;
-  /** Timestamp when current execution started (for race condition protection) */
-  executionStartedAt = 0;
-  constructor(config2) {
-    super();
-    this.logger = config2.logger.child({ component: "SupervisorAgent" });
-    this.getMessageBroadcaster = config2.getMessageBroadcaster;
-    this.getChatHistoryService = config2.getChatHistoryService;
-    const env = getEnv();
-    const llm = this.createLLM(env);
-    const terminateSessionCallback = async (sessionId) => {
-      const terminate = config2.getTerminateSession?.();
-      if (!terminate) {
-        this.logger.warn("Terminate session callback not available");
-        return false;
-      }
-      return terminate(sessionId);
-    };
-    const tools = [
-      ...createWorkspaceTools(config2.workspaceDiscovery),
-      ...createWorktreeTools(config2.workspaceDiscovery, config2.agentSessionManager),
-      ...createSessionTools(
-        config2.sessionManager,
-        config2.agentSessionManager,
-        config2.workspaceDiscovery,
-        config2.workspacesRoot,
-        config2.getMessageBroadcaster,
-        config2.getChatHistoryService,
-        () => this.clearContext(),
-        terminateSessionCallback
-      ),
-      ...createFilesystemTools(config2.workspacesRoot)
-    ];
-    this.logger.info({ toolCount: tools.length }, "Creating Supervisor Agent with tools");
-    this.agent = createReactAgent({
-      llm,
-      tools
-    });
-  }
-  /**
-   * Creates the LLM instance based on configuration.
-   */
-  createLLM(env) {
-    const provider = env.AGENT_PROVIDER;
-    const apiKey = env.AGENT_API_KEY;
-    const modelName = env.AGENT_MODEL_NAME;
-    const baseUrl = env.AGENT_BASE_URL;
-    const temperature = env.AGENT_TEMPERATURE;
-    if (!apiKey) {
-      throw new Error("AGENT_API_KEY is required for Supervisor Agent");
-    }
-    this.logger.info({ provider, model: modelName }, "Initializing LLM");
-    return new ChatOpenAI({
-      openAIApiKey: apiKey,
-      modelName,
-      temperature,
-      configuration: baseUrl ? {
-        baseURL: baseUrl
-      } : void 0
-    });
-  }
-  /**
-   * Executes a command through the supervisor agent.
-   * Note: deviceId is used for routing responses, not for history (history is global).
-   */
-  async execute(command, deviceId, currentSessionId) {
-    this.logger.info({ command, deviceId, currentSessionId }, "Executing supervisor command");
-    try {
-      const history = this.getConversationHistory();
-      const messages2 = [
-        ...this.buildSystemMessage(),
-        ...this.buildHistoryMessages(history),
-        new HumanMessage(command)
-      ];
-      const result = await this.agent.invoke({
-        messages: messages2
-      });
-      const agentMessages = result.messages;
-      const lastMessage = agentMessages[agentMessages.length - 1];
-      const content = lastMessage?.content;
-      const output = typeof content === "string" ? content : JSON.stringify(content);
-      this.addToHistory("user", command);
-      this.addToHistory("assistant", output);
-      this.logger.debug({ output: output.slice(0, 200) }, "Supervisor command completed");
-      return {
-        output,
-        sessionId: currentSessionId
-      };
-    } catch (error) {
-      this.logger.error({ error, command }, "Supervisor command failed");
-      const errorMessage = error instanceof Error ? error.message : "An unexpected error occurred";
-      return {
-        output: `Error: ${errorMessage}`
-      };
-    }
-  }
-  /**
-   * Executes a command with streaming output.
-   * Emits 'blocks' events as content is generated.
-   * Note: deviceId is used for routing responses, history is global.
-   */
-  async executeWithStream(command, deviceId) {
-    this.logger.info({ command, deviceId, wasCancelledBefore: this.isCancelled }, "Executing supervisor command with streaming");
-    this.abortController = new AbortController();
-    this.isExecuting = true;
-    this.isCancelled = false;
-    this.executionStartedAt = Date.now();
-    this.logger.debug({ isCancelled: this.isCancelled, isExecuting: this.isExecuting }, "Flags reset for new execution");
-    try {
-      const history = this.getConversationHistory();
-      const messages2 = [
-        ...this.buildSystemMessage(),
-        ...this.buildHistoryMessages(history),
-        new HumanMessage(command)
-      ];
-      if (this.isExecuting && !this.isCancelled) {
-        const statusBlock = createStatusBlock("Processing...");
-        this.logger.debug({ deviceId, blockType: "status" }, "Emitting status block");
-        this.emit("blocks", deviceId, [statusBlock], false);
-      }
-      this.logger.info({ deviceId }, "Starting LangGraph agent stream");
-      const stream = await this.agent.stream(
-        { messages: messages2 },
-        {
-          streamMode: "values",
-          signal: this.abortController.signal
-        }
-      );
-      let finalOutput = "";
-      const allBlocks = [];
-      for await (const chunk of stream) {
-        if (this.isCancelled || !this.isExecuting) {
-          this.logger.info({ deviceId, isCancelled: this.isCancelled, isExecuting: this.isExecuting }, "Supervisor execution cancelled, stopping stream processing");
-          return;
-        }
-        const chunkData = chunk;
-        const chunkMessages = chunkData.messages;
-        if (!chunkMessages || chunkMessages.length === 0) continue;
-        const lastMessage = chunkMessages[chunkMessages.length - 1];
-        if (!lastMessage) continue;
-        if (isAIMessage(lastMessage)) {
-          const content = lastMessage.content;
-          if (typeof content === "string" && content.length > 0) {
-            finalOutput = content;
-            if (this.isExecuting && !this.isCancelled) {
-              const textBlock = createTextBlock(content);
-              this.emit("blocks", deviceId, [textBlock], false);
-              accumulateBlocks(allBlocks, [textBlock]);
-            }
-          } else if (Array.isArray(content)) {
-            for (const item of content) {
-              if (typeof item === "object" && this.isExecuting && !this.isCancelled) {
-                const block = this.parseContentItem(item);
-                if (block) {
-                  this.emit("blocks", deviceId, [block], false);
-                  accumulateBlocks(allBlocks, [block]);
-                }
-              }
-            }
-          }
-        }
-        if (lastMessage.getType() === "tool" && this.isExecuting && !this.isCancelled) {
-          const toolContent = lastMessage.content;
-          const toolName = lastMessage.name ?? "tool";
-          const toolCallId = lastMessage.tool_call_id;
-          const toolBlock = createToolBlock(
-            toolName,
-            "completed",
-            void 0,
-            typeof toolContent === "string" ? toolContent : JSON.stringify(toolContent),
-            toolCallId
-          );
-          this.emit("blocks", deviceId, [toolBlock], false);
-          accumulateBlocks(allBlocks, [toolBlock]);
+        if (fileStat.size > 100 * 1024) {
+          return `File is too large (${Math.round(fileStat.size / 1024)}KB). Maximum is 100KB.`;
         }
+        const content = await readFile2(resolvedPath, "utf-8");
+        const lines = content.split("\n");
+        if (maxLines && lines.length > maxLines) {
+          return `File: ${path} (showing first ${maxLines} of ${lines.length} lines)
+
+${lines.slice(0, maxLines).join("\n")}
+
+... (${lines.length - maxLines} more lines)`;
+        }
+        return `File: ${path}
+
+${content}`;
+      } catch (error) {
+        return `Error reading file: ${error instanceof Error ? error.message : String(error)}`;
       }
-      if (this.isExecuting && !this.isCancelled) {
-        this.addToHistory("user", command);
-        this.addToHistory("assistant", finalOutput);
-        const finalBlocks = mergeToolBlocks(allBlocks);
-        const completionBlock = createStatusBlock("Complete");
-        this.emit("blocks", deviceId, [completionBlock], true, finalOutput, finalBlocks);
-        this.logger.debug({ output: finalOutput.slice(0, 200) }, "Supervisor streaming completed");
-      } else {
-        this.logger.info({ deviceId, isCancelled: this.isCancelled, isExecuting: this.isExecuting }, "Supervisor streaming ended due to cancellation");
-      }
-    } catch (error) {
-      if (this.isCancelled || !this.isExecuting) {
-        this.logger.info({ deviceId }, "Supervisor execution cancelled (caught in error handler)");
-        return;
+    },
+    {
+      name: "read_file",
+      description: "Reads the contents of a file. Limited to 100KB files for safety.",
+      schema: z8.object({
+        path: z8.string().describe("Path to the file"),
+        maxLines: z8.number().optional().describe("Maximum number of lines to return")
+      })
+    }
+  );
+  const getFileInfo = tool5(
+    async ({ path }) => {
+      try {
+        const resolvedPath = resolveSafePath(path, workspacesRoot);
+        const fileStat = await stat2(resolvedPath);
+        const info = [
+          `Path: ${path}`,
+          `Type: ${fileStat.isDirectory() ? "Directory" : "File"}`,
+          `Size: ${formatSize(fileStat.size)}`,
+          `Modified: ${fileStat.mtime.toISOString()}`,
+          `Created: ${fileStat.birthtime.toISOString()}`
+        ];
+        return info.join("\n");
+      } catch (error) {
+        return `Error getting file info: ${error instanceof Error ? error.message : String(error)}`;
       }
-      this.logger.error({ error, command }, "Supervisor streaming failed");
-      const errorMessage = error instanceof Error ? error.message : "An unexpected error occurred";
-      const errorBlock = createErrorBlock(errorMessage);
-      this.emit("blocks", deviceId, [errorBlock], true);
-    } finally {
-      this.isExecuting = false;
-      this.abortController = null;
+    },
+    {
+      name: "get_file_info",
+      description: "Gets information about a file or directory (size, modified date, etc.).",
+      schema: z8.object({
+        path: z8.string().describe("Path to the file or directory")
+      })
     }
+  );
+  return [listDirectory, readFileContent, getFileInfo];
+}
+function resolveSafePath(path, workspacesRoot) {
+  const resolved = path.startsWith("/") ? path : join10(workspacesRoot, path);
+  const normalized = resolve(resolved);
+  const homeDir = process.env.HOME ?? "/";
+  if (!normalized.startsWith(workspacesRoot) && !normalized.startsWith(homeDir)) {
+    throw new Error(`Access denied: Path must be within ${workspacesRoot} or home directory`);
   }
-  /**
-   * Parses a content item from LangGraph into a ContentBlock.
-   */
-  parseContentItem(item) {
-    const type = item.type;
-    if (type === "text" && typeof item.text === "string" && item.text.trim()) {
-      return createTextBlock(item.text);
+  return normalized;
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+  return `${(bytes / 1024 / 1024 / 1024).toFixed(1)} GB`;
+}
+
+// src/infrastructure/agents/supervisor/tools/backlog-tools.ts
+import { join as join11 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { tool as tool6 } from "@langchain/core/tools";
+import { z as z9 } from "zod";
+function createBacklogTools(sessionManager, agentSessionManager, backlogManagers, workspacesRoot, getMessageBroadcaster, logger) {
+  const createBacklogSession = tool6(
+    async (args) => {
+      const finalBacklogId = args.backlogId ?? `${args.project}-${Date.now()}`;
+      let normalizedWorktree = args.worktree;
+      if (normalizedWorktree && (normalizedWorktree.toLowerCase() === "main" || normalizedWorktree.toLowerCase() === "master")) {
+        normalizedWorktree = void 0;
+      }
+      const root = workspacesRoot ?? "/workspaces";
+      let workingDir;
+      if (!normalizedWorktree) {
+        workingDir = join11(root, args.workspace, args.project);
+      } else {
+        workingDir = join11(root, args.workspace, `${args.project}--${normalizedWorktree}`);
+      }
+      const workspacePath = new WorkspacePath(
+        args.workspace,
+        args.project,
+        normalizedWorktree
+      );
+      if (!existsSync8(workingDir)) {
+        const details = normalizedWorktree ? `The worktree/branch "${normalizedWorktree}" is checked out` : `The main/master branch is checked out`;
+        return `\u274C ERROR: Project path does not exist: ${workingDir}
+
+Please make sure:
+1. The workspace "${args.workspace}" exists
+2. The project "${args.project}" exists
+3. ${details}
+
+Use list_worktrees to see available branches for the project.`;
+      }
+      const session = await sessionManager.createSession({
+        sessionType: "backlog-agent",
+        workspacePath,
+        workingDir,
+        backlogId: finalBacklogId
+      });
+      if (session.type !== "backlog-agent") {
+        return `Failed to create backlog session`;
+      }
+      const backlogSession = session;
+      const noopFn = () => {
+      };
+      const noopLogger = {
+        level: "silent",
+        debug: noopFn,
+        info: noopFn,
+        warn: noopFn,
+        error: noopFn,
+        fatal: noopFn,
+        trace: noopFn,
+        silent: noopFn,
+        child: () => noopLogger
+      };
+      const backlogLogger = logger ?? noopLogger;
+      const manager = BacklogAgentManager.createEmpty(
+        backlogSession,
+        workingDir,
+        agentSessionManager,
+        backlogLogger
+      );
+      backlogManagers.set(session.id.value, manager);
+      const broadcaster = getMessageBroadcaster?.();
+      if (broadcaster) {
+        broadcaster.broadcastToAll(JSON.stringify({
+          type: "session.created",
+          session_id: session.id.value,
+          payload: {
+            session_type: "backlog-agent",
+            workspace: args.workspace,
+            project: args.project,
+            worktree: normalizedWorktree,
+            working_dir: workingDir
+          }
+        }));
+      }
+      return `\u2705 Created backlog session "${finalBacklogId}" at ${workingDir}
+Session ID: ${session.id.value}`;
+    },
+    {
+      name: "create_backlog_session",
+      description: "Create a new Backlog Agent session for autonomous development (uses system default model)",
+      schema: z9.object({
+        workspace: z9.string().describe("Workspace name"),
+        project: z9.string().describe("Project name"),
+        worktree: z9.string().optional().describe("Git worktree/branch name. Omit for main/master branch"),
+        backlogId: z9.string().optional().describe("Custom backlog identifier")
+      })
     }
-    if (type === "tool_use") {
-      const name = typeof item.name === "string" ? item.name : "tool";
-      const input = item.input;
-      const toolUseId = typeof item.id === "string" ? item.id : void 0;
-      return createToolBlock(name, "running", input, void 0, toolUseId);
+  );
+  const listBacklogSessions = tool6(
+    () => {
+      const sessions2 = Array.from(backlogManagers.entries()).map(
+        ([sessionId, manager]) => `- ${sessionId}: ${manager.getBacklog().id} (${manager.getSession().agentName})`
+      ).join("\n");
+      if (sessions2.length === 0) {
+        return "No active backlog sessions";
+      }
+      return `Active Backlog Sessions:
+${sessions2}`;
+    },
+    {
+      name: "list_backlog_sessions",
+      description: "List all active Backlog Agent sessions",
+      schema: z9.object({})
     }
-    return null;
-  }
-  /**
-   * Cancels the current execution if running.
-   * Returns true if cancellation was initiated.
-   */
-  cancel() {
-    if (!this.isProcessingCommand && !this.isExecuting) {
-      this.logger.debug(
-        { isProcessingCommand: this.isProcessingCommand, isExecuting: this.isExecuting },
-        "No active execution to cancel"
-      );
-      return false;
+  );
+  const getBacklogStatus = tool6(
+    (args) => {
+      const manager = backlogManagers.get(args.sessionId);
+      if (!manager) {
+        return `Backlog session "${args.sessionId}" not found`;
+      }
+      const backlog = manager.getBacklog();
+      const summary = backlog.summary ?? {
+        total: backlog.tasks.length,
+        completed: 0,
+        failed: 0,
+        in_progress: 0,
+        pending: backlog.tasks.length
+      };
+      const percentage = summary.total > 0 ? summary.completed / summary.total * 100 : 0;
+      const worktreeDisplay = backlog.worktree ?? "main";
+      return `
+\u{1F4CA} Backlog: ${backlog.id}
+Progress: ${summary.completed}/${summary.total} (${percentage.toFixed(0)}%)
+- Completed: ${summary.completed}
+- In Progress: ${summary.in_progress}
+- Pending: ${summary.pending}
+- Failed: ${summary.failed}
+
+Agent: ${manager.getSession().agentName}
+Worktree: ${worktreeDisplay}
+      `.trim();
+    },
+    {
+      name: "get_backlog_status",
+      description: "Get status of a backlog session",
+      schema: z9.object({
+        sessionId: z9.string().describe("Backlog session ID")
+      })
     }
-    const timeSinceStart = Date.now() - this.executionStartedAt;
-    if (this.isExecuting && timeSinceStart < 500) {
-      this.logger.info(
-        { timeSinceStart, isProcessingCommand: this.isProcessingCommand },
-        "Ignoring cancel - execution just started (race condition protection)"
+  );
+  const addTaskToBacklog = tool6(
+    async (args) => {
+      const manager = backlogManagers.get(args.sessionId);
+      if (!manager) {
+        return `Backlog session "${args.sessionId}" not found`;
+      }
+      const blocks = await manager.executeCommand(
+        `add task: "${args.title}" - ${args.description}${args.criteria ? ` (criteria: ${args.criteria})` : ""}`
       );
-      return false;
-    }
-    this.logger.info(
-      { isProcessingCommand: this.isProcessingCommand, isExecuting: this.isExecuting, timeSinceStart },
-      "Cancelling supervisor execution"
-    );
-    this.isCancelled = true;
-    this.isExecuting = false;
-    this.isProcessingCommand = false;
-    if (this.abortController) {
-      this.abortController.abort();
+      return blocks.map((b) => b.block_type === "text" ? b.content : "").join("\n");
+    },
+    {
+      name: "add_task_to_backlog",
+      description: "Add a task to a backlog",
+      schema: z9.object({
+        sessionId: z9.string().describe("Backlog session ID"),
+        title: z9.string().describe("Task title"),
+        description: z9.string().describe("Task description"),
+        criteria: z9.string().optional().describe("Acceptance criteria")
+      })
     }
-    return true;
-  }
-  /**
-   * Check if execution was cancelled.
-   * Used by main.ts to filter out any late-arriving blocks.
-   */
-  wasCancelled() {
-    return this.isCancelled;
-  }
-  /**
-   * Starts command processing (before STT/LLM execution).
-   * Returns an AbortController that can be used to cancel STT and other operations.
-   */
-  startProcessing() {
-    this.abortController = new AbortController();
-    this.isProcessingCommand = true;
-    this.isCancelled = false;
-    this.logger.debug("Started command processing");
-    return this.abortController;
-  }
-  /**
-   * Checks if command processing is active (STT or LLM execution).
-   */
-  isProcessing() {
-    return this.isProcessingCommand || this.isExecuting;
-  }
-  /**
-   * 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 (in-memory only).
-   * Also resets cancellation state to allow new commands.
-   * @deprecated Use clearContext() for full context clearing with persistence and broadcast.
-   */
-  clearHistory() {
-    this.conversationHistory = [];
-    this.isCancelled = false;
-    this.logger.info("Global conversation history cleared");
-  }
-  /**
-   * Clears supervisor context completely:
-   * - In-memory conversation history
-   * - Persistent history in database
-   * - Notifies all connected clients
-   */
-  clearContext() {
-    this.conversationHistory = [];
-    this.isCancelled = false;
-    const chatHistoryService = this.getChatHistoryService?.();
-    if (chatHistoryService) {
-      chatHistoryService.clearSupervisorHistory();
+  );
+  const startBacklogHarness = tool6(
+    async (args) => {
+      const manager = backlogManagers.get(args.sessionId);
+      if (!manager) {
+        return `Backlog session "${args.sessionId}" not found`;
+      }
+      const blocks = await manager.executeCommand("start");
+      return blocks.map((b) => b.block_type === "text" ? b.content : "").join("\n");
+    },
+    {
+      name: "start_backlog_harness",
+      description: "Start autonomous execution of a backlog",
+      schema: z9.object({
+        sessionId: z9.string().describe("Backlog session ID")
+      })
     }
-    const broadcaster = this.getMessageBroadcaster?.();
-    if (broadcaster) {
-      const clearNotification = JSON.stringify({
-        type: "supervisor.context_cleared",
-        payload: { timestamp: Date.now() }
-      });
-      broadcaster.broadcastToAll(clearNotification);
+  );
+  const stopBacklogHarness = tool6(
+    async (args) => {
+      const manager = backlogManagers.get(args.sessionId);
+      if (!manager) {
+        return `Backlog session "${args.sessionId}" not found`;
+      }
+      const blocks = await manager.executeCommand("stop");
+      return blocks.map((b) => b.block_type === "text" ? b.content : "").join("\n");
+    },
+    {
+      name: "stop_backlog_harness",
+      description: "Stop autonomous execution of a backlog",
+      schema: z9.object({
+        sessionId: z9.string().describe("Backlog session ID")
+      })
     }
-    this.logger.info("Supervisor context cleared (in-memory, persistent, and clients notified)");
-  }
-  /**
-   * Resets the cancellation state.
-   * Call this before starting a new command to ensure previous cancellation doesn't affect it.
-   */
-  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");
+  );
+  return {
+    createBacklogSession,
+    listBacklogSessions,
+    getBacklogStatus,
+    addTaskToBacklog,
+    startBacklogHarness,
+    stopBacklogHarness
+  };
+}
+
+// src/infrastructure/agents/supervisor/supervisor-agent.ts
+var SupervisorAgent = class extends LangGraphAgent {
+  getMessageBroadcaster;
+  getChatHistoryService;
+  sessionManager;
+  agentSessionManager;
+  workspaceDiscovery;
+  workspacesRoot;
+  getTerminateSession;
+  constructor(config2) {
+    super(config2.logger);
+    this.getMessageBroadcaster = config2.getMessageBroadcaster;
+    this.getChatHistoryService = config2.getChatHistoryService;
+    this.sessionManager = config2.sessionManager;
+    this.agentSessionManager = config2.agentSessionManager;
+    this.workspaceDiscovery = config2.workspaceDiscovery;
+    this.workspacesRoot = config2.workspacesRoot;
+    this.getTerminateSession = config2.getTerminateSession;
+    this.initializeAgent();
   }
-  /**
-   * Builds the system message for the agent.
-   */
-  buildSystemMessage() {
-    const systemPrompt = `## MANDATORY RULES (STRICTLY ENFORCED)
+  buildSystemPrompt() {
+    return `## MANDATORY RULES (STRICTLY ENFORCED)
 
 You MUST always respond in English.
 
@@ -8047,6 +10057,59 @@ IMPORTANT: When \`list_worktrees\` shows a worktree named "main" with \`isMain:
 
 ---
 
+## BACKLOG SESSIONS (Autonomous Development)
+
+Backlog sessions are special autonomous coding sessions that use the default system LLM model to execute a series of tasks.
+
+### Creating Backlog Sessions (CRITICAL PATH VALIDATION):
+
+IMPORTANT: You MUST validate the project path EXISTS before creating a backlog session!
+
+Step 1: Call \`list_worktrees\` for the project to see all available branches/worktrees
+Step 2: PARSE THE OUTPUT CAREFULLY:
+   - Output format: "Worktrees for 'workspace/project':
+- worktree-name: branch-name (/path/to/directory)"
+   - Example: "- main: main (/Users/roman/tiflis-code-work/roman/eva)"
+   - This means the main branch is at /Users/roman/tiflis-code-work/roman/eva (NO --main suffix!)
+Step 3: Determine the correct worktree parameter:
+   - If worktree is "main" or "master" (the default/primary branch):
+     * Check the path shown: /Users/roman/tiflis-code-work/roman/eva
+     * The path has NO worktree suffix (no --main, no --master)
+     * DO NOT PASS WORKTREE PARAMETER - omit it entirely
+   - If worktree is a feature branch (e.g., "feature-auth"):
+     * The path would be: /Users/roman/tiflis-code-work/roman/eva--feature-auth
+     * PASS worktree="feature-auth" parameter
+Step 4: Call \`create_backlog_session\` with workspace, project, and worktree (only if non-main)
+Step 5: Confirm the session was created successfully
+
+### Path Construction Rules (CRITICAL):
+- Worktree parameter controls the directory name pattern:
+  * Omit worktree \u2192 uses: /workspaces/{workspace}/{project}
+  * Pass worktree="feature-x" \u2192 uses: /workspaces/{workspace}/{project}--feature-x
+- NEVER pass worktree="main" or worktree="master" - just omit the parameter instead
+- ALWAYS check list_worktrees output to see actual paths
+- Only pass worktree when the branch name appears in the path AFTER the project name with -- separator
+
+### Example Flows:
+
+User: "Create a backlog for eva on the main branch"
+Step 1: Call list_worktrees(roman, eva)
+Step 2: Output shows: "- main: main (/Users/roman/tiflis-code-work/roman/eva)"
+   \u2192 Path is /roman/eva (no --main suffix)
+   \u2192 This is the main branch, omit worktree parameter
+Step 3: Call create_backlog_session(workspace="roman", project="eva")  [NO worktree parameter!]
+Step 4: \u2705 Created at /Users/roman/tiflis-code-work/roman/eva
+
+User: "Create a backlog for tiflis-code on the feature-auth branch"
+Step 1: Call list_worktrees(tiflis, tiflis-code)
+Step 2: Output shows: "- feature-auth: feature/auth (/Users/roman/tiflis-code-work/tiflis/tiflis-code--feature-auth)"
+   \u2192 Path has --feature-auth suffix
+   \u2192 This is a feature branch, pass worktree parameter
+Step 3: Call create_backlog_session(workspace="tiflis", project="tiflis-code", worktree="feature-auth")
+Step 4: \u2705 Created at /Users/roman/tiflis-code-work/tiflis/tiflis-code--feature-auth
+
+---
+
 ## WORKTREE MANAGEMENT
 
 Worktrees allow working on multiple branches simultaneously in separate directories.
@@ -8075,45 +10138,117 @@ Creating worktrees with \`create_worktree\`:
 - ALWAYS use bullet lists or numbered lists instead of tables
 - Keep list items short and scannable for mobile reading
 - ALWAYS prioritize safety - check before deleting/merging`;
-    return [new HumanMessage(`[System Instructions]
-${systemPrompt}
-[End Instructions]`)];
   }
   /**
-   * Builds messages from conversation history.
+   * Implements abstract method: create tools for Supervisor.
+   */
+  createTools() {
+    const terminateSessionCallback = async (sessionId) => {
+      const terminate = this.getTerminateSession?.();
+      if (!terminate) {
+        this.logger.warn("Terminate session callback not available");
+        return false;
+      }
+      return terminate(sessionId);
+    };
+    return [
+      ...createWorkspaceTools(this.workspaceDiscovery),
+      ...createWorktreeTools(this.workspaceDiscovery, this.agentSessionManager),
+      ...createSessionTools(
+        this.sessionManager,
+        this.agentSessionManager,
+        this.workspaceDiscovery,
+        this.workspacesRoot,
+        this.getMessageBroadcaster,
+        this.getChatHistoryService,
+        () => this.clearContext(),
+        terminateSessionCallback
+      ),
+      ...createFilesystemTools(this.workspacesRoot),
+      ...Object.values(createBacklogTools(
+        this.sessionManager,
+        this.agentSessionManager,
+        this.sessionManager.getBacklogManagers?.() ?? /* @__PURE__ */ new Map(),
+        this.workspacesRoot,
+        this.getMessageBroadcaster,
+        this.logger
+      ))
+    ];
+  }
+  /**
+   * Implements abstract method: create state manager for Supervisor.
    */
-  buildHistoryMessages(history) {
-    return history.map(
-      (entry) => entry.role === "user" ? new HumanMessage(entry.content) : new AIMessage(entry.content)
-    );
+  createStateManager() {
+    const chatHistoryService = this.getChatHistoryService?.();
+    if (!chatHistoryService) {
+      throw new Error("ChatHistoryService is required for SupervisorAgent");
+    }
+    return new SupervisorStateManager(chatHistoryService);
   }
   /**
-   * Gets global conversation history.
+   * Clears supervisor context completely:
+   * - In-memory conversation history
+   * - Persistent history in database
+   * - Notifies all connected clients
    */
-  getConversationHistory() {
-    return this.conversationHistory;
+  clearContext() {
+    this.conversationHistory = [];
+    this.isCancelled = false;
+    const chatHistoryService = this.getChatHistoryService?.();
+    if (chatHistoryService) {
+      chatHistoryService.clearSupervisorHistory();
+    }
+    const broadcaster = this.getMessageBroadcaster?.();
+    if (broadcaster) {
+      const clearNotification = JSON.stringify({
+        type: "supervisor.context_cleared",
+        payload: { timestamp: Date.now() }
+      });
+      broadcaster.broadcastToAll(clearNotification);
+    }
+    this.logger.info("Supervisor context cleared (in-memory, persistent, and clients notified)");
   }
   /**
-   * Adds an entry to global conversation history.
+   * Synchronous execute method for ISupervisorAgent interface compatibility.
+   * Internally calls executeWithStream and returns a result.
    */
-  addToHistory(role, content) {
-    this.conversationHistory.push({ role, content });
-    if (this.conversationHistory.length > 20) {
-      this.conversationHistory.splice(0, this.conversationHistory.length - 20);
+  async execute(command, deviceId, _currentSessionId) {
+    let output = "";
+    const blockHandler = (_deviceId, _blocks, isComplete, finalOutput) => {
+      if (isComplete && finalOutput) {
+        output = finalOutput;
+      }
+    };
+    this.on("blocks", blockHandler);
+    try {
+      await this.executeWithStream(command, deviceId);
+    } finally {
+      this.removeListener("blocks", blockHandler);
     }
+    return { output };
+  }
+  clearHistory() {
+    this.clearContext();
+  }
+  /**
+   * Records acknowledgment of context clear from a device.
+   * Used for multi-device synchronization.
+   */
+  recordClearAck(_broadcastId, _deviceId) {
+    this.logger.debug({ _broadcastId, _deviceId }, "Context clear acknowledgment received");
   }
 };
 
 // src/infrastructure/mock/mock-supervisor-agent.ts
-import { EventEmitter as EventEmitter5 } from "events";
+import { EventEmitter as EventEmitter7 } 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 { readFileSync as readFileSync6, existsSync as existsSync9 } from "fs";
+import { join as join12, 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 DEFAULT_FIXTURES_PATH = join12(__dirname, "fixtures");
 var fixtureCache = /* @__PURE__ */ new Map();
 function loadFixture(name, customPath) {
   const cacheKey = `${customPath ?? "default"}:${name}`;
@@ -8122,13 +10257,13 @@ function loadFixture(name, customPath) {
     return cached;
   }
   const fixturesDir = customPath ?? DEFAULT_FIXTURES_PATH;
-  const filePath = join7(fixturesDir, `${name}.json`);
-  if (!existsSync3(filePath)) {
+  const filePath = join12(fixturesDir, `${name}.json`);
+  if (!existsSync9(filePath)) {
     console.warn(`[MockMode] Fixture not found: ${filePath}`);
     return null;
   }
   try {
-    const content = readFileSync2(filePath, "utf-8");
+    const content = readFileSync6(filePath, "utf-8");
     const fixture = JSON.parse(content);
     fixtureCache.set(cacheKey, fixture);
     return fixture;
@@ -8196,7 +10331,7 @@ function sleep(ms) {
 }
 
 // src/infrastructure/mock/mock-supervisor-agent.ts
-var MockSupervisorAgent = class extends EventEmitter5 {
+var MockSupervisorAgent = class extends EventEmitter7 {
   logger;
   fixturesPath;
   fixture;
@@ -8375,18 +10510,23 @@ var MockSupervisorAgent = class extends EventEmitter5 {
   getConversationHistory() {
     return [...this.conversationHistory];
   }
-  /**
-   * Sleep utility.
-   */
+  clearContext() {
+    this.conversationHistory = [];
+    this.isCancelled = false;
+    this.logger.info("Mock context cleared");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  recordClearAck(_broadcastId, _deviceId) {
+  }
   sleep(ms) {
     return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
 };
 
 // src/infrastructure/mock/mock-agent-session-manager.ts
-import { EventEmitter as EventEmitter6 } from "events";
+import { EventEmitter as EventEmitter8 } from "events";
 import { randomUUID as randomUUID3 } from "crypto";
-var MockAgentSessionManager = class extends EventEmitter6 {
+var MockAgentSessionManager = class extends EventEmitter8 {
   sessions = /* @__PURE__ */ new Map();
   fixtures = /* @__PURE__ */ new Map();
   logger;
@@ -8607,7 +10747,7 @@ var MockAgentSessionManager = class extends EventEmitter6 {
 
 // src/infrastructure/speech/stt-service.ts
 import { writeFile as writeFile2, unlink as unlink2 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join13 } from "path";
 import { tmpdir } from "os";
 import { randomUUID as randomUUID4 } from "crypto";
 var STTService = class {
@@ -8661,7 +10801,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 = join8(tmpdir(), `stt-${randomUUID4()}.${format}`);
+    const tempPath = join13(tmpdir(), `stt-${randomUUID4()}.${format}`);
     try {
       if (signal?.aborted) {
         throw new Error("Transcription cancelled");
@@ -8709,7 +10849,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 = join8(tmpdir(), `stt-${randomUUID4()}.${format}`);
+    const tempPath = join13(tmpdir(), `stt-${randomUUID4()}.${format}`);
     try {
       if (signal?.aborted) {
         throw new Error("Transcription cancelled");
@@ -9088,6 +11228,27 @@ function createSummarizationService(env, logger) {
   return new SummarizationService(config2, logger);
 }
 
+// src/domain/value-objects/chat-message.ts
+import { randomUUID as randomUUID5 } from "crypto";
+function createChatMessage(type, content, metadata) {
+  return {
+    id: randomUUID5(),
+    timestamp: Date.now(),
+    type,
+    content,
+    metadata
+  };
+}
+function createUserMessage(content) {
+  return createChatMessage("user", content);
+}
+function createAssistantMessage(content, metadata) {
+  return createChatMessage("assistant", content, metadata);
+}
+function createErrorMessage(content, metadata) {
+  return createChatMessage("error", content, metadata);
+}
+
 // src/main.ts
 function printBanner(version) {
   const dim = "\x1B[2m";
@@ -9181,7 +11342,7 @@ function handleTunnelMessage(rawMessage, tunnelClient, messageBroadcaster, creat
     );
   }
 }
-function handleAuthMessageViaTunnel(data, tunnelClient, authenticateClient, logger, subscriptionService) {
+function handleAuthMessageViaTunnel(data, tunnelClient, authenticateClient, logger, subscriptionService, messageBroadcaster) {
   const authResult = AuthMessageSchema.safeParse(data);
   if (!authResult.success) {
     logger.warn(
@@ -9211,6 +11372,32 @@ function handleAuthMessageViaTunnel(data, tunnelClient, authenticateClient, logg
         );
       }
     }
+    if (messageBroadcaster) {
+      const bufferedMessages = messageBroadcaster.flushAuthBuffer(deviceId);
+      if (bufferedMessages.length > 0) {
+        logger.info(
+          { deviceId, messageCount: bufferedMessages.length },
+          "Flushing buffered messages after subscription restore"
+        );
+        (async () => {
+          for (const bufferedMsg of bufferedMessages) {
+            try {
+              await messageBroadcaster.broadcastToSubscribers(
+                bufferedMsg.sessionId,
+                bufferedMsg.message
+              );
+            } catch (error) {
+              logger.error(
+                { error, deviceId, sessionId: bufferedMsg.sessionId },
+                "Failed to send buffered message"
+              );
+            }
+          }
+        })().catch((error) => {
+          logger.error({ error, deviceId }, "Error flushing buffered messages");
+        });
+      }
+    }
     const responseJson = JSON.stringify(result);
     if (tunnelClient.send(responseJson)) {
       logger.info(
@@ -9292,6 +11479,7 @@ async function bootstrap() {
   chatHistoryService.ensureSupervisorSession();
   const workstationMetadataRepository = new WorkstationMetadataRepository();
   const subscriptionRepository = new SubscriptionRepository();
+  const sessionRepository = new SessionRepository();
   const clientRegistry = new InMemoryClientRegistry(logger);
   const workspaceDiscovery = new FileSystemWorkspaceDiscovery({
     workspacesRoot: env.WORKSPACES_ROOT
@@ -9308,8 +11496,19 @@ async function bootstrap() {
     ptyManager,
     agentSessionManager,
     workspacesRoot: env.WORKSPACES_ROOT,
-    logger
+    logger,
+    sessionRepository
   });
+  try {
+    logger.info("About to call sessionManager.restoreSessions()");
+    await sessionManager.restoreSessions();
+    logger.info("sessionManager.restoreSessions() completed successfully");
+  } catch (error) {
+    logger.error(
+      { error: error instanceof Error ? error.message : String(error), stack: error instanceof Error ? error.stack : void 0 },
+      "Failed to restore sessions from database"
+    );
+  }
   if (env.MOCK_MODE) {
     const mockAgentManager = agentSessionManager;
     await sessionManager.createSession({
@@ -9400,7 +11599,7 @@ async function bootstrap() {
     },
     accumulate(newBlocks) {
       if (this.blocks.length === 0 && newBlocks.length > 0) {
-        this.streamingMessageId = randomUUID5();
+        this.streamingMessageId = randomUUID6();
       }
       accumulateBlocks(this.blocks, newBlocks);
     }
@@ -9449,7 +11648,7 @@ async function bootstrap() {
     }
   };
   const createMessageHandlers = () => ({
-    auth: (socket, message) => {
+    auth: async (socket, message) => {
       const authMessage = message;
       const deviceId = authMessage.payload.device_id;
       const result = authenticateClient.execute({
@@ -9467,6 +11666,21 @@ async function bootstrap() {
           );
         }
       }
+      if (broadcaster) {
+        const bufferedMessages = broadcaster.flushAuthBuffer(deviceId);
+        if (bufferedMessages.length > 0) {
+          logger.info(
+            { deviceId, messageCount: bufferedMessages.length },
+            "Flushing buffered messages after subscription restore"
+          );
+          for (const bufferedMsg of bufferedMessages) {
+            await broadcaster.broadcastToSubscribers(
+              bufferedMsg.sessionId,
+              bufferedMsg.message
+            );
+          }
+        }
+      }
       sendToDevice(socket, deviceId, JSON.stringify(result));
       return Promise.resolve();
     },
@@ -9500,7 +11714,14 @@ async function bootstrap() {
       const inMemorySessions = sessionManager.getSessionInfos();
       const persistedAgentSessions = chatHistoryService.getActiveAgentSessions();
       logger.debug(
-        { persistedAgentSessions, inMemoryCount: inMemorySessions.length },
+        {
+          inMemoryCount: inMemorySessions.length,
+          inMemorySessionTypes: inMemorySessions.map((s) => ({
+            id: s.session_id,
+            type: s.session_type
+          })),
+          persistedAgentCount: persistedAgentSessions.length
+        },
         "Sync: fetched sessions"
       );
       const inMemorySessionIds = new Set(
@@ -9866,7 +12087,7 @@ async function bootstrap() {
         logger.info({ wasCancelled }, "supervisorAgent.cancel() returned");
         if (messageBroadcaster) {
           const cancelBlock = {
-            id: randomUUID5(),
+            id: randomUUID6(),
             block_type: "cancel",
             content: "Cancelled by user"
           };
@@ -9911,7 +12132,7 @@ async function bootstrap() {
       return Promise.resolve();
     },
     // Clear supervisor conversation history (global)
-    "supervisor.clear_context": (socket, message) => {
+    "supervisor.clear_context": async (socket, message) => {
       const clearMessage = message;
       const directClient = clientRegistry.getBySocket(socket);
       const tunnelClient2 = clearMessage.device_id ? clientRegistry.getByDeviceId(new DeviceId(clearMessage.device_id)) : void 0;
@@ -10034,18 +12255,21 @@ async function bootstrap() {
         const sessionId = subscribeMessage.session_id;
         const agentSession = agentSessionManager.getSession(sessionId);
         const isPersistedAgent = !agentSession && chatHistoryService.getActiveAgentSessions().some((s) => s.sessionId === sessionId);
-        if (agentSession || isPersistedAgent) {
+        const backlogManagers = sessionManager.getBacklogManagers();
+        const isBacklogSession = backlogManagers.has(sessionId);
+        if (agentSession || isPersistedAgent || isBacklogSession) {
           client.subscribe(new SessionId(sessionId));
           logger.info(
             {
               deviceId: client.deviceId.value,
               sessionId,
+              sessionType: isBacklogSession ? "backlog-agent" : "agent",
               allSubscriptions: client.getSubscriptions(),
               clientStatus: client.status
             },
-            "Client subscribed to agent session"
+            "Client subscribed to session"
           );
-          const isExecuting = agentSessionManager.isExecuting(sessionId);
+          const isExecuting = isBacklogSession ? false : agentSessionManager.isExecuting(sessionId);
           const currentStreamingBlocks = agentMessageAccumulator.get(sessionId) ?? [];
           const streamingMessageId = currentStreamingBlocks.length > 0 ? agentStreamingMessageIds.get(sessionId) : void 0;
           sendToDevice(
@@ -10063,11 +12287,12 @@ async function bootstrap() {
             {
               deviceId: client.deviceId.value,
               sessionId,
+              sessionType: isBacklogSession ? "backlog-agent" : "agent",
               isExecuting,
               streamingBlocksCount: currentStreamingBlocks.length,
               streamingMessageId
             },
-            "Agent session subscribed (v1.13 - use history.request for messages)"
+            "Session subscribed (use history.request for messages)"
           );
         } else {
           const result = subscriptionService.subscribe(
@@ -10100,21 +12325,42 @@ async function bootstrap() {
       return Promise.resolve();
     },
     "session.unsubscribe": (socket, message) => {
-      if (!subscriptionService) return Promise.resolve();
       const unsubscribeMessage = message;
       const client = clientRegistry.getBySocket(socket) ?? (unsubscribeMessage.device_id ? clientRegistry.getByDeviceId(
         new DeviceId(unsubscribeMessage.device_id)
       ) : void 0);
       if (client?.isAuthenticated) {
-        const result = subscriptionService.unsubscribe(
-          client.deviceId.value,
-          unsubscribeMessage.session_id
-        );
-        sendToDevice(
-          socket,
-          unsubscribeMessage.device_id,
-          JSON.stringify(result)
-        );
+        const sessionId = unsubscribeMessage.session_id;
+        const backlogManagers = sessionManager.getBacklogManagers();
+        const isBacklogSession = backlogManagers.has(sessionId);
+        if (isBacklogSession) {
+          client.unsubscribe(new SessionId(sessionId));
+          logger.info(
+            {
+              deviceId: client.deviceId.value,
+              sessionId
+            },
+            "Client unsubscribed from backlog-agent session"
+          );
+          sendToDevice(
+            socket,
+            unsubscribeMessage.device_id,
+            JSON.stringify({
+              type: "session.unsubscribed",
+              session_id: sessionId
+            })
+          );
+        } else if (subscriptionService) {
+          const result = subscriptionService.unsubscribe(
+            client.deviceId.value,
+            sessionId
+          );
+          sendToDevice(
+            socket,
+            unsubscribeMessage.device_id,
+            JSON.stringify(result)
+          );
+        }
       }
       return Promise.resolve();
     },
@@ -10140,6 +12386,153 @@ async function bootstrap() {
         );
       }
       cancelledDuringTranscription.delete(sessionId);
+      const backlogManagers = sessionManager.getBacklogManagers();
+      const isBacklogSession = backlogManagers.has(sessionId);
+      if (isBacklogSession) {
+        const manager = backlogManagers.get(sessionId);
+        if (!manager) {
+          logger.error(
+            { sessionId },
+            "Backlog manager found in map but is undefined - this should not happen"
+          );
+          const errorMessage = {
+            type: "session.output",
+            session_id: sessionId,
+            payload: {
+              content_blocks: [
+                {
+                  id: "error",
+                  blockType: "error",
+                  content: "Internal error: backlog manager not properly initialized"
+                }
+              ],
+              content: "Internal error: backlog manager not properly initialized",
+              content_type: "agent",
+              is_complete: true,
+              timestamp: Date.now(),
+              message_id: messageId
+            }
+          };
+          if (messageBroadcaster) {
+            void messageBroadcaster.broadcastToSubscribers(
+              sessionId,
+              JSON.stringify(errorMessage)
+            );
+          }
+          return;
+        }
+        const prompt = execMessage.payload.content ?? execMessage.payload.text ?? execMessage.payload.prompt ?? "";
+        if (prompt) {
+          chatHistoryService.saveMessage(sessionId, createUserMessage(prompt), true);
+        }
+        try {
+          const blocks = await manager.executeCommand(prompt);
+          if (blocks.length > 0) {
+            const assistantContent = blocks.map((b) => b.content).join("\n");
+            chatHistoryService.saveMessage(
+              sessionId,
+              createAssistantMessage(assistantContent),
+              true
+            );
+          }
+          if (messageBroadcaster) {
+            const streamingMessageId = getOrCreateBacklogStreamingMessageId(sessionId);
+            const protocolBlocks = blocks.map((block) => ({
+              id: block.id,
+              blockType: block.block_type,
+              content: block.content,
+              metadata: "metadata" in block ? block.metadata : void 0
+            }));
+            const contentText = protocolBlocks.map((b) => b.content).join("\n");
+            const streamingMessage = {
+              type: "session.output",
+              session_id: sessionId,
+              streaming_message_id: streamingMessageId,
+              payload: {
+                content_type: "agent",
+                content: contentText,
+                content_blocks: protocolBlocks,
+                timestamp: Date.now(),
+                is_complete: false
+              }
+            };
+            void messageBroadcaster.broadcastToSubscribers(
+              sessionId,
+              JSON.stringify(streamingMessage)
+            );
+            const completionMessage = {
+              type: "session.output",
+              session_id: sessionId,
+              streaming_message_id: streamingMessageId,
+              payload: {
+                content_type: "agent",
+                content: contentText,
+                content_blocks: protocolBlocks,
+                timestamp: Date.now(),
+                is_complete: true
+              }
+            };
+            void messageBroadcaster.broadcastToSubscribers(
+              sessionId,
+              JSON.stringify(completionMessage)
+            );
+            clearBacklogStreamingMessageId(sessionId);
+          }
+        } catch (error) {
+          const errorContent = error instanceof Error ? error.message : "Unknown error";
+          logger.error(
+            { error, sessionId, errorContent, stack: error instanceof Error ? error.stack : void 0 },
+            "Failed to execute backlog command"
+          );
+          chatHistoryService.saveMessage(
+            sessionId,
+            createErrorMessage(errorContent),
+            true
+          );
+          if (messageBroadcaster) {
+            const streamingMessageId = getOrCreateBacklogStreamingMessageId(sessionId);
+            const errorBlock = {
+              id: "error",
+              blockType: "error",
+              content: errorContent
+            };
+            const errorStreamingMessage = {
+              type: "session.output",
+              session_id: sessionId,
+              streaming_message_id: streamingMessageId,
+              payload: {
+                content_type: "agent",
+                content: errorContent,
+                content_blocks: [errorBlock],
+                timestamp: Date.now(),
+                is_complete: false
+              }
+            };
+            void messageBroadcaster.broadcastToSubscribers(
+              sessionId,
+              JSON.stringify(errorStreamingMessage)
+            );
+            const errorCompletionMessage = {
+              type: "session.output",
+              session_id: sessionId,
+              streaming_message_id: streamingMessageId,
+              payload: {
+                content_type: "agent",
+                content: errorContent,
+                content_blocks: [errorBlock],
+                timestamp: Date.now(),
+                is_complete: true
+              }
+            };
+            void messageBroadcaster.broadcastToSubscribers(
+              sessionId,
+              JSON.stringify(errorCompletionMessage)
+            );
+            clearBacklogStreamingMessageId(sessionId);
+          }
+        }
+        return;
+      }
       if (execMessage.payload.audio) {
         logger.info(
           { sessionId, hasAudio: true, messageId },
@@ -10408,7 +12801,7 @@ async function bootstrap() {
         }
         if (messageBroadcaster) {
           const cancelBlock = {
-            id: randomUUID5(),
+            id: randomUUID6(),
             block_type: "cancel",
             content: "Cancelled by user"
           };
@@ -10869,8 +13262,27 @@ async function bootstrap() {
               tunnelClient,
               authenticateClient,
               logger,
-              subscriptionService
+              subscriptionService,
+              broadcaster
             );
+          } else if (messageType === "supervisor.context_cleared.ack") {
+            try {
+              const ackData = data;
+              const broadcastId = ackData.payload?.broadcast_id;
+              const deviceId = ackData.payload?.device_id;
+              if (broadcastId && deviceId && supervisorAgent) {
+                supervisorAgent.recordClearAck(broadcastId, deviceId);
+                logger.debug(
+                  { broadcastId, deviceId },
+                  "Recorded context clear acknowledgment"
+                );
+              }
+            } catch (ackError) {
+              logger.warn(
+                { error: ackError, message: message.slice(0, 100) },
+                "Failed to process context clear acknowledgment"
+              );
+            }
           } else {
             handleTunnelMessage(
               message,
@@ -10932,7 +13344,7 @@ async function bootstrap() {
   const getOrCreateAgentStreamingMessageId = (sessionId) => {
     let messageId = agentStreamingMessageIds.get(sessionId);
     if (!messageId) {
-      messageId = randomUUID5();
+      messageId = randomUUID6();
       agentStreamingMessageIds.set(sessionId, messageId);
     }
     return messageId;
@@ -10949,6 +13361,18 @@ async function bootstrap() {
     }, STREAMING_STATE_GRACE_PERIOD_MS);
     agentCleanupTimeouts.set(sessionId, timeout);
   };
+  const backlogStreamingMessageIds = /* @__PURE__ */ new Map();
+  const getOrCreateBacklogStreamingMessageId = (sessionId) => {
+    let messageId = backlogStreamingMessageIds.get(sessionId);
+    if (!messageId) {
+      messageId = randomUUID6();
+      backlogStreamingMessageIds.set(sessionId, messageId);
+    }
+    return messageId;
+  };
+  const clearBacklogStreamingMessageId = (sessionId) => {
+    backlogStreamingMessageIds.delete(sessionId);
+  };
   agentSessionManager.on(
     "blocks",
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
@@ -11516,6 +13940,11 @@ bootstrap().catch((error) => {
  * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
  * @license FSL-1.1-NC
  */
+/**
+ * @file session-repository.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ */
 /**
  * @file schemas.ts
  * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
@@ -11658,11 +14087,6 @@ bootstrap().catch((error) => {
  * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
  * @license FSL-1.1-NC
  */
-/**
- * @file session-repository.ts
- * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
- * @license FSL-1.1-NC
- */
 /**
  * @file audio-storage.ts
  * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
@@ -11680,11 +14104,69 @@ bootstrap().catch((error) => {
  * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
  * @license FSL-1.1-NC
  */
+/**
+ * @file backlog-agent-session.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ */
+/**
+ * @file backlog.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ */
+/**
+ * @file backlog-harness.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ */
+/**
+ * @file lang-graph-agent.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ *
+ * Abstract base class for all LangGraph-based agents.
+ * Provides unified streaming, state management, and event emission patterns.
+ */
+/**
+ * @file backlog-state-manager.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ *
+ * AgentStateManager implementation for backlog persistence.
+ * Persists both conversation history and backlog state to files and database.
+ */
+/**
+ * @file backlog-agent-tools.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ *
+ * LangGraph tools for backlog agent operations.
+ */
+/**
+ * @file backlog-agent.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ *
+ * LangGraph-based Backlog Agent for executing backlog commands.
+ * Extends LangGraphAgent base class for unified streaming and state management.
+ */
+/**
+ * @file backlog-agent-manager.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ */
 /**
  * @file in-memory-session-manager.ts
  * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
  * @license FSL-1.1-NC
  */
+/**
+ * @file supervisor-state-manager.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ *
+ * AgentStateManager implementation for SupervisorAgent database persistence.
+ */
 /**
  * @file workspace-tools.ts
  * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
@@ -11713,12 +14195,18 @@ bootstrap().catch((error) => {
  *
  * LangGraph tools for file system operations.
  */
+/**
+ * @file backlog-tools.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ */
 /**
  * @file supervisor-agent.ts
  * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
  * @license FSL-1.1-NC
  *
  * LangGraph-based Supervisor Agent for managing workstation resources.
+ * Extends LangGraphAgent base class for unified streaming and state management.
  */
 /**
  * @file fixture-loader.ts
@@ -11772,6 +14260,11 @@ bootstrap().catch((error) => {
  * Service for summarizing long responses before TTS synthesis.
  * Uses the same LLM provider as the supervisor agent.
  */
+/**
+ * @file chat-message.ts
+ * @copyright 2025 Roman Barinov <rbarinov@gmail.com>
+ * @license FSL-1.1-NC
+ */
 /**
  * @file main.ts
  * @copyright 2025 Roman Barinov <rbarinov@gmail.com>