main.js

const { app, BrowserWindow, clipboard, dialog, ipcMain, Menu, protocol, screen, shell } = require('electron');
const { Worker } = require('worker_threads');
const path = require('path');
const fs = require('fs');
const os = require('os');
const pty = require('node-pty');
const log = require('electron-log');
// getFolderIndexMtimeMs moved to session-cache.js
const { startMcpServer, shutdownMcpServer, shutdownAll: shutdownAllMcp, resolvePendingDiff, rekeyMcpServer, cleanStaleLockFiles } = require('./mcp-bridge');
const { fetchAndTransformUsage } = require('./claude-auth');
const { runStatsCommand, refreshStatsCache } = require('./stats-refresh');
const { readHead } = require('./jsonl-scan');
const codexAuth = require('./codex-auth');

// SWITCHBOARD_DATA_DIR isolates a dev/test instance from the installed app:
// db.js puts switchboard.db under it, and pointing userData there gives the
// instance its own single-instance lock (requestSingleInstanceLock keys on
// userData), so both can run side by side.
if (process.env.SWITCHBOARD_DATA_DIR) {
  app.setPath('userData', path.resolve(process.env.SWITCHBOARD_DATA_DIR, 'electron'));
}

log.transports.file.level = app.isPackaged ? 'info' : 'debug';
log.transports.console.level = app.isPackaged ? 'info' : 'debug';

try { require('electron-reloader')(module, { watchRenderer: true }); } catch {};

// Clean env for child processes — strips Electron internals that cause nested
// Electron apps (or node-pty inside them) to malfunction, and pins a UTF-8
// LC_CTYPE when the launch environment has no locale. See pty-env.js.
const { buildPtyEnv } = require('./pty-env');
const cleanPtyEnv = buildPtyEnv(process.env);
const { shouldStartFresh, shouldBlockArchivedSession } = require('./session-launch');
const { createTerminalActivity } = require('./terminal-activity');

// Shell profiles → shell-profiles.js
const { discoverShellProfiles, getShellProfiles, resolveShell, isWindows, isWslShell, windowsToWslPath, shellArgs, quoteArgvForShell } = require('./shell-profiles');
const { scanSchedules } = require('./schedule-runner');
const { encodeProjectPath } = require('./encode-project-path');
const { resolveEffectiveSettings } = require('./resolve-effective-settings');
const { listProjectDirectory, readProjectFile, readPreviewFile, openFileExternally } = require('./project-files');
const { manageProjectEntry } = require('./file-management');
const { resolveTerminalFiles } = require('./terminal-file-links');
const { PREVIEW_SCHEME, PREVIEW_SCHEMES, handlePreviewAssetRequest } = require('./preview-assets');
protocol.registerSchemesAsPrivileged(PREVIEW_SCHEMES);
const { createTaskManager } = require('./task-manager');
const { lastAssistantMessage } = require('./session-preview');


// --- Auto-updater (only in packaged builds) ---
let autoUpdater = null;
if (app.isPackaged || process.env.FORCE_UPDATER) {
  autoUpdater = require('electron-updater').autoUpdater;
  autoUpdater.logger = log;
  autoUpdater.autoDownload = true;
  autoUpdater.autoInstallOnAppQuit = true;
  if (!app.isPackaged) autoUpdater.forceDevUpdateConfig = true;

  function sendUpdaterEvent(type, data) {
    log.info(`[updater] ${type}`, data || '');
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('updater-event', type, data);
    }
  }
  autoUpdater.on('checking-for-update', () => sendUpdaterEvent('checking'));
  autoUpdater.on('update-available', (info) => sendUpdaterEvent('update-available', info));
  autoUpdater.on('update-not-available', (info) => sendUpdaterEvent('update-not-available', info));
  autoUpdater.on('download-progress', (progress) => sendUpdaterEvent('download-progress', progress));
  autoUpdater.on('update-downloaded', (info) => sendUpdaterEvent('update-downloaded', info));
  autoUpdater.on('error', (err) => {
    log.error('[updater] Error:', err?.message || String(err));
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('updater-event', 'error', { message: err?.message || String(err) });
    }
  });
}
const {
  getMeta, getAllMeta, toggleStar, setName, setArchived,
  isCachePopulated, getAllCached, getCachedByFolder, getCachedSession, upsertCachedSessions,
  updateCachedAiTitle,
  deleteCachedSession, deleteCachedFolder,
  getFolderMeta, getAllFolderMeta, setFolderMeta,
  upsertSearchEntries, updateSearchTitle, deleteSearchSession, deleteSearchFolder, deleteSearchType,
  searchByType, isSearchIndexPopulated, searchFtsRecreated,
  getSetting, setSetting, deleteSetting,
  copySessionAssignment, moveSessionAssignment, rekeyPlanLinks,
  closeDb,
} = require('./db');
const dbModule = require('./db');

const { getHarness, DEFAULT_HARNESS, transcriptPath, availableHarnesses, allHarnesses, progressBusyState,
        harnessForFolder: getHarnessForFolder } = require('./harnesses');
const claudeHarness = getHarness(DEFAULT_HARNESS);
const PROJECTS_DIR = claudeHarness.sessionsRoot();
const PLANS_DIR = path.join(os.homedir(), '.claude', 'plans');
const CLAUDE_DIR = path.join(os.homedir(), '.claude');
const STATS_CACHE_PATH = path.join(CLAUDE_DIR, 'stats-cache.json');
const MAX_BUFFER_SIZE = 256 * 1024;

// Active PTY sessions
const activeSessions = new Map();
let mainWindow = null;
let appIsQuitting = false;

function createWindow() {
  // Restore saved window bounds
  const savedBounds = getSetting('global')?.windowBounds;
  let bounds = { width: 1400, height: 900 };

  let restorePosition = null;
  if (savedBounds && savedBounds.width && savedBounds.height) {
    bounds.width = savedBounds.width;
    bounds.height = savedBounds.height;

    // Only restore position if it's on a visible display
    if (savedBounds.x != null && savedBounds.y != null) {
      const displays = screen.getAllDisplays();
      const onScreen = displays.some(d => {
        const b = d.bounds;
        return savedBounds.x >= b.x - 100 && savedBounds.x < b.x + b.width &&
               savedBounds.y >= b.y - 100 && savedBounds.y < b.y + b.height;
      });
      if (onScreen) {
        restorePosition = { x: savedBounds.x, y: savedBounds.y };
      }
    }
  }

  mainWindow = new BrowserWindow({
    ...bounds,
    minWidth: 800,
    minHeight: 500,
    title: 'Switchboard',
    icon: path.join(__dirname, 'build', 'icon.png'),
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      nodeIntegration: false,
      nodeIntegrationInSubFrames: false,
      contextIsolation: true,
    },
  });

  // Set position after creation to prevent macOS from clamping size
  if (restorePosition) {
    mainWindow.setBounds({ ...restorePosition, width: bounds.width, height: bounds.height });
  }

  mainWindow.loadFile(path.join(__dirname, 'public', 'index.html'));

  // Open external links in the system browser instead of a child BrowserWindow
  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
    if (/^https?:\/\//i.test(url)) shell.openExternal(url).catch(() => {});
    return { action: 'deny' };
  });
  mainWindow.webContents.on('will-navigate', (event, url) => {
    if (url !== mainWindow.webContents.getURL()) {
      event.preventDefault();
      if (/^https?:\/\//i.test(url)) shell.openExternal(url).catch(() => {});
    }
  });
  // Override window.open so xterm WebLinksAddon's default handler (which does
  // window.open() then sets location.href) routes through our IPC instead of
  // creating a child BrowserWindow.
  mainWindow.webContents.on('did-finish-load', () => {
    mainWindow.webContents.executeJavaScript(`
      window.open = function(url) {
        if (url && /^https?:\\/\\//i.test(url)) { window.api.openExternal(url); return null; }
        const proxy = {};
        Object.defineProperty(proxy, 'location', { get() {
          const loc = {};
          Object.defineProperty(loc, 'href', {
            set(u) { if (/^https?:\\/\\//i.test(u)) window.api.openExternal(u); }
          });
          return loc;
        }});
        return proxy;
      };
      void 0;
    `);
  });

  // Prevent Cmd+R / Ctrl+Shift+R from reloading the page (Chromium built-in).
  // Ctrl+R alone on macOS is NOT a reload shortcut and must pass through to xterm
  // for reverse-i-search.
  mainWindow.webContents.on('before-input-event', (event, input) => {
    if (input.type !== 'keyDown') return;
    const key = input.key.toLowerCase();
    if (key === 'r' && input.meta) event.preventDefault();
    if (key === 'r' && input.control && input.shift) event.preventDefault();
  });

  // Save window bounds on move/resize (debounced)
  let boundsTimer = null;
  const saveBounds = () => {
    if (boundsTimer) clearTimeout(boundsTimer);
    boundsTimer = setTimeout(() => {
      if (!mainWindow || mainWindow.isDestroyed() || mainWindow.isMinimized()) return;
      const b = mainWindow.getBounds();
      const global = getSetting('global') || {};
      global.windowBounds = { x: b.x, y: b.y, width: b.width, height: b.height };
      setSetting('global', global);
    }, 500);
  };
  mainWindow.on('resize', saveBounds);
  mainWindow.on('move', saveBounds);

  // Also save immediately before close (debounce may not have flushed)
  mainWindow.on('close', () => {
    if (boundsTimer) clearTimeout(boundsTimer);
    if (!mainWindow.isMinimized()) {
      const b = mainWindow.getBounds();
      const global = getSetting('global') || {};
      global.windowBounds = { x: b.x, y: b.y, width: b.width, height: b.height };
      setSetting('global', global);
    }
  });

  mainWindow.on('closed', () => {
    // On macOS the app stays alive in the dock after the last window closes.
    // Kill all running PTY processes so orphaned `claude` processes don't
    // accumulate in the background with no way for the user to interact.
    for (const [id, session] of activeSessions) {
      if (!session.exited) {
        try { session.pty.kill(); } catch {}
      }
      activeSessions.delete(id);
    }
    taskManager.shutdown();
    mainWindow = null;
  });
}

function buildMenu() {
  const template = [
    {
      label: app.name,
      submenu: [
        { role: 'about' },
        { type: 'separator' },
        { role: 'hide' },
        { role: 'hideOthers' },
        { role: 'unhide' },
        { type: 'separator' },
        { role: 'quit' },
      ],
    },
    {
      label: 'Edit',
      submenu: [
        { role: 'undo' },
        { role: 'redo' },
        { type: 'separator' },
        { role: 'cut' },
        { role: 'copy' },
        { role: 'paste' },
        { role: 'selectAll' },
      ],
    },
    {
      label: 'View',
      submenu: [
        { role: 'toggleDevTools' },
        { type: 'separator' },
        { role: 'resetZoom' },
        { role: 'zoomIn' },
        { role: 'zoomOut' },
        { type: 'separator' },
        { role: 'togglefullscreen' },
      ],
    },
  ];
  Menu.setApplicationMenu(Menu.buildFromTemplate(template));
}

