@phenx-inc/ctlsurf 0.1.21 → 0.3.0

package/out/main/index.js

@@ -176,6 +176,25 @@ class CtlsurfApi {
     const folder = await this.request("GET", `/folders/${folderId}`);
     return folder?.pages || [];
   }
+  async getFolder(folderId) {
+    return this.request("GET", `/folders/${folderId}`);
+  }
+  // ─── Datastore ───────────────────────────────────────
+  async getPageBlockSummaries(pageId) {
+    return this.request("GET", `/blocks/page/${pageId}/summary`);
+  }
+  async addRow(blockId, data) {
+    return this.request("POST", `/datastore/${blockId}/rows`, { data });
+  }
+  async updateRow(blockId, rowId, data) {
+    return this.request("PUT", `/datastore/${blockId}/rows/${rowId}`, { data });
+  }
+  async getDatastoreSchema(blockId) {
+    return this.request("GET", `/datastore/${blockId}/schema`);
+  }
+  async updateDatastoreSchema(blockId, columns) {
+    return this.request("PUT", `/datastore/${blockId}/schema`, { columns });
+  }
   async findFolderByGitRemote(gitRemote) {
     const folders = await this.request("GET", "/folders");
     return folders?.find((f) => f.git_remote === gitRemote || f.root_path === gitRemote) || null;
@@ -4185,7 +4204,7 @@ function requireWebsocketServer() {
 }
 requireWebsocketServer();
 const WS = typeof WebSocket !== "undefined" ? WebSocket : WebSocket$1;
-function log$2(...args) {
+function log$3(...args) {
   try {
     console.log(...args);
   } catch {
@@ -4281,7 +4300,7 @@ class WorkerWsClient {
   }
   doConnect() {
     if (!this.apiKey || !this.registration) {
-      log$2("[worker-ws] No API key or registration, skipping connect");
+      log$3("[worker-ws] No API key or registration, skipping connect");
       return;
     }
     this.clearTimers();
@@ -4304,22 +4323,22 @@ class WorkerWsClient {
   doConnectNow() {
     if (!this.apiKey || !this.registration) return;
     if (!this.shouldReconnect) {
-      log$2("[worker-ws] shouldReconnect is false, aborting connect");
+      log$3("[worker-ws] shouldReconnect is false, aborting connect");
       return;
     }
     this.setStatus("connecting");
     const wsBase = this.baseUrl.replace(/^http/, "ws");
     const url = `${wsBase}/api/ws/worker?token=${encodeURIComponent(this.apiKey)}`;
-    log$2(`[worker-ws] Connecting to ${url.replace(/token=.*/, "token=***")}...`);
+    log$3(`[worker-ws] Connecting to ${url.replace(/token=.*/, "token=***")}...`);
     try {
       this.ws = new WS(url);
     } catch (err) {
-      log$2("[worker-ws] Failed to create WebSocket:", err);
+      log$3("[worker-ws] Failed to create WebSocket:", err);
       this.scheduleReconnect();
       return;
     }
     this.ws.onopen = () => {
-      log$2("[worker-ws] Connected, sending register");
+      log$3("[worker-ws] Connected, sending register");
       this.reconnectDelay = RECONNECT_DELAY_MS;
       this.send({
         type: "register",
@@ -4332,11 +4351,11 @@ class WorkerWsClient {
         const data = JSON.parse(String(event.data));
         this.handleMessage(data);
       } catch (err) {
-        log$2("[worker-ws] Failed to parse message:", err);
+        log$3("[worker-ws] Failed to parse message:", err);
       }
     };
     this.ws.onclose = (event) => {
-      log$2(`[worker-ws] Disconnected: ${event.code} ${event.reason}`);
+      log$3(`[worker-ws] Disconnected: ${event.code} ${event.reason}`);
       this.ws = null;
       this.clearHeartbeat();
       this.setStatus("disconnected");
@@ -4345,7 +4364,7 @@ class WorkerWsClient {
       }
     };
     this.ws.onerror = () => {
-      log$2("[worker-ws] WebSocket error");
+      log$3("[worker-ws] WebSocket error");
     };
   }
   handleMessage(data) {
@@ -4373,7 +4392,7 @@ class WorkerWsClient {
         break;
       }
       case "approved": {
-        log$2("[worker-ws] Worker approved!");
+        log$3("[worker-ws] Worker approved!");
         this.setStatus("connected");
         break;
       }
@@ -4431,18 +4450,211 @@ class WorkerWsClient {
     }
   }
 }
+const DATASTORE_TITLE = "Time Tracking";
+const AGENT_DATASTORE_PAGE_TITLE = "Agent Datastore";
+const FIRST_CHECKPOINT_DELAY_MS = 30 * 1e3;
+const CHECKPOINT_INTERVAL_MS = 5 * 60 * 1e3;
+const COLUMNS = [
+  { name: "Started", type: "date" },
+  { name: "Active Time", type: "number" },
+  { name: "Agent", type: "text" },
+  { name: "Worker", type: "text" },
+  { name: "Session", type: "text" },
+  { name: "Notes", type: "text" }
+];
+function log$2(...args) {
+  try {
+    console.log("[time-tracker]", ...args);
+  } catch {
+  }
+}
+function findPageByTitle(pages, title) {
+  for (const p of pages) {
+    if (p?.title === title) return p;
+    if (p?.children?.length) {
+      const c = findPageByTitle(p.children, title);
+      if (c) return c;
+    }
+  }
+  return null;
+}
+class TimeTracker {
+  api;
+  sessions = /* @__PURE__ */ new Map();
+  blockCache = /* @__PURE__ */ new Map();
+  constructor(api) {
+    this.api = api;
+  }
+  async startSession(tabId, cwd, agentName, idleTimeoutMin) {
+    if (this.sessions.has(tabId)) {
+      await this.endSession(tabId);
+    }
+    try {
+      const blockId = await this.ensureDatastore(cwd);
+      if (!blockId) {
+        log$2(`No "${AGENT_DATASTORE_PAGE_TITLE}" page found for ${cwd} — tracking disabled for this session`);
+        return;
+      }
+      const startedAt = Date.now();
+      const startedIso = new Date(startedAt).toISOString();
+      const sessionUuid = require$$1.randomUUID();
+      const row = await this.api.addRow(blockId, {
+        Started: startedIso,
+        "Active Time": 0,
+        Agent: agentName,
+        Worker: os.hostname(),
+        Session: sessionUuid,
+        Notes: ""
+      });
+      const rowId = row?.id;
+      if (!rowId) {
+        log$2("addRow returned no id; aborting tracking", row);
+        return;
+      }
+      const state = {
+        blockId,
+        rowId,
+        cwd,
+        startedAt,
+        lastActivity: startedAt,
+        activeMs: 0,
+        idleTimeoutMs: Math.max(1, idleTimeoutMin) * 60 * 1e3,
+        firstCheckpointTimer: null,
+        checkpointTimer: null,
+        ended: false
+      };
+      state.firstCheckpointTimer = setTimeout(() => {
+        void this.checkpoint(tabId);
+        const live = this.sessions.get(tabId);
+        if (live && !live.ended) {
+          live.checkpointTimer = setInterval(() => {
+            void this.checkpoint(tabId);
+          }, CHECKPOINT_INTERVAL_MS);
+        }
+      }, FIRST_CHECKPOINT_DELAY_MS);
+      this.sessions.set(tabId, state);
+      log$2(`Started tracking tab=${tabId} agent="${agentName}" cwd=${cwd}`);
+    } catch (err) {
+      log$2(`startSession failed: ${err?.message || err}`);
+    }
+  }
+  isTracking(tabId) {
+    const s = this.sessions.get(tabId);
+    return !!s && !s.ended;
+  }
+  recordActivity(tabId) {
+    const s = this.sessions.get(tabId);
+    if (!s || s.ended) return;
+    const now = Date.now();
+    const delta = now - s.lastActivity;
+    if (delta < s.idleTimeoutMs) {
+      s.activeMs += delta;
+    }
+    s.lastActivity = now;
+  }
+  async endSession(tabId) {
+    const s = this.sessions.get(tabId);
+    if (!s || s.ended) return;
+    s.ended = true;
+    if (s.firstCheckpointTimer) clearTimeout(s.firstCheckpointTimer);
+    if (s.checkpointTimer) clearInterval(s.checkpointTimer);
+    try {
+      await this.writeRow(s, Date.now());
+    } catch (err) {
+      log$2(`endSession write failed: ${err?.message || err}`);
+    }
+    this.sessions.delete(tabId);
+  }
+  async endAll() {
+    const ids = [...this.sessions.keys()];
+    await Promise.all(ids.map((id) => this.endSession(id)));
+  }
+  async checkpoint(tabId) {
+    const s = this.sessions.get(tabId);
+    if (!s || s.ended) return;
+    try {
+      await this.writeRow(s, Date.now());
+    } catch (err) {
+      log$2(`checkpoint failed: ${err?.message || err}`);
+    }
+  }
+  async writeRow(s, _endTimeMs) {
+    const activeMin = Math.round(s.activeMs / 6e4);
+    await this.api.updateRow(s.blockId, s.rowId, {
+      "Active Time": activeMin
+    });
+  }
+  async ensureDatastore(cwd) {
+    const cached = this.blockCache.get(cwd);
+    if (cached) return cached;
+    let folder = null;
+    try {
+      folder = await this.api.findFolderByPath(cwd);
+    } catch {
+      return null;
+    }
+    if (!folder?.id) return null;
+    const folderDetail = await this.api.getFolder(folder.id);
+    const agentPage = findPageByTitle(folderDetail?.pages || [], AGENT_DATASTORE_PAGE_TITLE);
+    if (!agentPage?.id) return null;
+    const summaries = await this.api.getPageBlockSummaries(agentPage.id);
+    const existing = (summaries || []).find((b) => b?.type === "datastore" && b?.title === DATASTORE_TITLE);
+    if (existing?.id) {
+      await this.ensureColumns(existing.id);
+      this.blockCache.set(cwd, existing.id);
+      return existing.id;
+    }
+    const columns = COLUMNS.map((c, i) => ({ id: `col_${i}`, name: c.name, type: c.type }));
+    const created = await this.api.createBlock(agentPage.id, {
+      type: "datastore",
+      title: DATASTORE_TITLE,
+      props: { columns }
+    });
+    if (created?.id) {
+      log$2(`Created "${DATASTORE_TITLE}" datastore on Agent Datastore page for ${cwd}`);
+      this.blockCache.set(cwd, created.id);
+      return created.id;
+    }
+    return null;
+  }
+  async ensureColumns(blockId) {
+    try {
+      const schema = await this.api.getDatastoreSchema(blockId);
+      const existingCols = schema.columns || [];
+      const existingNames = new Set(existingCols.map((c) => c.name));
+      const missing = COLUMNS.filter((c) => !existingNames.has(c.name));
+      if (missing.length === 0) return;
+      const usedIds = new Set(existingCols.map((c) => c.id));
+      let nextIdx = existingCols.length;
+      const appended = missing.map((c) => {
+        let id = `col_${nextIdx++}`;
+        while (usedIds.has(id)) id = `col_${nextIdx++}`;
+        usedIds.add(id);
+        return { id, name: c.name, type: c.type };
+      });
+      const merged = [...existingCols, ...appended];
+      await this.api.updateDatastoreSchema(blockId, merged);
+      log$2(`Added ${missing.length} missing column(s) to existing Time Tracking datastore: ${missing.map((c) => c.name).join(", ")}`);
+    } catch (err) {
+      log$2(`ensureColumns failed: ${err?.message || err}`);
+    }
+  }
+}
 function log$1(...args) {
   try {
     console.log(...args);
   } catch {
   }
 }
+const DEFAULT_IDLE_TIMEOUT_MIN = 15;
 const DEFAULT_PROFILES = {
   production: {
     name: "Production",
     apiKey: "",
     baseUrl: "https://app.ctlsurf.com",
-    dataspacePageId: ""
+    dataspacePageId: "",
+    trackTime: true,
+    idleTimeoutMin: 15
   }
 };
 const TERM_STREAM_INTERVAL_MS = 50;
@@ -4453,17 +4665,16 @@ class Orchestrator {
   ctlsurfApi = new CtlsurfApi();
   bridge = new ConversationBridge();
   workerWs;
+  timeTracker = new TimeTracker(this.ctlsurfApi);
   // State
-  ptyManager = null;
+  tabs = /* @__PURE__ */ new Map();
+  activeTabId = null;
   currentAgent = null;
   currentCwd = null;
   settings = {
     activeProfile: "production",
     profiles: { ...DEFAULT_PROFILES }
   };
-  // Terminal stream batching
-  termStreamBuffer = "";
-  termStreamTimer = null;
   constructor(settingsDir, events) {
     this.settingsDir = settingsDir;
     this.events = events;
@@ -4477,8 +4688,9 @@ class Orchestrator {
         events.onWorkerMessage(message);
         this.workerWs.sendAck(message.id);
         if (message.type === "prompt" || message.type === "task_dispatch") {
-          if (this.ptyManager) {
-            this.ptyManager.write(message.content + "\r");
+          const activeTab = this.activeTabId ? this.tabs.get(this.activeTabId) : null;
+          if (activeTab) {
+            activeTab.ptyManager.write(message.content + "\r");
             this.bridge.feedInput(message.content);
           }
         }
@@ -4491,7 +4703,8 @@ class Orchestrator {
         }
       },
       onTerminalInput: (data) => {
-        this.ptyManager?.write(data);
+        const activeTab = this.activeTabId ? this.tabs.get(this.activeTabId) : null;
+        activeTab?.ptyManager.write(data);
       }
     });
     this.bridge.setWsClient(this.workerWs);
@@ -4587,7 +4800,9 @@ class Orchestrator {
         name: p.name,
         baseUrl: p.baseUrl,
         hasApiKey: !!p.apiKey,
-        dataspacePageId: p.dataspacePageId || null
+        dataspacePageId: p.dataspacePageId || null,
+        trackTime: p.trackTime !== false,
+        idleTimeoutMin: p.idleTimeoutMin ?? DEFAULT_IDLE_TIMEOUT_MIN
       }))
     };
   }
@@ -4599,7 +4814,9 @@ class Orchestrator {
       name: p.name,
       baseUrl: p.baseUrl,
       hasApiKey: !!p.apiKey,
-      dataspacePageId: p.dataspacePageId || ""
+      dataspacePageId: p.dataspacePageId || "",
+      trackTime: p.trackTime !== false,
+      idleTimeoutMin: p.idleTimeoutMin ?? DEFAULT_IDLE_TIMEOUT_MIN
     };
   }
   saveProfile(profileId, data) {
@@ -4608,7 +4825,9 @@ class Orchestrator {
       name: data.name,
       apiKey: data.apiKey !== void 0 ? data.apiKey : existing?.apiKey || "",
       baseUrl: data.baseUrl || "https://app.ctlsurf.com",
-      dataspacePageId: data.dataspacePageId || ""
+      dataspacePageId: data.dataspacePageId || "",
+      trackTime: data.trackTime !== void 0 ? data.trackTime : existing?.trackTime !== false,
+      idleTimeoutMin: data.idleTimeoutMin !== void 0 ? data.idleTimeoutMin : existing?.idleTimeoutMin ?? DEFAULT_IDLE_TIMEOUT_MIN
     };
     this.saveSettings();
     if (profileId === this.settings.activeProfile) {
@@ -4645,33 +4864,55 @@ class Orchestrator {
     this.saveSettings();
     return { ok: true };
   }
-  // ─── PTY & Agent ────────────────────────────────
-  async spawnAgent(agent, cwd) {
-    if (this.ptyManager) {
-      this.bridge.endSession();
-      this.ptyManager.kill();
+  // ─── PTY & Agent (multi-tab) ─────────────────────
+  async spawnAgent(tabId, agent, cwd, opts) {
+    const existing = this.tabs.get(tabId);
+    if (existing) {
+      if (existing.termStreamTimer) clearTimeout(existing.termStreamTimer);
+      existing.ptyManager.kill();
+      this.tabs.delete(tabId);
     }
     this.currentAgent = agent;
     const prevCwd = this.currentCwd;
     this.currentCwd = cwd;
+    this.activeTabId = tabId;
     if (prevCwd !== cwd) {
       this.events.onCwdChanged();
     }
-    this.ptyManager = new PtyManager(agent, cwd);
-    this.ptyManager.onData((data) => {
-      this.events.onPtyData(data);
-      this.bridge.feedOutput(data);
-      this.streamTerminalData(data);
+    const ptyManager = new PtyManager(agent, cwd);
+    const tab = { ptyManager, agent, cwd, termStreamBuffer: "", termStreamTimer: null };
+    this.tabs.set(tabId, tab);
+    ptyManager.onData((data) => {
+      this.events.onPtyData(tabId, data);
+      this.timeTracker.recordActivity(tabId);
+      if (tabId === this.activeTabId) {
+        this.bridge.feedOutput(data);
+        this.streamTerminalData(tabId, data);
+      }
     });
-    const thisPtyManager = this.ptyManager;
-    this.ptyManager.onExit(async (exitCode) => {
-      this.events.onPtyExit(exitCode);
-      this.bridge.endSession();
-      if (thisPtyManager === this.ptyManager && this.currentAgent && isCodingAgent(this.currentAgent)) {
-        this.workerWs.disconnect();
+    ptyManager.onExit(async (exitCode) => {
+      this.events.onPtyExit(tabId, exitCode);
+      await this.timeTracker.endSession(tabId);
+      if (tabId === this.activeTabId) {
+        this.bridge.endSession();
+        if (this.currentAgent && isCodingAgent(this.currentAgent)) {
+          this.workerWs.disconnect();
+        }
       }
+      const t = this.tabs.get(tabId);
+      if (t?.termStreamTimer) clearTimeout(t.termStreamTimer);
     });
     this.bridge.startSession();
+    const profile = this.getActiveProfile();
+    const shouldTrack = opts?.trackTime !== void 0 ? opts.trackTime : profile.trackTime !== false;
+    if (shouldTrack) {
+      void this.timeTracker.startSession(
+        tabId,
+        cwd,
+        agent.name,
+        profile.idleTimeoutMin ?? DEFAULT_IDLE_TIMEOUT_MIN
+      );
+    }
     if (isCodingAgent(agent)) {
       this.connectWorkerWs(agent, cwd);
     } else {
@@ -4679,21 +4920,66 @@ class Orchestrator {
       this.checkProjectStatus(cwd);
     }
   }
-  writePty(data) {
-    this.ptyManager?.write(data);
-    this.bridge.feedInput(data);
+  writePty(tabId, data) {
+    this.tabs.get(tabId)?.ptyManager.write(data);
+    if (tabId === this.activeTabId) {
+      this.bridge.feedInput(data);
+    }
   }
-  resizePty(cols, rows) {
-    this.ptyManager?.resize(cols, rows);
-    this.bridge.resize(cols, rows);
-    this.workerWs.sendTerminalResize(cols, rows);
+  resizePty(tabId, cols, rows) {
+    this.tabs.get(tabId)?.ptyManager.resize(cols, rows);
+    if (tabId === this.activeTabId) {
+      this.bridge.resize(cols, rows);
+      this.workerWs.sendTerminalResize(cols, rows);
+    }
   }
-  async killAgent() {
-    this.bridge.endSession();
-    this.ptyManager?.kill();
-    this.ptyManager = null;
-    if (this.currentAgent && isCodingAgent(this.currentAgent)) {
-      this.workerWs.disconnect();
+  async killTab(tabId) {
+    const tab = this.tabs.get(tabId);
+    if (!tab) return;
+    if (tab.termStreamTimer) clearTimeout(tab.termStreamTimer);
+    await this.timeTracker.endSession(tabId);
+    tab.ptyManager.kill();
+    this.tabs.delete(tabId);
+    if (tabId === this.activeTabId) {
+      this.bridge.endSession();
+      if (isCodingAgent(tab.agent)) {
+        this.workerWs.disconnect();
+      }
+      const remaining = [...this.tabs.keys()];
+      this.activeTabId = remaining.length > 0 ? remaining[remaining.length - 1] : null;
+    }
+  }
+  setActiveTab(tabId) {
+    this.activeTabId = tabId;
+    const tab = this.tabs.get(tabId);
+    if (tab) {
+      this.currentAgent = tab.agent;
+      this.currentCwd = tab.cwd;
+    }
+  }
+  getTabIds() {
+    return [...this.tabs.keys()];
+  }
+  // ─── Tracking control (active tab) ──────────────
+  isActiveTabTracking() {
+    if (!this.activeTabId) return false;
+    return this.timeTracker.isTracking(this.activeTabId);
+  }
+  async setActiveTabTracking(enabled) {
+    if (!this.activeTabId) return;
+    const tab = this.tabs.get(this.activeTabId);
+    if (!tab) return;
+    if (enabled) {
+      if (this.timeTracker.isTracking(this.activeTabId)) return;
+      const profile = this.getActiveProfile();
+      await this.timeTracker.startSession(
+        this.activeTabId,
+        tab.cwd,
+        tab.agent.name,
+        profile.idleTimeoutMin ?? DEFAULT_IDLE_TIMEOUT_MIN
+      );
+    } else {
+      await this.timeTracker.endSession(this.activeTabId);
     }
   }
   // ─── Worker WebSocket ───────────────────────────
@@ -4724,28 +5010,30 @@ class Orchestrator {
       this.events.onWorkerStatus("no_project");
     }
   }
-  streamTerminalData(data) {
-    this.termStreamBuffer += data;
-    if (!this.termStreamTimer) {
-      this.termStreamTimer = setTimeout(() => {
-        if (this.termStreamBuffer) {
-          this.workerWs.sendTerminalData(this.termStreamBuffer);
-          this.termStreamBuffer = "";
+  streamTerminalData(tabId, data) {
+    const tab = this.tabs.get(tabId);
+    if (!tab) return;
+    tab.termStreamBuffer += data;
+    if (!tab.termStreamTimer) {
+      tab.termStreamTimer = setTimeout(() => {
+        if (tab.termStreamBuffer) {
+          this.workerWs.sendTerminalData(tab.termStreamBuffer);
+          tab.termStreamBuffer = "";
         }
-        this.termStreamTimer = null;
+        tab.termStreamTimer = null;
       }, TERM_STREAM_INTERVAL_MS);
     }
   }
   // ─── Shutdown ───────────────────────────────────
   async shutdown() {
     this.bridge.endSession();
-    this.ptyManager?.kill();
-    this.ptyManager = null;
-    this.workerWs.disconnect();
-    if (this.termStreamTimer) {
-      clearTimeout(this.termStreamTimer);
-      this.termStreamTimer = null;
+    await this.timeTracker.endAll();
+    for (const [, tab] of this.tabs) {
+      if (tab.termStreamTimer) clearTimeout(tab.termStreamTimer);
+      tab.ptyManager.kill();
     }
+    this.tabs.clear();
+    this.workerWs.disconnect();
   }
 }
 process.stdout?.on?.("error", () => {
@@ -4766,15 +5054,62 @@ function log(...args) {
   }
 }
 let mainWindow = null;
+function getProjectAbbrev(cwdPath) {
+  const folderName = cwdPath.split("/").filter(Boolean).pop() || "";
+  if (!folderName) return "";
+  const words = folderName.replace(/([a-z])([A-Z])/g, "$1 $2").split(/[-_.\s]+/).filter(Boolean);
+  if (words.length >= 2) {
+    return words.slice(0, 4).map((w) => w[0]).join("").toUpperCase();
+  }
+  const word = words[0];
+  if (word.length <= 3) return word.toUpperCase();
+  return word.slice(0, 2).toUpperCase();
+}
+function createOverlayIcon(text) {
+  const size = 32;
+  const canvas = Buffer.alloc(size * size * 4, 0);
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      const cx = x - size / 2;
+      const cy = y - size / 2;
+      const dist = Math.sqrt(cx * cx + cy * cy);
+      if (dist <= size / 2) {
+        const idx = (y * size + x) * 4;
+        canvas[idx] = 122;
+        canvas[idx + 1] = 162;
+        canvas[idx + 2] = 247;
+        canvas[idx + 3] = 220;
+      }
+    }
+  }
+  return electron.nativeImage.createFromBuffer(canvas, { width: size, height: size });
+}
+function updateProjectBadge(cwdPath) {
+  if (!cwdPath) return;
+  const abbrev = getProjectAbbrev(cwdPath);
+  if (process.platform === "darwin" && electron.app.dock) {
+    electron.app.dock.setBadge(abbrev);
+  }
+  if (process.platform === "win32" && mainWindow) {
+    mainWindow.setOverlayIcon(createOverlayIcon(), abbrev);
+  }
+  if (mainWindow) {
+    const folderName = cwdPath.split("/").filter(Boolean).pop() || "ctlsurf-worker";
+    mainWindow.setTitle(`ctlsurf-worker — ${folderName}`);
+  }
+}
 const orchestrator = new Orchestrator(
   getSettingsDir(),
   {
-    onPtyData: (data) => mainWindow?.webContents.send("pty:data", data),
-    onPtyExit: (code) => mainWindow?.webContents.send("pty:exit", code),
+    onPtyData: (tabId, data) => mainWindow?.webContents.send("pty:data", tabId, data),
+    onPtyExit: (tabId, code) => mainWindow?.webContents.send("pty:exit", tabId, code),
     onWorkerStatus: (status) => mainWindow?.webContents.send("worker:status", status),
     onWorkerMessage: (message) => mainWindow?.webContents.send("worker:message", message),
     onWorkerRegistered: (data) => mainWindow?.webContents.send("worker:registered", data),
-    onCwdChanged: () => mainWindow?.webContents.send("app:cwdChanged")
+    onCwdChanged: () => {
+      mainWindow?.webContents.send("app:cwdChanged");
+      updateProjectBadge(orchestrator.cwd);
+    }
   }
 );
 function createWindow() {
@@ -4802,18 +5137,21 @@ function createWindow() {
     mainWindow = null;
   });
 }
-electron.ipcMain.handle("pty:spawn", async (_event, agent, cwd) => {
-  await orchestrator.spawnAgent(agent, cwd);
+electron.ipcMain.handle("pty:spawn", async (_event, tabId, agent, cwd) => {
+  await orchestrator.spawnAgent(tabId, agent, cwd);
   return { ok: true };
 });
-electron.ipcMain.handle("pty:write", (_event, data) => {
-  orchestrator.writePty(data);
+electron.ipcMain.handle("pty:write", (_event, tabId, data) => {
+  orchestrator.writePty(tabId, data);
 });
-electron.ipcMain.handle("pty:resize", (_event, cols, rows) => {
-  orchestrator.resizePty(cols, rows);
+electron.ipcMain.handle("pty:resize", (_event, tabId, cols, rows) => {
+  orchestrator.resizePty(tabId, cols, rows);
 });
-electron.ipcMain.handle("pty:kill", async () => {
-  await orchestrator.killAgent();
+electron.ipcMain.handle("pty:kill", async (_event, tabId) => {
+  await orchestrator.killTab(tabId);
+});
+electron.ipcMain.handle("pty:setActiveTab", (_event, tabId) => {
+  orchestrator.setActiveTab(tabId);
 });
 electron.ipcMain.handle("agents:list", () => getBuiltinAgents());
 electron.ipcMain.handle("agents:default", () => getDefaultAgent());
@@ -4941,6 +5279,11 @@ electron.ipcMain.handle("profiles:save", (_event, id, data) => {
 });
 electron.ipcMain.handle("profiles:switch", (_event, id) => orchestrator.switchProfile(id));
 electron.ipcMain.handle("profiles:delete", (_event, id) => orchestrator.deleteProfile(id));
+electron.ipcMain.handle("tracking:get", () => ({ active: orchestrator.isActiveTabTracking() }));
+electron.ipcMain.handle("tracking:set", async (_event, enabled) => {
+  await orchestrator.setActiveTabTracking(enabled);
+  return { active: orchestrator.isActiveTabTracking() };
+});
 electron.ipcMain.handle("settings:get", (_event, key) => {
   const profile = orchestrator.getActiveProfile();
   if (key === "ctlsurfApiKey") return profile.apiKey ? "***configured***" : null;
@@ -4975,8 +5318,7 @@ electron.app.whenReady().then(() => {
   if (process.platform === "darwin" && electron.app.dock) {
     const iconPath = path.join(__dirname, "../../resources/icon.png");
     try {
-      const { nativeImage } = require("electron");
-      electron.app.dock.setIcon(nativeImage.createFromPath(iconPath));
+      electron.app.dock.setIcon(electron.nativeImage.createFromPath(iconPath));
     } catch {
     }
   }