@akiojin/gwt 4.1.0 → 4.2.0

package/src/cli/ui/__tests__/components/App.shortcuts.test.tsx

@@ -35,10 +35,10 @@ vi.mock("../../hooks/useScreenState.js", () => ({
   useScreenState: (...args: unknown[]) => useScreenStateMock(...args),
 }));
 
-vi.mock("../../../../worktree.js", async () => {
+vi.mock("../../../../worktree.ts", async () => {
   const actual = await vi.importActual<
-    typeof import("../../../../worktree.js")
-  >("../../../../worktree.js");
+    typeof import("../../../../worktree.ts")
+  >("../../../../worktree.ts");
   return {
     ...actual,
     getMergedPRWorktrees: getMergedPRWorktreesMock,
@@ -48,10 +48,10 @@ vi.mock("../../../../worktree.js", async () => {
   };
 });
 
-vi.mock("../../../../git.js", async () => {
+vi.mock("../../../../git.ts", async () => {
   const actual =
-    await vi.importActual<typeof import("../../../../git.js")>(
-      "../../../../git.js",
+    await vi.importActual<typeof import("../../../../git.ts")>(
+      "../../../../git.ts",
     );
   return {
     ...actual,
@@ -92,7 +92,20 @@ describe("App shortcuts integration", () => {
     goBackMock.mockClear();
     resetMock.mockClear();
     useGitDataMock.mockReturnValue({
-      branches: [],
+      branches: [
+        {
+          name: "feature/add-new-feature",
+          type: "local",
+          branchType: "feature",
+          isCurrent: false,
+        },
+        {
+          name: "hotfix/urgent-fix",
+          type: "local",
+          branchType: "hotfix",
+          isCurrent: false,
+        },
+      ],
       worktrees: [
         {
           branch: "feature/existing",
@@ -197,6 +210,8 @@ describe("App shortcuts integration", () => {
 
   it("displays per-branch cleanup indicators and waits before clearing results", async () => {
     vi.useFakeTimers();
+    const originalNodeEnv = process.env.NODE_ENV;
+    process.env.NODE_ENV = "production";
 
     try {
       const onExit = vi.fn();
@@ -234,8 +249,22 @@ describe("App shortcuts integration", () => {
         throw new Error("BranchListScreen props missing");
       }
 
+      await act(async () => {
+        initialProps.onToggleSelect?.("feature/add-new-feature");
+        initialProps.onToggleSelect?.("hotfix/urgent-fix");
+      });
+
+      await act(async () => {
+        await Promise.resolve();
+      });
+
+      const selectedProps = branchListProps.at(-1);
+      expect(selectedProps?.selectedBranches).toEqual([
+        "feature/add-new-feature",
+        "hotfix/urgent-fix",
+      ]);
       act(() => {
-        initialProps.onCleanupCommand?.();
+        selectedProps?.onCleanupCommand?.();
       });
 
       await act(async () => {
@@ -296,6 +325,7 @@ describe("App shortcuts integration", () => {
         ),
       ).toBe(false);
     } finally {
+      process.env.NODE_ENV = originalNodeEnv;
       vi.useRealTimers();
     }
   });

package/src/cli/ui/__tests__/components/App.test.tsx

@@ -251,6 +251,7 @@ describe("App", () => {
   });
 
   describe("BranchActionSelectorScreen integration", () => {
+    // TODO: replace placeholder assertions with real integration checks.
     it("should show BranchActionSelectorScreen after branch selection", () => {
       useGitDataMock.mockImplementation(() => ({
         branches: mockBranches,
@@ -263,7 +264,7 @@ describe("App", () => {
       const onExit = vi.fn();
       const { container } = render(<App onExit={onExit} />);
 
-      // After implementation, should verify BranchActionSelectorScreen appears
+      // TODO: verify BranchActionSelectorScreen appears
       expect(container).toBeDefined();
     });
 
@@ -279,7 +280,7 @@ describe("App", () => {
       const onExit = vi.fn();
       const { container } = render(<App onExit={onExit} />);
 
-      // After implementation, should verify navigation to AIToolSelectorScreen
+      // TODO: verify navigation to AIToolSelectorScreen
       expect(container).toBeDefined();
     });
 
@@ -295,7 +296,7 @@ describe("App", () => {
       const onExit = vi.fn();
       const { container } = render(<App onExit={onExit} />);
 
-      // After implementation, should verify navigation to BranchCreatorScreen
+      // TODO: verify navigation to BranchCreatorScreen
       expect(container).toBeDefined();
     });
   });

package/src/cli/ui/__tests__/components/ModelSelectorScreen.initial.test.tsx

@@ -54,6 +54,7 @@ describe("ModelSelectorScreen initial selection", () => {
 
     await waitFor(() => expect(selectMocks.length).toBeGreaterThan(0));
     const modelSelect = selectMocks.at(-1);
+    expect(modelSelect).toBeDefined();
     const index = modelSelect.initialIndex as number;
     // codex-cli models: ["", gpt-5.2-codex, gpt-5.1-codex-max, gpt-5.1-codex-mini, gpt-5.2]
     // (index 0 = Default/Auto, index 2 = gpt-5.1-codex-max)

package/src/cli/ui/__tests__/components/common/Select.test.tsx

@@ -12,6 +12,9 @@ interface TestItem {
   value: string;
 }
 
+const delay = (ms = 0): Promise<void> =>
+  new Promise((resolve) => setTimeout(resolve, ms));
+
 describe("Select", () => {
   const mockItems: TestItem[] = [
     { label: "Option 1", value: "opt1" },
@@ -281,4 +284,46 @@ describe("Select", () => {
       expect(onSelect).not.toHaveBeenCalled();
     });
   });
+
+  describe('Space/Escape handlers', () => {
+    it('should call onSpace with the currently highlighted item', async () => {
+      const onSelect = vi.fn();
+      const onSpace = vi.fn();
+      const { stdin } = render(
+        <Select items={mockItems} onSelect={onSelect} onSpace={onSpace} />
+      );
+
+      stdin.write(' ');
+      await delay(10);
+
+      expect(onSpace).toHaveBeenCalledTimes(1);
+      expect(onSpace).toHaveBeenCalledWith(mockItems[0]);
+    });
+
+    it('should not trigger onSpace when disabled', async () => {
+      const onSelect = vi.fn();
+      const onSpace = vi.fn();
+      const { stdin } = render(
+        <Select items={mockItems} onSelect={onSelect} onSpace={onSpace} disabled />
+      );
+
+      stdin.write(' ');
+      await delay(10);
+
+      expect(onSpace).not.toHaveBeenCalled();
+    });
+
+    it('should call onEscape when escape key is pressed', async () => {
+      const onSelect = vi.fn();
+      const onEscape = vi.fn();
+      const { stdin } = render(
+        <Select items={mockItems} onSelect={onSelect} onEscape={onEscape} />
+      );
+
+      stdin.write('\u001B');
+      await delay(30);
+
+      expect(onEscape).toHaveBeenCalledTimes(1);
+    });
+  });
 });

package/src/cli/ui/components/App.tsx

@@ -53,6 +53,7 @@ import {
 import {
   getDefaultInferenceForModel,
   getDefaultModelOption,
+  normalizeModelId,
 } from "../utils/modelOptions.js";
 import {
   resolveContinueSessionId,
@@ -386,10 +387,15 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
               }
             }
 
+            const normalizedModel = normalizeModelId(
+              entry.toolId as AITool,
+              entry.model ?? null,
+            );
+
             return {
               toolId: entry.toolId as AITool,
               toolLabel: entry.toolLabel,
-              model: entry.model ?? null,
+              model: normalizedModel ?? null,
               inferenceLevel: (entry.reasoningLevel ??
                 sessionData?.reasoningLevel ??
                 null) as InferenceLevel | null,
@@ -1069,6 +1075,7 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
       if (selectedBranch && selectedTool) {
         const defaultModel = getDefaultModelOption(selectedTool);
         const resolvedModel = selectedModel?.model ?? defaultModel?.id ?? null;
+        const normalizedModel = normalizeModelId(selectedTool, resolvedModel);
         const resolvedInference =
           selectedModel?.inferenceLevel ??
           getDefaultInferenceForModel(defaultModel ?? undefined);
@@ -1080,7 +1087,7 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
           tool: selectedTool,
           mode: executionMode,
           skipPermissions: skip,
-          ...(resolvedModel !== undefined ? { model: resolvedModel } : {}),
+          ...(normalizedModel !== undefined ? { model: normalizedModel } : {}),
           ...(resolvedInference !== undefined
             ? { inferenceLevel: resolvedInference }
             : {}),
@@ -1122,10 +1129,14 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
 
       setSelectedTool(selected.toolId);
       setPreferredToolId(selected.toolId);
+      const normalizedQuickStartModel = normalizeModelId(
+        selected.toolId as AITool,
+        selected.model ?? null,
+      );
       setSelectedModel(
-        selected.model
+        normalizedQuickStartModel
           ? ({
-              model: selected.model,
+              model: normalizedQuickStartModel,
               inferenceLevel: selected.inferenceLevel ?? undefined,
             } as ModelSelectionResult)
           : null,

package/src/cli/ui/components/common/Select.tsx

@@ -28,6 +28,8 @@ export interface SelectProps<T extends SelectItem = SelectItem> {
   // Optional controlled component props for cursor position
   selectedIndex?: number;
   onSelectedIndexChange?: (index: number) => void;
+  onSpace?: (item: T) => void;
+  onEscape?: () => void;
 }
 
 /**
@@ -47,7 +49,9 @@ function arePropsEqual<T extends SelectItem = SelectItem>(
     prevProps.onSelect !== nextProps.onSelect ||
     prevProps.onSelectedIndexChange !== nextProps.onSelectedIndexChange ||
     prevProps.renderIndicator !== nextProps.renderIndicator ||
-    prevProps.renderItem !== nextProps.renderItem
+    prevProps.renderItem !== nextProps.renderItem ||
+    prevProps.onSpace !== nextProps.onSpace ||
+    prevProps.onEscape !== nextProps.onEscape
   ) {
     return false;
   }
@@ -93,6 +97,8 @@ const SelectComponent = <T extends SelectItem = SelectItem>({
   renderItem,
   selectedIndex: externalSelectedIndex,
   onSelectedIndexChange,
+  onSpace,
+  onEscape,
 }: SelectProps<T>) => {
   // Support both controlled and uncontrolled modes
   const [internalSelectedIndex, setInternalSelectedIndex] =
@@ -177,6 +183,13 @@ const SelectComponent = <T extends SelectItem = SelectItem>({
       if (selectedItem && !disabled) {
         onSelect(selectedItem);
       }
+    } else if (input === ' ' && onSpace) {
+      const selectedItem = items[selectedIndex];
+      if (selectedItem && !disabled) {
+        onSpace(selectedItem);
+      }
+    } else if (key.escape && onEscape) {
+      onEscape();
     }
     // All other keys are ignored and will propagate to parent components
   });

package/src/cli/ui/utils/modelOptions.test.ts

@@ -3,6 +3,7 @@ import {
   getModelOptions,
   getDefaultInferenceForModel,
   getDefaultModelOption,
+  normalizeModelId,
 } from "./modelOptions.js";
 
 const byId = (tool: string) => getModelOptions(tool).map((m) => m.id);
@@ -74,6 +75,17 @@ describe("modelOptions", () => {
     ]);
   });
 
+  it("normalizes known Claude model typos and casing", () => {
+    expect(normalizeModelId("claude-code", "opuss")).toBe("opus");
+    expect(normalizeModelId("claude-code", "Opus")).toBe("opus");
+    expect(normalizeModelId("claude-code", "sonnet")).toBe("sonnet");
+    expect(normalizeModelId("claude-code", null)).toBeNull();
+    expect(normalizeModelId("claude-code", undefined)).toBeNull();
+    expect(normalizeModelId("claude-code", "")).toBeNull();
+    expect(normalizeModelId("claude-code", "  ")).toBeNull();
+    expect(normalizeModelId("claude-code", "  opus  ")).toBe("opus");
+  });
+
   it("returns no models for unsupported tools", () => {
     expect(byId("unknown-tool")).toEqual([]);
   });

package/src/cli/ui/utils/modelOptions.ts

@@ -2,6 +2,7 @@ import type { AITool, InferenceLevel, ModelOption } from "../types.js";
 
 const CODEX_BASE_LEVELS: InferenceLevel[] = ["high", "medium", "low"];
 const CODEX_MAX_LEVELS: InferenceLevel[] = ["xhigh", "high", "medium", "low"];
+const CLAUDE_MODEL_ALIASES = new Set(["opus", "sonnet", "haiku"]);
 
 const MODEL_OPTIONS: Record<string, ModelOption[]> = {
   "claude-code": [
@@ -130,3 +131,21 @@ export function getDefaultInferenceForModel(
   const levels = getInferenceLevelsForModel(model);
   return levels[0];
 }
+
+/**
+ * Normalize a model identifier for consistent display and persistence.
+ */
+export function normalizeModelId(
+  tool: AITool,
+  model?: string | null,
+): string | null {
+  if (model === null || model === undefined) return model ?? null;
+  const trimmed = model.trim();
+  if (!trimmed) return null;
+  if (tool === "claude-code") {
+    const lower = trimmed.toLowerCase();
+    if (lower === "opuss") return "opus";
+    if (CLAUDE_MODEL_ALIASES.has(lower)) return lower;
+  }
+  return trimmed;
+}

package/src/index.ts

@@ -7,6 +7,11 @@ import {
   fetchAllRemotes,
   pullFastForward,
   getBranchDivergenceStatuses,
+  hasUncommittedChanges,
+  hasUnpushedCommits,
+  getUncommittedChangesCount,
+  getUnpushedCommitsCount,
+  pushBranchToRemote,
   GitError,
 } from "./git.js";
 import { launchClaudeCode } from "./claude.js";
@@ -23,10 +28,10 @@ import {
 import chalk from "chalk";
 import type { SelectionResult } from "./cli/ui/components/App.js";
 import {
-  worktreeExists,
   isProtectedBranchName,
   switchToProtectedBranch,
   WorktreeError,
+  resolveWorktreePathForBranch,
 } from "./worktree.js";
 import {
   getTerminalStreams,
@@ -44,16 +49,18 @@ import {
 import { getPackageVersion } from "./utils.js";
 import { findLatestClaudeSessionId } from "./utils/session.js";
 import { resolveContinueSessionId } from "./cli/ui/utils/continueSession.js";
+import { normalizeModelId } from "./cli/ui/utils/modelOptions.js";
 import {
   installDependenciesForWorktree,
   DependencyInstallError,
   type DependencyInstallResult,
 } from "./services/dependency-installer.js";
-import { waitForEnter } from "./utils/prompt.js";
+import { confirmYesNo, waitForEnter } from "./utils/prompt.js";
 
 const ERROR_PROMPT = chalk.yellow(
   "Review the error details, then press Enter to continue.",
 );
+const POST_SESSION_DELAY_MS = 3000;
 
 // Category: cli
 const appLogger = createLogger({ category: "cli" });
@@ -299,9 +306,10 @@ export async function handleAIToolWorkflow(
   } = selectionResult;
 
   const branchLabel = displayName ?? branch;
+  const normalizedModel = normalizeModelId(tool, model ?? null);
   const modelInfo =
-    model || inferenceLevel
-      ? `, model=${model ?? "default"}${inferenceLevel ? `/${inferenceLevel}` : ""}`
+    normalizedModel || inferenceLevel
+      ? `, model=${normalizedModel ?? "default"}${inferenceLevel ? `/${inferenceLevel}` : ""}`
       : "";
   printInfo(
     `Selected: ${branchLabel} with ${tool} (${mode} mode${modelInfo}, skipPermissions: ${skipPermissions})`,
@@ -328,7 +336,16 @@ export async function handleAIToolWorkflow(
       ensureOptions.isNewBranch = !localExists;
     }
 
-    const existingWorktree = await worktreeExists(branch);
+    const existingWorktreeResolution =
+      await resolveWorktreePathForBranch(branch);
+    const existingWorktree = existingWorktreeResolution.path;
+    if (!existingWorktree && existingWorktreeResolution.mismatch) {
+      const actualBranch =
+        existingWorktreeResolution.mismatch.actualBranch ?? "unknown";
+      printWarning(
+        `Worktree mismatch detected: ${existingWorktreeResolution.mismatch.path} is checked out to '${actualBranch}'. Creating or reusing the correct worktree for '${branch}'.`,
+      );
+    }
 
     const isProtectedBranch =
       isProtectedBranchName(branch) ||
@@ -543,7 +560,7 @@ export async function handleAIToolWorkflow(
         lastUsedTool: tool,
         toolLabel: toolConfig.displayName ?? tool,
         mode,
-        model: model ?? null,
+        model: normalizedModel ?? null,
         reasoningLevel: inferenceLevel ?? null,
         skipPermissions: skipPermissions ?? null,
         timestamp: Date.now(),
@@ -602,8 +619,8 @@ export async function handleAIToolWorkflow(
         envOverrides: sharedEnv,
         sessionId: resumeSessionId,
       };
-      if (model) {
-        launchOptions.model = model;
+      if (normalizedModel) {
+        launchOptions.model = normalizedModel;
       }
       launchResult = await launchClaudeCode(worktreePath, launchOptions);
     } else if (tool === "codex-cli") {
@@ -625,8 +642,8 @@ export async function handleAIToolWorkflow(
         envOverrides: sharedEnv,
         sessionId: resumeSessionId,
       };
-      if (model) {
-        launchOptions.model = model;
+      if (normalizedModel) {
+        launchOptions.model = normalizedModel;
       }
       if (inferenceLevel) {
         launchOptions.reasoningEffort = inferenceLevel as CodexReasoningEffort;
@@ -650,8 +667,8 @@ export async function handleAIToolWorkflow(
         envOverrides: sharedEnv,
         sessionId: resumeSessionId,
       };
-      if (model) {
-        launchOptions.model = model;
+      if (normalizedModel) {
+        launchOptions.model = normalizedModel;
       }
       launchResult = await launchGeminiCLI(worktreePath, launchOptions);
     } else {
@@ -738,7 +755,7 @@ export async function handleAIToolWorkflow(
       lastUsedTool: tool,
       toolLabel: toolConfig.displayName ?? tool,
       mode,
-      model: model ?? null,
+      model: normalizedModel ?? null,
       reasoningLevel: inferenceLevel ?? null,
       skipPermissions: skipPermissions ?? null,
       timestamp: Date.now(),
@@ -746,8 +763,47 @@ export async function handleAIToolWorkflow(
       lastSessionId: finalSessionId,
     });
 
+    try {
+      const [hasUncommitted, hasUnpushed] = await Promise.all([
+        hasUncommittedChanges(worktreePath),
+        hasUnpushedCommits(worktreePath, branch),
+      ]);
+
+      if (hasUncommitted) {
+        const uncommittedCount = await getUncommittedChangesCount(worktreePath);
+        const countLabel =
+          uncommittedCount > 0 ? ` (${uncommittedCount}件)` : "";
+        printWarning(`未コミットの変更があります${countLabel}。`);
+      }
+
+      if (hasUnpushed) {
+        const unpushedCount = await getUnpushedCommitsCount(
+          worktreePath,
+          branch,
+        );
+        const countLabel = unpushedCount > 0 ? ` (${unpushedCount}件)` : "";
+        const shouldPush = await confirmYesNo(
+          `未プッシュのコミットがあります${countLabel}。プッシュしますか？`,
+          { defaultValue: false },
+        );
+        if (shouldPush) {
+          printInfo(`Pushing origin/${branch}...`);
+          try {
+            await pushBranchToRemote(worktreePath, branch);
+            printInfo(`Push completed for ${branch}.`);
+          } catch (error) {
+            const details =
+              error instanceof Error ? error.message : String(error);
+            printWarning(`Push failed for ${branch}: ${details}`);
+          }
+        }
+      }
+    } catch (error) {
+      const details = error instanceof Error ? error.message : String(error);
+      printWarning(`Failed to check git status after session: ${details}`);
+    }
     // Small buffer before returning to branch list to avoid abrupt screen swap
-    await new Promise((resolve) => setTimeout(resolve, 3000));
+    await new Promise((resolve) => setTimeout(resolve, POST_SESSION_DELAY_MS));
     printInfo("Session completed successfully. Returning to main menu...");
     return;
   } catch (error) {

package/src/utils/__tests__/prompt.test.ts

@@ -1,5 +1,5 @@
 import { PassThrough } from "node:stream";
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it, vi, beforeEach } from "vitest";
 
 // Shared mock target to avoid hoisting issues
 const terminalStreams: Record<string, unknown> = {};
@@ -16,16 +16,32 @@ const withTimeout = <T>(promise: Promise<T>, ms = 500): Promise<T> =>
     ),
   ]);
 
+const resetTerminalStreams = () => {
+  vi.resetModules();
+  for (const key of Object.keys(terminalStreams)) {
+    delete terminalStreams[key];
+  }
+};
+
+const setupTerminalStreams = (isTTY: boolean) => {
+  const stdin = new PassThrough() as unknown as NodeJS.ReadStream;
+  const stdout = new PassThrough() as unknown as NodeJS.WriteStream;
+  Object.defineProperty(stdin, "isTTY", { value: isTTY, configurable: true });
+  const exitRawMode = vi.fn();
+  Object.assign(terminalStreams, {
+    stdin,
+    stdout,
+    stderr: stdout,
+    usingFallback: false,
+    exitRawMode,
+  });
+  return { stdin, stdout, exitRawMode };
+};
+
 describe("waitForEnter", () => {
   it("uses terminal stdin/stdout and resolves after newline on TTY", async () => {
-    vi.resetModules();
-    for (const key of Object.keys(terminalStreams)) {
-      delete terminalStreams[key];
-    }
-
-    const stdin = new PassThrough() as unknown as NodeJS.ReadStream;
-    const stdout = new PassThrough() as unknown as NodeJS.WriteStream;
-    Object.defineProperty(stdin, "isTTY", { value: true });
+    resetTerminalStreams();
+    const { stdin, exitRawMode } = setupTerminalStreams(true);
 
     let resumed = false;
     let paused = false;
@@ -41,16 +57,6 @@ describe("waitForEnter", () => {
       return originalPause();
     }) as typeof stdin.pause;
 
-    const exitRawMode = vi.fn();
-
-    Object.assign(terminalStreams, {
-      stdin,
-      stdout,
-      stderr: stdout,
-      usingFallback: false,
-      exitRawMode,
-    });
-
     const { waitForEnter } = await import("../prompt.js");
 
     const waiting = withTimeout(waitForEnter("prompt"), 200);
@@ -63,22 +69,8 @@ describe("waitForEnter", () => {
   });
 
   it("returns immediately on non-TTY stdin", async () => {
-    vi.resetModules();
-    for (const key of Object.keys(terminalStreams)) {
-      delete terminalStreams[key];
-    }
-
-    const stdin = new PassThrough() as unknown as NodeJS.ReadStream;
-    const stdout = new PassThrough() as unknown as NodeJS.WriteStream;
-    Object.defineProperty(stdin, "isTTY", { value: false });
-
-    Object.assign(terminalStreams, {
-      stdin,
-      stdout,
-      stderr: stdout,
-      usingFallback: false,
-      exitRawMode: vi.fn(),
-    });
+    resetTerminalStreams();
+    setupTerminalStreams(false);
 
     const { waitForEnter } = await import("../prompt.js");
 
@@ -87,3 +79,48 @@ describe("waitForEnter", () => {
     expect(Date.now() - start).toBeLessThan(50);
   });
 });
+
+describe("confirmYesNo", () => {
+  let stdin: NodeJS.ReadStream;
+  let exitRawMode: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    resetTerminalStreams();
+    const setup = setupTerminalStreams(true);
+    stdin = setup.stdin;
+    exitRawMode = setup.exitRawMode;
+  });
+
+  it("resolves true when user inputs y on TTY", async () => {
+    const { confirmYesNo } = await import("../prompt.js");
+
+    const waiting = withTimeout(confirmYesNo("push?"), 200);
+    stdin.write("y\n");
+
+    await expect(waiting).resolves.toBe(true);
+    expect(exitRawMode).toHaveBeenCalled();
+  });
+
+  it("uses default value when input is empty on TTY", async () => {
+    const { confirmYesNo } = await import("../prompt.js");
+
+    const waiting = withTimeout(
+      confirmYesNo("push?", { defaultValue: true }),
+      200,
+    );
+    stdin.write("\n");
+
+    await expect(waiting).resolves.toBe(true);
+  });
+
+  it("returns default immediately on non-TTY stdin", async () => {
+    Object.defineProperty(stdin, "isTTY", { value: false });
+
+    const { confirmYesNo } = await import("../prompt.js");
+
+    const start = Date.now();
+    const result = await confirmYesNo("push?", { defaultValue: false });
+    expect(result).toBe(false);
+    expect(Date.now() - start).toBeLessThan(50);
+  });
+});