@akiojin/gwt 4.11.6 → 4.12.1

package/src/services/codingAgentResolver.ts

@@ -5,10 +5,13 @@ import { CLAUDE_CODE_TOOL } from "../config/builtin-coding-agents.js";
 import {
   CODEX_DEFAULT_ARGS,
   CLAUDE_PERMISSION_SKIP_ARGS,
+  shouldEnableCodexSkillsFlag,
+  withCodexSkillsFlag,
 } from "../shared/codingAgentConstants.js";
 import { prepareCodingAgentExecution } from "./codingAgentCommandResolver.js";
 import type { CodingAgentLaunchOptions } from "../types/tools.js";
 import { createLogger } from "../logging/logger.js";
+import { findCommand } from "../utils/command.js";
 
 const logger = createLogger({ category: "resolver" });
 
@@ -267,17 +270,21 @@ export function buildCodexArgs(options: CodexCommandOptions = {}): string[] {
 export async function resolveCodexCommand(
   options: CodexCommandOptions = {},
 ): Promise<ResolvedCommand> {
-  const args = buildCodexArgs(options);
+  const codexLookup = await findCommand("codex");
+  const baseArgs = buildCodexArgs(options);
+  const args = withCodexSkillsFlag(
+    baseArgs,
+    shouldEnableCodexSkillsFlag(codexLookup.version),
+  );
 
   // フルパスを取得（node-ptyはシェルを経由しないため必要）
-  const codexPath = await resolveCommandPath("codex");
-  if (codexPath) {
+  if (codexLookup.source === "installed" && codexLookup.path) {
     logger.info(
-      { command: codexPath, usesFallback: false },
+      { command: codexLookup.path, usesFallback: false },
       "Codex command resolved",
     );
     return {
-      command: codexPath,
+      command: codexLookup.path,
       args,
       usesFallback: 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/shared/codingAgentConstants.ts

@@ -28,3 +28,76 @@ export const CODEX_DEFAULT_ARGS = [
   "-c",
   "shell_environment_policy.experimental_use_profile=true",
 ] as const;
+
+export const CODEX_SKILLS_FLAG_DEPRECATED_FROM = "0.80.0";
+
+type ParsedVersion = {
+  major: number;
+  minor: number;
+  patch: number;
+  prerelease: string | null;
+};
+
+const MODEL_FLAG_PREFIX = "--model=";
+
+function normalizeVersion(value?: string | null): string | null {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  return trimmed.replace(/^v/i, "");
+}
+
+function parseVersion(value?: string | null): ParsedVersion | null {
+  const normalized = normalizeVersion(value);
+  if (!normalized) return null;
+  const match = normalized.match(
+    /^(\d+)\.(\d+)(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?$/,
+  );
+  if (!match) return null;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3] ?? "0");
+  if (![major, minor, patch].every(Number.isFinite)) return null;
+  return {
+    major,
+    minor,
+    patch,
+    prerelease: match[4] ?? null,
+  };
+}
+
+function compareVersions(a: ParsedVersion, b: ParsedVersion): number {
+  if (a.major !== b.major) return a.major - b.major;
+  if (a.minor !== b.minor) return a.minor - b.minor;
+  if (a.patch !== b.patch) return a.patch - b.patch;
+  if (a.prerelease && !b.prerelease) return -1;
+  if (!a.prerelease && b.prerelease) return 1;
+  if (a.prerelease && b.prerelease) {
+    return a.prerelease.localeCompare(b.prerelease);
+  }
+  return 0;
+}
+
+export function shouldEnableCodexSkillsFlag(version?: string | null): boolean {
+  const parsed = parseVersion(version);
+  if (!parsed) return false;
+  const threshold = parseVersion(CODEX_SKILLS_FLAG_DEPRECATED_FROM);
+  if (!threshold) return false;
+  return compareVersions(parsed, threshold) < 0;
+}
+
+export function withCodexSkillsFlag(
+  args: readonly string[],
+  enable: boolean,
+): string[] {
+  if (!enable) return Array.from(args);
+  const alreadyEnabled = args.some(
+    (arg, index) => arg === "--enable" && args[index + 1] === "skills",
+  );
+  if (alreadyEnabled) return Array.from(args);
+  const next = Array.from(args);
+  const modelIndex = next.findIndex((arg) => arg.startsWith(MODEL_FLAG_PREFIX));
+  const insertIndex = modelIndex === -1 ? next.length : modelIndex;
+  next.splice(insertIndex, 0, "--enable", "skills");
+  return next;
+}

package/src/utils/bun-runtime.ts

@@ -0,0 +1,29 @@
+export interface BunReexecInput {
+  hasBunGlobal: boolean;
+  bunExecPath?: string | null;
+  argv: string[];
+  scriptPath: string;
+}
+
+export interface BunReexecCommand {
+  command: string;
+  args: string[];
+}
+
+export function buildBunReexecCommand(
+  input: BunReexecInput,
+): BunReexecCommand | null {
+  if (input.hasBunGlobal) {
+    return null;
+  }
+
+  const scriptPath = input.scriptPath?.trim();
+  if (!scriptPath) {
+    return null;
+  }
+
+  const bunCommand = input.bunExecPath?.trim() || "bun";
+  const args = [scriptPath, ...(input.argv?.slice(2) ?? [])];
+
+  return { command: bunCommand, args };
+}

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,64 @@ 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 };
+    }
+
+    // (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)

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

@@ -13,8 +13,10 @@ import type { OpenCodeSessionInfo, SessionSearchOptions } from "../types.js";
 import {
   collectFilesIterative,
   matchesCwd,
+  resolveBranchFromCwd,
   readSessionInfoFromFile,
 } from "../common.js";
+import { listAllWorktrees } from "../../../worktree.js";
 
 /**
  * Returns the OpenCode session directory
@@ -73,15 +75,50 @@ export async function findLatestOpenCodeSession(
     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 };
   }
 
@@ -98,7 +135,11 @@ export async function findLatestOpenCodeSessionId(
   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)

package/src/utils/session/types.ts

@@ -16,6 +16,10 @@ export interface SessionSearchOptions {
   windowMs?: number;
   /** Working directory filter */
   cwd?: string | null;
+  /** Branch name filter (resolved from session cwd via worktree paths) */
+  branch?: string | null;
+  /** Optional worktree list to avoid shelling out for branch mapping */
+  worktrees?: { path: string; branch: string }[] | null;
 }
 
 /**