@staff0rd/assist 0.284.1 → 0.286.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.284.1",
+  version: "0.286.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -275,6 +275,14 @@ var assistConfigSchema = z2.strictObject({
   screenshot: z2.strictObject({
     outputDir: z2.string().default("./screenshots")
   }).default({ outputDir: "./screenshots" }),
+  sessions: z2.strictObject({
+    // why: Windows .claude/projects root as seen from WSL (e.g. /mnt/c/Users/<user>/.claude/projects); when set its transcripts are discovered and tagged windows-origin
+    windowsProjectsRoot: z2.string().optional(),
+    // why: host the WSL daemon dials to reach the native Windows daemon over TCP (WSL can't use the Windows named pipe); defaults to 127.0.0.1 (WSL2 mirrored networking). NAT-mode users set the Windows host IP.
+    windowsDaemonHost: z2.string().optional(),
+    // why: TCP port the native Windows daemon listens on for the WSL bridge; defaults to 51764
+    windowsDaemonPort: z2.number().optional()
+  }).optional(),
   backlog: z2.strictObject({
     databaseUrl: z2.string().optional()
   }).default({}),
@@ -12069,10 +12077,10 @@ async function getAccessToken(apiKey) {
     }
   });
   if (!response.ok) {
-    const errorText = await response.text();
+    const errorText2 = await response.text();
     throw new Error(
       `Failed to get access token: ${response.status} ${response.statusText}
-${errorText}`
+${errorText2}`
     );
   }
   const tokenData = await response.json();
@@ -18100,11 +18108,11 @@ function toSessionInfo({
 }
 
 // src/commands/sessions/daemon/broadcastSessions.ts
-function broadcastSessions(sessions, clients) {
+function broadcastSessions(sessions, clients, windowsSessions = []) {
   persistLiveSessions(sessions);
   broadcast(clients, {
     type: "sessions",
-    sessions: [...sessions.values()].map(toSessionInfo)
+    sessions: [...sessions.values()].map(toSessionInfo).concat(windowsSessions)
   });
 }
 
@@ -18228,9 +18236,10 @@ function replayScrollback(sessions, client) {
 }
 
 // src/commands/sessions/daemon/greetClient.ts
-function greetClient(client, sessions, list4) {
+function greetClient(client, sessions, list4, windowsProxy) {
   sendTo(client, { type: "sessions", sessions: list4() });
   replayScrollback(sessions, client);
+  windowsProxy.replayScrollback(client);
 }
 
 // src/commands/sessions/daemon/shouldAutoDismiss.ts
@@ -18470,6 +18479,308 @@ function shutdownSessions(sessions) {
   }
 }
 
+// src/commands/sessions/daemon/connectToWindowsDaemon.ts
+import * as net2 from "net";
+
+// src/commands/sessions/daemon/windowsDaemonPort.ts
+var DEFAULT_PORT = 51764;
+var DEFAULT_HOST = "127.0.0.1";
+function windowsDaemonPort() {
+  return loadConfig().sessions?.windowsDaemonPort ?? DEFAULT_PORT;
+}
+function windowsDaemonHost() {
+  return loadConfig().sessions?.windowsDaemonHost ?? DEFAULT_HOST;
+}
+
+// src/commands/sessions/daemon/connectToWindowsDaemon.ts
+function connectToWindowsDaemon() {
+  return new Promise((resolve16, reject) => {
+    const socket = net2.connect(windowsDaemonPort(), windowsDaemonHost());
+    socket.once("connect", () => resolve16(socket));
+    socket.once("error", reject);
+  });
+}
+async function isWindowsDaemonRunning() {
+  try {
+    (await connectToWindowsDaemon()).destroy();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/sessions/daemon/ensureWindowsDaemonRunning.ts
+import { spawn as spawn10 } from "child_process";
+var SPAWN_TIMEOUT_MS2 = 3e4;
+var RETRY_DELAY_MS2 = 300;
+async function ensureWindowsDaemonRunning() {
+  if (await isWindowsDaemonRunning()) return;
+  launchWindowsDaemon();
+  await waitForWindowsDaemon();
+}
+function launchWindowsDaemon() {
+  const child = spawn10(
+    "cmd.exe",
+    ["/c", "start", "", "assist", "daemon", "run"],
+    { detached: true, stdio: "ignore" }
+  );
+  child.on(
+    "error",
+    (e) => daemonLog(`failed to launch windows daemon: ${e.message}`)
+  );
+  child.unref();
+}
+async function waitForWindowsDaemon() {
+  const deadline = Date.now() + SPAWN_TIMEOUT_MS2;
+  while (Date.now() < deadline) {
+    await delay2(RETRY_DELAY_MS2);
+    if (await isWindowsDaemonRunning()) return;
+  }
+  throw new Error(
+    "Windows daemon did not start; is assist installed on the Windows host?"
+  );
+}
+function delay2(ms) {
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
+}
+
+// src/commands/sessions/daemon/buildHello.ts
+var ASSIST_VERSION = package_default.version;
+function buildHello() {
+  return { type: "hello", version: ASSIST_VERSION };
+}
+function isHello(msg) {
+  return msg.type === "hello" && typeof msg.version === "string";
+}
+function versionsMatch(a, b) {
+  return a === b;
+}
+
+// src/commands/sessions/daemon/toWindowsSessionId.ts
+var PREFIX = "w-";
+function toWindowsSessionId(id) {
+  return `${PREFIX}${id}`;
+}
+function isWindowsSessionId(id) {
+  return id.startsWith(PREFIX);
+}
+function stripWindowsSessionId(id) {
+  return id.startsWith(PREFIX) ? id.slice(PREFIX.length) : id;
+}
+
+// src/commands/sessions/daemon/WindowsProxyState.ts
+var MAX_SCROLLBACK2 = 256 * 1024;
+function createState(broadcast2, onSessionsChanged) {
+  return {
+    windowsSessions: [],
+    scrollback: /* @__PURE__ */ new Map(),
+    pendingCreators: [],
+    broadcast: broadcast2,
+    onSessionsChanged
+  };
+}
+function resetState(state) {
+  state.windowsSessions = [];
+  state.scrollback.clear();
+  state.pendingCreators = [];
+}
+function replayScrollback2(state, client) {
+  for (const [sessionId, data] of state.scrollback)
+    if (data) sendTo(client, { type: "output", sessionId, data });
+}
+function appendScrollback2(state, sessionId, data) {
+  const next3 = (state.scrollback.get(sessionId) ?? "") + data;
+  state.scrollback.set(
+    sessionId,
+    next3.length > MAX_SCROLLBACK2 ? next3.slice(-MAX_SCROLLBACK2) : next3
+  );
+}
+
+// src/commands/sessions/daemon/handleInbound.ts
+function handleInbound(state, line) {
+  let msg;
+  try {
+    msg = JSON.parse(line);
+  } catch {
+    return;
+  }
+  inbound[msg.type]?.(state, msg);
+}
+var inbound = {
+  hello: (_state, msg) => handleHello(msg),
+  created: handleCreated,
+  sessions: handleSessions,
+  output: handleOutput,
+  clear: relayWithSessionId,
+  error: (state, msg) => state.broadcast(msg)
+};
+function handleHello(msg) {
+  if (isHello(msg) && !versionsMatch(msg.version, ASSIST_VERSION))
+    daemonLog(
+      `windows daemon version mismatch: ${msg.version} (wsl ${ASSIST_VERSION})`
+    );
+}
+function handleCreated(state, msg) {
+  const client = state.pendingCreators.shift();
+  if (client) sendTo(client, { type: "created", sessionId: nsId(msg) });
+}
+function handleSessions(state, msg) {
+  state.windowsSessions = msg.sessions.map((s) => ({
+    ...s,
+    id: toWindowsSessionId(s.id)
+  }));
+  const live = new Set(state.windowsSessions.map((s) => s.id));
+  for (const id of state.scrollback.keys())
+    if (!live.has(id)) state.scrollback.delete(id);
+  state.onSessionsChanged();
+}
+function handleOutput(state, msg) {
+  const sessionId = nsId(msg);
+  const data = msg.data;
+  appendScrollback2(state, sessionId, data);
+  state.broadcast({ type: "output", sessionId, data });
+}
+function relayWithSessionId(state, msg) {
+  state.broadcast({ ...msg, sessionId: nsId(msg) });
+}
+function nsId(msg) {
+  return toWindowsSessionId(msg.sessionId);
+}
+
+// src/commands/sessions/daemon/isWindowsCwd.ts
+function isWindowsCwd(cwd) {
+  return /^[A-Za-z]:[\\/]/.test(cwd);
+}
+function shouldProxyToWindows(cwd) {
+  return detectPlatform() === "wsl" && isWindowsCwd(cwd);
+}
+
+// src/commands/sessions/daemon/WindowsConnection.ts
+import { createInterface as createInterface5 } from "readline";
+var WindowsConnection = class {
+  constructor(deps2) {
+    this.deps = deps2;
+  }
+  connection = null;
+  socket = null;
+  ensure() {
+    if (this.connection) return this.connection;
+    const connection = this.open();
+    this.connection = connection;
+    connection.catch(() => {
+      if (this.connection === connection) this.connection = null;
+    });
+    return connection;
+  }
+  write(msg) {
+    this.socket?.write(`${JSON.stringify(msg)}
+`);
+  }
+  trySend(msg) {
+    if (!this.socket?.writable) return false;
+    this.write(msg);
+    return true;
+  }
+  dispose() {
+    this.socket?.destroy();
+    this.reset();
+  }
+  async open() {
+    const socket = await this.deps.connect();
+    this.socket = socket;
+    const lines = createInterface5({ input: socket });
+    lines.on("error", () => {
+    });
+    lines.on("line", (line) => this.deps.onLine(line));
+    socket.on("error", () => {
+    });
+    socket.on("close", () => {
+      this.reset();
+      this.deps.onClose();
+    });
+    this.write(buildHello());
+    return socket;
+  }
+  reset() {
+    this.socket = null;
+    this.connection = null;
+  }
+};
+
+// src/commands/sessions/daemon/WindowsProxy.ts
+var WindowsProxy = class {
+  state;
+  conn;
+  constructor(clients, onSessionsChanged, connect3 = defaultConnect) {
+    this.state = createState(
+      (msg) => broadcast(clients, msg),
+      onSessionsChanged
+    );
+    this.conn = new WindowsConnection({
+      connect: connect3,
+      onLine: (line) => handleInbound(this.state, line),
+      onClose: () => this.handleClose()
+    });
+  }
+  sessions() {
+    return this.state.windowsSessions;
+  }
+  replayScrollback(client) {
+    replayScrollback2(this.state, client);
+  }
+  // Returns true when the message targets Windows: a create/resume in a
+  // windows-origin cwd is forwarded, as is I/O for a namespaced session id.
+  route(client, data) {
+    if (isWindowsCreate(data)) {
+      void this.forwardCreate(client, data);
+      return true;
+    }
+    if (isWindowsIo(data)) {
+      const sessionId = stripWindowsSessionId(data.sessionId);
+      this.conn.trySend({ ...data, sessionId });
+      return true;
+    }
+    return false;
+  }
+  dispose() {
+    this.conn.dispose();
+  }
+  async forwardCreate(client, data) {
+    try {
+      await this.conn.ensure();
+      this.state.pendingCreators.push(client);
+      this.conn.write(data);
+    } catch (e) {
+      sendTo(client, {
+        type: "error",
+        message: `Windows session unavailable: ${errorText(e)}`
+      });
+    }
+  }
+  handleClose() {
+    for (const client of this.state.pendingCreators)
+      sendTo(client, {
+        type: "error",
+        message: "Windows daemon connection closed"
+      });
+    resetState(this.state);
+    this.state.onSessionsChanged();
+  }
+};
+function isWindowsCreate(data) {
+  return typeof data.cwd === "string" && shouldProxyToWindows(data.cwd);
+}
+function isWindowsIo(data) {
+  return typeof data.sessionId === "string" && isWindowsSessionId(data.sessionId);
+}
+async function defaultConnect() {
+  await ensureWindowsDaemonRunning();
+  return connectToWindowsDaemon();
+}
+function errorText(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+
 // src/commands/sessions/daemon/watchClaudeSessionId.ts
 import * as fs27 from "fs";
 import * as path48 from "path";
@@ -18567,23 +18878,20 @@ function matchMarker(text3, tag) {
 }
 
 // src/commands/sessions/shared/parseSessionFile.ts
-async function parseSessionFile(filePath) {
+async function parseSessionFile(filePath, origin = "wsl") {
   let handle;
   try {
     handle = await fs25.promises.open(filePath, "r");
-    const buf = Buffer.alloc(16384);
-    const { bytesRead } = await handle.read(buf, 0, buf.length, 0);
-    const lines = buf.toString("utf8", 0, bytesRead).split("\n").filter(Boolean);
-    const meta = extractSessionMeta(lines);
+    const meta = extractSessionMeta(await readHeadLines(handle));
     if (!meta.sessionId) return null;
     const timestamp = meta.timestamp || (await fs25.promises.stat(filePath)).mtime.toISOString();
-    const project = meta.cwd ? path46.basename(meta.cwd) : dirNameToProject(filePath);
     return {
       sessionId: meta.sessionId,
       name: meta.name || `Session ${meta.sessionId.slice(0, 8)}`,
-      project,
+      project: deriveProject(meta.cwd, filePath, origin),
       cwd: meta.cwd,
       timestamp,
+      origin,
       ...deriveHistoryFields(meta.commandName, meta.commandArgs, meta.name)
     };
   } catch {
@@ -18592,6 +18900,15 @@ async function parseSessionFile(filePath) {
     await handle?.close();
   }
 }
+async function readHeadLines(handle) {
+  const buf = Buffer.alloc(16384);
+  const { bytesRead } = await handle.read(buf, 0, buf.length, 0);
+  return buf.toString("utf8", 0, bytesRead).split("\n").filter(Boolean);
+}
+function deriveProject(cwd, filePath, origin) {
+  if (!cwd) return dirNameToProject(filePath);
+  return origin === "windows" ? path46.win32.basename(cwd) : path46.basename(cwd);
+}
 function dirNameToProject(filePath) {
   const dirName = path46.basename(path46.dirname(filePath));
   const parts = dirName.split("--");
@@ -18599,38 +18916,52 @@ function dirNameToProject(filePath) {
 }
 
 // src/commands/sessions/shared/discoverSessions.ts
+function sessionRoots() {
+  const roots = [
+    { dir: path47.join(os.homedir(), ".claude", "projects"), origin: "wsl" }
+  ];
+  const windowsRoot = loadConfig().sessions?.windowsProjectsRoot;
+  if (windowsRoot) roots.push({ dir: windowsRoot, origin: "windows" });
+  return roots;
+}
 async function discoverSessionJsonlPaths() {
-  const projectsDir = path47.join(os.homedir(), ".claude", "projects");
-  let projectDirs;
-  try {
-    projectDirs = await fs26.promises.readdir(projectsDir);
-  } catch {
-    return [];
-  }
-  const paths = [];
+  const results = [];
   await Promise.all(
-    projectDirs.map(async (dirName) => {
-      const dirPath = path47.join(projectsDir, dirName);
-      let entries;
+    sessionRoots().map(async ({ dir, origin }) => {
+      let projectDirs;
       try {
-        entries = await fs26.promises.readdir(dirPath);
+        projectDirs = await fs26.promises.readdir(dir);
       } catch {
         return;
       }
-      const jsonlFiles = entries.filter((e) => e.endsWith(".jsonl"));
-      for (const file of jsonlFiles) {
-        paths.push(path47.join(dirPath, file));
-      }
+      await Promise.all(
+        projectDirs.map(async (dirName) => {
+          const dirPath = path47.join(dir, dirName);
+          let entries;
+          try {
+            entries = await fs26.promises.readdir(dirPath);
+          } catch {
+            return;
+          }
+          for (const file of entries) {
+            if (file.endsWith(".jsonl"))
+              results.push({ path: path47.join(dirPath, file), origin });
+          }
+        })
+      );
     })
   );
-  return paths;
+  return results;
+}
+async function discoverSessionFiles() {
+  return (await discoverSessionJsonlPaths()).map((p) => p.path);
 }
 async function discoverSessions() {
   const paths = await discoverSessionJsonlPaths();
   const sessions = [];
   await Promise.all(
-    paths.map(async (filePath) => {
-      const session = await parseSessionFile(filePath);
+    paths.map(async ({ path: filePath, origin }) => {
+      const session = await parseSessionFile(filePath, origin);
       if (session) sessions.push(session);
     })
   );
@@ -18656,10 +18987,10 @@ async function watchClaudeSessionId(options2) {
 async function findLatestSessionId(options2) {
   const paths = await discoverSessionJsonlPaths();
   let latest = null;
-  for (const filePath of paths) {
+  for (const { path: filePath, origin } of paths) {
     const createdMs = await createdSince(filePath, options2.sinceMs);
     if (createdMs === null) continue;
-    const meta = await parseSessionFile(filePath);
+    const meta = await parseSessionFile(filePath, origin);
     if (!meta?.cwd || options2.isClaimed(meta.sessionId)) continue;
     if (path48.resolve(meta.cwd) !== path48.resolve(options2.cwd)) continue;
     if (!latest || createdMs > latest.createdMs)
@@ -18753,10 +19084,12 @@ var SessionManager = class {
   clients = /* @__PURE__ */ new Set();
   nextId = 1;
   shuttingDown = false;
+  // why: dispatch calls windowsProxy.route() to forward windows-origin sessions
+  windowsProxy = new WindowsProxy(this.clients, () => this.notify());
   addClient(client) {
     this.clients.add(client);
     this.onIdleChange?.(this.isIdle());
-    greetClient(client, this.sessions, () => this.listSessions());
+    greetClient(client, this.sessions, this.listSessions, this.windowsProxy);
   }
   removeClient(client) {
     this.clients.delete(client);
@@ -18825,22 +19158,24 @@ var SessionManager = class {
   setAutoAdvance(id, enabled) {
     if (setAutoAdvance(this.sessions, id, enabled)) this.notify();
   }
-  listSessions() {
-    return [...this.sessions.values()].map(toSessionInfo);
-  }
+  listSessions = () => {
+    const local = [...this.sessions.values()].map(toSessionInfo);
+    return local.concat(this.windowsProxy.sessions());
+  };
   notify = () => {
     if (this.shuttingDown) return;
-    broadcastSessions(this.sessions, this.clients);
+    const windows = this.windowsProxy.sessions();
+    broadcastSessions(this.sessions, this.clients, windows);
     this.onIdleChange?.(this.isIdle());
   };
 };
 
 // src/commands/sessions/daemon/startDaemonServer.ts
 import { unlinkSync as unlinkSync19 } from "fs";
-import * as net2 from "net";
+import * as net3 from "net";
 
 // src/commands/sessions/daemon/handleConnection.ts
-import { createInterface as createInterface5 } from "readline";
+import { createInterface as createInterface6 } from "readline";
 
 // src/commands/sessions/shared/parseTranscript.ts
 import * as fs28 from "fs";
@@ -18894,11 +19229,13 @@ function cleanUserText(value) {
 import * as path49 from "path";
 async function findSessionJsonlPath(sessionId) {
   const paths = await discoverSessionJsonlPaths();
-  const direct = paths.find((p) => path49.basename(p, ".jsonl") === sessionId);
-  if (direct) return direct;
+  const direct = paths.find(
+    (p) => path49.basename(p.path, ".jsonl") === sessionId
+  );
+  if (direct) return direct.path;
   for (const p of paths) {
-    const meta = await parseSessionFile(p);
-    if (meta?.sessionId === sessionId) return p;
+    const meta = await parseSessionFile(p.path, p.origin);
+    if (meta?.sessionId === sessionId) return p.path;
   }
   return null;
 }
@@ -18932,46 +19269,11 @@ function safeParse2(line) {
 }
 
 // src/commands/sessions/daemon/dispatchMessage.ts
-function sendCreated(client, id) {
-  sendTo(client, { type: "created", sessionId: id });
-}
-function handleCreate(client, manager, data) {
-  sendCreated(
-    client,
-    manager.spawn(
-      data.prompt,
-      data.cwd
-    )
-  );
-}
-function handleCreateRun(client, manager, data) {
-  sendCreated(
-    client,
-    manager.spawnRun(
-      data.runName,
-      data.runArgs ?? [],
-      data.cwd
-    )
-  );
-}
-function handleCreateAssist(client, manager, data) {
-  sendCreated(
-    client,
-    manager.spawnAssist(
-      data.assistArgs ?? [],
-      data.cwd
-    )
-  );
-}
-function handleResume(client, manager, data) {
-  sendCreated(
-    client,
-    manager.resume(
-      data.sessionId,
-      data.cwd,
-      data.name
-    )
-  );
+function creator(spawn11) {
+  return (client, m, d) => {
+    if (m.windowsProxy.route(client, d)) return;
+    sendTo(client, { type: "created", sessionId: spawn11(m, d) });
+  };
 }
 function handleHistory(client) {
   discoverSessions().then(
@@ -18989,21 +19291,54 @@ function handleShutdown(client, manager) {
   sendTo(client, { type: "shutting-down" });
   setImmediate(() => process.exit(0));
 }
+function routed(local) {
+  return (client, m, d) => {
+    if (!m.windowsProxy.route(client, d)) local(client, m, d);
+  };
+}
 var handlers = {
   ping: (client) => sendTo(client, { type: "pong", pid: process.pid }),
-  create: handleCreate,
-  "create-run": handleCreateRun,
-  "create-assist": handleCreateAssist,
-  resume: handleResume,
+  hello: (client) => sendTo(client, buildHello()),
+  create: creator(
+    (m, d) => m.spawn(d.prompt, d.cwd)
+  ),
+  "create-run": creator(
+    (m, d) => m.spawnRun(
+      d.runName,
+      d.runArgs ?? [],
+      d.cwd
+    )
+  ),
+  "create-assist": creator(
+    (m, d) => m.spawnAssist(
+      d.assistArgs ?? [],
+      d.cwd
+    )
+  ),
+  resume: creator(
+    (m, d) => m.resume(
+      d.sessionId,
+      d.cwd,
+      d.name
+    )
+  ),
   history: handleHistory,
   "fetch-transcript": handleFetchTranscript,
   shutdown: handleShutdown,
-  input: (_client, m, d) => m.writeToSession(d.sessionId, d.data),
-  resize: (_client, m, d) => m.resizeSession(d.sessionId, d.cols, d.rows),
-  retry: (_client, m, d) => m.retrySession(d.sessionId),
-  dismiss: (_client, m, d) => m.dismissSession(d.sessionId),
-  "set-autorun": (_client, m, d) => m.setAutoRun(d.sessionId, d.enabled),
-  "set-autoadvance": (_client, m, d) => m.setAutoAdvance(d.sessionId, d.enabled)
+  input: routed(
+    (_client, m, d) => m.writeToSession(d.sessionId, d.data)
+  ),
+  resize: routed(
+    (_client, m, d) => m.resizeSession(d.sessionId, d.cols, d.rows)
+  ),
+  retry: routed((_client, m, d) => m.retrySession(d.sessionId)),
+  dismiss: routed((_client, m, d) => m.dismissSession(d.sessionId)),
+  "set-autorun": routed(
+    (_client, m, d) => m.setAutoRun(d.sessionId, d.enabled)
+  ),
+  "set-autoadvance": routed(
+    (_client, m, d) => m.setAutoAdvance(d.sessionId, d.enabled)
+  )
 };
 function dispatchMessage(client, manager, data) {
   handlers[data.type]?.(client, manager, data);
@@ -19018,7 +19353,7 @@ function handleConnection(socket, manager) {
     }
   };
   manager.addClient(client);
-  const lines = createInterface5({ input: socket });
+  const lines = createInterface6({ input: socket });
   lines.on("error", () => {
   });
   lines.on("line", (line) => {
@@ -19095,9 +19430,10 @@ function cleanupOwnedFiles() {
 
 // src/commands/sessions/daemon/startDaemonServer.ts
 function startDaemonServer(manager, checkAutoExit) {
-  const server = net2.createServer(
+  const server = net3.createServer(
     (socket) => handleConnection(socket, manager)
   );
+  if (process.platform === "win32") startWindowsBridge(manager);
   let retried = false;
   server.on("error", (e) => {
     if (e.code !== "EADDRINUSE" || retried) {
@@ -19109,6 +19445,17 @@ function startDaemonServer(manager, checkAutoExit) {
   });
   server.listen(daemonPaths.socket, () => onListening(manager, checkAutoExit));
 }
+function startWindowsBridge(manager) {
+  const port = windowsDaemonPort();
+  const bridge = net3.createServer(
+    (socket) => handleConnection(socket, manager)
+  );
+  bridge.on(
+    "error",
+    (e) => daemonLog(`windows bridge error: ${e.message}`)
+  );
+  bridge.listen(port, () => daemonLog(`windows bridge listening on :${port}`));
+}
 async function recoverFromAddrInUse(server, manager, checkAutoExit) {
   if (await isDaemonRunning()) {
     daemonLog("another daemon owns the socket; exiting");
@@ -19286,7 +19633,7 @@ ${firstMessage}`);
 
 // src/commands/sessions/summarise/index.ts
 async function summarise4(options2) {
-  const files = await discoverSessionJsonlPaths();
+  const files = await discoverSessionFiles();
   if (files.length === 0) {
     console.log(chalk161.yellow("No sessions found."));
     return;