// --- Session cache helpers ---

const { deriveProjectPath } = claudeHarness;

// Session cache → session-cache.js
const sessionCache = require('./session-cache');
sessionCache.init({
  PROJECTS_DIR,
  activeSessions,
  getMainWindow: () => mainWindow,
  log,
  db: {
    deleteCachedFolder, getCachedByFolder, getCachedSession, upsertCachedSessions, deleteCachedSession,
    deleteSearchFolder, deleteSearchSession, upsertSearchEntries,
    setFolderMeta, getAllFolderMeta, getAllMeta, getAllCached, getSetting, setSetting, getMeta, setName,
    updateCachedAiTitle, updateSearchTitle,
  },
});
const { refreshFolder, reconcileCacheFromFilesystem, buildProjectsFromCache,
        notifyRendererProjectsChanged, sendStatus, populateCacheViaWorker,
        refreshHarnessTitles, initializeHiddenProjectTimestamps } = sessionCache;

// --- Projects (a piece of work with a folder on disk) ---
const projects = require('./projects');
projects.init({
  db: dbModule,
  log,
  buildProjectsFromCache,
  notifyRendererProjectsChanged,
  isHarnessId: (id) => allHarnesses().some(h => h.id === id),
  plansDir: PLANS_DIR,
});
// An upgrade can change the working rules in the brief. Bring every project's
// managed blocks up to date once at startup; unchanged files are not written.
projects.syncAllProjectBriefs().catch(err => log.error('[projects] brief sync failed:', err?.message || String(err)));
// Watch every project's plan-tracker.md and todos.md so a tick made by a
// session is credited to it and the page refreshes.
projects.initPlanWatch({
  activeSessions,
  send: (channel, ...args) => {
    if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send(channel, ...args);
  },
});

// --- IPC: browse-folder ---
ipcMain.handle('browse-folder', async () => {
  const result = await dialog.showOpenDialog(mainWindow, {
    properties: ['openDirectory', 'createDirectory'],
    title: 'Select Project Folder',
  });
  if (result.canceled || !result.filePaths.length) return null;
  return result.filePaths[0];
});

// --- IPC: add-project ---
ipcMain.handle('add-project', (_event, projectPath) => {
  try {
    // Validate the path exists and is a directory
    const stat = fs.statSync(projectPath);
    if (!stat.isDirectory()) return { error: 'Path is not a directory' };

    // Unhide if previously hidden
    const global = getSetting('global') || {};
    if (global.hiddenProjects && global.hiddenProjects.includes(projectPath)) {
      global.hiddenProjects = global.hiddenProjects.filter(p => p !== projectPath);
      if (global.hiddenProjectTimestamps) {
        delete global.hiddenProjectTimestamps[projectPath];
      }
      setSetting('global', global);
    }

    // Create the corresponding folder in ~/.claude/projects/ so it persists
    const folder = encodeProjectPath(projectPath);
    const folderPath = path.join(PROJECTS_DIR, folder);
    if (!fs.existsSync(folderPath)) {
      fs.mkdirSync(folderPath, { recursive: true });
    }

    // Seed a minimal .jsonl so deriveProjectPath can read the cwd
    if (!fs.readdirSync(folderPath).some(f => f.endsWith('.jsonl'))) {
      const seedId = require('crypto').randomUUID();
      const seedFile = path.join(folderPath, seedId + '.jsonl');
      const now = new Date().toISOString();
      const line = JSON.stringify({ type: 'user', cwd: projectPath, sessionId: seedId, uuid: require('crypto').randomUUID(), timestamp: now, message: { role: 'user', content: 'New project' } });
      fs.writeFileSync(seedFile, line + '\n');
    }

    // Immediately index the new folder so it's in cache before frontend renders
    refreshFolder(folder);
    notifyRendererProjectsChanged();

    return { ok: true, folder, projectPath };
  } catch (err) {
    return { error: err.message };
  }
});

// --- IPC: remove-project ---
ipcMain.handle('remove-project', (_event, projectPath) => {
  try {
    // Add to hidden projects list
    const global = getSetting('global') || {};
    const hidden = global.hiddenProjects || [];
    if (!hidden.includes(projectPath)) hidden.push(projectPath);
    global.hiddenProjects = hidden;
    global.hiddenProjectTimestamps = {
      ...(global.hiddenProjectTimestamps || {}),
      [projectPath]: Date.now(),
    };
    setSetting('global', global);

    // Clean up DB cache and search index for this folder
    const folder = encodeProjectPath(projectPath);
    deleteCachedFolder(folder);
    deleteSearchFolder(folder);
    deleteSetting('project:' + projectPath);

    notifyRendererProjectsChanged();
    return { ok: true };
  } catch (err) {
    return { error: err.message };
  }
});

// --- IPC: projects ---
// Every mutating handler notifies the renderer itself (projects.js), so both
// the Sessions and the Projects tab refresh from one event.
function guarded(fn) {
  return async (_event, ...args) => {
    try { return await fn(...args); } catch (err) {
      log.error('[projects]', err);
      return { error: err.message };
    }
  };
}
ipcMain.handle('get-project-tree', guarded((showArchived) => {
  // Mirrors get-projects: until the cache is populated there is nothing to
  // file, and the renderer is told via projects-changed once there is.
  if (!isCachePopulated() || !isSearchIndexPopulated()) return { projects: [] };
  return projects.buildProjectTree(!!showArchived);
}));
ipcMain.handle('create-project', guarded((spec) => projects.createProject(spec || {})));
ipcMain.handle('update-project', guarded((id, patch) => projects.updateProject(id, patch || {})));
ipcMain.handle('delete-project', guarded((id) => projects.deleteProject(id)));
ipcMain.handle('attach-project-folder', guarded((id, spec) => projects.attachFolder(id, spec || {})));
ipcMain.handle('detach-project-folder', guarded((id, folderPath, opts) => projects.detachFolder(id, folderPath, opts || {})));
ipcMain.handle('set-session-assignment', guarded((sessionId, projectId, trackId) => {
  const cleanProjectId = projectId || null;
  const cleanTrackId = trackId || null;
  const result = projects.assignSession(sessionId, cleanProjectId, cleanTrackId);
  // Raw terminals have no transcript to rehydrate this relationship from.
  // Keep the live PTY metadata aligned with the durable renderer descriptor so
  // a renderer reload cannot put a moved terminal back in its old location.
  if (!result?.error) {
    const session = activeSessions.get(sessionId);
    if (session?.isPlainTerminal) {
      session.projectId = cleanProjectId;
      session.trackId = cleanProjectId ? cleanTrackId : null;
    }
  }
  return result;
}));
// Scheduled tasks. The tick that fires them is startScheduleTicker below.
ipcMain.handle('list-schedules', guarded(() => projects.listSchedules()));
ipcMain.handle('create-schedule', guarded((spec) => projects.createSchedule(spec || {})));
ipcMain.handle('update-schedule', guarded((id, patch) => projects.updateSchedule(id, patch || {})));
ipcMain.handle('delete-schedule', guarded((id) => projects.deleteSchedule(id)));
ipcMain.handle('resolve-schedule-launch', guarded((id) => projects.resolveScheduleLaunch(id)));
ipcMain.handle('get-schedule-context', guarded((spec) => projects.resolveScheduleContext(spec || {})));
ipcMain.handle('create-track', guarded((projectId, spec) => projects.createTrack(projectId, spec || {})));
ipcMain.handle('update-track', guarded((id, patch) => projects.updateTrack(id, patch || {})));
ipcMain.handle('delete-track', guarded((id, options = {}) => {
  const track = dbModule.getTrack(id);
  if (!track) return { error: 'Track not found' };
  const archiveSessions = options.archiveSessions === true;
  // Raw terminals have no transcript row, but participate in track deletion.
  for (const [sid, session] of activeSessions) {
    if (session.trackId === id && session.isPlainTerminal) dbModule.setSessionAssignment(sid, track.projectId, id);
  }
  const result = projects.deleteTrack(id, { archiveSessions });
  if (result.error) return result;
  const affected = new Set(result.sessionIds);
  for (const [sid, session] of activeSessions) {
    if (session.trackId !== id && !affected.has(sid)) continue;
    session.trackId = null;
    session.formerTrackName = track.name;
    if (archiveSessions && !session.exited) {
      session.stopRequested = true;
      try { session.pty.kill(); } catch (error) { log.error('[delete-track] stop failed', error); }
    }
  }
  return result;
}));
ipcMain.handle('get-projects-root', guarded(() => projects.projectsRoot()));
ipcMain.handle('get-project-git-status', guarded((id, opts) => projects.folderGitStatus(id, opts || {})));
ipcMain.handle('get-project-git-info', guarded((id) => projects.projectGitInfo(id)));
ipcMain.handle('get-project-git-diff', guarded((id, folderPath, filePath) => projects.projectGitDiff(id, folderPath, filePath)));
ipcMain.handle('get-folder-git-status', guarded((folderPath) => projects.folderGitInfo(String(folderPath || ''))));
// The .env files a folder has, and the ones the dialog ticks by default,
// so a new worktree can be offered its repository's local environment.
ipcMain.handle('list-env-files', guarded((folderPath) => ({
  ok: true,
  files: projects.listEnvFiles(String(folderPath || '')),
  defaults: projects.defaultEnvSelection(String(folderPath || '')),
})));
ipcMain.handle('save-project-brief', guarded((id, content) => projects.saveBrief(id, content)));
ipcMain.handle('create-project-file', guarded((id, name, content) => projects.createProjectFile(id, name, content)));
ipcMain.handle('add-project-files', guarded((id, sourcePaths) => projects.addProjectFiles(id, sourcePaths)));
ipcMain.handle('list-recent-project-files', guarded((id) => projects.listRecentProjectFiles(id)));
ipcMain.handle('get-project-plan', guarded((id) => projects.readProjectPlan(id)));
ipcMain.handle('set-plan-item', guarded((id, kind, line, done) => projects.setPlanItem(id, kind, line, done)));
ipcMain.handle('append-plan-item', guarded((id, kind, text) => projects.appendPlanItem(id, kind, text)));
ipcMain.handle('edit-plan-item', guarded((id, kind, line, text) => projects.editPlanItem(id, kind, line, text)));
ipcMain.handle('adopt-plan', guarded((id, filename, opts) => projects.adoptPlan(id, filename, opts || {})));
ipcMain.handle('list-templates', guarded(() => projects.listTemplates()));

// --- IPC: get-projects ---
ipcMain.handle('open-external', (_event, url) => {
  log.info('[open-external IPC]', url);
  if (/^https?:\/\//i.test(url)) return shell.openExternal(url);
});

// Reveal a folder in the OS file manager. Only existing directories, so a
// renderer value can never launch a file.
ipcMain.handle('open-path', async (_event, target) => {
  try {
    const resolved = path.resolve(String(target || ''));
    if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory()) return { error: 'Not a folder' };
    const err = await shell.openPath(resolved);
    return err ? { error: err } : { ok: true };
  } catch (err) {
    return { error: err.message };
  }
});

