@akiojin/gwt 4.12.0 → 4.12.1

package/src/codex.ts

@@ -17,8 +17,14 @@ import {
   runAgentWithPty,
   shouldCaptureAgentOutput,
 } from "./logging/agentOutput.js";
+import { createLogger } from "./logging/logger.js";
+import {
+  shouldEnableCodexSkillsFlag,
+  withCodexSkillsFlag,
+} from "./shared/codingAgentConstants.js";
 
 const CODEX_CLI_PACKAGE = "@openai/codex";
+const logger = createLogger({ category: "codex" });
 
 /**
  * Reasoning effort levels supported by Codex CLI.
@@ -47,8 +53,6 @@ export const buildDefaultCodexArgs = (
 ): string[] => [
   "--enable",
   "web_search_request",
-  "--enable",
-  "skills",
   `--model=${model}`,
   "--sandbox",
   "workspace-write",
@@ -171,7 +175,18 @@ export async function launchCodexCLI(
       args.push(...options.extraArgs);
     }
 
-    const codexArgs = buildDefaultCodexArgs(model, reasoningEffort);
+    const requestedVersion = options.version ?? "latest";
+    const codexLookup = await findCommand("codex");
+    const skillsFlagVersion =
+      requestedVersion === "installed"
+        ? (codexLookup.version ?? null)
+        : requestedVersion === "latest"
+          ? null
+          : requestedVersion;
+    const codexArgs = withCodexSkillsFlag(
+      buildDefaultCodexArgs(model, reasoningEffort),
+      shouldEnableCodexSkillsFlag(skillsFlagVersion),
+    );
 
     args.push(...codexArgs);
 
@@ -191,26 +206,34 @@ export async function launchCodexCLI(
     const captureOutput = shouldCaptureAgentOutput(env);
     const childStdio = captureOutput ? null : createChildStdio();
 
-    // Auto-detect locally installed codex command
-    const codexLookup = await findCommand("codex");
+    // codexLookup is used to decide local vs bunx execution
 
     const execChild = async (child: Promise<unknown>) => {
       try {
-        await child;
+        const result = (await child) as {
+          exitCode?: number | null;
+          signal?: string | null;
+        };
+        return {
+          exitCode: result.exitCode ?? 0,
+          signal: result.signal ?? null,
+        };
       } catch (execError: unknown) {
         // Treat SIGINT/SIGTERM as normal exit (user pressed Ctrl+C)
         const signal = (execError as { signal?: unknown })?.signal;
+        const exitCode =
+          (execError as { exitCode?: number | null })?.exitCode ?? null;
         if (signal === "SIGINT" || signal === "SIGTERM") {
-          return;
+          return { exitCode, signal };
         }
         throw execError;
       }
     };
-    // Treat SIGHUP (1), SIGINT (2), SIGTERM (15) as normal exit signals
-    // SIGHUP can occur when the PTY closes, SIGINT/SIGTERM are user interrupts
+    // Treat SIGINT (2), SIGTERM (15) as normal exit signals (user interrupts)
     const isNormalExitSignal = (signal?: number | null) =>
-      signal === 1 || signal === 2 || signal === 15;
+      signal === 2 || signal === 15;
     const runCommand = async (command: string, commandArgs: string[]) => {
+      const runStartedAt = Date.now();
       if (captureOutput) {
         const result = await runAgentWithPty({
           command,
@@ -219,12 +242,27 @@ export async function launchCodexCLI(
           env,
           agentId: "codex-cli",
         });
-        if (isNormalExitSignal(result.signal)) {
+        const durationMs = Date.now() - runStartedAt;
+        const exitCode = result.exitCode ?? null;
+        const signal = result.signal ?? null;
+        const signalIsNormal = isNormalExitSignal(signal);
+        const hasError =
+          (!signalIsNormal && signal !== null && signal !== undefined) ||
+          (exitCode !== null && exitCode !== 0);
+        if (hasError) {
+          logger.error({ exitCode, signal, durationMs }, "Codex CLI exited");
+        } else {
+          logger.info({ exitCode, signal, durationMs }, "Codex CLI exited");
+        }
+        if (signalIsNormal) {
           return;
         }
-        if (result.exitCode !== null && result.exitCode !== 0) {
+        if (signal !== null && signal !== undefined) {
+          throw new Error(`Codex CLI terminated by signal ${signal}`);
+        }
+        if (exitCode !== null && exitCode !== 0) {
           throw new Error(
-            `Codex CLI exited with code ${result.exitCode ?? "unknown"}`,
+            `Codex CLI exited with code ${exitCode ?? "unknown"}`,
           );
         }
         return;
@@ -234,19 +272,37 @@ export async function launchCodexCLI(
         return;
       }
 
-      const child = execa(command, commandArgs, {
-        cwd: worktreePath,
-        stdin: childStdio.stdin,
-        stdout: childStdio.stdout,
-        stderr: childStdio.stderr,
-        env,
-      });
-      await execChild(child);
+      try {
+        const child = execa(command, commandArgs, {
+          cwd: worktreePath,
+          stdin: childStdio.stdin,
+          stdout: childStdio.stdout,
+          stderr: childStdio.stderr,
+          env,
+        });
+        const result = await execChild(child);
+        const durationMs = Date.now() - runStartedAt;
+        logger.info(
+          {
+            exitCode: result.exitCode ?? null,
+            signal: result.signal,
+            durationMs,
+          },
+          "Codex CLI exited",
+        );
+      } catch (execError: unknown) {
+        const durationMs = Date.now() - runStartedAt;
+        const exitCode =
+          (execError as { exitCode?: number | null })?.exitCode ?? null;
+        const signal =
+          (execError as { signal?: string | null })?.signal ?? null;
+        logger.error({ exitCode, signal, durationMs }, "Codex CLI failed");
+        throw execError;
+      }
     };
 
     // Determine execution strategy based on version selection
     // FR-063b: "installed" option only appears when local command exists
-    const requestedVersion = options.version ?? "latest";
     let selectedVersion = requestedVersion;
 
     if (requestedVersion === "installed" && !codexLookup.path) {

package/src/index.ts

@@ -727,6 +727,9 @@ export async function handleAIToolWorkflow(
             cwd: worktreePath,
             sharedEnv,
           };
+        if (tool === "opencode" && normalizedModel) {
+          customLaunchOptions.extraArgs = ["-m", normalizedModel];
+        }
         if (toolVersion) {
           customLaunchOptions.version = toolVersion;
         }

package/src/logging/reader.ts

@@ -14,6 +14,7 @@ export type LogTargetReason =
   | "worktree-inaccessible"
   | "current-working-directory"
   | "working-directory"
+  | "working-directory-fallback"
   | "no-worktree";
 
 export interface LogTargetBranch {
@@ -115,7 +116,7 @@ export async function listLogFiles(logDir: string): Promise<LogFileInfo[]> {
       }
     }
 
-    return files.sort((a, b) => b.date.localeCompare(a.date));
+    return files.sort((a, b) => b.mtimeMs - a.mtimeMs);
   } catch (error) {
     const err = error as NodeJS.ErrnoException;
     if (err.code === "ENOENT") {
@@ -125,6 +126,52 @@ export async function listLogFiles(logDir: string): Promise<LogFileInfo[]> {
   }
 }
 
+const getLatestLogMtimeWithContent = async (
+  logDir: string,
+): Promise<number | null> => {
+  const files = await listLogFiles(logDir);
+  for (const file of files) {
+    const lines = await readLogFileLines(file.path);
+    if (lines.length > 0) {
+      return file.mtimeMs;
+    }
+  }
+  return null;
+};
+
+export async function selectLogTargetByRecency(
+  primary: LogTargetResolution,
+  fallback: LogTargetResolution,
+): Promise<LogTargetResolution> {
+  if (!primary.logDir || !primary.sourcePath) {
+    return primary;
+  }
+  if (!fallback.logDir || !fallback.sourcePath) {
+    return primary;
+  }
+  if (primary.logDir === fallback.logDir) {
+    return primary;
+  }
+  if (primary.reason !== "worktree") {
+    return primary;
+  }
+
+  const [primaryMtime, fallbackMtime] = await Promise.all([
+    getLatestLogMtimeWithContent(primary.logDir),
+    getLatestLogMtimeWithContent(fallback.logDir),
+  ]);
+
+  if (
+    fallbackMtime !== null &&
+    (primaryMtime === null || fallbackMtime > primaryMtime)
+  ) {
+    return {
+      ...fallback,
+      reason: "working-directory-fallback",
+    };
+  }
+  return primary;
+}
 export async function clearLogFiles(logDir: string): Promise<number> {
   const files = await listLogFiles(logDir);
   let cleared = 0;

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/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/parsers/codex.ts

@@ -119,7 +119,6 @@ export async function findLatestCodexSession(
       return { id: sessionId, mtime: file.mtime };
     }
 
-    // Priority 2: Fallback to reading file content if filename lacks UUID
     // (already handled via info above)
   }