@akiojin/gwt 4.12.0 → 4.12.2

package/src/cli/ui/__tests__/solid/AppSolid.cleanup.test.tsx

@@ -486,6 +486,97 @@ describe("AppSolid unsafe selection confirm", () => {
     }
   });
 
+  it("shows confirm when safety check is pending", async () => {
+    let resolveStatus: ((value: unknown[]) => void) | null = null;
+    const pendingPromise = new Promise<unknown[]>((resolve) => {
+      resolveStatus = resolve;
+    });
+    const getCleanupStatusMock = mock(async () => pendingPromise);
+
+    mock.module?.("../../../../worktree.js", () => ({
+      listAdditionalWorktrees: mock(async () => []),
+      repairWorktrees: mock(async () => ({
+        repairedCount: 0,
+        failedCount: 0,
+        failures: [],
+      })),
+      removeWorktree: mock(async () => {}),
+      getCleanupStatus: getCleanupStatusMock,
+      isProtectedBranchName: mock(() => false),
+    }));
+
+    mock.module?.("../../../../git.js", () => ({
+      getRepositoryRoot: mock(async () => "/repo"),
+      getAllBranches: mock(async () => []),
+      getLocalBranches: mock(async () => []),
+      getCurrentBranch: mock(async () => "main"),
+      deleteBranch: mock(async () => {}),
+    }));
+
+    mock.module?.("../../../../config/index.js", () => ({
+      getConfig: mock(async () => ({ defaultBaseBranch: "main" })),
+      getLastToolUsageMap: mock(async () => new Map()),
+      loadSession: mock(async () => null),
+    }));
+
+    mock.module?.("../../../../config/tools.js", () => ({
+      getAllCodingAgents: mock(async () => [
+        { id: "codex-cli", displayName: "Codex CLI" },
+      ]),
+    }));
+
+    mock.module?.("../../../../config/profiles.js", () => ({
+      loadProfiles: mock(async () => ({ profiles: {}, activeProfile: null })),
+      createProfile: mock(async () => {}),
+      updateProfile: mock(async () => {}),
+      deleteProfile: mock(async () => {}),
+      setActiveProfile: mock(async () => {}),
+    }));
+
+    const { AppSolid } = await import("../../App.solid.js");
+
+    const branch = createBranch({
+      name: "feature/pending",
+      label: "feature/pending",
+      value: "feature/pending",
+    });
+    const stats = makeStats({ localCount: 1, worktreeCount: 1 });
+
+    const testSetup = await testRender(
+      () => (
+        <AppSolid
+          branches={[branch]}
+          stats={stats}
+          version={null}
+          toolStatuses={[]}
+        />
+      ),
+      { width: 80, height: 24 },
+    );
+    await testSetup.renderOnce();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    await testSetup.renderOnce();
+
+    try {
+      await testSetup.mockInput.typeText(" ");
+      await testSetup.renderOnce();
+
+      let frame = testSetup.captureCharFrame();
+      expect(frame).toContain("Safety check in progress. Select anyway?");
+
+      await testSetup.mockInput.typeText("n");
+      await testSetup.renderOnce();
+
+      frame = testSetup.captureCharFrame();
+      expect(frame).toContain("[ ] w");
+      expect(frame).toContain("feature/pending");
+      expect(frame).not.toContain("Safety check in progress. Select anyway?");
+    } finally {
+      resolveStatus?.([]);
+      testSetup.renderer.destroy();
+    }
+  });
+
   it("does not propagate Enter from confirm to branch selection", async () => {
     const getCleanupStatusMock = mock(async () => [
       {

package/src/cli/ui/__tests__/solid/components/WizardController.test.tsx

@@ -0,0 +1,63 @@
+/** @jsxImportSource @opentui/solid */
+import { describe, expect, it, mock } from "bun:test";
+import { testRender } from "@opentui/solid";
+import type { ToolSessionEntry } from "../../../../config/index.js";
+
+mock.module("../../../utils/versionFetcher.js", () => ({
+  fetchInstalledVersionForAgent: mock(async () => null),
+  createInstalledOption: (version: string) => ({
+    label: `installed (${version})`,
+    value: "installed",
+  }),
+  versionInfoToSelectItem: (v: { version: string }) => ({
+    label: v.version,
+    value: v.version,
+  }),
+}));
+
+describe("WizardController", () => {
+  it("keeps version selection visible after agent select", async () => {
+    const history: ToolSessionEntry[] = [];
+
+    const { WizardController } =
+      await import("../../../components/solid/WizardController.js");
+
+    const testSetup = await testRender(
+      () => (
+        <WizardController
+          visible
+          selectedBranchName="feature/test"
+          history={history}
+          onClose={() => {}}
+          onComplete={() => {}}
+          onResume={() => {}}
+          onStartNew={() => {}}
+        />
+      ),
+      { width: 80, height: 24 },
+    );
+    await testSetup.renderOnce();
+
+    try {
+      let frame = testSetup.captureCharFrame();
+      expect(frame).toContain("What would you like to do?");
+
+      // Open existing worktree
+      testSetup.mockInput.pressEnter();
+      await testSetup.renderOnce();
+
+      frame = testSetup.captureCharFrame();
+      expect(frame).toContain("Select coding agent:");
+
+      // Select default agent (Enter)
+      testSetup.mockInput.pressEnter();
+      await testSetup.renderOnce();
+
+      frame = testSetup.captureCharFrame();
+      expect(frame).toContain("Select version:");
+      expect(frame).not.toContain("Select Model:");
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+});

package/src/cli/ui/__tests__/solid/components/WizardSteps.test.tsx

@@ -1,15 +1,24 @@
 /** @jsxImportSource @opentui/solid */
-import { describe, expect, it } from "bun:test";
+import { beforeEach, describe, expect, it } from "bun:test";
 import { testRender } from "@opentui/solid";
 import {
   BranchTypeStep,
   BranchNameStep,
   AgentSelectStep,
+  VersionSelectStep,
   ModelSelectStep,
   ReasoningLevelStep,
   ExecutionModeStep,
   SkipPermissionsStep,
 } from "../../../components/solid/WizardSteps.js";
+import {
+  clearInstalledVersionCache,
+  setInstalledVersionCache,
+} from "../../../utils/installedVersionCache.js";
+import {
+  clearVersionCache,
+  setVersionCache,
+} from "../../../utils/versionCache.js";
 
 // T405: ブランチタイプ選択ステップのテスト
 describe("BranchTypeStep", () => {
@@ -128,6 +137,65 @@ describe("AgentSelectStep", () => {
   });
 });
 
+// T407a: バージョン選択ステップのテスト
+describe("VersionSelectStep", () => {
+  beforeEach(() => {
+    clearInstalledVersionCache();
+    clearVersionCache();
+  });
+
+  it("renders installed option from cache", async () => {
+    setInstalledVersionCache("claude-code", {
+      version: "1.2.3",
+      path: "/usr/local/bin/claude",
+    });
+    setVersionCache("claude-code", []);
+
+    const testSetup = await testRender(
+      () => (
+        <VersionSelectStep
+          agentId="claude-code"
+          onSelect={() => {}}
+          onBack={() => {}}
+        />
+      ),
+      { width: 60, height: 20 },
+    );
+    await testSetup.renderOnce();
+
+    try {
+      const frame = testSetup.captureCharFrame();
+      expect(frame).toContain("Select version");
+      expect(frame).toContain("installed@1.2.3");
+      expect(frame).toContain("latest");
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+
+  it("does not render installed option when cache is empty", async () => {
+    const testSetup = await testRender(
+      () => (
+        <VersionSelectStep
+          agentId="claude-code"
+          onSelect={() => {}}
+          onBack={() => {}}
+        />
+      ),
+      { width: 60, height: 20 },
+    );
+    await testSetup.renderOnce();
+
+    try {
+      const frame = testSetup.captureCharFrame();
+      expect(frame).toContain("latest");
+      expect(frame).not.toContain("installed@");
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+});
+
 // T408: モデル選択ステップのテスト
 describe("ModelSelectStep", () => {
   it("renders model options for Claude Code", async () => {
@@ -150,6 +218,28 @@ describe("ModelSelectStep", () => {
       testSetup.renderer.destroy();
     }
   });
+
+  it("renders model options for OpenCode", async () => {
+    const testSetup = await testRender(
+      () => (
+        <ModelSelectStep
+          agentId="opencode"
+          onSelect={() => {}}
+          onBack={() => {}}
+        />
+      ),
+      { width: 60, height: 20 },
+    );
+    await testSetup.renderOnce();
+
+    try {
+      const frame = testSetup.captureCharFrame();
+      expect(frame).toContain("Default (Auto)");
+      expect(frame).toContain("Custom");
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
 });
 
 // T409: 推論レベル選択ステップ（Codexのみ）のテスト

package/src/cli/ui/components/solid/WizardController.tsx

@@ -1,5 +1,11 @@
 /** @jsxImportSource @opentui/solid */
-import { createSignal, createEffect, createMemo, Show } from "solid-js";
+import {
+  createSignal,
+  createEffect,
+  createMemo,
+  onCleanup,
+  Show,
+} from "solid-js";
 import { useKeyboard } from "@opentui/solid";
 import type { ToolSessionEntry } from "../../../../config/index.js";
 import type { CodingAgentId, InferenceLevel } from "../../types.js";
@@ -13,6 +19,7 @@ import {
   AgentSelectStep,
   VersionSelectStep,
   ModelSelectStep,
+  ModelInputStep,
   ReasoningLevelStep,
   ExecutionModeStep,
   SkipPermissionsStep,
@@ -53,6 +60,7 @@ type WizardStep =
   | "agent-select"
   | "version-select"
   | "model-select"
+  | "model-input"
   | "reasoning-level"
   | "execution-mode"
   | "skip-permissions";
@@ -87,9 +95,11 @@ export function WizardController(props: WizardControllerProps) {
   >(undefined);
   const [executionMode, setExecutionMode] =
     createSignal<ExecutionMode>("normal");
+  const [versionSelectionReady, setVersionSelectionReady] = createSignal(false);
 
   // キー伝播防止: ステップ遷移直後は focused を無効にする
   const [isTransitioning, setIsTransitioning] = createSignal(true);
+  let versionSelectionTimer: ReturnType<typeof setTimeout> | null = null;
 
   // Reset state when wizard becomes visible
   function getInitialStep(): WizardStep {
@@ -168,6 +178,28 @@ export function WizardController(props: WizardControllerProps) {
     startTransition();
   };
 
+  createEffect(() => {
+    const currentStep = step();
+    if (versionSelectionTimer) {
+      clearTimeout(versionSelectionTimer);
+      versionSelectionTimer = null;
+    }
+    if (currentStep === "version-select") {
+      setVersionSelectionReady(false);
+      versionSelectionTimer = setTimeout(() => {
+        setVersionSelectionReady(true);
+      }, 50);
+      return;
+    }
+    setVersionSelectionReady(false);
+  });
+
+  onCleanup(() => {
+    if (versionSelectionTimer) {
+      clearTimeout(versionSelectionTimer);
+    }
+  });
+
   // Determine if reasoning level step is needed
   const needsReasoningLevel = createMemo(() => {
     return selectedAgent() === "codex-cli";
@@ -213,12 +245,20 @@ export function WizardController(props: WizardControllerProps) {
   };
 
   const handleVersionSelect = (version: string) => {
+    if (!versionSelectionReady() || step() !== "version-select") {
+      return;
+    }
     // "installed" を明示的に保存し、未指定時は後方互換で "latest" にフォールバックできるようにする
     setSelectedVersion(version);
     goToStep("model-select");
   };
 
   const handleModelSelect = (model: string) => {
+    const agent = selectedAgent();
+    if (agent === "opencode" && model === "__custom__") {
+      goToStep("model-input");
+      return;
+    }
     setSelectedModel(model);
     if (needsReasoningLevel()) {
       goToStep("reasoning-level");
@@ -227,6 +267,19 @@ export function WizardController(props: WizardControllerProps) {
     }
   };
 
+  const handleModelInputSubmit = (value: string) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return;
+    }
+    setSelectedModel(trimmed);
+    if (needsReasoningLevel()) {
+      goToStep("reasoning-level");
+    } else {
+      goToStep("execution-mode");
+    }
+  };
+
   const handleReasoningLevelSelect = (level: string) => {
     setReasoningLevel(level as InferenceLevel);
     goToStep("execution-mode");
@@ -346,6 +399,17 @@ export function WizardController(props: WizardControllerProps) {
       );
     }
 
+    if (currentStep === "model-input") {
+      return (
+        <ModelInputStep
+          agentId={selectedAgent() ?? "claude-code"}
+          onSubmit={handleModelInputSubmit}
+          onBack={goBack}
+          focused={focused}
+        />
+      );
+    }
+
     if (currentStep === "reasoning-level") {
       return (
         <ReasoningLevelStep

package/src/cli/ui/components/solid/WizardSteps.tsx

@@ -2,7 +2,7 @@
 import { TextAttributes } from "@opentui/core";
 import type { SelectRenderable } from "@opentui/core";
 import { useKeyboard } from "@opentui/solid";
-import { createEffect, createResource, createSignal } from "solid-js";
+import { createEffect, createSignal } from "solid-js";
 import { SelectInput, type SelectInputItem } from "./SelectInput.js";
 import { TextInput } from "./TextInput.js";
 import { getModelOptions } from "../../utils/modelOptions.js";
@@ -12,10 +12,10 @@ import { getAgentTerminalColor } from "../../../../utils/coding-agent-colors.js"
 import { getVersionCache } from "../../utils/versionCache.js";
 import { selectionStyle } from "../../core/theme.js";
 import {
-  fetchInstalledVersionForAgent,
   versionInfoToSelectItem,
   createInstalledOption,
 } from "../../utils/versionFetcher.js";
+import { getInstalledVersionCache } from "../../utils/installedVersionCache.js";
 
 /**
  * WizardSteps - ウィザードの各ステップコンポーネント
@@ -441,6 +441,54 @@ export function ModelSelectStep(props: ModelSelectStepProps) {
   );
 }
 
+// T408b: カスタムモデル入力ステップ
+export interface ModelInputStepProps extends StepProps {
+  agentId: CodingAgentId;
+  onSubmit: (value: string) => void;
+}
+
+export function ModelInputStep(props: ModelInputStepProps) {
+  const [value, setValue] = createSignal("");
+  const scroll = useWizardScroll();
+  const placeholder = props.agentId === "opencode" ? "provider/model" : "model";
+
+  createEffect(() => {
+    if (props.focused === false) {
+      return;
+    }
+    if (!scroll) {
+      return;
+    }
+    scroll.ensureLineVisible(2);
+  });
+
+  const handleSubmit = (next: string) => {
+    const trimmed = next.trim();
+    if (!trimmed) {
+      return;
+    }
+    props.onSubmit(trimmed);
+  };
+
+  return (
+    <box flexDirection="column">
+      <text fg="cyan" attributes={TextAttributes.BOLD}>
+        Enter custom model:
+      </text>
+      <text> </text>
+      <TextInput
+        value={value()}
+        onChange={setValue}
+        onSubmit={handleSubmit}
+        placeholder={placeholder}
+        focused={props.focused ?? true}
+      />
+      <text> </text>
+      <text attributes={TextAttributes.DIM}>[Enter] Submit [Esc] Back</text>
+    </box>
+  );
+}
+
 // T409: 推論レベル選択ステップ（Codexのみ）
 export interface ReasoningLevelStepProps extends StepProps {
   onSelect: (level: string) => void;
@@ -642,14 +690,11 @@ export function VersionSelectStep(props: VersionSelectStepProps) {
     return cached.map(versionInfoToSelectItem);
   };
 
-  // インストール済み情報を取得 (still needs async fetch for local command check)
-  const [installedOption] = createResource(
-    () => props.agentId,
-    async (agentId: string) => {
-      const installed = await fetchInstalledVersionForAgent(agentId);
-      return installed ? createInstalledOption(installed) : null;
-    },
-  );
+  // インストール済み情報は起動時にキャッシュ済み（FR-017）
+  const installedOption = () => {
+    const installed = getInstalledVersionCache(props.agentId);
+    return installed ? createInstalledOption(installed) : null;
+  };
 
   // 全オプション（installed + latest + cached versions）
   const allOptions = (): SelectInputItem[] => {

package/src/cli/ui/utils/__tests__/installedVersionCache.test.ts

@@ -0,0 +1,46 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import {
+  clearInstalledVersionCache,
+  getInstalledVersionCache,
+  prefetchInstalledVersions,
+  setInstalledVersionCache,
+} from "../installedVersionCache.js";
+
+describe("installedVersionCache", () => {
+  beforeEach(() => {
+    clearInstalledVersionCache();
+  });
+
+  it("stores and retrieves installed versions", () => {
+    setInstalledVersionCache("claude-code", {
+      version: "1.0.0",
+      path: "/usr/local/bin/claude",
+    });
+
+    const cached = getInstalledVersionCache("claude-code");
+    expect(cached).toEqual({
+      version: "1.0.0",
+      path: "/usr/local/bin/claude",
+    });
+  });
+
+  it("prefetches installed versions with custom fetcher", async () => {
+    await prefetchInstalledVersions(["claude-code", "codex-cli"], async (id) =>
+      id === "claude-code" ? { version: "2.0.0", path: "/opt/claude" } : null,
+    );
+
+    expect(getInstalledVersionCache("claude-code")).toEqual({
+      version: "2.0.0",
+      path: "/opt/claude",
+    });
+    expect(getInstalledVersionCache("codex-cli")).toBeNull();
+  });
+
+  it("stores null when fetcher throws", async () => {
+    await prefetchInstalledVersions(["gemini-cli"], async () => {
+      throw new Error("boom");
+    });
+
+    expect(getInstalledVersionCache("gemini-cli")).toBeNull();
+  });
+});

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

@@ -0,0 +1,84 @@
+/**
+ * Installed version cache for coding agents (FR-017)
+ *
+ * Caches locally installed agent versions detected at startup
+ * to avoid async fetch during wizard navigation.
+ */
+
+import type { InstalledVersionInfo } from "./versionFetcher.js";
+import { fetchInstalledVersionForAgent } from "./versionFetcher.js";
+
+/**
+ * In-memory cache for installed versions
+ * Maps agentId -> InstalledVersionInfo | null
+ */
+const installedVersionCache = new Map<string, InstalledVersionInfo | null>();
+
+/**
+ * Type for installed version fetch function (injectable for testing)
+ */
+export type InstalledVersionFetcher = (
+  agentId: string,
+) => Promise<InstalledVersionInfo | null>;
+
+/**
+ * Get cached installed version for an agent
+ * @returns Cached info or null if not installed/unknown
+ */
+export function getInstalledVersionCache(
+  agentId: string,
+): InstalledVersionInfo | null {
+  const cached = installedVersionCache.get(agentId);
+  return cached ?? null;
+}
+
+/**
+ * Set installed version cache (for testing or direct population)
+ */
+export function setInstalledVersionCache(
+  agentId: string,
+  installed: InstalledVersionInfo | null,
+): void {
+  installedVersionCache.set(agentId, installed);
+}
+
+/**
+ * Clear installed version cache
+ */
+export function clearInstalledVersionCache(): void {
+  installedVersionCache.clear();
+}
+
+/**
+ * Prefetch installed versions for multiple agents in parallel
+ * This should be called at application startup
+ *
+ * @param agentIds - List of agent IDs to prefetch
+ * @param fetchFn - Optional custom fetch function (for testing)
+ */
+export async function prefetchInstalledVersions(
+  agentIds: string[],
+  fetchFn?: InstalledVersionFetcher,
+): Promise<void> {
+  const fetcher =
+    fetchFn ??
+    (async (agentId: string) => fetchInstalledVersionForAgent(agentId));
+
+  const results = await Promise.allSettled(
+    agentIds.map(async (agentId) => {
+      try {
+        const installed = await fetcher(agentId);
+        setInstalledVersionCache(agentId, installed);
+      } catch {
+        setInstalledVersionCache(agentId, null);
+      }
+    }),
+  );
+
+  // Swallow any rejections to keep startup non-blocking
+  for (const result of results) {
+    if (result.status === "rejected") {
+      // no-op
+    }
+  }
+}

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

@@ -75,6 +75,12 @@ describe("modelOptions", () => {
     ]);
   });
 
+  it("includes OpenCode default and custom options", () => {
+    expect(byId("opencode")).toEqual(["", "__custom__"]);
+    const defaultModel = getDefaultModelOption("opencode");
+    expect(defaultModel?.id).toBe("");
+  });
+
   it("normalizes known Claude model typos and casing", () => {
     expect(normalizeModelId("claude-code", "opuss")).toBe("opus");
     expect(normalizeModelId("claude-code", "Opus")).toBe("opus");

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

@@ -103,6 +103,19 @@ const MODEL_OPTIONS: Record<string, ModelOption[]> = {
       description: "Fastest for simple tasks",
     },
   ],
+  opencode: [
+    {
+      id: "",
+      label: "Default (Auto)",
+      description: "Use OpenCode default model",
+      isDefault: true,
+    },
+    {
+      id: "__custom__",
+      label: "Custom (provider/model)",
+      description: "Enter a provider/model identifier",
+    },
+  ],
 };
 
 export function getModelOptions(tool: CodingAgentId): ModelOption[] {
@@ -144,6 +157,9 @@ export function normalizeModelId(
   if (model === null || model === undefined) return model ?? null;
   const trimmed = model.trim();
   if (!trimmed) return null;
+  if (tool === "opencode" && trimmed === "__custom__") {
+    return null;
+  }
   if (tool === "claude-code") {
     const lower = trimmed.toLowerCase();
     if (lower === "opuss") return "opus";