// --- IPC: clipboard write ---
// The renderer's navigator.clipboard.writeText is gated on focus/user-activation and
// is flaky-to-dead on Linux/Wayland (Ozone). The main-process clipboard has no such
// strings attached, so all terminal copies go through here.
ipcMain.handle('clipboard-write-text', (_event, text) => {
  if (typeof text === 'string') clipboard.writeText(text);
});

// --- IPC: MCP bridge ---
ipcMain.on('mcp-diff-response', (_event, sessionId, diffId, action, editedContent) => {
  resolvePendingDiff(sessionId, diffId, action, editedContent);
});

ipcMain.handle('resolve-terminal-files', (_event, references) => resolveTerminalFiles(references));

ipcMain.handle('open-file-externally', async (_event, filePath, projectRoot) => {
  try {
    return { ok: true, ...await openFileExternally(filePath, projectRoot, shell) };
  } catch (err) {
    return { ok: false, error: err.message };
  }
});

ipcMain.handle('read-file-for-panel', async (_event, filePath) => {
  try {
    return { ok: true, ...readPreviewFile(filePath) };
  } catch (err) {
    return { ok: false, error: err.message, code: err.code };
  }
});

ipcMain.handle('list-project-directory', async (_event, projectPath, relativePath) => {
  try {
    return { ok: true, entries: listProjectDirectory(projectPath, relativePath) };
  } catch (err) {
    return { ok: false, error: err.message };
  }
});

ipcMain.handle('manage-project-entry', async (_event, projectPath, relativePath, action, newName) => {
  try {
    const result = await manageProjectEntry(projectPath, relativePath, action, newName, {
      shell,
      confirmTrash: async (filePath, isDirectory) => {
        const destination = process.platform === 'win32' ? 'Recycle Bin' : 'Trash';
        const choice = await dialog.showMessageBox(mainWindow, {
          type: 'question',
          message: `Move "${path.basename(filePath)}" to the ${destination}?`,
          detail: `${isDirectory ? 'The folder and its contents' : 'The file'} can be restored from the ${destination}. Open previews of this item will close; unsaved edits will be discarded.`,
          buttons: ['Cancel', `Move to ${destination}`], defaultId: 0, cancelId: 0,
          noLink: true,
        });
        return choice.response === 1;
      },
    });
    return { ok: true, ...result };
  } catch (err) {
    return { ok: false, error: err.message };
  }
});

ipcMain.handle('read-project-file', async (_event, projectPath, relativePath) => {
  try {
    return { ok: true, ...readProjectFile(projectPath, relativePath) };
  } catch (err) {
    return { ok: false, error: err.message, code: err.code };
  }
});

ipcMain.handle('save-file-for-panel', async (_event, filePath, content) => {
  try {
    const resolved = path.resolve(filePath);
    if (!fs.existsSync(resolved)) return { ok: false, error: 'File does not exist' };
    fs.writeFileSync(resolved, content, 'utf8');
    return { ok: true };
  } catch (err) {
    return { ok: false, error: err.message };
  }
});

// ── File Watching (for viewer panels) ────────────────────────────────
const fileWatchers = new Map(); // filePath → FSWatcher

ipcMain.handle('watch-file', (_event, filePath) => {
  const resolved = path.resolve(filePath);
  if (fileWatchers.has(resolved)) return { ok: true };
  try {
    let debounce = null;
    const watcher = fs.watch(resolved, (eventType) => {
      if (eventType !== 'change') return;
      if (debounce) clearTimeout(debounce);
      debounce = setTimeout(() => {
        if (mainWindow && !mainWindow.isDestroyed()) {
          mainWindow.webContents.send('file-changed', resolved);
        }
      }, 300);
    });
    fileWatchers.set(resolved, watcher);
    return { ok: true };
  } catch (err) {
    return { ok: false, error: err.message };
  }
});

ipcMain.handle('unwatch-file', (_event, filePath) => {
  const resolved = path.resolve(filePath);
  const watcher = fileWatchers.get(resolved);
  if (watcher) {
    watcher.close();
    fileWatchers.delete(resolved);
  }
  return { ok: true };
});

ipcMain.handle('get-projects', (_event, showArchived) => {
  try {
    const needsPopulate = !isCachePopulated() || !isSearchIndexPopulated();

    if (needsPopulate) {
      populateCacheViaWorker();
      return [];
    }

    // Pick up folders changed while the app was closed, or never indexed by an
    // older build, so sessions/worktrees don't silently go missing. Stat-gated,
    // so it's cheap when nothing has changed.
    reconcileCacheFromFilesystem();
    // Backstop for a dropped fs.watch event: a session waiting for its
    // transcript would otherwise stay stuck under its temporary id. Only runs
    // while something is actually waiting.
    if (hasPendingLaunches()) sweepPendingLaunches();
    return buildProjectsFromCache(showArchived);
  } catch (err) {
    console.error('Error listing projects:', err);
    return [];
  }
});

// --- IPC: get-plans ---
ipcMain.handle('get-plans', () => {
  try {
    if (!fs.existsSync(PLANS_DIR)) return [];
    const files = fs.readdirSync(PLANS_DIR).filter(f => f.endsWith('.md'));
    const plans = [];
    for (const file of files) {
      const filePath = path.join(PLANS_DIR, file);
      try {
        const stat = fs.statSync(filePath);
        const content = fs.readFileSync(filePath, 'utf8');
        const firstLine = content.split('\n').find(l => l.trim());
        const title = firstLine && firstLine.startsWith('# ')
          ? firstLine.slice(2).trim()
          : file.replace(/\.md$/, '');
        plans.push({ filename: file, title, modified: stat.mtime.toISOString() });
      } catch {}
    }
    plans.sort((a, b) => new Date(b.modified) - new Date(a.modified));

    // Index plans for FTS
    try {
      deleteSearchType('plan');
      upsertSearchEntries(plans.map(p => ({
        id: p.filename, type: 'plan', folder: null,
        title: p.title,
        body: fs.readFileSync(path.join(PLANS_DIR, p.filename), 'utf8'),
      })));
    } catch {}

    return plans;
  } catch (err) {
    console.error('Error reading plans:', err);
    return [];
  }
});

// --- IPC: read-plan ---
ipcMain.handle('read-plan', (_event, filename) => {
  try {
    const filePath = path.join(PLANS_DIR, path.basename(filename));
    const content = fs.readFileSync(filePath, 'utf8');
    return { content, filePath };
  } catch (err) {
    console.error('Error reading plan:', err);
    return { content: '', filePath: '' };
  }
});

// --- IPC: save-plan ---
ipcMain.handle('save-plan', (_event, filePath, content) => {
  try {
    const resolved = path.resolve(filePath);
    if (!resolved.startsWith(PLANS_DIR)) {
      return { ok: false, error: 'path outside plans directory' };
    }
    fs.writeFileSync(resolved, content, 'utf8');
    return { ok: true };
  } catch (err) {
    console.error('Error saving plan:', err);
    return { ok: false, error: err.message };
  }
});

// --- IPC: get-stats ---
ipcMain.handle('get-stats', () => {
  if (!harnessEnabled(DEFAULT_HARNESS)) return null;
  try {
    if (!fs.existsSync(STATS_CACHE_PATH)) return null;
    const raw = fs.readFileSync(STATS_CACHE_PATH, 'utf8');
    return JSON.parse(raw);
  } catch (err) {
    console.error('Error reading stats cache:', err);
    return null;
  }
});

// --- IPC: refresh-stats ---
let statsRefreshInFlight = null;
ipcMain.handle('refresh-stats', async () => {
  if (!harnessEnabled(DEFAULT_HARNESS)) return { stats: null, usage: {} };
  if (statsRefreshInFlight) return statsRefreshInFlight;

  statsRefreshInFlight = (async () => {
    const usagePromise = fetchAndTransformUsage().catch(() => ({}));
    const result = await refreshStatsCache(STATS_CACHE_PATH, () => {
      const globalSettings = getSetting('global') || {};
      const profile = resolveShell(globalSettings.shellProfile || SETTING_DEFAULTS.shellProfile);
      return runStatsCommand({
        spawn: (...args) => pty.spawn(...args),
        shell: profile.path,
        args: shellArgs(profile.path, 'claude "/stats"', profile.args || []),
        options: {
          name: 'xterm-256color', cols: 120, rows: 40, cwd: os.homedir(),
          env: {
            ...cleanPtyEnv,
            TERM: 'xterm-256color', COLORTERM: 'truecolor',
            TERM_PROGRAM: 'iTerm.app', TERM_PROGRAM_VERSION: '3.6.6',
            FORCE_COLOR: '3', ITERM_SESSION_ID: '1',
          },
        },
      });
    });
    if (result.statsError) log.warn('Error refreshing stats:', result.statsError);
    return { ...result, usage: await usagePromise || {} };
  })();
  try { return await statsRefreshInFlight; }
  finally { statsRefreshInFlight = null; }
});

// --- IPC: get-usage (lightweight, API-only, no PTY) ---
ipcMain.handle('get-usage', async () => {
  if (!harnessEnabled(DEFAULT_HARNESS)) return {};
  try {
    return await fetchAndTransformUsage() || {};
  } catch (err) {
    log.error('Error fetching usage:', err);
    return {};
  }
});

// --- IPC: get-codex-usage --- (same idea for the codex account)
ipcMain.handle('get-codex-usage', async () => {
  // Nothing is fetched for a CLI the user switched off, or one that was never
  // signed in — no request, no error surfaced.
  if (!harnessEnabled('codex')) return {};
  try {
    return await codexAuth.fetchAndTransformUsage() || {};
  } catch (err) {
    log.error('Error fetching codex usage:', err);
    return {};
  }
});

// --- IPC: get-memories ---
function folderToShortPath(folder) {
  // Convert "-Users-me-dev-my-app" → "dev/my-app"
  const parts = folder.replace(/^-/, '').split('-');
  const meaningful = parts.filter(Boolean);
  return meaningful.slice(-2).join('/');
}

/** Scan a directory for .md files (non-recursive). Returns array of { filename, filePath, modified }. */
function scanMdFiles(dir) {
  const results = [];
  try {
    if (!fs.existsSync(dir)) return results;
    const entries = fs.readdirSync(dir, { withFileTypes: true });
    for (const e of entries) {
      if (e.isFile() && e.name.endsWith('.md')) {
        const fp = path.join(dir, e.name);
        const content = fs.readFileSync(fp, 'utf8').trim();
        if (content) {
          const stat = fs.statSync(fp);
          results.push({ filename: e.name, filePath: fp, modified: stat.mtime.toISOString() });
        }
      }
    }
  } catch {}
  return results;
}

