@akiojin/gwt 4.11.6 → 4.12.0

package/src/logging/reader.ts

@@ -9,6 +9,25 @@ export interface LogFileInfo {
   mtimeMs: number;
 }
 
+export type LogTargetReason =
+  | "worktree"
+  | "worktree-inaccessible"
+  | "current-working-directory"
+  | "working-directory"
+  | "no-worktree";
+
+export interface LogTargetBranch {
+  name: string;
+  isCurrent?: boolean;
+  worktree?: { path: string; isAccessible?: boolean } | undefined;
+}
+
+export interface LogTargetResolution {
+  logDir: string | null;
+  sourcePath: string | null;
+  reason: LogTargetReason;
+}
+
 const LOG_FILENAME_PATTERN = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
 
 export function resolveLogDir(cwd: string = process.cwd()): string {
@@ -16,6 +35,46 @@ export function resolveLogDir(cwd: string = process.cwd()): string {
   return path.join(os.homedir(), ".gwt", "logs", cwdBase);
 }
 
+export function resolveLogTarget(
+  branch: LogTargetBranch | null,
+  workingDirectory: string = process.cwd(),
+): LogTargetResolution {
+  if (!branch) {
+    return {
+      logDir: resolveLogDir(workingDirectory),
+      sourcePath: workingDirectory,
+      reason: "working-directory",
+    };
+  }
+
+  const worktreePath = branch.worktree?.path;
+  if (worktreePath) {
+    const accessible = branch.worktree?.isAccessible !== false;
+    if (accessible) {
+      return {
+        logDir: resolveLogDir(worktreePath),
+        sourcePath: worktreePath,
+        reason: "worktree",
+      };
+    }
+    return {
+      logDir: null,
+      sourcePath: worktreePath,
+      reason: "worktree-inaccessible",
+    };
+  }
+
+  if (branch.isCurrent) {
+    return {
+      logDir: resolveLogDir(workingDirectory),
+      sourcePath: workingDirectory,
+      reason: "current-working-directory",
+    };
+  }
+
+  return { logDir: null, sourcePath: null, reason: "no-worktree" };
+}
+
 export function buildLogFilePath(logDir: string, date: string): string {
   return path.join(logDir, `${date}.jsonl`);
 }
@@ -66,6 +125,23 @@ export async function listLogFiles(logDir: string): Promise<LogFileInfo[]> {
   }
 }
 
