@phenx-inc/ctlsurf 0.3.13 → 0.3.15

package/out/main/index.js

@@ -59,6 +59,21 @@ function getShellCommand() {
   if (process.platform === "win32") return "powershell.exe";
   return process.env.SHELL || "/bin/zsh";
 }
+function isCommandAvailable(command) {
+  const dirs = (process.env.PATH || "").split(path.delimiter).filter(Boolean);
+  const isWin = process.platform === "win32";
+  const exts = isWin ? (process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean) : [""];
+  for (const dir of dirs) {
+    for (const ext of exts) {
+      try {
+        fs.accessSync(path.join(dir, command + ext), isWin ? fs.constants.F_OK : fs.constants.X_OK);
+        return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
 function getBuiltinAgents() {
   return [
     {
@@ -85,8 +100,14 @@ function getBuiltinAgents() {
     }
   ];
 }
+function getAvailableAgents() {
+  const all = getBuiltinAgents();
+  const coding = all.filter((a) => isCodingAgent(a) && isCommandAvailable(a.command));
+  const shell = all.filter((a) => !isCodingAgent(a));
+  return [...coding, ...shell];
+}
 function getDefaultAgent() {
-  return getBuiltinAgents()[0];
+  return getAvailableAgents()[0];
 }
 function isCodingAgent(agent) {
   return agent.id !== "shell";
@@ -230,6 +251,14 @@ class CtlsurfApi {
   async updateRow(blockId, rowId, data) {
     return this.request("PUT", `/datastore/${blockId}/rows/${rowId}`, { data });
   }
+  async queryRows(blockId, opts) {
+    const params = new URLSearchParams();
+    if (opts?.orderBy) params.set("order_by", opts.orderBy);
+    if (opts?.order) params.set("order", opts.order);
+    params.set("limit", String(opts?.limit ?? 200));
+    const qs = params.toString();
+    return this.request("GET", `/datastore/${blockId}/rows${qs ? `?${qs}` : ""}`);
+  }
   async getDatastoreSchema(blockId) {
     return this.request("GET", `/datastore/${blockId}/schema`);
   }
@@ -9902,7 +9931,7 @@ function requireWebsocketServer() {
   return websocketServer;
 }
 requireWebsocketServer();
-function log$2(...args) {
+function log$3(...args) {
   try {
     console.log(...args);
   } catch {
@@ -9999,7 +10028,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();
@@ -10022,22 +10051,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",
@@ -10050,11 +10079,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");
@@ -10063,7 +10092,7 @@ class WorkerWsClient {
       }
     };
     this.ws.onerror = () => {
-      log$2("[worker-ws] WebSocket error");
+      log$3("[worker-ws] WebSocket error");
     };
   }
   handleMessage(data) {
@@ -10072,7 +10101,7 @@ class WorkerWsClient {
       case "registered": {
         this.workerId = data.worker_id;
         const workerStatus = data.status;
-        log$2(`[worker-ws] Registered as ${this.workerId}, status: ${workerStatus}`);
+        log$3(`[worker-ws] Registered as ${this.workerId}, status: ${workerStatus}`);
         if (workerStatus === "pending_approval") {
           this.setStatus("pending_approval");
         } else {
@@ -10091,14 +10120,14 @@ class WorkerWsClient {
         break;
       }
       case "approved": {
-        log$2("[worker-ws] Worker approved!");
+        log$3("[worker-ws] Worker approved!");
         this.setStatus("connected");
         break;
       }
       case "message": {
         const msg = data.message;
         if (msg) {
-          log$2(`[worker-ws] Received message: ${msg.id}`);
+          log$3(`[worker-ws] Received message: ${msg.id}`);
           this.events.onMessage(msg);
         }
         break;
@@ -10113,7 +10142,7 @@ class WorkerWsClient {
       case "heartbeat_ack":
         break;
       default:
-        log$2(`[worker-ws] Unknown message type: ${msgType}`);
+        log$3(`[worker-ws] Unknown message type: ${msgType}`);
     }
   }
   send(data) {
@@ -10135,7 +10164,7 @@ class WorkerWsClient {
   }
   scheduleReconnect() {
     if (!this.shouldReconnect) return;
-    log$2(`[worker-ws] Reconnecting in ${this.reconnectDelay / 1e3}s...`);
+    log$3(`[worker-ws] Reconnecting in ${this.reconnectDelay / 1e3}s...`);
     this.reconnectTimer = setTimeout(() => {
       this.doConnect();
     }, this.reconnectDelay);
@@ -10149,12 +10178,12 @@ class WorkerWsClient {
     }
   }
 }
-const DATASTORE_TITLE = "Time Tracking";
-const AGENT_DATASTORE_PAGE_TITLE = "Agent Datastore";
-const SYSTEM_KEY = "time_tracking";
+const DATASTORE_TITLE$1 = "Time Tracking";
+const AGENT_DATASTORE_PAGE_TITLE$1 = "Agent Datastore";
+const SYSTEM_KEY$1 = "time_tracking";
 const FIRST_CHECKPOINT_DELAY_MS = 30 * 1e3;
 const CHECKPOINT_INTERVAL_MS = 5 * 60 * 1e3;
-const COLUMNS = [
+const COLUMNS$1 = [
   { name: "Started", type: "text" },
   { name: "Active Time", type: "number" },
   { name: "Last Updated", type: "date" },
@@ -10178,17 +10207,17 @@ function isSameLocalDay(a, b2) {
   const db = new Date(b2);
   return da.getFullYear() === db.getFullYear() && da.getMonth() === db.getMonth() && da.getDate() === db.getDate();
 }
-function log$1(...args) {
+function log$2(...args) {
   try {
     console.log("[time-tracker]", ...args);
   } catch {
   }
 }
-function findPageByTitle(pages, title) {
+function findPageByTitle$1(pages, title) {
   for (const p2 of pages) {
     if (p2?.title === title) return p2;
     if (p2?.children?.length) {
-      const c = findPageByTitle(p2.children, title);
+      const c = findPageByTitle$1(p2.children, title);
       if (c) return c;
     }
   }
@@ -10234,7 +10263,7 @@ class TimeTracker {
       }
     }, FIRST_CHECKPOINT_DELAY_MS);
     const pending = !state.blockId || !state.rowId;
-    log$1(`Started tracking tab=${tabId} agent="${agentName}" cwd=${cwd}${pending ? " (pending datastore — will retry on each checkpoint)" : ""}`);
+    log$2(`Started tracking tab=${tabId} agent="${agentName}" cwd=${cwd}${pending ? " (pending datastore — will retry on each checkpoint)" : ""}`);
   }
   /** Attempts to locate (or create) the datastore + add the session row.
    * Returns true once the session is resolved (blockId + rowId set).
@@ -10258,15 +10287,15 @@ class TimeTracker {
       });
       const rowId = row?.id;
       if (!rowId) {
-        log$1(`addRow returned no id for tab=${tabId}; will retry on next checkpoint`);
+        log$2(`addRow returned no id for tab=${tabId}; will retry on next checkpoint`);
         return false;
       }
       s.blockId = blockId;
       s.rowId = rowId;
-      log$1(`Resolved datastore for tab=${tabId} (cwd=${s.cwd})`);
+      log$2(`Resolved datastore for tab=${tabId} (cwd=${s.cwd})`);
       return true;
     } catch (err) {
-      log$1(`tryResolve failed for tab=${tabId}: ${err?.message || err}`);
+      log$2(`tryResolve failed for tab=${tabId}: ${err?.message || err}`);
       return false;
     }
   }
@@ -10294,12 +10323,12 @@ class TimeTracker {
     if (!s || s.ended) return;
     this.rollingOver.add(tabId);
     const { cwd, agentName, idleTimeoutMin } = s;
-    log$1(`Day rolled over for tab=${tabId}; ending session and starting fresh`);
+    log$2(`Day rolled over for tab=${tabId}; ending session and starting fresh`);
     try {
       await this.endSession(tabId);
       await this.startSession(tabId, cwd, agentName, idleTimeoutMin);
     } catch (err) {
-      log$1(`rollover failed: ${err?.message || err}`);
+      log$2(`rollover failed: ${err?.message || err}`);
     } finally {
       this.rollingOver.delete(tabId);
     }
@@ -10316,10 +10345,10 @@ class TimeTracker {
       if (s.blockId && s.rowId) {
         await this.writeRow(s, Date.now());
       } else {
-        log$1(`endSession for tab=${tabId}: never resolved datastore; ${Math.round(s.activeMs / 6e4)}min not recorded`);
+        log$2(`endSession for tab=${tabId}: never resolved datastore; ${Math.round(s.activeMs / 6e4)}min not recorded`);
       }
     } catch (err) {
-      log$1(`endSession write failed: ${err?.message || err}`);
+      log$2(`endSession write failed: ${err?.message || err}`);
     }
     s.ended = true;
     this.sessions.delete(tabId);
@@ -10337,12 +10366,12 @@ class TimeTracker {
     try {
       await this.writeRow(s, Date.now());
     } catch (err) {
-      log$1(`checkpoint failed: ${err?.message || err}; retrying in 2s`);
+      log$2(`checkpoint failed: ${err?.message || err}; retrying in 2s`);
       setTimeout(() => {
         const live = this.sessions.get(tabId);
         if (!live || live.ended || !live.blockId || !live.rowId) return;
         this.writeRow(live, Date.now()).catch((err2) => {
-          log$1(`checkpoint retry failed: ${err2?.message || err2}`);
+          log$2(`checkpoint retry failed: ${err2?.message || err2}`);
         });
       }, 2e3);
     }
@@ -10356,6 +10385,205 @@ class TimeTracker {
     });
   }
   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$1(folderDetail?.pages || [], AGENT_DATASTORE_PAGE_TITLE$1);
+    if (!agentPage?.id) return null;
+    const blockId = await this.findOrAdoptBlock(agentPage.id);
+    if (blockId) {
+      await this.ensureColumns(blockId);
+      this.blockCache.set(cwd, blockId);
+      return blockId;
+    }
+    const columns = COLUMNS$1.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$1,
+      props: { columns, system_key: SYSTEM_KEY$1 }
+    });
+    if (created?.id) {
+      log$2(`Created "${DATASTORE_TITLE$1}" datastore on Agent Datastore page for ${cwd}`);
+      this.blockCache.set(cwd, created.id);
+      return created.id;
+    }
+    return null;
+  }
+  /** Finds an existing Time Tracking block on the page. Prefers a system_key match
+   * (which survives title renames). Falls back to title match for legacy blocks
+   * created before system_key existed, and backfills system_key on the way out. */
+  async findOrAdoptBlock(pageId) {
+    const summaries = await this.api.getPageBlockSummaries(pageId) || [];
+    const datastoreSummaries = summaries.filter((b2) => b2?.type === "datastore" && b2?.id);
+    if (datastoreSummaries.length === 0) return null;
+    let titleFallbackId = null;
+    let titleFallbackProps = null;
+    for (const s of datastoreSummaries) {
+      try {
+        const block = await this.api.getBlock(s.id);
+        const props = block?.props || {};
+        if (props.system_key === SYSTEM_KEY$1) {
+          return s.id;
+        }
+        if (s.title === DATASTORE_TITLE$1 && titleFallbackId === null) {
+          titleFallbackId = s.id;
+          titleFallbackProps = props;
+        }
+      } catch (err) {
+        log$2(`getBlock(${s.id}) failed during lookup: ${err?.message || err}`);
+      }
+    }
+    if (titleFallbackId) {
+      try {
+        await this.api.updateBlock(titleFallbackId, {
+          props: { ...titleFallbackProps || {}, system_key: SYSTEM_KEY$1 }
+        });
+        log$2(`Backfilled system_key on legacy Time Tracking block ${titleFallbackId}`);
+      } catch (err) {
+        log$2(`backfill system_key failed on ${titleFallbackId}: ${err?.message || err}`);
+      }
+      return titleFallbackId;
+    }
+    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$1.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}`);
+    }
+  }
+}
+const DATASTORE_TITLE = "Tickets";
+const AGENT_DATASTORE_PAGE_TITLE = "Agent Datastore";
+const SYSTEM_KEY = "tickets";
+const STATUS_OPTIONS = [
+  { value: "Open", color: "blue" },
+  { value: "In Progress", color: "yellow" },
+  { value: "Blocked", color: "red" },
+  { value: "Done", color: "green" }
+];
+const PRIORITY_OPTIONS = [
+  { value: "Low", color: "gray" },
+  { value: "Med", color: "yellow" },
+  { value: "High", color: "red" }
+];
+const COLUMNS = [
+  { name: "Title", type: "text" },
+  { name: "Description", type: "text" },
+  { name: "Status", type: "select", options: STATUS_OPTIONS },
+  { name: "Priority", type: "select", options: PRIORITY_OPTIONS },
+  { name: "Created", type: "date" }
+];
+function log$1(...args) {
+  try {
+    console.log("[ticket-store]", ...args);
+  } catch {
+  }
+}
+function findPageByTitle(pages, title) {
+  for (const p2 of pages) {
+    if (p2?.title === title) return p2;
+    if (p2?.children?.length) {
+      const c = findPageByTitle(p2.children, title);
+      if (c) return c;
+    }
+  }
+  return null;
+}
+class TicketStore {
+  api;
+  blockCache = /* @__PURE__ */ new Map();
+  constructor(api) {
+    this.api = api;
+  }
+  /** Resolves (or creates) the project's Tickets datastore and appends a row. */
+  async addTicket(cwd, input) {
+    const title = input.title?.trim();
+    if (!title) return { ok: false, error: "Title is required" };
+    try {
+      const blockId = await this.ensureDatastore(cwd, true);
+      if (!blockId) {
+        return { ok: false, error: "No ctlsurf project found for this folder" };
+      }
+      await this.api.addRow(blockId, {
+        Title: title,
+        Description: input.description?.trim() || "",
+        Status: input.status || "Open",
+        Priority: input.priority || "Med",
+        Created: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      log$1(`Added ticket "${title}" for ${cwd}`);
+      return { ok: true };
+    } catch (err) {
+      log$1(`addTicket failed for ${cwd}: ${err?.message || err}`);
+      return { ok: false, error: err?.message || String(err) };
+    }
+  }
+  /** Updates an existing ticket row in the project's Tickets datastore. */
+  async updateTicket(cwd, rowId, input) {
+    const title = input.title?.trim();
+    if (!title) return { ok: false, error: "Title is required" };
+    try {
+      const blockId = await this.ensureDatastore(cwd, false);
+      if (!blockId) return { ok: false, error: "No Tickets datastore for this project" };
+      await this.api.updateRow(blockId, rowId, {
+        Title: title,
+        Description: input.description?.trim() || "",
+        Status: input.status || "Open",
+        Priority: input.priority || "Med"
+      });
+      log$1(`Updated ticket ${rowId} for ${cwd}`);
+      return { ok: true };
+    } catch (err) {
+      log$1(`updateTicket failed for ${cwd}: ${err?.message || err}`);
+      return { ok: false, error: err?.message || String(err) };
+    }
+  }
+  /** Lists existing tickets for the project, newest first. Does not create the
+   * datastore — an unconfigured project simply has no tickets yet. */
+  async listTickets(cwd) {
+    try {
+      const blockId = await this.ensureDatastore(cwd, false);
+      if (!blockId) return { ok: true, tickets: [] };
+      const res = await this.api.queryRows(blockId, { orderBy: "Created", order: "desc", limit: 200 });
+      const tickets = (res?.rows || []).map((r) => ({
+        id: r.id,
+        title: String(r.data?.Title ?? ""),
+        description: String(r.data?.Description ?? ""),
+        status: String(r.data?.Status ?? "Open"),
+        priority: String(r.data?.Priority ?? "Med"),
+        created: r.data?.Created ?? r.created_at ?? null
+      }));
+      return { ok: true, tickets };
+    } catch (err) {
+      log$1(`listTickets failed for ${cwd}: ${err?.message || err}`);
+      return { ok: false, tickets: [], error: err?.message || String(err) };
+    }
+  }
+  async ensureDatastore(cwd, create) {
     const cached = this.blockCache.get(cwd);
     if (cached) return cached;
     let folder = null;
@@ -10374,7 +10602,13 @@ class TimeTracker {
       this.blockCache.set(cwd, blockId);
       return blockId;
     }
-    const columns = COLUMNS.map((c, i) => ({ id: `col_${i}`, name: c.name, type: c.type }));
+    if (!create) return null;
+    const columns = COLUMNS.map((c, i) => ({
+      id: `col_${i}`,
+      name: c.name,
+      type: c.type,
+      ...c.options ? { options: c.options } : {}
+    }));
     const created = await this.api.createBlock(agentPage.id, {
       type: "datastore",
       title: DATASTORE_TITLE,
@@ -10387,9 +10621,9 @@ class TimeTracker {
     }
     return null;
   }
-  /** Finds an existing Time Tracking block on the page. Prefers a system_key match
+  /** Finds an existing Tickets block on the page. Prefers a system_key match
    * (which survives title renames). Falls back to title match for legacy blocks
-   * created before system_key existed, and backfills system_key on the way out. */
+   * and backfills system_key on the way out. */
   async findOrAdoptBlock(pageId) {
     const summaries = await this.api.getPageBlockSummaries(pageId) || [];
     const datastoreSummaries = summaries.filter((b2) => b2?.type === "datastore" && b2?.id);
@@ -10416,7 +10650,7 @@ class TimeTracker {
         await this.api.updateBlock(titleFallbackId, {
           props: { ...titleFallbackProps || {}, system_key: SYSTEM_KEY }
         });
-        log$1(`Backfilled system_key on legacy Time Tracking block ${titleFallbackId}`);
+        log$1(`Backfilled system_key on legacy Tickets block ${titleFallbackId}`);
       } catch (err) {
         log$1(`backfill system_key failed on ${titleFallbackId}: ${err?.message || err}`);
       }
@@ -10437,11 +10671,11 @@ class TimeTracker {
         let id = `col_${nextIdx++}`;
         while (usedIds.has(id)) id = `col_${nextIdx++}`;
         usedIds.add(id);
-        return { id, name: c.name, type: c.type };
+        return { id, name: c.name, type: c.type, ...c.options ? { options: c.options } : {} };
       });
       const merged = [...existingCols, ...appended];
       await this.api.updateDatastoreSchema(blockId, merged);
-      log$1(`Added ${missing.length} missing column(s) to existing Time Tracking datastore: ${missing.map((c) => c.name).join(", ")}`);
+      log$1(`Added ${missing.length} missing column(s) to existing Tickets datastore: ${missing.map((c) => c.name).join(", ")}`);
     } catch (err) {
       log$1(`ensureColumns failed: ${err?.message || err}`);
     }
@@ -10468,6 +10702,7 @@ class Orchestrator {
   bridge = new ConversationBridge();
   workerWs;
   timeTracker = new TimeTracker(this.ctlsurfApi);
+  ticketStore = new TicketStore(this.ctlsurfApi);
   // State
   tabs = /* @__PURE__ */ new Map();
   activeTabId = null;
@@ -10480,16 +10715,17 @@ class Orchestrator {
   };
   noProjectPollTimer = null;
   noProjectPollCwd = null;
+  currentProjectName = null;
   constructor(settingsDir, events) {
     this.settingsDir = settingsDir;
     this.events = events;
     this.workerWs = new WorkerWsClient({
       onStatusChange: (status) => {
-        log$2(`[worker-ws] Status: ${status}`);
+        log$3(`[worker-ws] Status: ${status}`);
         events.onWorkerStatus(status);
       },
       onMessage: (message) => {
-        log$2(`[worker-ws] Incoming message: ${message.id} (${message.type})`);
+        log$3(`[worker-ws] Incoming message: ${message.id} (${message.type})`);
         events.onWorkerMessage(message);
         this.workerWs.sendAck(message.id);
         if (message.type === "prompt" || message.type === "task_dispatch") {
@@ -10501,15 +10737,17 @@ class Orchestrator {
         }
       },
       onRegistered: (data) => {
-        log$2(`[worker-ws] Registered: worker_id=${data.worker_id}, folder_id=${data.folder_id}, status=${data.status}`);
+        log$3(`[worker-ws] Registered: worker_id=${data.worker_id}, folder_id=${data.folder_id}, status=${data.status}`);
         events.onWorkerRegistered(data);
         if (!data.folder_id) {
+          this.setProjectName(null);
           events.onWorkerStatus("no_project");
           if (this.currentCwd && data.status !== "pending_approval") {
             this.startNoProjectPolling(this.currentCwd);
           }
         } else {
           this.stopNoProjectPolling();
+          this.resolveProjectName(data.folder_id);
         }
       },
       onTerminalInput: (data) => {
@@ -10544,6 +10782,26 @@ class Orchestrator {
   get cwd() {
     return this.currentCwd;
   }
+  // Name of the connected ctlsurf project (folder) for the desktop header.
+  get projectName() {
+    return this.currentProjectName;
+  }
+  setProjectName(name) {
+    if (this.currentProjectName === name) return;
+    this.currentProjectName = name;
+    this.events.onProjectChanged?.(name);
+  }
+  // Resolve the connected folder's human-readable name. Best-effort: a failed
+  // lookup just leaves the project name unset rather than blocking anything.
+  async resolveProjectName(folderId) {
+    try {
+      const folder = await this.ctlsurfApi.getFolder(folderId);
+      const name = folder?.name ?? folder?.title;
+      this.setProjectName(typeof name === "string" && name ? name : null);
+    } catch (err) {
+      log$3(`[worker-ws] Failed to resolve project name for folder ${folderId}: ${err}`);
+    }
+  }
   get agent() {
     return this.currentAgent;
   }
@@ -10559,7 +10817,7 @@ class Orchestrator {
     const baseUrl = profile.baseUrl || process.env.CTLSURF_BASE_URL || "https://app.ctlsurf.com";
     this.ctlsurfApi.setBaseUrl(baseUrl);
     this.workerWs.setBaseUrl(baseUrl);
-    log$2(`[settings] Profile applied: ${profile.name} (${baseUrl})`);
+    log$3(`[settings] Profile applied: ${profile.name} (${baseUrl})`);
   }
   loadSettings() {
     try {
@@ -10584,7 +10842,7 @@ class Orchestrator {
             logChat: !!raw.logChat
           };
           this.saveSettings();
-          log$2("[settings] Migrated legacy settings to profiles");
+          log$3("[settings] Migrated legacy settings to profiles");
         } else {
           this.settings = raw;
           if (!this.settings.profiles.production) {
@@ -10611,7 +10869,7 @@ class Orchestrator {
       fs.mkdirSync(this.settingsDir, { recursive: true });
       fs.writeFileSync(settingsPath, JSON.stringify(this.settings, null, 2));
     } catch (err) {
-      log$2("[settings] Failed to save:", err.message);
+      log$3("[settings] Failed to save:", err.message);
     }
   }
   overrideApiKey(key) {
@@ -10816,12 +11074,42 @@ class Orchestrator {
       await this.timeTracker.endSession(this.activeTabId);
     }
   }
+  // ─── Tickets (active tab) ───────────────────────
+  /** cwd of the focused terminal tab, or null if no tab is active. */
+  getActiveTabCwd() {
+    if (!this.activeTabId) return null;
+    return this.tabs.get(this.activeTabId)?.cwd ?? null;
+  }
+  async addTicketForActiveTab(input) {
+    const cwd = this.getActiveTabCwd();
+    if (!cwd) return { ok: false, error: "No active terminal tab" };
+    if (!this.ctlsurfApi.getApiKey()) {
+      return { ok: false, error: "ctlsurf API key not configured" };
+    }
+    return this.ticketStore.addTicket(cwd, input);
+  }
+  async updateTicketForActiveTab(rowId, input) {
+    const cwd = this.getActiveTabCwd();
+    if (!cwd) return { ok: false, error: "No active terminal tab" };
+    if (!this.ctlsurfApi.getApiKey()) {
+      return { ok: false, error: "ctlsurf API key not configured" };
+    }
+    return this.ticketStore.updateTicket(cwd, rowId, input);
+  }
+  async listTicketsForActiveTab() {
+    const cwd = this.getActiveTabCwd();
+    if (!cwd) return { ok: false, tickets: [], error: "No active terminal tab" };
+    if (!this.ctlsurfApi.getApiKey()) {
+      return { ok: false, tickets: [], error: "ctlsurf API key not configured" };
+    }
+    return this.ticketStore.listTickets(cwd);
+  }
   // ─── Worker WebSocket ───────────────────────────
   connectWorkerWs(agent, cwd) {
     const profile = this.getActiveProfile();
     const apiKey = profile.apiKey || process.env.CTLSURF_API_KEY;
     if (!apiKey) {
-      log$2("[worker-ws] No API key, skipping WS connect");
+      log$3("[worker-ws] No API key, skipping WS connect");
       return;
     }
     this.stopNoProjectPolling();
@@ -10835,7 +11123,7 @@ class Orchestrator {
     if (this.noProjectPollTimer && this.noProjectPollCwd === cwd) return;
     this.stopNoProjectPolling();
     this.noProjectPollCwd = cwd;
-    log$2(`[worker-ws] Polling for project folder at ${cwd}`);
+    log$3(`[worker-ws] Polling for project folder at ${cwd}`);
     this.noProjectPollTimer = setInterval(() => {
       void this.checkForProjectFolder(cwd);
     }, NO_PROJECT_POLL_MS);
@@ -10856,7 +11144,7 @@ class Orchestrator {
     try {
       const folder = await this.ctlsurfApi.findFolderByPath(cwd);
       if (folder?.id && this.currentCwd === cwd && this.currentAgent) {
-        log$2(`[worker-ws] Project folder appeared (${folder.id}); reconnecting`);
+        log$3(`[worker-ws] Project folder appeared (${folder.id}); reconnecting`);
         const agent = this.currentAgent;
         this.stopNoProjectPolling();
         this.workerWs.disconnect();
@@ -10978,6 +11266,7 @@ const orchestrator = new Orchestrator(
     onWorkerStatus: (status) => mainWindow?.webContents.send("worker:status", status),
     onWorkerMessage: (message) => mainWindow?.webContents.send("worker:message", message),
     onWorkerRegistered: (data) => mainWindow?.webContents.send("worker:registered", data),
+    onProjectChanged: (name) => mainWindow?.webContents.send("app:projectChanged", name),
     onCwdChanged: () => {
       mainWindow?.webContents.send("app:cwdChanged");
       updateProjectBadge(orchestrator.cwd);
@@ -11025,10 +11314,11 @@ electron.ipcMain.handle("pty:kill", async (_event, tabId) => {
 electron.ipcMain.handle("pty:setActiveTab", (_event, tabId) => {
   orchestrator.setActiveTab(tabId);
 });
-electron.ipcMain.handle("agents:list", () => getBuiltinAgents());
+electron.ipcMain.handle("agents:list", () => getAvailableAgents());
 electron.ipcMain.handle("agents:default", () => getDefaultAgent());
 electron.ipcMain.handle("app:homePath", () => electron.app.getPath("home"));
 electron.ipcMain.handle("app:cwd", () => process.env.CTLSURF_WORKER_CWD || process.cwd());
+electron.ipcMain.handle("app:projectName", () => orchestrator.projectName);
 electron.ipcMain.handle("app:browseCwd", async () => {
   if (!mainWindow) return null;
   const result = await electron.dialog.showOpenDialog(mainWindow, {
@@ -11181,6 +11471,19 @@ electron.ipcMain.handle("tracking:set", async (_event, enabled) => {
   await orchestrator.setActiveTabTracking(enabled);
   return { active: orchestrator.isActiveTabTracking() };
 });
+electron.ipcMain.handle("tickets:project", () => {
+  const cwd = orchestrator.getActiveTabCwd();
+  return { cwd, name: cwd ? cwd.split("/").filter(Boolean).pop() || cwd : null };
+});
+electron.ipcMain.handle("tickets:add", async (_event, input) => {
+  return orchestrator.addTicketForActiveTab(input);
+});
+electron.ipcMain.handle("tickets:update", async (_event, rowId, input) => {
+  return orchestrator.updateTicketForActiveTab(rowId, input);
+});
+electron.ipcMain.handle("tickets:list", async () => {
+  return orchestrator.listTicketsForActiveTab();
+});
 electron.ipcMain.handle("settings:get", (_event, key) => {
   const profile = orchestrator.getActiveProfile();
   if (key === "ctlsurfApiKey") return profile.apiKey ? "***configured***" : null;