ipcMain.handle('get-memories', () => {
  const global = getSetting('global') || {};
  const hiddenProjects = new Set(global.hiddenProjects || []);

  // --- Global files ---
  const globalFiles = scanMdFiles(CLAUDE_DIR).map(f => ({ ...f, displayPath: '~/.claude' }));

  // --- Per-project files ---
  const projects = [];
  try {
    if (fs.existsSync(PROJECTS_DIR)) {
      const folders = fs.readdirSync(PROJECTS_DIR, { withFileTypes: true })
        .filter(d => d.isDirectory() && d.name !== '.git')
        .map(d => d.name);

      for (const folder of folders) {
        const folderPath = path.join(PROJECTS_DIR, folder);
        const projectPath = deriveProjectPath(folderPath, folder);
        if (projectPath && hiddenProjects.has(projectPath)) continue;

        // Use same 2-deep short path as Sessions tab (e.g. "dev/my-app")
        // Splits on both separators — `cwd` is backslash-separated on Windows,
        // where splitting on '/' alone left the whole path as one segment.
        const shortName = projectPath
          ? projectPath.split(/[\\/]/).filter(Boolean).slice(-2).join('/')
          : folderToShortPath(folder);
        const files = [];
        const seenPaths = new Set();

        // 1. ~/.claude/projects/{folder}/ — claude-home .md files
        const claudeHomeFiles = scanMdFiles(folderPath);
        for (const f of claudeHomeFiles) {
          files.push({ ...f, displayPath: '~/.claude', source: 'claude-home' });
          seenPaths.add(f.filePath);
        }
        // memory/MEMORY.md
        const memoryDir = path.join(folderPath, 'memory');
        const memoryFiles = scanMdFiles(memoryDir);
        for (const f of memoryFiles) {
          files.push({ ...f, displayPath: '~/.claude', source: 'claude-home' });
          seenPaths.add(f.filePath);
        }

        // 2. {projectPath}/ — project root CLAUDE.md, agents.md
        if (projectPath) {
          for (const name of ['CLAUDE.md', 'GEMINI.md', 'agents.md']) {
            const fp = path.join(projectPath, name);
            try {
              if (fs.existsSync(fp)) {
                const content = fs.readFileSync(fp, 'utf8').trim();
                if (content && !seenPaths.has(fp)) {
                  const stat = fs.statSync(fp);
                  files.push({ filename: name, filePath: fp, modified: stat.mtime.toISOString(), displayPath: shortName + '/', source: 'project' });
                  seenPaths.add(fp);
                }
              }
            } catch {}
          }

          // 3. {projectPath}/.claude/ — commands/*.md and other .md files
          const dotClaudeDir = path.join(projectPath, '.claude');
          const dotClaudeFiles = scanMdFiles(dotClaudeDir);
          for (const f of dotClaudeFiles) {
            if (!seenPaths.has(f.filePath)) {
              files.push({ ...f, displayPath: shortName + '/.claude/', source: 'project' });
              seenPaths.add(f.filePath);
            }
          }
          // commands/*.md
          const commandsDir = path.join(dotClaudeDir, 'commands');
          const commandFiles = scanMdFiles(commandsDir);
          for (const f of commandFiles) {
            if (!seenPaths.has(f.filePath)) {
              files.push({ ...f, displayPath: shortName + '/.claude/commands/', source: 'project' });
              seenPaths.add(f.filePath);
            }
          }
        }

        if (files.length > 0) {
          projects.push({ folder, projectPath: projectPath || '', shortName, files });
        }
      }
    }
  } catch (err) {
    console.error('Error scanning memories:', err);
  }

  // Sort projects by most recent file modified date
  projects.sort((a, b) => {
    const aMax = Math.max(...a.files.map(f => new Date(f.modified).getTime()));
    const bMax = Math.max(...b.files.map(f => new Date(f.modified).getTime()));
    return bMax - aMax;
  });

  const result = { global: { files: globalFiles }, projects };

  // Index all files for FTS
  try {
    deleteSearchType('memory');
    const allFiles = [
      ...globalFiles.map(f => ({ ...f, label: 'Global' })),
      ...projects.flatMap(p => p.files.map(f => ({ ...f, label: p.shortName }))),
    ];
    upsertSearchEntries(allFiles.map(f => ({
      id: f.filePath, type: 'memory', folder: null,
      title: f.label + ' ' + f.filename,
      body: fs.readFileSync(f.filePath, 'utf8'),
    })));
  } catch {}

  return result;
});

// --- IPC: read-memory ---
ipcMain.handle('read-memory', (_event, filePath) => {
  try {
    const resolved = path.resolve(filePath);
    // Allow paths under ~/.claude/ or any .md file that exists
    if (!resolved.endsWith('.md')) return '';
    if (!resolved.startsWith(CLAUDE_DIR) && !fs.existsSync(resolved)) return '';
    return fs.readFileSync(resolved, 'utf8');
  } catch (err) {
    console.error('Error reading memory file:', err);
    return '';
  }
});

// --- IPC: save-memory ---
ipcMain.handle('save-memory', (_event, filePath, content) => {
  try {
    const resolved = path.resolve(filePath);
    if (!resolved.endsWith('.md')) return { ok: false, error: 'not a .md file' };
    if (!fs.existsSync(resolved)) return { ok: false, error: 'file does not exist' };
    fs.writeFileSync(resolved, content, 'utf8');
    return { ok: true };
  } catch (err) {
    console.error('Error saving memory file:', err);
    return { ok: false, error: err.message };
  }
});

// --- IPC: search ---
ipcMain.handle('search-session-ids', (_event, query, sessionIds) => {
  if (typeof query !== 'string' || !Array.isArray(sessionIds) || sessionIds.some(id => typeof id !== 'string')) return [];
  return dbModule.searchSessionIds(query, sessionIds);
});

ipcMain.handle('search', (_event, type, query, titleOnly) => {
  return searchByType(type, query, 50, !!titleOnly);
});

// --- IPC: settings ---
ipcMain.handle('get-setting', (_event, key) => {
  return getSetting(key);
});

ipcMain.handle('set-setting', (_event, key, value) => {
  const beforeSet = key === 'global' ? disabledHarnessIds() : null;
  const before = beforeSet ? [...beforeSet].sort().join(',') : null;

  if (key === 'global' && Array.isArray(value?.disabledHarnesses)) {
    // At least one CLI has to stay on, or the app has nothing to show and no
    // way to start anything. The settings panel already prevents this; this is
    // the guard for any other writer. The id that was just switched off is the
    // one refused, which is what the UI does too.
    const launchable = allHarnesses().filter(h => h.buildLaunchArgs).map(h => h.id);
    const disabled = new Set(value.disabledHarnesses);
    if (launchable.length && launchable.every(id => disabled.has(id))) {
      const justAdded = launchable.filter(id => disabled.has(id) && !beforeSet.has(id));
      const keep = justAdded[0] || launchable[0];
      log.warn(`[harness-toggle] refusing to disable every CLI; keeping ${keep} on`);
      value = { ...value, disabledHarnesses: value.disabledHarnesses.filter(id => id !== keep) };
    }
  }

  setSetting(key, value);

  if (key === 'global') {
    const after = [...disabledHarnessIds()].sort().join(',');
    if (before !== after) {
      // Something was switched on or off. Watchers follow the new set, and a
      // reconcile picks up whatever a newly-enabled harness did while it was
      // being ignored — incremental, because its cached rows were kept and the
      // folder mtime gate re-reads only what actually changed.
      stopHarnessWatchers();
      startHarnessWatchers();
      try { projectsWatcher?.close(); } catch {}
      projectsWatcher = null;
      startProjectsWatcher();
      try { reconcileCacheFromFilesystem(); } catch (err) { log.error('[harness-toggle]', err.message); }
      notifyRendererProjectsChanged();
      // The status bar quota gauge only re-reads on a 5-minute timer, so
      // without this a switched-off CLI keeps its bars until the next tick.
      if (mainWindow && !mainWindow.isDestroyed()) {
        mainWindow.webContents.send('harnesses-changed');
      }
    }
  }
  return { ok: true };
});

ipcMain.handle('delete-setting', (_event, key) => {
  deleteSetting(key);
  return { ok: true };
});

// --- Scheduled tasks ---

const SETTING_DEFAULTS = {
  permissionMode: null,
  dangerouslySkipPermissions: false,
  worktree: false,
  worktreeName: '',
  chrome: false,
  preLaunchCmd: '',
  addDirs: '',
  // Claude's model and effort. Empty leaves the choice to claude.
  model: '',
  effort: '',
  visibleSessionCount: 5,
  sidebarWidth: 340,
  terminalTheme: 'switchboard',
  mcpEmulation: false,
  shellProfile: 'auto',
  // Codex equivalents of the permission settings above. Kept separate because
  // the vocabularies do not map: codex has no permission modes, and Claude has
  // no sandbox policy. An empty value means "leave it to codex's own config".
  // The app starts on workspace-write: a project's attached folders only reach
  // codex under that sandbox, and read-only sessions cannot do the work.
  codexSandbox: 'workspace-write',
  codexApproval: '',
  codexModel: '',
  codexEffort: '',
};

// --- Harness enablement ---
//
// A disabled harness is not scanned, not watched, not listed as something to
// start, and its sessions are hidden. Its cached rows are deliberately KEPT:
// re-enabling then costs an incremental reconcile rather than a full re-index,
// and nothing is lost if the toggle was a mistake.
function disabledHarnessIds() {
  const global = getSetting('global') || {};
  return new Set(global.disabledHarnesses || []);
}

function harnessEnabled(id) {
  return !disabledHarnessIds().has(id || DEFAULT_HARNESS);
}

// --- IPC: harnesses --- (which CLIs this machine has, and which are switched on)
ipcMain.handle('get-harnesses', () => {
  const disabled = disabledHarnessIds();
  return allHarnesses()
    .filter(h => h.buildLaunchArgs)
    .map(h => ({ id: h.id, label: h.label, enabled: !disabled.has(h.id) }));
});

// Codex's model catalog, for model suggestions and the per-model reasoning
// efforts in session and schedule settings.
ipcMain.handle('get-codex-models', () => getHarness('codex')?.readModelCatalog?.() || []);

ipcMain.handle('get-shell-profiles', () => {
  _shellProfiles = null; // refresh on each request
  return getShellProfiles();
});

function effectiveSettings(projectPath) {
  const global = getSetting('global') || {};
  const project = projectPath ? (getSetting('project:' + projectPath) || {}) : {};
  return resolveEffectiveSettings(SETTING_DEFAULTS, global, project);
}

ipcMain.handle('get-effective-settings', (_event, projectPath) => effectiveSettings(projectPath));

// Task processes deliberately live outside activeSessions. A server can be
// stopped, restarted, or reattached without changing an AI session lifecycle.
const taskManager = createTaskManager({
  baseEnv: cleanPtyEnv,
  getShellProfile: (projectPath) => resolveShell(effectiveSettings(projectPath).shellProfile),
  // A project worktree inherits its source repo's tasks.json.
  resolveWorktreeParent: (projectPath) => projects.worktreeParentFor(projectPath),
  log,
  send: (channel, ...args) => {
    if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send(channel, ...args);
  },
});