+export async function clearLogFiles(logDir: string): Promise<number> {
+  const files = await listLogFiles(logDir);
+  let cleared = 0;
+  for (const file of files) {
+    try {
+      await fs.truncate(file.path, 0);
+      cleared += 1;
+    } catch (error) {
+      const err = error as NodeJS.ErrnoException;
+      if (err.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  return cleared;
+}
+
 export async function listRecentLogFiles(
   logDir: string,
   days = 7,
@@ -74,3 +150,44 @@ export async function listRecentLogFiles(
   const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
   return files.filter((file) => file.mtimeMs >= cutoff);
 }
+
+export interface LogReadResult {
+  date: string;
+  lines: string[];
+}
+
+export async function readLogLinesForDate(
+  logDir: string,
+  preferredDate: string,
+): Promise<LogReadResult | null> {
+  const files = await listLogFiles(logDir);
+  if (files.length === 0) {
+    return null;
+  }
+
+  const ordered: LogFileInfo[] = [];
+  const preferred = files.find((file) => file.date === preferredDate);
+  if (preferred) {
+    ordered.push(preferred);
+  }
+  for (const file of files) {
+    if (preferred && file.date === preferred.date) {
+      continue;
+    }
+    ordered.push(file);
+  }
+
+  for (const file of ordered) {
+    const lines = await readLogFileLines(file.path);
+    if (lines.length > 0) {
+      return { date: file.date, lines };
+    }
+  }
+
+  const fallback = files[0];
+  if (!fallback) {
+    return { date: preferredDate, lines: [] };
+  }
+  const fallbackDate = preferred?.date ?? fallback.date;
+  return { date: fallbackDate, lines: [] };
+}

package/src/services/__tests__/BatchMergeService.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, mock, beforeEach, afterEach } from "bun:test";
 import { BatchMergeService } from "../BatchMergeService";
-import type { BatchMergeConfig } from "../../ui/types";
+import type { BatchMergeConfig, BatchMergeProgress } from "../../cli/ui/types";
 
 // Mock git module
 mock.module("../../git", () => ({
@@ -235,7 +235,9 @@ describe("BatchMergeService", () => {
       (
         worktree.generateWorktreePath as ReturnType<typeof mock>
       ).mockResolvedValue("/repo/.worktrees/feature-b");
-      (worktree.createWorktree as ReturnType<typeof mock>).mockResolvedValue();
+      (worktree.createWorktree as ReturnType<typeof mock>).mockResolvedValue(
+        undefined,
+      );
 
       const worktreePath = await service.ensureWorktree("feature/b");
 
@@ -271,7 +273,9 @@ describe("BatchMergeService", () => {
     });
 
     it("should successfully merge without conflicts", async () => {
-      (git.mergeFromBranch as ReturnType<typeof mock>).mockResolvedValue();
+      (git.mergeFromBranch as ReturnType<typeof mock>).mockResolvedValue(
+        undefined,
+      );
       (git.hasMergeConflict as ReturnType<typeof mock>).mockResolvedValue(
         false,
       );
@@ -293,7 +297,7 @@ describe("BatchMergeService", () => {
         new Error("Merge conflict"),
       );
       (git.hasMergeConflict as ReturnType<typeof mock>).mockResolvedValue(true);
-      (git.abortMerge as ReturnType<typeof mock>).mockResolvedValue();
+      (git.abortMerge as ReturnType<typeof mock>).mockResolvedValue(undefined);
 
       const status = await service.mergeBranch("feature/a", "main", config);
 
@@ -339,11 +343,13 @@ describe("BatchMergeService", () => {
     });
 
     it("should rollback with resetToHead after successful dry-run merge", async () => {
-      (git.mergeFromBranch as ReturnType<typeof mock>).mockResolvedValue();
+      (git.mergeFromBranch as ReturnType<typeof mock>).mockResolvedValue(
+        undefined,
+      );
       (git.hasMergeConflict as ReturnType<typeof mock>).mockResolvedValue(
         false,
       );
-      (git.resetToHead as ReturnType<typeof mock>).mockResolvedValue();
+      (git.resetToHead as ReturnType<typeof mock>).mockResolvedValue(undefined);
 
       const status = await service.mergeBranch(
         "feature/a",
@@ -368,7 +374,7 @@ describe("BatchMergeService", () => {
         new Error("CONFLICT (content)"),
       );
       (git.hasMergeConflict as ReturnType<typeof mock>).mockResolvedValue(true);
-      (git.abortMerge as ReturnType<typeof mock>).mockResolvedValue();
+      (git.abortMerge as ReturnType<typeof mock>).mockResolvedValue(undefined);
 
       const status = await service.mergeBranch(
         "feature/a",
@@ -405,14 +411,18 @@ describe("BatchMergeService", () => {
     });
 
     it("should push successfully after merge when autoPush is enabled", async () => {
-      (git.mergeFromBranch as ReturnType<typeof mock>).mockResolvedValue();
+      (git.mergeFromBranch as ReturnType<typeof mock>).mockResolvedValue(
+        undefined,
+      );
       (git.hasMergeConflict as ReturnType<typeof mock>).mockResolvedValue(
         false,
       );
       (git.getCurrentBranchName as ReturnType<typeof mock>).mockResolvedValue(
         "feature/a",
       );
-      (git.pushBranchToRemote as ReturnType<typeof mock>).mockResolvedValue();
+      (git.pushBranchToRemote as ReturnType<typeof mock>).mockResolvedValue(
+        undefined,
+      );
 
       const status = await service.mergeBranch(
         "feature/a",
@@ -431,7 +441,9 @@ describe("BatchMergeService", () => {
     });
 
     it("should handle push failure without failing merge", async () => {
-      (git.mergeFromBranch as ReturnType<typeof mock>).mockResolvedValue();
+      (git.mergeFromBranch as ReturnType<typeof mock>).mockResolvedValue(
+        undefined,
+      );
       (git.hasMergeConflict as ReturnType<typeof mock>).mockResolvedValue(
         false,
       );
@@ -455,7 +467,9 @@ describe("BatchMergeService", () => {
 
     it("should not push when autoPush is false", async () => {
       const noPushConfig = { ...autoPushConfig, autoPush: false };
-      (git.mergeFromBranch as ReturnType<typeof mock>).mockResolvedValue();
+      (git.mergeFromBranch as ReturnType<typeof mock>).mockResolvedValue(
+        undefined,
+      );
       (git.hasMergeConflict as ReturnType<typeof mock>).mockResolvedValue(
         false,
       );
@@ -482,7 +496,9 @@ describe("BatchMergeService", () => {
         autoPush: false,
       };
 
-      (git.fetchAllRemotes as ReturnType<typeof mock>).mockResolvedValue();
+      (git.fetchAllRemotes as ReturnType<typeof mock>).mockResolvedValue(
+        undefined,
+      );
       (git.getRepositoryRoot as ReturnType<typeof mock>).mockResolvedValue(
         "/repo",
       );
@@ -492,8 +508,12 @@ describe("BatchMergeService", () => {
       (worktree.generateWorktreePath as ReturnType<typeof mock>)
         .mockResolvedValueOnce("/repo/.worktrees/feature-a")
         .mockResolvedValueOnce("/repo/.worktrees/feature-b");
-      (worktree.createWorktree as ReturnType<typeof mock>).mockResolvedValue();
-      (git.mergeFromBranch as ReturnType<typeof mock>).mockResolvedValue();
+      (worktree.createWorktree as ReturnType<typeof mock>).mockResolvedValue(
+        undefined,
+      );
+      (git.mergeFromBranch as ReturnType<typeof mock>).mockResolvedValue(
+        undefined,
+      );
       (git.hasMergeConflict as ReturnType<typeof mock>).mockResolvedValue(
         false,
       );

package/src/services/dependency-installer.ts

@@ -1,5 +1,5 @@
 import path from "node:path";
-import fs from "node:fs/promises";
+import { access } from "node:fs/promises";
 import { execa } from "execa";
 
 export type PackageManager = "bun" | "pnpm" | "npm";
@@ -72,7 +72,7 @@ const INSTALL_CANDIDATES: PackageManagerCandidate[] = [
 
 async function fileExists(targetPath: string): Promise<boolean> {
   try {
-    await fs.access(targetPath);
+    await access(targetPath);
     return true;
   } catch (error) {
     const code = (error as NodeJS.ErrnoException)?.code;

package/src/utils/session/common.ts

@@ -444,3 +444,31 @@ export function matchesCwd(
     isPathPrefix(normalizedSession, normalizedTarget)
   );
 }
+
+/**
+ * Resolves a branch name for a session cwd using worktree paths.
+ * Picks the worktree with the longest matching path prefix.
+ */
+export function resolveBranchFromCwd(
+  sessionCwd: string | null,
+  worktrees: { path: string; branch: string }[],
+): string | null {
+  if (!sessionCwd) return null;
+  const normalizedSession = normalizePath(sessionCwd);
+  let bestMatch: { branch: string; path: string } | null = null;
+
+  for (const worktree of worktrees) {
+    if (!worktree?.path || !worktree.branch) continue;
+    const normalizedPath = normalizePath(worktree.path);
+    if (
+      normalizedSession === normalizedPath ||
+      isPathPrefix(normalizedPath, normalizedSession)
+    ) {
+      if (!bestMatch || normalizedPath.length > bestMatch.path.length) {
+        bestMatch = { branch: worktree.branch, path: normalizedPath };
+      }
+    }
+  }
+
+  return bestMatch?.branch ?? null;
+}

package/src/utils/session/parsers/claude.ts

@@ -16,6 +16,7 @@ import {
   readFileContent,
   checkFileStat,
 } from "../common.js";
+import { listAllWorktrees } from "../../../worktree.js";
 
 /**
  * Encodes a project path for Claude's directory structure.
@@ -75,36 +76,72 @@ function getClaudeRootCandidates(): string[] {
  * 3. ~/.claude/history.jsonl (global history fallback)
  *
  * @param cwd - The working directory to find sessions for
- * @param options - Search options (since, until, preferClosestTo, windowMs)
+ * @param options - Search options (since, until, preferClosestTo, windowMs, branch/worktrees)
  * @returns Session info with ID and modification time, or null if not found
  */
 export async function findLatestClaudeSession(
   cwd: string,
-  options: Omit<SessionSearchOptions, "cwd"> = {},
+  options: SessionSearchOptions = {},
 ): Promise<ClaudeSessionInfo | null> {
   const rootCandidates = getClaudeRootCandidates();
-  const encodedPaths = generateClaudeProjectPathCandidates(cwd);
-
-  for (const claudeRoot of rootCandidates) {
-    for (const encoded of encodedPaths) {
-      const projectDir = path.join(claudeRoot, "projects", encoded);
-      const sessionsDir = path.join(projectDir, "sessions");
-
-      // 1) Look under sessions/ (official location)
-      const session = await findNewestSessionIdFromDir(
-        sessionsDir,
-        false,
-        options,
-      );
-      if (session) return session;
+  const branchFilter =
+    typeof options.branch === "string" && options.branch.trim().length > 0
+      ? options.branch.trim()
+      : null;
 
-      // 2) Look directly under project dir and subdirs
-      const rootSession = await findNewestSessionIdFromDir(
-        projectDir,
-        true,
-        options,
-      );
-      if (rootSession) return rootSession;
+  let cwdCandidates: string[] = [];
+  if (branchFilter) {
+    let worktrees: { path: string; branch: string }[] = [];
+    if (Array.isArray(options.worktrees) && options.worktrees.length > 0) {
+      worktrees = options.worktrees
+        .filter((entry) => entry?.path && entry?.branch)
+        .map((entry) => ({ path: entry.path, branch: entry.branch }));
+    } else {
+      try {
+        const allWorktrees = await listAllWorktrees();
+        worktrees = allWorktrees
+          .filter((entry) => entry?.path && entry?.branch)
+          .map((entry) => ({ path: entry.path, branch: entry.branch }));
+      } catch {
+        worktrees = [];
+      }
+    }
+    const matches = worktrees
+      .filter((entry) => entry.branch === branchFilter)
+      .map((entry) => entry.path);
+    if (!matches.length) return null;
+    cwdCandidates = matches;
+  } else {
+    const baseCwd = options.cwd ?? cwd;
+    if (!baseCwd) return null;
+    cwdCandidates = [baseCwd];
+  }
+
+  const uniqueCwds = Array.from(new Set(cwdCandidates));
+
+  for (const candidateCwd of uniqueCwds) {
+    const encodedPaths = generateClaudeProjectPathCandidates(candidateCwd);
+    for (const claudeRoot of rootCandidates) {
+      for (const encoded of encodedPaths) {
+        const projectDir = path.join(claudeRoot, "projects", encoded);
+        const sessionsDir = path.join(projectDir, "sessions");
+
+        // 1) Look under sessions/ (official location)
+        const session = await findNewestSessionIdFromDir(
+          sessionsDir,
+          false,
+          options,
+        );
+        if (session) return session;
+
+        // 2) Look directly under project dir and subdirs
+        const rootSession = await findNewestSessionIdFromDir(
+          projectDir,
+          true,
+          options,
+        );
+        if (rootSession) return rootSession;
+      }
     }
   }
 
@@ -124,7 +161,10 @@ export async function findLatestClaudeSession(
           typeof parsed.project === "string" ? parsed.project : null;
         const sessionId =
           typeof parsed.sessionId === "string" ? parsed.sessionId : null;
-        if (project && sessionId && matchesCwd(project, cwd)) {
+        const matchesProject = uniqueCwds.some((candidate) =>
+          matchesCwd(project, candidate),
+        );
+        if (project && sessionId && matchesProject) {
           return { id: sessionId, mtime: historyStat.mtimeMs };
         }
       } catch {
@@ -141,14 +181,14 @@ export async function findLatestClaudeSession(
 /**
  * Finds the latest Claude session ID for a given working directory.
  * @param cwd - The working directory to find sessions for
- * @param options - Search options (since, until, preferClosestTo, windowMs)
+ * @param options - Search options (since, until, preferClosestTo, windowMs, branch/worktrees)
  * @returns Session ID string or null if not found
  */
 export async function findLatestClaudeSessionId(
   cwd: string,
-  options: Omit<SessionSearchOptions, "cwd"> = {},
+  options: SessionSearchOptions = {},
 ): Promise<string | null> {
-  const found = await findLatestClaudeSession(cwd, options);
+  const found = await findLatestClaudeSession(options.cwd ?? cwd, options);
   return found?.id ?? null;
 }
 
@@ -167,6 +207,9 @@ export async function waitForClaudeSessionId(
     until?: number;
     preferClosestTo?: number;
     windowMs?: number;
+    branch?: string | null;
+    worktrees?: { path: string; branch: string }[] | null;
+    cwd?: string | null;
   } = {},
 ): Promise<string | null> {
   const timeoutMs = options.timeoutMs ?? 120_000;
@@ -174,15 +217,22 @@ export async function waitForClaudeSessionId(
   const deadline = Date.now() + timeoutMs;
 
   // Build search options once outside the loop
-  const searchOptions: Omit<SessionSearchOptions, "cwd"> = {};
+  const searchOptions: SessionSearchOptions = {};
   if (options.since !== undefined) searchOptions.since = options.since;
   if (options.until !== undefined) searchOptions.until = options.until;
   if (options.preferClosestTo !== undefined)
     searchOptions.preferClosestTo = options.preferClosestTo;
   if (options.windowMs !== undefined) searchOptions.windowMs = options.windowMs;
+  if (options.branch !== undefined) searchOptions.branch = options.branch;
+  if (options.worktrees !== undefined)
+    searchOptions.worktrees = options.worktrees;
+  if (options.cwd !== undefined) searchOptions.cwd = options.cwd;
 
   while (Date.now() < deadline) {
-    const found = await findLatestClaudeSession(cwd, searchOptions);
+    const found = await findLatestClaudeSession(
+      options.cwd ?? cwd,
+      searchOptions,
+    );
     if (found?.id) return found.id;
     await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
   }

package/src/utils/session/parsers/codex.ts

@@ -14,8 +14,10 @@ import {
   UUID_REGEX,
   collectFilesIterative,
   matchesCwd,
+  resolveBranchFromCwd,
   readSessionInfoFromFile,
 } from "../common.js";
+import { listAllWorktrees } from "../../../worktree.js";
 
 /**
  * Finds the latest Codex session with optional time filtering and cwd matching.
@@ -63,43 +65,65 @@ export async function findLatestCodexSession(
     return b.mtime - a.mtime;
   });
 
-  let fallbackMissingCwd: CodexSessionInfo | null = null;
+  const branchFilter =
+    typeof options.branch === "string" && options.branch.trim().length > 0
+      ? options.branch.trim()
+      : null;
+  const shouldCheckBranch = Boolean(branchFilter);
+  const shouldCheckCwd = Boolean(options.cwd) && !shouldCheckBranch;
+
+  let worktrees: { path: string; branch: string }[] = [];
+  if (shouldCheckBranch) {
+    if (Array.isArray(options.worktrees) && options.worktrees.length > 0) {
+      worktrees = options.worktrees
+        .filter((entry) => entry?.path && entry?.branch)
+        .map((entry) => ({ path: entry.path, branch: entry.branch }));
+    } else {
+      try {
+        const allWorktrees = await listAllWorktrees();
+        worktrees = allWorktrees
+          .filter((entry) => entry?.path && entry?.branch)
+          .map((entry) => ({ path: entry.path, branch: entry.branch }));
+      } catch {
+        worktrees = [];
+      }
+    }
+    if (!worktrees.length) return null;
+  }
 
   for (const file of ordered) {
     // Priority 1: Extract session ID from filename (most reliable for Codex)
     const filenameMatch = path.basename(file.fullPath).match(UUID_REGEX);
-    if (filenameMatch) {
-      const sessionId = filenameMatch[0];
-      // If cwd filtering is needed, read file content to check cwd
-      if (options.cwd) {
-        const info = await readSessionInfoFromFile(file.fullPath);
-        if (matchesCwd(info.cwd, options.cwd)) {
-          return { id: sessionId, mtime: file.mtime };
-        }
-        if (!info.cwd && !fallbackMissingCwd) {
-          fallbackMissingCwd = { id: sessionId, mtime: file.mtime };
-        }
-        continue; // cwd doesn't match, try next file
+    const idFromName = filenameMatch?.[0] ?? null;
+    const needsInfo = shouldCheckBranch || shouldCheckCwd || !idFromName;
+    const info = needsInfo
+      ? await readSessionInfoFromFile(file.fullPath)
+      : null;
+    const sessionCwd = info?.cwd ?? null;
+
+    if (shouldCheckBranch) {
+      const resolvedBranch = resolveBranchFromCwd(sessionCwd, worktrees);
+      if (resolvedBranch !== branchFilter) {
+        continue;
       }
-      return { id: sessionId, mtime: file.mtime };
     }
 
-    // Priority 2: Fallback to reading file content if filename lacks UUID
-    const info = await readSessionInfoFromFile(file.fullPath);
-    if (!info.id) continue;
-    if (options.cwd) {
-      if (matchesCwd(info.cwd, options.cwd)) {
-        return { id: info.id, mtime: file.mtime };
+    if (shouldCheckCwd && options.cwd) {
+      if (!matchesCwd(sessionCwd, options.cwd)) {
+        continue;
       }
-      if (!info.cwd && !fallbackMissingCwd) {
-        fallbackMissingCwd = { id: info.id, mtime: file.mtime };
-      }
-      continue;
     }
-    return { id: info.id, mtime: file.mtime };
+
+    const sessionId = idFromName ?? info?.id ?? null;
+    if (sessionId) {
+      return { id: sessionId, mtime: file.mtime };
+    }
+
+    // Priority 2: Fallback to reading file content if filename lacks UUID
+    // (already handled via info above)
   }
 
-  return fallbackMissingCwd;
+  return null;
 }
 
 /**

package/src/utils/session/parsers/gemini.ts

@@ -12,8 +12,10 @@ import type { GeminiSessionInfo, SessionSearchOptions } from "../types.js";
 import {
   collectFilesIterative,
   matchesCwd,
+  resolveBranchFromCwd,
   readSessionInfoFromFile,
 } from "../common.js";
+import { listAllWorktrees } from "../../../worktree.js";
 
 /**
  * Finds the latest Gemini session with optional time filtering and cwd matching.
@@ -57,15 +59,50 @@ export async function findLatestGeminiSession(
     return b.mtime - a.mtime;
   });
 
+  const branchFilter =
+    typeof options.branch === "string" && options.branch.trim().length > 0
+      ? options.branch.trim()
+      : null;
+  const shouldCheckBranch = Boolean(branchFilter);
+  const shouldCheckCwd = Boolean(options.cwd) && !shouldCheckBranch;
+
+  let worktrees: { path: string; branch: string }[] = [];
+  if (shouldCheckBranch) {
+    if (Array.isArray(options.worktrees) && options.worktrees.length > 0) {
+      worktrees = options.worktrees
+        .filter((entry) => entry?.path && entry?.branch)
+        .map((entry) => ({ path: entry.path, branch: entry.branch }));
+    } else {
+      try {
+        const allWorktrees = await listAllWorktrees();
+        worktrees = allWorktrees
+          .filter((entry) => entry?.path && entry?.branch)
+          .map((entry) => ({ path: entry.path, branch: entry.branch }));
+      } catch {
+        worktrees = [];
+      }
+    }
+    if (!worktrees.length) return null;
+  }
+
   for (const file of pool) {
     const info = await readSessionInfoFromFile(file.fullPath);
     if (!info.id) continue;
-    if (options.cwd) {
-      if (matchesCwd(info.cwd, options.cwd)) {
-        return { id: info.id, mtime: file.mtime };
+    const sessionCwd = info.cwd ?? null;
+
+    if (shouldCheckBranch) {
+      const resolvedBranch = resolveBranchFromCwd(sessionCwd, worktrees);
+      if (resolvedBranch !== branchFilter) {
+        continue;
       }
-      continue;
     }
+
+    if (shouldCheckCwd && options.cwd) {
+      if (!matchesCwd(sessionCwd, options.cwd)) {
+        continue;
+      }
+    }
+
     return { id: info.id, mtime: file.mtime };
   }
 
@@ -82,7 +119,11 @@ export async function findLatestGeminiSessionId(
   cwd: string,
   options: SessionSearchOptions = {},
 ): Promise<string | null> {
-  const searchOptions: SessionSearchOptions = { cwd: options.cwd ?? cwd };
+  const searchOptions: SessionSearchOptions = {
+    cwd: options.cwd ?? cwd,
+    branch: options.branch ?? null,
+    worktrees: options.worktrees ?? null,
+  };
   if (options.since !== undefined) searchOptions.since = options.since;
   if (options.until !== undefined) searchOptions.until = options.until;
   if (options.preferClosestTo !== undefined)