@akiojin/gwt 4.11.6 → 4.12.1

package/src/launcher.ts

@@ -9,7 +9,14 @@ import { execa } from "execa";
 import chalk from "chalk";
 import type { CodingAgent, CodingAgentLaunchOptions } from "./types/tools.js";
 import { createLogger } from "./logging/logger.js";
-import { resolveVersionSuffix } from "./utils/npmRegistry.js";
+import {
+  runAgentWithPty,
+  shouldCaptureAgentOutput,
+} from "./logging/agentOutput.js";
+import {
+  parsePackageCommand,
+  resolveVersionSuffix,
+} from "./utils/npmRegistry.js";
 import { writeTerminalLine } from "./utils/terminal.js";
 
 const logger = createLogger({ category: "launcher" });
@@ -125,14 +132,32 @@ export async function launchCodingAgent(
     ...(options.sharedEnv ?? {}),
     ...(agent.env ?? {}),
   };
+  const workingDir = options.cwd ?? process.cwd();
+  const captureOutput = shouldCaptureAgentOutput(env);
 
   // execa共通オプション（cwdがundefinedの場合は含めない）
   const execaOptions = {
     stdio: "inherit" as const,
-    ...(options.cwd ? { cwd: options.cwd } : {}),
+    ...(workingDir ? { cwd: workingDir } : {}),
     env,
   };
 