ipcMain.handle('list-project-tasks', (_event, projectPath) => taskManager.listTasks(projectPath));
ipcMain.handle('list-tasks-for-projects', (_event, projectPaths) => taskManager.listTasksForProjects(projectPaths));
ipcMain.handle('get-task-run', (_event, projectPath, label) => taskManager.getRun(projectPath, label));
ipcMain.handle('start-task', (_event, projectPath, label) => taskManager.startTask(projectPath, label));
ipcMain.handle('stop-task', (_event, projectPath, label) => taskManager.stopTask(projectPath, label));
ipcMain.handle('stop-all-tasks', (_event, projectPath) => taskManager.stopAllTasks(projectPath));
ipcMain.handle('restart-task', (_event, projectPath, label) => taskManager.restartTask(projectPath, label));
ipcMain.on('task-input', (_event, projectPath, label, data) => taskManager.sendInput(projectPath, label, data));
ipcMain.on('task-resize', (_event, projectPath, label, cols, rows) => taskManager.resize(projectPath, label, cols, rows));

// --- IPC: get-active-sessions ---
ipcMain.handle('get-active-sessions', () => {
  const active = [];
  for (const [sessionId, session] of activeSessions) {
    if (!session.exited) active.push(sessionId);
  }
  return active;
});

// --- IPC: get-active-terminals --- (plain terminal sessions for renderer restore)
ipcMain.handle('get-active-terminals', () => {
  const terminals = [];
  for (const [sessionId, session] of activeSessions) {
    if (!session.exited && session.isPlainTerminal) {
      terminals.push({
        sessionId,
        projectPath: session.projectPath,
        projectId: session.projectId || null,
        trackId: session.trackId || null,
      });
    }
  }
  return terminals;
});

// --- IPC: stop-session ---
ipcMain.handle('stop-session', (_event, sessionId) => {
  const session = activeSessions.get(sessionId);
  if (!session || session.exited) return { ok: false, error: 'not running' };
  session.stopRequested = true;
  session.pty.kill();
  return { ok: true };
});

// --- IPC: toggle-star ---
ipcMain.handle('toggle-star', (_event, sessionId) => {
  const starred = toggleStar(sessionId);
  return { starred };
});

// --- IPC: rename-session ---
ipcMain.handle('rename-session', (_event, sessionId, name) => {
  setName(sessionId, name || null);
  // Update search index title to include the new name
  const cached = getCachedSession(sessionId);
  const summary = cached?.summary || '';
  updateSearchTitle(sessionId, 'session', (name ? name + ' ' : '') + summary);
  return { name: name || null };
});

function readSessionViewerEntries(row) {
  // The harness owns its transcript naming and its on-disk format. Normalize
  // here so neither transcript consumer needs runtime-specific branches.
  const jsonlPath = transcriptPath(row);
  const harness = getHarness(row.runtime);
  const content = fs.readFileSync(jsonlPath, 'utf-8');
  const entries = [];
  for (const line of content.split('\n')) {
    if (!line.trim()) continue;
    try { entries.push(JSON.parse(line)); } catch {}
  }
  return harness.toViewerEntries(entries);
}

ipcMain.handle('read-session-jsonl', (_event, sessionId) => {
  const row = getCachedSession(sessionId);
  if (!row) return { error: 'Session not found in cache' };
  try {
    return { entries: readSessionViewerEntries(row) };
  } catch (err) {
    return { error: err.message };
  }
});

ipcMain.handle('get-session-last-message', (_event, sessionId) => {
  const row = getCachedSession(sessionId);
  if (!row) return { error: 'Session not found in cache' };
  try {
    const { text, truncated } = lastAssistantMessage(readSessionViewerEntries(row));
    return { text, truncated };
  } catch (err) {
    return { error: err.message };
  }
});

// --- IPC: archive-session ---

ipcMain.handle('archive-session', (_event, sessionId, archived) => {
  const val = archived ? 1 : 0;
  setArchived(sessionId, val);
  return { archived: val };
});

