@bakapiano/ccsm 0.9.0 → 0.10.1

package/lib/favorites.js

@@ -1,51 +0,0 @@
-'use strict';
-
-// User-pinned ("favorited") sessions, keyed by sessionId at
-// $DATA_DIR/favorites.json. Each entry captures enough metadata
-// (cwd, title, gitBranch) to render the row even after the session's
-// jsonl is gone — entries are best-effort archival.
-
-const { DATA_DIR } = require('./config');
-const { createKeyedJsonStore } = require('./jsonStore');
-
-const store = createKeyedJsonStore({
-  dataDir: DATA_DIR,
-  filename: 'favorites.json',
-});
-
-async function addFavorite(sessionId, info = {}) {
-  if (!sessionId) throw new Error('addFavorite: sessionId required');
-  const map = await store.load();
-  const existing = map[sessionId];
-  const next = existing
-    ? { ...existing, ...info, sessionId }
-    : {
-        sessionId,
-        cwd: info.cwd || null,
-        title: info.title || null,
-        gitBranch: info.gitBranch || null,
-        label: info.label || null,
-        addedAt: Date.now(),
-      };
-  return store.set(sessionId, next);
-}
-
-async function hasFavorite(sessionId) {
-  const map = await store.load();
-  return sessionId in map;
-}
-
-async function listFavorites() {
-  const list = await store.list();
-  return list.sort((a, b) => (b.addedAt || 0) - (a.addedAt || 0));
-}
-
-module.exports = {
-  loadFavorites: store.load,
-  saveFavorites: store.save,
-  listFavorites,
-  addFavorite,
-  removeFavorite: store.remove,
-  hasFavorite,
-  FAVORITES_PATH: store.filePath,
-};

package/lib/focus.js