+  const runWithCapture = async (command: string, commandArgs: string[]) => {
+    const result = await runAgentWithPty({
+      command,
+      args: commandArgs,
+      cwd: workingDir,
+      env,
+      agentId: agent.id,
+    });
+    if (result.signal !== null && result.signal !== undefined) {
+      throw new Error(`Coding agent terminated by signal ${result.signal}`);
+    }
+    if (result.exitCode !== null && result.exitCode !== 0) {
+      throw new Error(`Coding agent exited with code ${result.exitCode}`);
+    }
+  };
+
   logger.info(
     {
       agentId: agent.id,
@@ -146,7 +171,11 @@ export async function launchCodingAgent(
   switch (agent.type) {
     case "path": {
       // 絶対パスで直接実行
-      await execa(agent.command, args, execaOptions);
+      if (captureOutput) {
+        await runWithCapture(agent.command, args);
+      } else {
+        await execa(agent.command, args, execaOptions);
+      }
       logger.info({ agentId: agent.id }, "Coding agent completed (path)");
       break;
     }
@@ -154,9 +183,12 @@ export async function launchCodingAgent(
     case "bunx": {
       // bunx経由でパッケージ実行
       // バージョン指定がある場合はパッケージ名に付与
-      const selectedVersion = options.version ?? "installed";
-      const versionSuffix = resolveVersionSuffix(options.version);
-      const packageWithVersion = `${agent.command}${versionSuffix}`;
+      const { packageName, version: embeddedVersion } = parsePackageCommand(
+        agent.command,
+      );
+      const selectedVersion = options.version ?? embeddedVersion ?? "latest";
+      const versionSuffix = resolveVersionSuffix(selectedVersion);
+      const packageWithVersion = `${packageName}${versionSuffix}`;
 
       // FR-072: Log version information
       if (selectedVersion === "installed") {
@@ -167,7 +199,12 @@ export async function launchCodingAgent(
       writeTerminalLine(chalk.cyan(`   🔄 Using bunx ${packageWithVersion}`));
 
       // bunx [package@version] [args...]
-      await execa("bunx", [packageWithVersion, ...args], execaOptions);
+      const bunxCommand = captureOutput ? await resolveCommand("bunx") : "bunx";
+      if (captureOutput) {
+        await runWithCapture(bunxCommand, [packageWithVersion, ...args]);
+      } else {
+        await execa("bunx", [packageWithVersion, ...args], execaOptions);
+      }
       logger.info(
         { agentId: agent.id, version: selectedVersion },
         "Coding agent completed (bunx)",
@@ -178,7 +215,11 @@ export async function launchCodingAgent(
     case "command": {
       // PATH解決 → 実行
       const resolvedPath = await resolveCommand(agent.command);
-      await execa(resolvedPath, args, execaOptions);
+      if (captureOutput) {
+        await runWithCapture(resolvedPath, args);
+      } else {
+        await execa(resolvedPath, args, execaOptions);
+      }
       logger.info({ agentId: agent.id }, "Coding agent completed (command)");
       break;
     }

package/src/logging/agentOutput.ts

@@ -0,0 +1,216 @@
+import * as pty from "node-pty";
+import type { IPty } from "node-pty";
+import { createLogger } from "./logger.js";
+import { resolveLogDir } from "./reader.js";
+import { getTerminalStreams } from "../utils/terminal.js";
+
+export const CAPTURE_AGENT_OUTPUT_ENV = "GWT_CAPTURE_AGENT_OUTPUT";
+
+export function shouldCaptureAgentOutput(
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  const raw = env[CAPTURE_AGENT_OUTPUT_ENV];
+  if (raw === undefined) {
+    // Default to false to avoid PTY stdin/stdout conflicts with OpenTUI.
+    // Set GWT_CAPTURE_AGENT_OUTPUT=true to enable agent output logging.
+    return false;
+  }
+  const normalized = String(raw).trim().toLowerCase();
+  if (!normalized) {
+    return false;
+  }
+  return normalized === "true" || normalized === "1";
+}
+
+// eslint-disable-next-line no-control-regex
+const ANSI_PATTERN = new RegExp("\\u001b\\[[0-9;]*[A-Za-z]", "g");
+
+export function stripAnsi(value: string): string {
+  return value.replace(ANSI_PATTERN, "");
+}
+
+export interface AgentOutputLineBuffer {
+  push: (chunk: string) => void;
+  flush: () => void;
+}
+
+export function createAgentOutputLineBuffer(
+  onLine: (line: string) => void,
+): AgentOutputLineBuffer {
+  let buffer = "";
+
+  const push = (chunk: string) => {
+    const normalized = chunk.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    buffer += normalized;
+    while (true) {
+      const index = buffer.indexOf("\n");
+      if (index === -1) {
+        break;
+      }
+      const line = buffer.slice(0, index);
+      buffer = buffer.slice(index + 1);
+      onLine(line);
+    }
+  };
+
+  const flush = () => {
+    if (!buffer) {
+      return;
+    }
+    const line = buffer;
+    buffer = "";
+    onLine(line);
+  };
+
+  return { push, flush };
+}
+
+export interface AgentOutputCaptureOptions {
+  command: string;
+  args: string[];
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  agentId: string;
+}
+
+export interface AgentOutputCaptureResult {
+  exitCode: number | null;
+  signal?: number | null;
+}
+
+const normalizeEnv = (env: NodeJS.ProcessEnv): Record<string, string> =>
+  Object.fromEntries(
+    Object.entries(env).filter(
+      (entry): entry is [string, string] => typeof entry[1] === "string",
+    ),
+  );
+
+const getTerminalSize = (terminal: ReturnType<typeof getTerminalStreams>) => {
+  const stdout = terminal.stdout as
+    | (NodeJS.WriteStream & { columns?: number; rows?: number })
+    | undefined;
+  const cols = stdout?.columns ?? process.stdout.columns ?? 80;
+  const rows = stdout?.rows ?? process.stdout.rows ?? 24;
+  return { cols, rows };
+};
+
+export async function runAgentWithPty(
+  options: AgentOutputCaptureOptions,
+): Promise<AgentOutputCaptureResult> {
+  const terminal = getTerminalStreams();
+  const { cols, rows } = getTerminalSize(terminal);
+  const logDir = resolveLogDir(options.cwd);
+  const stdoutLogger = createLogger({
+    category: "agent.stdout",
+    logDir,
+    base: { agentId: options.agentId },
+  });
+  const stderrLogger = createLogger({
+    category: "agent.stderr",
+    logDir,
+    base: { agentId: options.agentId },
+  });
+
+  const normalizedEnv = normalizeEnv(options.env);
+  const ptyProcess: IPty = pty.spawn(options.command, options.args, {
+    name: process.env.TERM ?? "xterm-256color",
+    cols,
+    rows,
+    cwd: options.cwd,
+    env: normalizedEnv,
+  });
+
+  const lineBuffer = createAgentOutputLineBuffer((line) => {
+    const cleaned = stripAnsi(line).trimEnd();
+    if (!cleaned) {
+      return;
+    }
+    stdoutLogger.info(cleaned);
+  });
+
+  const stdout = terminal.stdout;
+  const writeToTerminal =
+    stdout && typeof stdout.write === "function"
+      ? stdout.write.bind(stdout)
+      : null;
+
+  ptyProcess.onData((data) => {
+    if (writeToTerminal) {
+      try {
+        writeToTerminal(data);
+      } catch {
+        // Ignore terminal write errors.
+      }
+    }
+    lineBuffer.push(data);
+  });
+
+  const stdin = terminal.stdin;
+  const handleInput = (chunk: Buffer | string) => {
+    const data = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    ptyProcess.write(data);
+  };
+
+  const stdinWasRaw =
+    stdin &&
+    typeof (stdin as NodeJS.ReadStream & { isRaw?: boolean }).isRaw ===
+      "boolean"
+      ? (stdin as NodeJS.ReadStream & { isRaw?: boolean }).isRaw
+      : undefined;
+
+  if (stdin && typeof stdin.on === "function") {
+    if (stdin.isTTY && typeof stdin.setRawMode === "function") {
+      try {
+        stdin.setRawMode(true);
+      } catch {
+        // Ignore raw mode errors.
+      }
+    }
+    if (typeof stdin.resume === "function") {
+      stdin.resume();
+    }
+    stdin.on("data", handleInput);
+  }
+
+  const handleResize = () => {
+    const next = getTerminalSize(terminal);
+    try {
+      ptyProcess.resize(next.cols, next.rows);
+    } catch {
+      // Ignore resize errors.
+    }
+  };
+  if (process.stdout && typeof process.stdout.on === "function") {
+    process.stdout.on("resize", handleResize);
+  }
+
+  return await new Promise<AgentOutputCaptureResult>((resolve) => {
+    ptyProcess.onExit(({ exitCode, signal }) => {
+      lineBuffer.flush();
+      if (stdin && typeof stdin.off === "function") {
+        stdin.off("data", handleInput);
+      }
+      if (stdin && typeof stdin.pause === "function") {
+        stdin.pause();
+      }
+      if (stdin && stdin.isTTY && typeof stdin.setRawMode === "function") {
+        try {
+          stdin.setRawMode(Boolean(stdinWasRaw));
+        } catch {
+          // Ignore raw mode restore errors.
+        }
+      }
+      if (process.stdout && typeof process.stdout.off === "function") {
+        process.stdout.off("resize", handleResize);
+      }
+      if (exitCode !== null && exitCode !== 0) {
+        stderrLogger.error(
+          { exitCode, signal },
+          "Agent exited with non-zero code",
+        );
+      }
+      const normalizedSignal = signal ?? null;
+      resolve({ exitCode, signal: normalizedSignal });
+    });
+  });
+}

package/src/logging/formatter.ts

@@ -19,17 +19,36 @@ const LEVEL_LABELS: Record<number, string> = {
   60: "FATAL",
 };
 
+const LOCAL_TIME_FORMATTER = new Intl.DateTimeFormat(undefined, {
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit",
+  hour12: false,
+});
+
+const formatLocalTimeParts = (date: Date): string => {
+  const parts = LOCAL_TIME_FORMATTER.formatToParts(date);
+  const get = (type: Intl.DateTimeFormatPartTypes) =>
+    parts.find((part) => part.type === type)?.value;
+  const hour = get("hour");
+  const minute = get("minute");
+  const second = get("second");
+
+  if (!hour || !minute || !second) {
+    return LOCAL_TIME_FORMATTER.format(date);
+  }
+
+  return `${hour}:${minute}:${second}`;
+};
+
 const formatTimeLabel = (
   value: unknown,
 ): { label: string; timestamp: number | null } => {
   if (typeof value === "string" || typeof value === "number") {
     const date = new Date(value);
     if (!Number.isNaN(date.getTime())) {
-      const hours = String(date.getHours()).padStart(2, "0");
-      const minutes = String(date.getMinutes()).padStart(2, "0");
-      const seconds = String(date.getSeconds()).padStart(2, "0");
       return {
-        label: `${hours}:${minutes}:${seconds}`,
+        label: formatLocalTimeParts(date),
         timestamp: date.getTime(),
       };
     }

package/src/logging/logger.ts

@@ -59,6 +59,7 @@ export function createLogger(config: LoggerConfig = {}): Logger {
     const destinationStream = pino.destination({
       dest: destination,
       sync: true,
+      append: true,
     });
     return pino(options, destinationStream);
   }
@@ -89,6 +90,7 @@ export function createLogger(config: LoggerConfig = {}): Logger {
   const destinationStream = pino.destination({
     dest: destination,
     sync: false,
+    append: true,
   });
   return pino(options, destinationStream);
 }

package/src/logging/reader.ts

@@ -9,6 +9,26 @@ export interface LogFileInfo {
   mtimeMs: number;
 }
 
+export type LogTargetReason =
+  | "worktree"
+  | "worktree-inaccessible"
+  | "current-working-directory"
+  | "working-directory"
+  | "working-directory-fallback"
+  | "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 +36,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`);
 }
@@ -56,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") {
@@ -66,6 +126,69 @@ 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;
+  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 +197,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,
       );