// --- IPC: open-terminal ---
ipcMain.handle('open-terminal', async (_event, sessionId, projectPath, isNew, sessionOptions) => {
  if (!mainWindow) return { ok: false, error: 'no window' };

  const isPlainTerminal = sessionOptions?.type === 'terminal';
  if (shouldBlockArchivedSession({
    isNew,
    isPlainTerminal,
    archived: getMeta(sessionId)?.archived,
  })) {
    return { ok: false, error: 'Session is archived. Unarchive it before resuming.' };
  }

  // Reattach to existing session
  if (activeSessions.has(sessionId)) {
    const session = activeSessions.get(sessionId);
    session.rendererAttached = true;
    session.firstResize = !session.isPlainTerminal;

    // If TUI is in alternate screen mode, send escape to switch into it
    if (session.altScreen && !session.isPlainTerminal) {
      mainWindow.webContents.send('terminal-data', sessionId, '\x1b[?1049h');
    }

    // Send buffered output for reattach
    for (const chunk of session.outputBuffer) {
      mainWindow.webContents.send('terminal-data', sessionId, chunk);
    }

    if (!session.isPlainTerminal) {
      // Hide cursor after buffer replay — the live PTY stream or resize nudge
      // will re-show it at the correct position, avoiding a stale cursor artifact
      mainWindow.webContents.send('terminal-data', sessionId, '\x1b[?25l');
    }

    return { ok: true, reattached: true, mcpActive: !!session.mcpServer };
  }

  // Spawn new PTY
  if (!fs.existsSync(projectPath)) {
    return { ok: false, error: `project directory no longer exists: ${projectPath}` };
  }

  // A session that never wrote a transcript cannot be resumed — the CLI has no
  // record of the id, and asking it to resume one produces an error the user
  // can do nothing about ("No saved session found with ID ..."). Start it
  // fresh instead, which is what re-opening a session that never got going
  // means in practice.
  const cachedSession = getCachedSession(sessionId);
  const startFresh = shouldStartFresh({
    isNew,
    isPlainTerminal,
    hasCachedSession: !!cachedSession,
    resumeExisting: !!sessionOptions?.resumeExisting,
  });
  if (startFresh && !isNew && !isPlainTerminal) {
    log.info(`[open-terminal] ${sessionId} has no transcript; starting a new session instead of resuming`);
  }

  // A session that belongs to a project gets the project folder and every
  // attached folder as extra directories, so the brief loads wherever it
  // starts and the agent can edit the repos. New sessions say which project
  // in their options; resumed ones are looked up by their assignment.
  let projectEnv = {};
  // A fork of a project session belongs to the same project and track, even
  // when it is started from the Sessions tab where no project is in play.
  if (!isPlainTerminal && sessionOptions?.forkFrom && !sessionOptions.projectId) {
    const source = getMeta(sessionOptions.forkFrom);
    if (source?.projectId) sessionOptions = { ...sessionOptions, projectId: source.projectId, trackId: source.trackId || null };
  }
  if (!isPlainTerminal) {
    const launchProjectId = sessionOptions?.projectId || getMeta(sessionId)?.projectId || null;
    if (launchProjectId) {
      try {
        const ctx = projects.launchContext(launchProjectId, projectPath);
        if (ctx && ctx.addDirs.length) {
          sessionOptions = { ...(sessionOptions || {}), addDirs: projects.mergeAddDirs(sessionOptions?.addDirs, ctx.addDirs) };
          projectEnv = ctx.env;
        }
        // A project worktree is already the isolated checkout; asking Claude
        // for another one on top of it would nest worktrees.
        if (ctx?.worktree && sessionOptions?.worktree) {
          sessionOptions = { ...sessionOptions };
          delete sessionOptions.worktree;
          delete sessionOptions.worktreeName;
        }
      } catch (err) {
        log.error('[projects] launch context failed', err);
      }
    }
  }

  // Which CLI drives this session. The cached row is authoritative for anything
  // that already exists on disk; the caller only gets to say for a brand-new
  // session, which has no row yet.
  const runtimeId = isPlainTerminal
    ? null
    : (cachedSession?.runtime || sessionOptions?.runtime || DEFAULT_HARNESS);
  const harness = runtimeId ? getHarness(runtimeId) : null;
  const isClaudeSession = runtimeId === DEFAULT_HARNESS;

  if (harness && !harness.buildLaunchArgs) {
    return { ok: false, error: `${harness.label} sessions cannot be launched yet` };
  }

  // Resolve shell profile from effective settings
  const effectiveProfileId = (() => {
    const global = getSetting('global') || {};
    const project = projectPath ? (getSetting('project:' + projectPath) || {}) : {};
    let profileId = SETTING_DEFAULTS.shellProfile;
    if (global.shellProfile !== undefined && global.shellProfile !== null) profileId = global.shellProfile;
    if (project.shellProfile !== undefined && project.shellProfile !== null) profileId = project.shellProfile;
    return profileId;
  })();
  // WSL profiles only work for plain terminals — Claude CLI sessions need the
  // Windows shell because session data lives on the Windows filesystem.
  const requestedProfile = resolveShell(effectiveProfileId);
  const useWslProfile = isWslShell(requestedProfile.path) && isPlainTerminal;
  const shellProfile = (isWslShell(requestedProfile.path) && !isPlainTerminal)
    ? resolveShell('auto')
    : requestedProfile;
  const shell = shellProfile.path;
  const shellExtraArgs = [...(shellProfile.args || [])];
  const isWsl = isWslShell(shell);
  // For WSL, convert Windows path to /mnt/ path and pass via --cd;
  // the spawn cwd must remain a valid Windows path for wsl.exe itself.
  if (isWsl) {
    const wslCwd = windowsToWslPath(projectPath);
    shellExtraArgs.unshift('--cd', wslCwd);
  }
  log.info(`[shell] profile=${shellProfile.id} shell=${shell} args=${JSON.stringify(shellExtraArgs)}`);

  let knownJsonlFiles = new Set();
  let sessionSlug = null;
  let projectFolder = null;

  if (isClaudeSession) {
    // Snapshot existing .jsonl files before spawning (for new session + fork/plan detection)
    projectFolder = encodeProjectPath(projectPath);
    const claudeProjectDir = path.join(PROJECTS_DIR, projectFolder);
    if (fs.existsSync(claudeProjectDir)) {
      try {
        knownJsonlFiles = new Set(
          fs.readdirSync(claudeProjectDir).filter(f => f.endsWith('.jsonl'))
        );
      } catch {}
    }

    // Read slug from the session's jsonl file (for plan-accept detection)
    if (!startFresh) {
      try {
        const jsonlPath = path.join(claudeProjectDir, sessionId + '.jsonl');
        const head = readHead(jsonlPath, 8192);
        const firstLines = head.split('\n').filter(Boolean);
        for (const line of firstLines) {
          const entry = JSON.parse(line);
          if (entry.slug) { sessionSlug = entry.slug; break; }
        }
      } catch {}
    }
  }

  let ptyProcess;
  let mcpServer = null;
  try {
    if (isPlainTerminal) {
      // Plain terminal: interactive login shell, no claude command
      // Do not inherit Claude Code's nested-session marker if Switchboard was
      // itself launched from Claude; this is the user's shell and `claude`
      // should resolve normally from their profile/PATH.
      const terminalEnv = {
        ...cleanPtyEnv,
        TERM: 'xterm-256color', COLORTERM: 'truecolor', TERM_PROGRAM: 'iTerm.app', TERM_PROGRAM_VERSION: '3.6.6', FORCE_COLOR: '3', ITERM_SESSION_ID: '1',
      };
      delete terminalEnv.CLAUDECODE;
      ptyProcess = pty.spawn(shell, shellArgs(shell, undefined, shellExtraArgs), {
        name: 'xterm-256color',
        cols: 120,
        rows: 30,
        cwd: isWsl ? os.homedir() : projectPath,
        env: terminalEnv,
      });
    } else {
      // Argv is built by the harness and quoted here, so a value can never be
      // spliced into the command line as shell syntax.
      const cliArgs = harness.buildLaunchArgs({
        sessionId, isNew: startFresh, options: sessionOptions,
      });

      let claudeCmd = harness.binary;
      if (cliArgs.length) claudeCmd += ' ' + quoteArgvForShell(shell, cliArgs);

      // preLaunchCmd is raw shell by design (e.g. "aws-vault exec profile --") — block newlines only
      if (sessionOptions?.preLaunchCmd) {
        const pre = String(sessionOptions.preLaunchCmd);
        if (/[\r\n]/.test(pre)) {
          return { ok: false, error: 'preLaunchCmd must not contain newlines' };
        }
        claudeCmd = pre + ' ' + claudeCmd;
      }

      // Start MCP server for this session so Claude CLI sends diffs/file opens to Switchboard
      // (skip if user disabled IDE emulation in global settings)
      if (isClaudeSession && sessionOptions?.mcpEmulation !== false) {
        try {
          mcpServer = await startMcpServer(sessionId, [projectPath], mainWindow, log);
          claudeCmd += ' --ide';
        } catch (err) {
          log.error(`[mcp] Failed to start MCP server for ${sessionId}: ${err.message}`);
        }
      }

      const ptyEnv = {
        ...cleanPtyEnv,
        TERM: 'xterm-256color', COLORTERM: 'truecolor',
        TERM_PROGRAM: 'iTerm.app', TERM_PROGRAM_VERSION: '3.6.6', FORCE_COLOR: '3', ITERM_SESSION_ID: '1',
        ...projectEnv,
      };
      // A harness that cannot be told its session id up front gets to stamp the
      // environment instead, so its transcript can be recognised afterwards.
      if (startFresh && harness.launchEnv) Object.assign(ptyEnv, harness.launchEnv(sessionId));
      if (mcpServer) {
        ptyEnv.CLAUDE_CODE_SSE_PORT = String(mcpServer.port);
      }

      ptyProcess = pty.spawn(shell, shellArgs(shell, claudeCmd, shellExtraArgs), {
        name: 'xterm-256color',
        cols: 120,
        rows: 30,
        cwd: isWsl ? os.homedir() : projectPath,
        // TERM_PROGRAM=iTerm.app: Claude Code checks this to decide whether to emit
        // OSC 9 notifications (e.g. "needs your attention"). Without it, the packaged
        // app's minimal Electron environment won't trigger those sequences.
        env: ptyEnv,
      });

    }
  } catch (err) {
    return { ok: false, error: `Error spawning PTY: ${err.message}` };
  }

  const session = {
    pty: ptyProcess, rendererAttached: true, exited: false,
    outputBuffer: [], outputBufferSize: 0, altScreen: false,
    projectPath, firstResize: true,
    projectFolder, knownJsonlFiles, sessionSlug,
    isPlainTerminal, runtime: runtimeId, forkFrom: sessionOptions?.forkFrom || null,
    // A plain terminal has no CLI to report a busy state, so one is derived
    // from the shell's own OSC 133 prompt marks, or from the PTY's foreground
    // process when the shell sends none. A harness session already has the
    // OSC 0 / OSC 9;4 handlers below.
    activity: isPlainTerminal ? createTerminalActivity({
      shellName: path.basename(shell),
      // On Windows `pty.process` is the console title, not a process name.
      canPollProcess: process.platform !== 'win32',
    }) : null,
    // Plain terminals have no transcript row to carry their project filing.
    // Keep the launch context on the live PTY so renderer reloads can put a
    // terminal started in an attached folder back into the same project/track.
    projectId: sessionOptions?.projectId || null,
    trackId: sessionOptions?.trackId || null,
    // Set for a harness whose real session id only appears once its transcript
    // does; cleared by resolvePendingLaunches when the transcript is matched.
    pendingLaunch: (harness?.needsIdDetection?.({ isNew: startFresh, options: sessionOptions })) ? {
      tag: harness.originatorTag ? harness.originatorTag(sessionId) : null,
      // A fork is identified by its parent, not by our env tag — codex copies
      // the originator from the thread being forked.
      forkFrom: sessionOptions?.forkFrom || null,
      projectPath,
      spawnedAt: Date.now(),
    } : null,
    mcpServer, _openedAt: Date.now(),
  };
  activeSessions.set(sessionId, session);
  if (session.activity) startTerminalActivitySweep();

  // A session launched from a project is filed there. Recorded under whatever
  // id the session has right now; resolvePendingLaunches moves it to the real
  // id for a harness that only learns its id from the transcript.
  if (startFresh && !isPlainTerminal && sessionOptions?.projectId) {
    try {
      const assignment = projects.recordLaunchAssignment(sessionId, sessionOptions);
      if (assignment) {
        session.projectId = assignment.projectId;
        session.trackId = assignment.trackId;
        // Started from a phase or a todo on the project page.
        const item = sessionOptions.planItem;
        if (item?.itemText) projects.recordPlanLink(assignment.projectId, item.file, item.itemText, sessionId, 'started');
      }
    } catch (err) {
      log.error('[projects] could not record launch assignment', err);
    }
  }
  // Started by a schedule: the session remembers which, the schedule
  // remembers the run. Folder schedules have no project, so this is separate
  // from the assignment above.
  if (startFresh && !isPlainTerminal && sessionOptions?.scheduleId) {
    try { projects.recordScheduleRun(sessionOptions.scheduleId, sessionId); } catch (err) {
      log.error('[schedule] could not record the run', err);
    }
  }
  // A resumed project session is a project session too, for the plan watcher.
  if (!isPlainTerminal && !session.projectId) {
    const meta = getMeta(session.realSessionId || sessionId);
    if (meta?.projectId) { session.projectId = meta.projectId; session.trackId = meta.trackId || null; }
  }

  ptyProcess.onData(data => {
    const currentId = session.realSessionId || sessionId;

    // Prompt marks for a plain terminal. Cheap on every chunk: the parse
    // returns immediately unless the chunk actually contains an OSC 133.
    if (session.activity) {
      const busy = session.activity.feedData(data);
      if (busy !== null) sendTerminalBusy(session, currentId, busy);
    }

    // Parse OSC sequences (title changes, progress, notifications, etc.)
    if (data.includes('\x1b]')) {
      const oscMatches = data.matchAll(/\x1b\](\d+);([^\x07\x1b]*)(?:\x07|\x1b\\)/g);
      for (const m of oscMatches) {
        const code = m[1];
        const payload = m[2].slice(0, 120);
        // Detect Claude CLI busy state from OSC 0 title (spinner chars = busy, ✳ = idle)
        if (code === '0' && harness) {
          // What a title means is the harness's business: Claude marks idle with
          // ✳, codex drops the spinner prefix and says "Action Required" when
          // it is blocked on the user.
          const titleState = harness.parseTitleState(payload);
          // Remembered for the OSC 9;4 handler below, which trusts the title
          // over a progress report from any process in the PTY.
          if (titleState) session._titleBusy = titleState === 'busy';
          const isBusy = titleState === 'busy';
          const isIdle = titleState === 'idle' || titleState === 'attention';
          log.debug(`[OSC 0] session=${currentId} state=${titleState || 'none'} wasBusy=${!!session._cliBusy}`);

          // A blocked session is announced by OSC 9 too, but only when the CLI's
          // notifications are on — which a session started before Switchboard
          // began forcing them is not. The title is the signal that is always
          // there, so it raises attention on its own. Latched, because the title
          // is rewritten on every repaint.
          if (titleState === 'attention') {
            if (!session._titleAttention) {
              session._titleAttention = true;
              log.info(`[OSC 0] session=${currentId} → ATTENTION "${payload}"`);
              if (mainWindow && !mainWindow.isDestroyed()) {
                mainWindow.webContents.send('terminal-notification', currentId, payload, 'attention');
              }
            }
          } else if (titleState) {
            session._titleAttention = false;
          }

          if (isBusy && !session._cliBusy) {
            session._cliBusy = true;
            session._oscIdle = false;
            log.debug(`[OSC 0] session=${currentId} → BUSY`);
            if (mainWindow && !mainWindow.isDestroyed()) {
              mainWindow.webContents.send('cli-busy-state', currentId, true);
            }
          } else if (isIdle && session._cliBusy) {
            session._cliBusy = false;
            session._oscIdle = true;
            log.debug(`[OSC 0] session=${currentId} → IDLE`);
            if (mainWindow && !mainWindow.isDestroyed()) {
              mainWindow.webContents.send('cli-busy-state', currentId, false);
            }
          }
        }
      }
      // Parse iTerm2 OSC 9 sequences (terminated by BEL \x07 or ST \x1b\\)
      const osc9Matches = data.matchAll(/\x1b\]9;([^\x07\x1b]*)(?:\x07|\x1b\\)/g);
      for (const osc9 of osc9Matches) {
        const payload = osc9[1];
        // OSC 9;4 progress: 4;0; = clear/done, 4;1;N = running at N%, 4;2;N = error, 4;3; = indeterminate
        if (payload.startsWith('4;')) {
          const level = payload.split(';')[1];
          const progressState = progressBusyState({ level, titleBusy: !!session._titleBusy });
          log.debug(`[OSC 9;4] session=${currentId} level=${level} payload="${payload}" state=${progressState || 'none'} titleBusy=${!!session._titleBusy} wasBusy=${!!session._cliBusy}`);
          if (progressState === 'busy' && !session._cliBusy) {
            session._cliBusy = true;
            session._oscIdle = false;
            log.debug(`[OSC 9;4] session=${currentId} → BUSY`);
            if (mainWindow && !mainWindow.isDestroyed()) {
              mainWindow.webContents.send('cli-busy-state', currentId, true);
            }
          } else if (progressState === 'idle' && session._cliBusy) {
            // The end of the progress run. Without acting on this, a busy state
            // raised by 9;4 could only be cleared by a spinner-to-idle title
            // change, which does not come for a slash command — the session sat
            // spinning until Claude's "waiting for your input" notice a full
            // minute later.
            session._cliBusy = false;
            session._oscIdle = true;
            log.debug(`[OSC 9;4] session=${currentId} → IDLE`);
            if (mainWindow && !mainWindow.isDestroyed()) {
              mainWindow.webContents.send('cli-busy-state', currentId, false);
            }
          }
        } else {
          // Regular notification (attention, permission, etc.). The harness
          // decides what its own wording means — codex says "Approval
          // requested: …" where Claude says "needs your permission…" — so the
          // renderer is handed a kind rather than re-deriving one from text.
          const kind = harness ? harness.classifyNotification(payload) : null;
          log.info(`[OSC 9] session=${currentId} kind=${kind || 'none'} message="${payload}"`);
          if (mainWindow && !mainWindow.isDestroyed()) {
            mainWindow.webContents.send('terminal-notification', currentId, payload, kind);
          }
        }
      }
    }

    // Standalone BEL (not part of an OSC sequence)
    if (data.includes('\x07') && !data.includes('\x1b]')) {
      log.info(`[BEL] session=${currentId}`);
    }

    // Track alternate screen mode (only if data contains the marker)
    if (data.includes('\x1b[?')) {
      if (data.includes('\x1b[?1049h') || data.includes('\x1b[?47h')) {
        session.altScreen = true;
        log.info(`[altscreen] session=${currentId} ON`);
      }
      if (data.includes('\x1b[?1049l') || data.includes('\x1b[?47l')) {
        session.altScreen = false;
        log.info(`[altscreen] session=${currentId} OFF`);
      }
    }

    // Buffer output (skip resize-triggered redraws for plain terminals)
    if (!session._suppressBuffer) {
      session.outputBuffer.push(data);
      session.outputBufferSize += data.length;
      while (session.outputBufferSize > MAX_BUFFER_SIZE && session.outputBuffer.length > 1) {
        session.outputBufferSize -= session.outputBuffer.shift().length;
      }
    }

    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('terminal-data', currentId, data);
    }
  });

  ptyProcess.onExit(({ exitCode, signal }) => {
    session.exited = true;
    // Clean up MCP server
    const mcpId = session.realSessionId || sessionId;
    shutdownMcpServer(mcpId);
    session.mcpServer = null;

    const realId = session.realSessionId || sessionId;
    // The renderer needs to tell "the user ended this" from "this died" to
    // decide whether to tear the terminal down or leave it up with a banner.
    // A signal kill reports exitCode 0, so pass the signal and the
    // stop-session flag along rather than making it guess from the code.
    const stopRequested = !!session.stopRequested;
    if (!appIsQuitting && mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('process-exited', realId, exitCode, signal, stopRequested);
      // If a fork/plan-accept transition re-keyed this session under realId
      // but the PTY exited before transition detection ran, also notify the
      // renderer for the original sessionId so it doesn't stay stuck as "Running".
      if (realId !== sessionId && activeSessions.has(sessionId)) {
        mainWindow.webContents.send('process-exited', sessionId, exitCode, signal, stopRequested);
      }
    }
    activeSessions.delete(realId);
    // Clean up the original key too in case transition detection hasn't run yet
    activeSessions.delete(sessionId);
  });

  if (sessionOptions?.forkFrom) {
    log.info(`[fork-spawn] tempId=${sessionId} forkFrom=${sessionOptions.forkFrom} folder=${projectFolder} knownFiles=${knownJsonlFiles.size}`);
  }

  return { ok: true, reattached: false, mcpActive: !!mcpServer };
});