@@ -1,369 +0,0 @@
-'use strict';
-
-// Focus helpers — find or raise a wt (or other terminal) window via Win32
-// APIs called through PowerShell + Add-Type.
-//
-// Two distinct use cases:
-//   1. focusByPid(pid)             — for the "focus" button in the UI: given
-//                                     a live claude.exe PID, walk parents to
-//                                     find the wt window hosting it.
-//   2. snapshotWindowsOf(name) +
-//      focusNewlyOpenedHwnd(...)  — for auto-focus after launch: snapshot the
-//                                     set of visible top-level windows owned by
-//                                     processes named e.g. "WindowsTerminal.exe"
-//                                     BEFORE launch, then poll for new HWNDs
-//                                     and focus the diff. HWND-based because
-//                                     modern wt is multi-window single-process —
-//                                     PID-based diff would always return empty.
-
-const { spawn } = require('node:child_process');
-
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-// One PowerShell helper handles both: list-windows-of and focus-hwnd modes.
-// Mode is passed via env var so we don't fight quoting.
-const FOCUS_HELPER_PS = String.raw`
-$ErrorActionPreference = 'Stop'
-
-Add-Type @'
-using System;
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading;
-public class CcsmWin {
-    [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr h);
-    [DllImport("user32.dll")] public static extern void SwitchToThisWindow(IntPtr h, bool t);
-    [DllImport("user32.dll")] public static extern bool ShowWindowAsync(IntPtr h, int n);
-    [DllImport("user32.dll")] public static extern bool IsIconic(IntPtr h);
-    [DllImport("user32.dll")] public static extern bool IsWindowVisible(IntPtr h);
-    [DllImport("user32.dll")] public static extern bool AttachThreadInput(uint a, uint b, bool x);
-    [DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr h, out uint pid);
-    [DllImport("kernel32.dll")] public static extern uint GetCurrentThreadId();
-    [DllImport("user32.dll")] public static extern void keybd_event(byte vk, byte scan, uint flags, UIntPtr extra);
-    [DllImport("user32.dll")] public static extern bool BringWindowToTop(IntPtr h);
-    [DllImport("user32.dll")] public static extern bool EnumWindows(EnumWindowsProc cb, IntPtr p);
-    [DllImport("user32.dll", CharSet=CharSet.Auto)] public static extern int GetWindowText(IntPtr h, StringBuilder s, int max);
-    [DllImport("user32.dll")] public static extern int GetWindowTextLength(IntPtr h);
-    [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr h, out RECT rect);
-    [DllImport("user32.dll")] public static extern bool SetWindowPos(IntPtr h, IntPtr after, int x, int y, int cx, int cy, uint flags);
-    [DllImport("user32.dll")] public static extern bool GetCursorPos(out POINT lpPoint);
-    [DllImport("user32.dll")] public static extern IntPtr MonitorFromPoint(POINT pt, uint dwFlags);
-    [DllImport("user32.dll")] public static extern bool GetMonitorInfo(IntPtr hMonitor, ref MONITORINFO mi);
-    [DllImport("user32.dll")] public static extern bool MoveWindow(IntPtr h, int x, int y, int w, int hgt, bool repaint);
-    public delegate bool EnumWindowsProc(IntPtr h, IntPtr p);
-
-    [StructLayout(LayoutKind.Sequential)]
-    public struct RECT { public int Left, Top, Right, Bottom; }
-    [StructLayout(LayoutKind.Sequential)]
-    public struct POINT { public int X, Y; }
-    [StructLayout(LayoutKind.Sequential)]
-    public struct MONITORINFO {
-        public uint cbSize;
-        public RECT rcMonitor;
-        public RECT rcWork;
-        public uint dwFlags;
-    }
-    const uint MONITOR_DEFAULTTONEAREST = 0x00000002;
-
-    public static List<object> EnumVisibleTopLevel() {
-        var results = new List<object>();
-        EnumWindows((h, l) => {
-            if (!IsWindowVisible(h)) return true;
-            int len = GetWindowTextLength(h);
-            if (len == 0) return true;
-            uint pid = 0;
-            GetWindowThreadProcessId(h, out pid);
-            var sb = new StringBuilder(len + 1);
-            GetWindowText(h, sb, sb.Capacity);
-            results.Add(new { hwnd = h.ToInt64(), pid = pid, title = sb.ToString() });
-            return true;
-        }, IntPtr.Zero);
-        return results;
-    }
-
-    // SWP flags
-    const uint SWP_NOSIZE = 0x0001;
-    const uint SWP_NOZORDER = 0x0004;
-    const uint SWP_NOACTIVATE = 0x0010;
-    const uint SWP_ASYNCWINDOWPOS = 0x4000;
-    const uint SWP_FLAGS = SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_ASYNCWINDOWPOS;
-
-    // Horizontal shake — small left/right offsets so the user's eye snaps
-    // to the activated window. ~220ms total.
-    public static void Jiggle(IntPtr h) {
-        RECT rc;
-        if (!GetWindowRect(h, out rc)) return;
-        int x = rc.Left;
-        int y = rc.Top;
-        int[] dx = new int[] { 8, -8, 6, -6, 0 };
-        foreach (int d in dx) {
-            SetWindowPos(h, IntPtr.Zero, x + d, y, 0, 0, SWP_FLAGS);
-            Thread.Sleep(38);
-        }
-    }
-
-    // Move the window to the center of whichever monitor the cursor is on.
-    // Preserves window size. Returns true if it moved.
-    public static bool MoveToCursorScreenCenter(IntPtr h) {
-        RECT wr;
-        if (!GetWindowRect(h, out wr)) return false;
-        int ww = wr.Right - wr.Left;
-        int wh = wr.Bottom - wr.Top;
-
-        POINT cursor;
-        if (!GetCursorPos(out cursor)) return false;
-        IntPtr hMon = MonitorFromPoint(cursor, MONITOR_DEFAULTTONEAREST);
-        if (hMon == IntPtr.Zero) return false;
-
-        MONITORINFO mi = new MONITORINFO();
-        mi.cbSize = (uint)Marshal.SizeOf(typeof(MONITORINFO));
-        if (!GetMonitorInfo(hMon, ref mi)) return false;
-
-        // Use the work area (excludes taskbar) so a centered window isn't
-        // pushed under the taskbar.
-        int sw = mi.rcWork.Right - mi.rcWork.Left;
-        int sh = mi.rcWork.Bottom - mi.rcWork.Top;
-        int nx = mi.rcWork.Left + (sw - ww) / 2;
-        int ny = mi.rcWork.Top + (sh - wh) / 2;
-        return MoveWindow(h, nx, ny, ww, wh, true);
-    }
-
-    public static bool Activate(IntPtr h, bool moveToCenter) {
-        if (IsIconic(h)) ShowWindowAsync(h, 9);
-        keybd_event(0x12, 0, 0, UIntPtr.Zero);
-        keybd_event(0x12, 0, 0x0002, UIntPtr.Zero);
-        uint ownerPid = 0;
-        uint t = GetWindowThreadProcessId(h, out ownerPid);
-        uint c = GetCurrentThreadId();
-        bool attached = false;
-        if (t != c) attached = AttachThreadInput(c, t, true);
-        BringWindowToTop(h);
-        bool ok = SetForegroundWindow(h);
-        SwitchToThisWindow(h, true);
-        if (attached) AttachThreadInput(c, t, false);
-        if (moveToCenter) MoveToCursorScreenCenter(h);
-        Jiggle(h);
-        return ok;
-    }
-}
-'@ | Out-Null
-
-$mode = $env:CCSM_FOCUS_MODE
-$arg  = $env:CCSM_FOCUS_ARG
-$moveToCenter = $env:CCSM_FOCUS_CENTER -eq '1'
-
-if ($mode -eq 'list') {
-    $procName = $arg -replace '\.exe$',''
-    $pidSet = @{}
-    foreach ($p in (Get-Process -Name $procName -ErrorAction SilentlyContinue)) {
-        $pidSet[[uint32]$p.Id] = $true
-    }
-    $all = [CcsmWin]::EnumVisibleTopLevel()
-    $items = @()
-    foreach ($w in $all) {
-        if ($pidSet.ContainsKey([uint32]$w.pid)) {
-            $items += (ConvertTo-Json @{
-                hwnd = [int64]$w.hwnd
-                pid = [int64]$w.pid
-                title = [string]$w.title
-            } -Compress)
-        }
-    }
-    Write-Output ('[' + ($items -join ',') + ']')
-    exit 0
-}
-
-if ($mode -eq 'focus-hwnd') {
-    $hwndInt = [int64]$arg
-    $hwnd = [IntPtr]::new($hwndInt)
-    $ok = [CcsmWin]::Activate($hwnd, $moveToCenter)
-    Write-Output (ConvertTo-Json @{ ok = $true; activated = $ok; hwnd = $hwndInt } -Compress)
-    exit 0
-}
-
-if ($mode -eq 'focus-pid') {
-    $current = [int]$arg
-    $hwnd = [IntPtr]::Zero
-    $found = $null
-    $chain = @()
-    for ($i = 0; $i -lt 12; $i++) {
-        $p = $null
-        try { $p = Get-Process -Id $current -ErrorAction Stop } catch { break }
-        $chain += @{ pid = $p.Id; name = $p.ProcessName; hwnd = $p.MainWindowHandle.ToInt64() }
-        if ($p.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $p.MainWindowHandle; $found = $p; break }
-        $parent = Get-CimInstance Win32_Process -Filter "ProcessId=$current" -ErrorAction SilentlyContinue | Select-Object -First 1
-        if (-not $parent -or -not $parent.ParentProcessId) { break }
-        $current = [int]$parent.ParentProcessId
-    }
-    if ($hwnd -eq [IntPtr]::Zero) {
-        Write-Output (ConvertTo-Json @{ ok = $false; error = "no window handle found for pid $arg"; chain = $chain } -Compress -Depth 5)
-        exit 1
-    }
-    $activated = [CcsmWin]::Activate($hwnd, $moveToCenter)
-    Write-Output (ConvertTo-Json @{
-        ok = $true; activated = $activated
-        hwnd = $hwnd.ToInt64()
-        windowPid = $found.Id
-        windowProcess = $found.ProcessName
-        windowTitle = $found.MainWindowTitle
-        chain = $chain
-    } -Compress -Depth 5)
-    exit 0
-}
-
-Write-Output (ConvertTo-Json @{ ok = $false; error = "unknown CCSM_FOCUS_MODE: $mode" } -Compress)
-exit 1
-`;
-
-function runPsHelper(mode, arg, opts = {}) {
-  return new Promise((resolve, reject) => {
-    const encoded = Buffer.from(FOCUS_HELPER_PS, 'utf16le').toString('base64');
-    const child = spawn(
-      'powershell.exe',
-      ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', encoded],
-      {
-        windowsHide: true,
-        env: {
-          ...process.env,
-          CCSM_FOCUS_MODE: mode,
-          CCSM_FOCUS_ARG: String(arg),
-          CCSM_FOCUS_CENTER: opts.moveToCenter ? '1' : '0',
-        },
-      }
-    );
-    let out = '';
-    let err = '';
-    child.stdout.on('data', (d) => (out += d.toString()));
-    child.stderr.on('data', (d) => (err += d.toString()));
-    child.on('error', reject);
-    child.on('close', (code) => {
-      const last = out.trim().split(/\r?\n/).pop();
-      try {
-        const parsed = JSON.parse(last);
-        if (Array.isArray(parsed)) {
-          resolve({ exitCode: code, value: parsed, stderr: err.trim() || undefined });
-        } else {
-          resolve({ exitCode: code, ...parsed, stderr: err.trim() || undefined });
-        }
-      } catch (e) {
-        reject(
-          new Error(
-            `focus helper (mode=${mode}) exit ${code}: ${err || out || '(no output)'}`
-          )
-        );
-      }
-    });
-  });
-}
-
-// ---- public API ----
-
-async function focusByPid(pid, opts = {}) {
-  const n = Number(pid);
-  if (!Number.isInteger(n) || n <= 0) throw new Error(`focusByPid: invalid pid ${pid}`);
-  return await runPsHelper('focus-pid', n, opts);
-}
-
-// Strip the leading wt status glyph + whitespace ("✳ ", "⠐ ", "⠠ " etc) so
-// the title compares cleanly. wt prefixes the tab title with a Braille-style
-// progress glyph or a sparkle/asterisk depending on activity.
-function cleanWtTitle(t) {
-  return String(t || '').replace(/^[^\w一-鿿]+/, '').trim();
-}
-
-// Best-effort: focus the wt window that belongs to a specific session.
-// Modern wt is single-process multi-window, so walking from claude.exe PID
-// up to wt.exe + taking MainWindowHandle always returns the same canonical
-// window regardless of which tab the session is actually in. Instead we
-// list all wt windows and match by tab title against the session's AI
-// title / cwd basename.
-async function focusBySession({ pid, sessionId, title, cwd, moveToCenter = false }) {
-  const procName = 'WindowsTerminal.exe';
-  const cands = await listWindowsOf(procName);
-  const opts = { moveToCenter };
-
-  const cleanedTitle = title ? cleanWtTitle(title) : '';
-  const cwdBase = cwd ? require('node:path').basename(cwd) : '';
-
-  // 1. Exact match on cleaned ai-title
-  if (cleanedTitle) {
-    const exact = cands.filter((w) => cleanWtTitle(w.title) === cleanedTitle);
-    if (exact.length === 1) {
-      const r = await focusByHwnd(exact[0].hwnd, opts);
-      return { ...r, matchedBy: 'title-exact', hwnd: exact[0].hwnd, windowTitle: exact[0].title };
-    }
-  }
-
-  // 2. Title substring match (some shells append " - <cwd>" etc)
-  if (cleanedTitle) {
-    const subs = cands.filter((w) => w.title.includes(cleanedTitle));
-    if (subs.length === 1) {
-      const r = await focusByHwnd(subs[0].hwnd, opts);
-      return { ...r, matchedBy: 'title-substring', hwnd: subs[0].hwnd, windowTitle: subs[0].title };
-    }
-  }
-
-  // 3. Match by cwd basename (workspace name shows up in title for fresh launches)
-  if (cwdBase) {
-    const byCwd = cands.filter((w) => w.title.includes(cwdBase));
-    if (byCwd.length === 1) {
-      const r = await focusByHwnd(byCwd[0].hwnd, opts);
-      return { ...r, matchedBy: 'cwd-basename', hwnd: byCwd[0].hwnd, windowTitle: byCwd[0].title };
-    }
-  }
-
-  // 4. Fall back to PID parent-chain walk (returns the wt process's
-  //    canonical MainWindowHandle — may be the wrong window when wt is
-  //    multi-window single-process, but better than nothing).
-  if (pid) {
-    const r = await focusByPid(pid, opts);
-    return { ...r, matchedBy: 'pid-fallback', ambiguous: true };
-  }
-  return { ok: false, error: 'no match by title/cwd and no pid given', matchedBy: 'none' };
-}
-
-async function focusByHwnd(hwnd, opts = {}) {
-  return await runPsHelper('focus-hwnd', hwnd, opts);
-}
-
-async function listWindowsOf(processName) {
-  const r = await runPsHelper('list', processName);
-  return Array.isArray(r.value) ? r.value : [];
-}
-
-async function snapshotWindowsOf(processName) {
-  const list = await listWindowsOf(processName);
-  return new Set(list.map((w) => Number(w.hwnd)));
-}
-
-async function focusNewlyOpenedHwnd(beforeHwnds, processName, opts = {}) {
-  const { timeoutMs = 8000, intervalMs = 300 } = opts;
-  const deadline = Date.now() + timeoutMs;
-  await sleep(intervalMs);
-  while (Date.now() < deadline) {
-    const after = await listWindowsOf(processName);
-    const fresh = after.filter((w) => !beforeHwnds.has(Number(w.hwnd)));
-    if (fresh.length > 0) {
-      const target = fresh[fresh.length - 1];
-      const r = await focusByHwnd(target.hwnd);
-      return { ...r, hwnd: target.hwnd, title: target.title, candidates: fresh };
-    }
-    await sleep(intervalMs);
-  }
-  return {
-    ok: false,
-    error: `no new ${processName} window appeared within ${timeoutMs}ms`,
-  };
-}
-
-module.exports = {
-  focusByPid,
-  focusBySession,
-  focusByHwnd,
-  listWindowsOf,
-  snapshotWindowsOf,
-  focusNewlyOpenedHwnd,
-};