// --- IPC: terminal-input (fire-and-forget) ---
ipcMain.on('terminal-input', (_event, sessionId, data) => {
  const session = activeSessions.get(sessionId);
  if (session && !session.exited) {
    session.pty.write(data);
  }
});

// --- IPC: terminal-resize (fire-and-forget) ---
ipcMain.on('terminal-resize', (_event, sessionId, cols, rows) => {
  const session = activeSessions.get(sessionId);
  if (session && !session.exited) {
    // For plain terminals, suppress buffering during resize to avoid
    // accumulating prompt redraws that pollute reattach replay
    if (session.isPlainTerminal) session._suppressBuffer = true;

    session.pty.resize(cols, rows);

    if (session.isPlainTerminal) {
      setTimeout(() => { session._suppressBuffer = false; }, 200);
    }

    // First resize: nudge to force TUI redraw on reattach (skip for plain terminals — causes duplicate prompts)
    if (session.firstResize && !session.isPlainTerminal) {
      session.firstResize = false;
      setTimeout(() => {
        try {
          session.pty.resize(cols + 1, rows);
          setTimeout(() => {
            try { session.pty.resize(cols, rows); } catch {}
          }, 50);
        } catch {}
      }, 50);
    }
  }
});

// --- IPC: close-terminal ---
ipcMain.on('close-terminal', (_event, sessionId) => {
  const session = activeSessions.get(sessionId);
  if (session) {
    session.rendererAttached = false;
    if (session.exited) {
      activeSessions.delete(sessionId);
    }
  }
});

// --- Plain-terminal activity: working, or waiting at the prompt? ---

/** One place to tell the renderer a terminal started or stopped working. */
function sendTerminalBusy(session, sessionId, busy) {
  session._cliBusy = busy;
  log.debug(`[terminal-activity] session=${sessionId} → ${busy ? 'BUSY' : 'IDLE'} ${JSON.stringify(session.activity.state())}`);
  if (mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.webContents.send('cli-busy-state', sessionId, busy);
  }
}

// One sweep for every tracked terminal rather than a timer each. Reading
// `pty.process` costs ~18us, and only a shell that sends no prompt marks is
// read at all, so 50 terminals stay well under a millisecond per sweep.
const TERMINAL_ACTIVITY_INTERVAL_MS = 500;
let terminalActivityTimer = null;

function sweepTerminalActivity() {
  let tracked = 0;
  for (const [sessionId, session] of activeSessions) {
    if (!session.activity || session.exited) continue;
    tracked++;
    let busy = null;
    if (session.activity.needsPoll()) {
      // A PTY that has just exited throws here rather than returning a name.
      let name = null;
      try { name = session.pty.process; } catch {}
      busy = session.activity.feedProcess(name);
    }
    // Ticked either way: a silent command crosses the busy threshold with no
    // output to settle on.
    if (busy === null) busy = session.activity.tick();
    if (busy !== null) sendTerminalBusy(session, sessionId, busy);
  }
  if (tracked === 0) {
    clearInterval(terminalActivityTimer);
    terminalActivityTimer = null;
  }
}

/** Started when the first terminal appears, stopped when the last one goes. */
function startTerminalActivitySweep() {
  if (terminalActivityTimer) return;
  terminalActivityTimer = setInterval(sweepTerminalActivity, TERMINAL_ACTIVITY_INTERVAL_MS);
  terminalActivityTimer.unref?.();
}

// Session transitions → session-transitions.js
const sessionTransitions = require('./session-transitions');
sessionTransitions.init({ PROJECTS_DIR, activeSessions, getMainWindow: () => mainWindow, log, rekeyMcpServer, copySessionAssignment });
const { detectSessionTransitions } = sessionTransitions;

// --- fs.watch on projects directory ---
let projectsWatcher = null;

function startProjectsWatcher() {
  if (!fs.existsSync(PROJECTS_DIR)) return;
  if (!harnessEnabled(DEFAULT_HARNESS)) return;

  const pendingFolders = new Set();
  let debounceTimer = null;

  function flushChanges() {
    debounceTimer = null;
    const folders = new Set(pendingFolders);
    pendingFolders.clear();

    // Claim a fork's transcript before indexing it, so the renderer learns the
    // real id in the same beat the row appears. A Claude fork mints its own id
    // (--fork-session ignores --session-id), so it needs this exactly as codex
    // sessions do.
    if (hasPendingLaunches()) {
      const candidates = [];
      for (const folder of folders) {
        try { candidates.push(...claudeHarness.listTranscripts(path.join(PROJECTS_DIR, folder))); } catch {}
      }
      resolvePendingLaunches(candidates);
    }

    let changed = false;
    for (const folder of folders) {
      const folderPath = path.join(PROJECTS_DIR, folder);
      if (fs.existsSync(folderPath)) {
        detectSessionTransitions(folder);
        refreshFolder(folder);
      } else {
        deleteCachedFolder(folder);
      }
      changed = true;
    }

    if (changed) {
      // A transcript folder moved: sessions only, not the projects themselves.
      notifyRendererProjectsChanged('sessions');
    }
  }

  try {
    projectsWatcher = fs.watch(PROJECTS_DIR, { recursive: true }, (_eventType, filename) => {
      if (!filename) return;

      // filename is relative, e.g. "folder-name/sessions-index.json" or "folder-name/abc.jsonl"
      const parts = filename.split(path.sep);
      const folder = parts[0];
      if (!folder || folder === '.git') return;

      // Only care about .jsonl changes or top-level folder add/remove
      const basename = parts[parts.length - 1];
      if (parts.length === 1) {
        pendingFolders.add(folder);
      } else if (basename.endsWith('.jsonl')) {
        pendingFolders.add(folder);
      } else {
        return;
      }

      if (debounceTimer) clearTimeout(debounceTimer);
      debounceTimer = setTimeout(flushChanges, 500);
    });

    projectsWatcher.on('error', (err) => {
      console.error('Projects watcher error:', err);
    });
  } catch (err) {
    console.error('Failed to start projects watcher:', err);
  }
}

/**
 * Adopt a just-written transcript as the real identity of a pending session.
 *
 * A harness that cannot be told its session id up front (codex) is launched
 * under a temporary uuid. When its transcript appears, the session is re-keyed
 * onto the real id — everything downstream (terminal data, exit, the renderer's
 * sidebar row) follows session.realSessionId, exactly as fork detection does.
 */
function resolvePendingLaunches(candidatePaths) {
  for (const [tempId, session] of [...activeSessions]) {
    if (session.exited || !session.pendingLaunch || session.realSessionId) continue;
    const harness = getHarness(session.runtime);
    if (!harness.matchesLaunch) continue;

    for (const filePath of candidatePaths) {
      const signals = harness.readLaunchSignals(filePath);
      if (!harness.matchesLaunch(signals, session.pendingLaunch)) continue;
      // Another live session already owns this transcript.
      if (activeSessions.has(signals.sessionId)) continue;

      const realId = signals.sessionId;
      log.info(`[launch-detect] ${tempId} → ${realId} (originator=${signals.originator || 'none'})`);
      session.realSessionId = realId;
      session.pendingLaunch = null;
      activeSessions.delete(tempId);
      activeSessions.set(realId, session);
      if (session.projectId) {
        try {
          moveSessionAssignment(tempId, realId);
          rekeyPlanLinks(tempId, realId);
        } catch (err) { log.error('[projects] assignment move failed', err); }
      }
      try { dbModule.rekeyScheduleSession(tempId, realId); } catch (err) { log.error('[schedule] rekey failed', err); }
      if (mainWindow && !mainWindow.isDestroyed()) {
        mainWindow.webContents.send('session-detected', tempId, realId);
      }
      break;
    }
  }
}