package/lib/labels.js

@@ -1,29 +0,0 @@
-'use strict';
-
-// User-defined display titles for sessions, keyed by sessionId at
-// $DATA_DIR/labels.json. Frontend overlays the label on top of the
-// AI-generated title when rendering live / recent / favorites.
-
-const path = require('node:path');
-const { DATA_DIR } = require('./config');
-const { createKeyedJsonStore } = require('./jsonStore');
-
-const MAX_LEN = 200;
-
-const store = createKeyedJsonStore({
-  dataDir: DATA_DIR,
-  filename: 'labels.json',
-  // Empty / null label triggers a remove via the factory contract.
-  transformValue: (v) => {
-    const trimmed = String(v || '').trim().slice(0, MAX_LEN);
-    return trimmed || null;
-  },
-});
-
-module.exports = {
-  loadLabels: store.load,
-  saveLabels: store.save,
-  setLabel: store.set,
-  removeLabel: store.remove,
-  LABELS_PATH: store.filePath,
-};

package/lib/launcher.js

@@ -1,219 +0,0 @@
-'use strict';
-
-const { spawn, exec } = require('node:child_process');
-const path = require('node:path');
-const fs = require('node:fs');
-
-// Terminal kinds we know how to open a new window for. Each entry has:
-//   processName  — what shows up in tasklist, used by focus.js to find the
-//                  newly-created window via HWND diff.
-//   spawn(opts)  — returns { spawned: ChildProcess, args: string[] }.
-//
-// All variants take { cwd, command, args, title, commandShell } and open a
-// new on-screen window with `command args...` running in `cwd`. `commandShell`
-// only matters for the wt kind — see comment there.
-const TERMINAL_KINDS = {
-  wt: {
-    processName: 'WindowsTerminal.exe',
-    spawn({ cwd, command, args, title, commandShell }) {
-      // `-w new` forces a new wt window. Without it, recent wt versions
-      // honor the user's "windowingBehavior" setting and may fold the
-      // invocation into an existing window as a tab — which breaks the
-      // "one window per session" promise and the auto-focus HWND diff.
-      const wtArgs = ['-w', 'new'];
-      if (title) wtArgs.push('--title', title);
-      wtArgs.push('-d', cwd);
-      if (command) {
-        // wt by default runs the command via CreateProcess (no shell), so a
-        // PowerShell alias / function / profile-defined name like "ccp" can't
-        // be found. Wrapping in pwsh/powershell loads $PROFILE and resolves
-        // those names. commandShell="none" reverts to direct invocation for
-        // anyone who wants raw exe semantics.
-        //
-        // We use -EncodedCommand (base64 UTF-16LE) instead of -Command because
-        // wt's CLI parser treats `;` as a sub-command separator at any nesting
-        // depth — a `;` inside our -Command string would make wt try to launch
-        // whatever follows as a brand-new wt sub-command. Base64 has no `;`.
-        if (commandShell === 'pwsh' || commandShell === 'powershell') {
-          const shellExe = commandShell === 'powershell' ? 'powershell.exe' : 'pwsh.exe';
-          wtArgs.push(
-            shellExe,
-            '-NoExit', '-NoLogo',
-            '-EncodedCommand', buildPwshEncodedCommand({ cwd, command, args })
-          );
-        } else {
-          wtArgs.push(command, ...args);
-        }
-      }
-      const spawned = spawn('wt.exe', wtArgs, {
-        detached: true,
-        stdio: 'ignore',
-        windowsHide: false,
-      });
-      spawned.unref();
-      return { spawned, args: wtArgs };
-    },
-  },
-  powershell: {
-    processName: 'powershell.exe',
-    spawn(opts) {
-      return spawnViaCmdStart('powershell.exe', opts);
-    },
-  },
-  pwsh: {
-    processName: 'pwsh.exe',
-    spawn(opts) {
-      return spawnViaCmdStart('pwsh.exe', opts);
-    },
-  },
-  cmd: {
-    processName: 'cmd.exe',
-    spawn({ cwd, command, args, title }) {
-      // cmd /K runs a command and stays open. We use `start` to create a new
-      // window. The empty "" is the new window's title slot.
-      const inner = command
-        ? [command, ...args].map(quoteForCmd).join(' ')
-        : '';
-      const cmdLine = inner ? `/K ${inner}` : '/K';
-      const spawned = spawn(
-        'cmd.exe',
-        ['/c', 'start', title || '', '/D', cwd, 'cmd.exe', cmdLine],
-        { detached: true, stdio: 'ignore', windowsHide: false }
-      );
-      spawned.unref();
-      return { spawned, args: ['/c', 'start', title || '', '/D', cwd, 'cmd.exe', cmdLine] };
-    },
-  },
-};
-
-function quoteForCmd(s) {
-  if (s == null) return '';
-  const str = String(s);
-  if (/[\s"&|<>^]/.test(str)) return '"' + str.replace(/"/g, '\\"') + '"';
-  return str;
-}
-
-function quoteForPwsh(s) {
-  return "'" + String(s).replace(/'/g, "''") + "'";
-}
-
-// Build a PowerShell command-line string that cd's into cwd then invokes
-// command with args via `&` (works for aliases, functions, scripts, exes).
-function buildPwshScript({ cwd, command, args }) {
-  const pieces = [`Set-Location -LiteralPath ${quoteForPwsh(cwd)}`];
-  if (command) {
-    const argTail = (args || []).map(quoteForPwsh).join(' ');
-    pieces.push(`& ${quoteForPwsh(command)} ${argTail}`.trim());
-  }
-  return pieces.join('; ');
-}
-
-// PowerShell -EncodedCommand expects UTF-16LE base64. We pass scripts this
-// way so the wt CLI parser doesn't munge ';' (which wt uses as a sub-command
-// separator at any nesting depth) or other shell metacharacters.
-function buildPwshEncodedCommand(opts) {
-  return Buffer.from(buildPwshScript(opts), 'utf16le').toString('base64');
-}
-
-// Helper for the powershell/pwsh kinds: open a new window via `cmd /c start`
-// running powershell/pwsh that cd's to cwd and runs the command.
-function spawnViaCmdStart(psExe, { cwd, command, args, title }) {
-  const psScript = buildPwshScript({ cwd, command, args });
-  const startArgs = [
-    '/c', 'start',
-    title || '',
-    '/D', cwd,
-    psExe,
-    '-NoExit', '-NoLogo',
-    '-Command', psScript,
-  ];
-  const spawned = spawn('cmd.exe', startArgs, {
-    detached: true,
-    stdio: 'ignore',
-    windowsHide: false,
-  });
-  spawned.unref();
-  return { spawned, args: startArgs };
-}
-
-function launchInTerminal({
-  cwd,
-  command = null,
-  args = [],
-  title = null,
-  terminal = 'wt',
-  commandShell = 'pwsh',
-}) {
-  if (!cwd) throw new Error('launchInTerminal: cwd required');
-  const kind = TERMINAL_KINDS[terminal];
-  if (!kind) throw new Error(`launchInTerminal: unknown terminal "${terminal}"`);
-  const resolved = path.resolve(cwd);
-  if (!fs.existsSync(resolved)) {
-    throw new Error(`launchInTerminal: cwd does not exist: ${resolved}`);
-  }
-  const { spawned, args: launchedArgs } = kind.spawn({
-    cwd: resolved,
-    command,
-    args,
-    title,
-    commandShell,
-  });
-  return {
-    pid: spawned.pid,
-    cwd: resolved,
-    terminal,
-    commandShell,
-    processName: kind.processName,
-    args: launchedArgs,
-  };
-}
-
-// Convenience wrappers — claudeCommand defaults to 'claude' but should be
-// supplied by the caller from config so the user's preference applies.
-function launchResume({ cwd, sessionId, title = null, terminal = 'wt', claudeCommand = 'claude', commandShell = 'pwsh' }) {
-  return launchInTerminal({
-    cwd,
-    command: claudeCommand,
-    args: ['--resume', sessionId],
-    title: title || `resume ${sessionId.slice(0, 8)}`,
-    terminal,
-    commandShell,
-  });
-}
-
-function launchNewClaude({
-  cwd,
-  title = null,
-  extraArgs = [],
-  terminal = 'wt',
-  claudeCommand = 'claude',
-  commandShell = 'pwsh',
-}) {
-  return launchInTerminal({
-    cwd,
-    command: claudeCommand,
-    args: extraArgs,
-    title: title || path.basename(cwd),
-    terminal,
-    commandShell,
-  });
-}
-
-function listTerminalKinds() {
-  return Object.keys(TERMINAL_KINDS).map((name) => ({
-    name,
-    processName: TERMINAL_KINDS[name].processName,
-  }));
-}
-
-function processNameFor(terminal) {
-  return TERMINAL_KINDS[terminal] ? TERMINAL_KINDS[terminal].processName : null;
-}
-
-module.exports = {
-  launchInTerminal,
-  launchResume,
-  launchNewClaude,
-  listTerminalKinds,
-  processNameFor,
-};