/**
 * Look through every folder a pending session could have landed in.
 *
 * Only the folders that changed since the launch are worth reading, which in
 * practice is today's date directory.
 */
function sweepPendingLaunches() {
  const roots = new Map(); // harness → earliest spawn time still waiting
  for (const session of activeSessions.values()) {
    if (session.exited || !session.pendingLaunch || session.realSessionId) continue;
    const h = getHarness(session.runtime);
    if (!h.matchesLaunch) continue;
    const at = session.pendingLaunch.spawnedAt;
    roots.set(h, Math.min(roots.get(h) ?? at, at));
  }

  for (const [h, since] of roots) {
    const candidates = [];
    // Claude's folders live under the injected PROJECTS_DIR, not its own root.
    const dirs = h.folderPrefix
      ? h.listFolders().map(f => h.folderPath(f.slice(h.folderPrefix.length)))
      : h.listFolders().map(f => path.join(PROJECTS_DIR, f));
    for (const dir of dirs) {
      for (const filePath of h.listTranscripts(dir)) {
        try {
          if (fs.statSync(filePath).mtimeMs >= since - 60000) candidates.push(filePath);
        } catch {}
      }
    }
    resolvePendingLaunches(candidates);
  }
}

/** Is any session still waiting for its transcript to appear? */
function hasPendingLaunches() {
  for (const session of activeSessions.values()) {
    if (!session.exited && session.pendingLaunch && !session.realSessionId) return true;
  }
  return false;
}

// --- fs.watch on each non-Claude harness's sessions directory ---
//
// Separate from startProjectsWatcher because the path shape is different: a
// Claude event names <project-folder>/<file>, a codex event names
// <YYYY>/<MM>/<DD>/<file>. Both end up calling refreshFolder with a folder key.
const harnessWatchers = [];

function resolveHarnessFolderPath(folder) {
  const h = getHarnessForFolder(folder);
  return h.folderPath(h.folderPrefix ? folder.slice(h.folderPrefix.length) : folder);
}

function stopHarnessWatchers() {
  while (harnessWatchers.length) {
    try { harnessWatchers.pop().close(); } catch {}
  }
}

function startHarnessWatchers() {
  for (const h of availableHarnesses()) {
    if (!h.folderPrefix) continue; // Claude's root is startProjectsWatcher's job
    if (!harnessEnabled(h.id)) continue;
    const root = h.sessionsRoot();
    if (!fs.existsSync(root)) continue;

    const pendingFolders = new Set();
    let debounceTimer = null;

    function flush() {
      debounceTimer = null;
      const folders = new Set(pendingFolders);
      pendingFolders.clear();

      // Claim transcripts before indexing them, so the renderer learns the real
      // session id in the same beat the row appears.
      if (hasPendingLaunches()) {
        const candidates = [];
        for (const folder of folders) {
          try { candidates.push(...h.listTranscripts(resolveHarnessFolderPath(folder))); } catch {}
        }
        resolvePendingLaunches(candidates);
      }

      for (const folder of folders) {
        try { refreshFolder(folder); } catch (err) { log.error('[harness-watch]', folder, err.message); }
      }
      const titlesChanged = refreshHarnessTitles(h);
      if (folders.size || titlesChanged) notifyRendererProjectsChanged('sessions');
    }

    try {
      const watcher = fs.watch(root, { recursive: true }, (_eventType, filename) => {
        if (!filename) return;
        const parts = filename.split(path.sep);
        // Transcripts sit at <YYYY>/<MM>/<DD>/<file>; anything shallower is a
        // directory being created, which the next file event will cover.
        if (parts.length < 4 || !parts[parts.length - 1].endsWith('.jsonl')) return;
        pendingFolders.add(h.folderPrefix + parts.slice(0, 3).join('/'));
        if (debounceTimer) clearTimeout(debounceTimer);
        debounceTimer = setTimeout(flush, 500);
      });
      watcher.on('error', (err) => log.error(`[harness-watch] ${h.id}:`, err.message));
      harnessWatchers.push(watcher);
      log.info(`[harness-watch] watching ${h.id} at ${root}`);
    } catch (err) {
      log.error(`[harness-watch] failed to watch ${h.id}:`, err.message);
    }

    // Codex names live next to sessions/, not underneath it, so the recursive
    // transcript watcher above can never observe an auto-title or `/rename`.
    // Watch the containing directory so atomic replacement of the index is
    // handled as well as ordinary appends.
    if (h.titleIndexPath && h.readSessionTitles) {
      const indexPath = h.titleIndexPath();
      const indexDir = path.dirname(indexPath);
      const indexName = path.basename(indexPath);
      let titleTimer = null;
      try {
        const titleWatcher = fs.watch(indexDir, (_eventType, filename) => {
          if (filename && String(filename) !== indexName) return;
          if (titleTimer) clearTimeout(titleTimer);
          titleTimer = setTimeout(() => {
            titleTimer = null;
            if (refreshHarnessTitles(h)) notifyRendererProjectsChanged('sessions');
          }, 300);
        });
        titleWatcher.on('error', (err) => log.error(`[harness-title-watch] ${h.id}:`, err.message));
        harnessWatchers.push(titleWatcher);
        log.info(`[harness-title-watch] watching ${h.id} at ${indexPath}`);
      } catch (err) {
        log.error(`[harness-title-watch] failed to watch ${h.id}:`, err.message);
      }
    }
  }
}

// --- IPC: app version ---
ipcMain.handle('get-app-version', () => app.getVersion());

// --- IPC: auto-updater ---
ipcMain.handle('updater-check', () => {
  if (!autoUpdater) return { available: false, dev: true };
  return autoUpdater.checkForUpdates();
});
ipcMain.handle('updater-download', () => {
  if (!autoUpdater) return;
  return autoUpdater.downloadUpdate();
});
ipcMain.handle('updater-install', () => {
  if (!autoUpdater) return;
  autoUpdater.quitAndInstall();
});

// --- App lifecycle ---
// Prevent a second Electron instance from killing active PTY sessions.
// This happens when the user replaces the AppImage while Switchboard is running:
// the OS spawns the new binary, which would otherwise initialise a second process
// and leave the first one's node-pty sessions orphaned or killed.
// requestSingleInstanceLock ensures only one instance runs at a time. The second
// launch quits immediately; the first brings its window to the front.
const gotSingleInstanceLock = app.requestSingleInstanceLock();
if (!gotSingleInstanceLock) {
  app.quit();
} else {
  // Focus the existing window when a second launch is attempted.
  app.on('second-instance', () => {
    if (mainWindow) {
      if (mainWindow.isMinimized()) mainWindow.restore();
      mainWindow.focus();
    }
  });


// --- Scheduled task ticker ---
// Main owns the clock: a renderer timer is throttled while the window is
// hidden, and a schedule has to fire at the minute it names. Each fire is one
// 'schedule-due' event; the renderer launches the session, because the
// terminal lives there. A schedule whose last session is still working is
// skipped by projects.dueSchedules.
let scheduleTickerStop = null;
// "Still working" is the CLI being busy, not the PTY being open: an
// interactive session sits at its prompt until someone closes it, and that
// must not stop the next run.
function isSessionBusy(sessionId) {
  const session = activeSessions.get(sessionId);
  return !!session && !session.exited && !!session._cliBusy;
}
function fireSchedules(ids, reason) {
  if (!ids.length || !mainWindow || mainWindow.isDestroyed()) return;
  for (const id of ids) {
    const launch = projects.resolveScheduleLaunch(id);
    if (launch.error) { log.warn(`[schedule] ${id}: ${launch.error}`); continue; }
    log.info(`[schedule] ${reason}: ${launch.schedule.name}`);
    mainWindow.webContents.send('schedule-due', launch);
  }
}
function startScheduleTicker() {
  if (scheduleTickerStop) return;
  let interval = null;
  const tick = () => {
    try { fireSchedules(projects.dueSchedules(new Date(), isSessionBusy), 'due'); } catch (err) {
      log.error('[schedule] tick failed', err);
    }
  };
  // Align to the minute so a 9:00 schedule fires at 9:00:00, not 9:00:37.
  const first = setTimeout(() => { tick(); interval = setInterval(tick, 60 * 1000); }, (60 - new Date().getSeconds()) * 1000);
  // Catch-up runs, for schedules that asked for it, once the renderer has had
  // time to load. Missed while the app was closed means missed since the last
  // run (projects.missedSchedules).
  const catchUp = setTimeout(() => {
    try { fireSchedules(projects.missedSchedules(new Date(), isSessionBusy), 'catch-up'); } catch (err) {
      log.error('[schedule] catch-up failed', err);
    }
  }, 20 * 1000);
  scheduleTickerStop = () => { clearTimeout(first); clearTimeout(catchUp); if (interval) clearInterval(interval); scheduleTickerStop = null; };
}

  app.whenReady().then(() => {
    protocol.handle(PREVIEW_SCHEME, handlePreviewAssetRequest);
    buildMenu();
    initializeHiddenProjectTimestamps();
    createWindow();
    startProjectsWatcher();
    startHarnessWatchers();
    // Retry legacy imports each launch; successful files are remembered in
    // the DB, including deleted tasks. Missing folders can be picked up later.
    // Then tick once a minute and launch due tasks through the renderer.
    try {
      const imported = projects.importLegacySchedules(scanSchedules(log));
      if (imported) log.info(`[schedule] Imported ${imported} schedule file(s) as folder schedules`);
    } catch (err) { log.error('[schedule] legacy import failed', err); }
    startScheduleTicker();

    // Re-index search if FTS table was recreated (e.g. tokenizer config change)
    if (searchFtsRecreated) populateCacheViaWorker();

    // Check for updates after launch
    if (autoUpdater) {
      setTimeout(() => autoUpdater.checkForUpdates().catch(e => log.error('[updater] check failed:', e?.message || String(e))), 5000);
      // Re-check every 4 hours for long-running sessions
      setInterval(() => autoUpdater.checkForUpdates().catch(e => log.error('[updater] check failed:', e?.message || String(e))), 4 * 60 * 60 * 1000);
    }

    app.on('activate', () => {
      if (BrowserWindow.getAllWindows().length === 0) createWindow();
    });
  }); // end app.whenReady
} // end gotSingleInstanceLock else-branch

app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') app.quit();
});

app.on('before-quit', () => {
  // The renderer persists raw-terminal descriptors and scrollback during its
  // unload. Do not report the shutdown kills as user-initiated terminal exits,
  // or that renderer cleanup would delete the descriptors before restart.
  appIsQuitting = true;
  // Shut down all MCP servers
  shutdownAllMcp();
  taskManager.shutdown();

  // Close filesystem watcher
  if (projectsWatcher) {
    projectsWatcher.close();
    projectsWatcher = null;
  }

  // Kill all PTY processes on quit
  for (const [, session] of activeSessions) {
    if (!session.exited) {
      try { session.pty.kill(); } catch {}
    }
  }
});

// Close SQLite after all windows are closed to avoid "connection is not open" errors
app.on('will-quit', () => {
  closeDb();
});