@akiojin/gwt 4.11.6 → 4.12.1

package/dist/opentui/index.solid.js

@@ -28,6 +28,164 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/utils/npmRegistry.ts
+function isPrerelease(version) {
+  return /-(alpha|beta|rc|canary|next|dev|pre)\b/i.test(version);
+}
+async function fetchPackageVersions(packageName, limit = DEFAULT_LIMIT, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  try {
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}`, {
+      signal: controller.signal,
+      headers: {
+        Accept: "application/json"
+      }
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      return [];
+    }
+    const data = await response.json();
+    if (!data.versions || !data.time) {
+      return [];
+    }
+    const versionsWithTime = [];
+    for (const version of Object.keys(data.versions)) {
+      const publishedAt = data.time[version];
+      if (publishedAt) {
+        versionsWithTime.push({ version, publishedAt });
+      }
+    }
+    versionsWithTime.sort((a, b) => {
+      const dateA = new Date(a.publishedAt).getTime();
+      const dateB = new Date(b.publishedAt).getTime();
+      return dateB - dateA;
+    });
+    const topVersions = versionsWithTime.slice(0, limit);
+    return topVersions.map((v) => ({
+      version: v.version,
+      isPrerelease: isPrerelease(v.version),
+      publishedAt: v.publishedAt
+    }));
+  } catch {
+    return [];
+  }
+}
+function parsePackageCommand(command) {
+  if (command.startsWith("@")) {
+    const firstSlash = command.indexOf("/");
+    if (firstSlash === -1) {
+      return { packageName: command, version: null };
+    }
+    const afterScope = command.substring(firstSlash + 1);
+    const atIndex2 = afterScope.indexOf("@");
+    if (atIndex2 === -1) {
+      return { packageName: command, version: null };
+    }
+    const packageName2 = command.substring(0, firstSlash + 1 + atIndex2);
+    const version2 = afterScope.substring(atIndex2 + 1);
+    return { packageName: packageName2, version: version2 };
+  }
+  const atIndex = command.indexOf("@");
+  if (atIndex === -1) {
+    return { packageName: command, version: null };
+  }
+  const packageName = command.substring(0, atIndex);
+  const version = command.substring(atIndex + 1);
+  return { packageName, version };
+}
+var DEFAULT_TIMEOUT_MS = 3000, DEFAULT_LIMIT = 10;
+
+// src/shared/codingAgentConstants.ts
+var CLAUDE_PERMISSION_SKIP_ARGS, CODEX_DEFAULT_ARGS;
+var init_codingAgentConstants = __esm(() => {
+  CLAUDE_PERMISSION_SKIP_ARGS = [
+    "--dangerously-skip-permissions"
+  ];
+  CODEX_DEFAULT_ARGS = [
+    "--enable",
+    "web_search_request",
+    "--model=gpt-5.2-codex",
+    "--sandbox",
+    "workspace-write",
+    "-c",
+    "model_reasoning_effort=high",
+    "-c",
+    "model_reasoning_summaries=detailed",
+    "-c",
+    "sandbox_workspace_write.network_access=true",
+    "-c",
+    "shell_environment_policy.inherit=all",
+    "-c",
+    "shell_environment_policy.ignore_default_excludes=true",
+    "-c",
+    "shell_environment_policy.experimental_use_profile=true"
+  ];
+});
+
+// src/config/builtin-coding-agents.ts
+var CLAUDE_CODE_TOOL, CODEX_CLI_TOOL, GEMINI_CLI_TOOL, OPENCODE_TOOL, BUILTIN_CODING_AGENTS;
+var init_builtin_coding_agents = __esm(() => {
+  init_codingAgentConstants();
+  CLAUDE_CODE_TOOL = {
+    id: "claude-code",
+    displayName: "Claude Code",
+    type: "bunx",
+    command: "@anthropic-ai/claude-code",
+    modeArgs: {
+      normal: [],
+      continue: ["-c"],
+      resume: ["-r"]
+    },
+    permissionSkipArgs: Array.from(CLAUDE_PERMISSION_SKIP_ARGS),
+    env: {
+      ENABLE_LSP_TOOL: "true"
+    }
+  };
+  CODEX_CLI_TOOL = {
+    id: "codex-cli",
+    displayName: "Codex",
+    type: "bunx",
+    command: "@openai/codex",
+    defaultArgs: Array.from(CODEX_DEFAULT_ARGS),
+    modeArgs: {
+      normal: [],
+      continue: ["resume", "--last"],
+      resume: ["resume"]
+    }
+  };
+  GEMINI_CLI_TOOL = {
+    id: "gemini-cli",
+    displayName: "Gemini",
+    type: "bunx",
+    command: "@google/gemini-cli",
+    modeArgs: {
+      normal: [],
+      continue: ["-r", "latest"],
+      resume: ["-r", "latest"]
+    },
+    permissionSkipArgs: ["-y"]
+  };
+  OPENCODE_TOOL = {
+    id: "opencode",
+    displayName: "OpenCode",
+    type: "bunx",
+    command: "opencode-ai",
+    modeArgs: {
+      normal: [],
+      continue: ["-c"],
+      resume: ["-s"]
+    }
+  };
+  BUILTIN_CODING_AGENTS = [
+    CLAUDE_CODE_TOOL,
+    CODEX_CLI_TOOL,
+    GEMINI_CLI_TOOL,
+    OPENCODE_TOOL
+  ];
+});
+
 // node_modules/is-plain-obj/index.js
 function isPlainObject(value) {
   if (typeof value !== "object" || value === null) {
@@ -3129,12 +3287,12 @@ var init_exports = __esm(() => {
 });
 
 // node_modules/get-stream/source/index.js
-import { on } from "events";
+import { on as on2 } from "events";
 import { finished } from "stream/promises";
 var init_source = __esm(() => {
   init_stream();
   init_exports();
-  Object.assign(nodeImports, { on, finished });
+  Object.assign(nodeImports, { on: on2, finished });
 });
 
 // node_modules/execa/lib/io/max-buffer.js
@@ -5044,7 +5202,7 @@ var init_main_sync = __esm(() => {
 });
 
 // node_modules/execa/lib/ipc/get-one.js
-import { once as once5, on as on2 } from "events";
+import { once as once5, on as on3 } from "events";
 var getOneMessage = ({ anyProcess, channel, isSubprocess, ipc }, { reference = true, filter } = {}) => {
   validateIpcMethod({
     methodName: "getOneMessage",
@@ -5081,7 +5239,7 @@ var getOneMessage = ({ anyProcess, channel, isSubprocess, ipc }, { reference = t
     const [message] = await once5(ipcEmitter, "message", { signal });
     return message;
   }
-  for await (const [message] of on2(ipcEmitter, "message", { signal })) {
+  for await (const [message] of on3(ipcEmitter, "message", { signal })) {
     if (filter(message)) {
       return message;
     }
@@ -5099,7 +5257,7 @@ var init_get_one = __esm(() => {
 });
 
 // node_modules/execa/lib/ipc/get-each.js
-import { once as once6, on as on3 } from "events";
+import { once as once6, on as on4 } from "events";
 var getEachMessage = ({ anyProcess, channel, isSubprocess, ipc }, { reference = true } = {}) => loopOnMessages({
   anyProcess,
   channel,
@@ -5148,7 +5306,7 @@ var getEachMessage = ({ anyProcess, channel, isSubprocess, ipc }, { reference =
   } catch {}
 }, iterateOnMessages = async function* ({ anyProcess, channel, ipcEmitter, isSubprocess, shouldAwait, controller, state, reference }) {
   try {
-    for await (const [message] of on3(ipcEmitter, "message", { signal: controller.signal })) {
+    for await (const [message] of on4(ipcEmitter, "message", { signal: controller.signal })) {
       throwIfStrictError(state);
       yield message;
     }
@@ -5316,7 +5474,7 @@ var init_handle_async = __esm(() => {
 });
 
 // node_modules/@sindresorhus/merge-streams/index.js
-import { on as on4, once as once7 } from "events";
+import { on as on5, once as once7 } from "events";
 import { PassThrough as PassThroughStream, getDefaultHighWaterMark as getDefaultHighWaterMark2 } from "stream";
 import { finished as finished2 } from "stream/promises";
 function mergeStreams(streams) {
@@ -5364,7 +5522,7 @@ var getHighWaterMark = (streams, objectMode) => {
     throw error;
   }
 }, onInputStreamsUnpipe = async (passThroughStream, streams, unpipeEvent, { signal }) => {
-  for await (const [unpipedStream] of on4(passThroughStream, "unpipe", { signal })) {
+  for await (const [unpipedStream] of on5(passThroughStream, "unpipe", { signal })) {
     if (streams.has(unpipedStream)) {
       unpipedStream.emit(unpipeEvent);
     }
@@ -6087,7 +6245,7 @@ var init_setup = __esm(() => {
 });
 
 // node_modules/execa/lib/io/iterate.js
-import { on as on5 } from "events";
+import { on as on6 } from "events";
 import { getDefaultHighWaterMark as getDefaultHighWaterMark3 } from "stream";
 var iterateOnSubprocessStream = ({ subprocessStdout, subprocess, binary, shouldEncode, encoding, preserveNewlines }) => {
   const controller = new AbortController;
@@ -6129,7 +6287,7 @@ var iterateOnSubprocessStream = ({ subprocessStdout, subprocess, binary, shouldE
     controller.abort();
   }
 }, iterateOnStream = ({ stream, controller, binary, shouldEncode, encoding, shouldSplit, preserveNewlines }) => {
-  const onStdoutChunk = on5(stream, "data", {
+  const onStdoutChunk = on6(stream, "data", {
     signal: controller.signal,
     highWaterMark: HIGH_WATER_MARK,
     highWatermark: HIGH_WATER_MARK
@@ -7209,6 +7367,182 @@ var init_execa = __esm(() => {
   } = getIpcExport());
 });
 
+// src/utils/command.ts
+import { existsSync as existsSync3 } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+async function getCommandVersion(commandPath) {
+  try {
+    const result = await execa(commandPath, ["--version"], {
+      timeout: 3000,
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "ignore"
+    });
+    const match = result.stdout.match(/(\d+\.\d+(?:\.\d+)?(?:-[\w.]+)?)/);
+    return match ? `v${match[1]}` : null;
+  } catch {
+    return null;
+  }
+}
+async function findCommand(commandName) {
+  const cached = commandLookupCache.get(commandName);
+  if (cached) {
+    return cached;
+  }
+  let lookupResult = null;
+  try {
+    const lookupCommand = process.platform === "win32" ? "where" : "which";
+    const execResult = await execa(lookupCommand, [commandName], {
+      shell: true,
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "ignore"
+    });
+    const foundPath = execResult.stdout.trim().split(`
+`)[0];
+    if (foundPath) {
+      lookupResult = { available: true, path: foundPath, source: "installed" };
+    }
+  } catch {}
+  if (!lookupResult) {
+    const knownPaths = KNOWN_INSTALL_PATHS[commandName];
+    if (knownPaths) {
+      const pathsToCheck = process.platform === "win32" ? knownPaths.win32 : knownPaths.unix;
+      for (const p of pathsToCheck) {
+        if (p && existsSync3(p)) {
+          lookupResult = { available: true, path: p, source: "installed" };
+          break;
+        }
+      }
+    }
+  }
+  if (!lookupResult) {
+    lookupResult = { available: true, path: null, source: "bunx" };
+  }
+  if (lookupResult.source === "installed" && lookupResult.path) {
+    lookupResult.version = await getCommandVersion(lookupResult.path);
+  } else {
+    lookupResult.version = null;
+  }
+  commandLookupCache.set(commandName, lookupResult);
+  return lookupResult;
+}
+var KNOWN_INSTALL_PATHS, commandLookupCache;
+var init_command3 = __esm(() => {
+  init_execa();
+  KNOWN_INSTALL_PATHS = {
+    claude: {
+      unix: [
+        join2(homedir(), ".bun", "bin", "claude"),
+        join2(homedir(), ".local", "bin", "claude"),
+        "/usr/local/bin/claude"
+      ],
+      win32: [
+        join2(process.env.LOCALAPPDATA ?? "", "Programs", "claude", "claude.exe"),
+        join2(homedir(), ".bun", "bin", "claude.exe")
+      ]
+    },
+    codex: {
+      unix: [
+        join2(homedir(), ".bun", "bin", "codex"),
+        join2(homedir(), ".local", "bin", "codex"),
+        "/usr/local/bin/codex"
+      ],
+      win32: [join2(homedir(), ".bun", "bin", "codex.exe")]
+    },
+    gemini: {
+      unix: [
+        join2(homedir(), ".bun", "bin", "gemini"),
+        join2(homedir(), ".local", "bin", "gemini"),
+        "/usr/local/bin/gemini"
+      ],
+      win32: [join2(homedir(), ".bun", "bin", "gemini.exe")]
+    },
+    opencode: {
+      unix: [
+        join2(homedir(), ".bun", "bin", "opencode"),
+        join2(homedir(), ".local", "bin", "opencode"),
+        "/usr/local/bin/opencode"
+      ],
+      win32: [join2(homedir(), ".bun", "bin", "opencode.exe")]
+    }
+  };
+  commandLookupCache = new Map;
+});
+
+// src/cli/ui/utils/versionFetcher.ts
+var exports_versionFetcher = {};
+__export(exports_versionFetcher, {
+  versionInfoToSelectItem: () => versionInfoToSelectItem,
+  getPackageNameForAgent: () => getPackageNameForAgent,
+  getBunxAgentIds: () => getBunxAgentIds,
+  fetchVersionOptionsForAgent: () => fetchVersionOptionsForAgent,
+  fetchInstalledVersionForAgent: () => fetchInstalledVersionForAgent,
+  createInstalledOption: () => createInstalledOption
+});
+function getPackageNameForAgent(agentId) {
+  const agent = BUILTIN_CODING_AGENTS.find((a2) => a2.id === agentId);
+  if (!agent || agent.type !== "bunx") {
+    return null;
+  }
+  const { packageName } = parsePackageCommand(agent.command);
+  return packageName;
+}
+async function fetchVersionOptionsForAgent(agentId) {
+  const packageName = getPackageNameForAgent(agentId);
+  if (!packageName) {
+    return [];
+  }
+  return fetchPackageVersions(packageName);
+}
+async function fetchInstalledVersionForAgent(agentId) {
+  const commandName = AGENT_COMMAND_MAP[agentId];
+  if (!commandName) {
+    return null;
+  }
+  const result = await findCommand(commandName);
+  if (result.source !== "installed" || !result.path) {
+    return null;
+  }
+  const version = result.version?.replace(/^v/, "") ?? "unknown";
+  return {
+    version,
+    path: result.path
+  };
+}
+function versionInfoToSelectItem(v) {
+  const item = {
+    label: v.isPrerelease ? `${v.version} (pre)` : v.version,
+    value: v.version
+  };
+  if (v.publishedAt) {
+    item.description = new Date(v.publishedAt).toLocaleDateString();
+  }
+  return item;
+}
+function createInstalledOption(installed) {
+  return {
+    label: `installed@${installed.version}`,
+    value: "installed",
+    description: installed.path
+  };
+}
+function getBunxAgentIds() {
+  return BUILTIN_CODING_AGENTS.filter((a2) => a2.type === "bunx").map((a2) => a2.id);
+}
+var AGENT_COMMAND_MAP;
+var init_versionFetcher = __esm(() => {
+  init_builtin_coding_agents();
+  init_command3();
+  AGENT_COMMAND_MAP = {
+    "claude-code": "claude",
+    "codex-cli": "codex",
+    "gemini-cli": "gemini",
+    opencode: "opencode"
+  };
+});
+
 // node_modules/pino-std-serializers/lib/err-helpers.js
 var require_err_helpers = __commonJS((exports, module2) => {
   var isErrorLike = (err) => {
@@ -42550,7 +42884,6 @@ var UNOWNED = {
   context: null,
   owner: null
 };
-var NO_INIT = {};
 var Owner = null;
 var Transition = null;
 var Scheduler = null;
@@ -42594,13 +42927,6 @@ function createSignal(value, options) {
   };
   return [readSignal.bind(s), setter];
 }
-function createComputed(fn, value, options) {
-  const c = createComputation(fn, value, true, STALE);
-  if (Scheduler && Transition && Transition.running)
-    Updates.push(c);
-  else
-    updateComputation(c);
-}
 function createRenderEffect(fn, value, options) {
   const c = createComputation(fn, value, false, STALE);
   if (Scheduler && Transition && Transition.running)
@@ -42630,163 +42956,8 @@ function createMemo(fn, value, options) {
     updateComputation(c);
   return readSignal.bind(c);
 }
-function isPromise(v) {
-  return v && typeof v === "object" && "then" in v;
-}
-function createResource(pSource, pFetcher, pOptions) {
-  let source;
-  let fetcher;
-  let options;
-  if (typeof pFetcher === "function") {
-    source = pSource;
-    fetcher = pFetcher;
-    options = pOptions || {};
-  } else {
-    source = true;
-    fetcher = pSource;
-    options = pFetcher || {};
-  }
-  let pr = null, initP = NO_INIT, id = null, loadedUnderTransition = false, scheduled = false, resolved = "initialValue" in options, dynamic = typeof source === "function" && createMemo(source);
-  const contexts = new Set, [value, setValue] = (options.storage || createSignal)(options.initialValue), [error, setError] = createSignal(undefined), [track, trigger] = createSignal(undefined, {
-    equals: false
-  }), [state, setState] = createSignal(resolved ? "ready" : "unresolved");
-  if (sharedConfig.context) {
-    id = sharedConfig.getNextContextId();
-    if (options.ssrLoadFrom === "initial")
-      initP = options.initialValue;
-    else if (sharedConfig.load && sharedConfig.has(id))
-      initP = sharedConfig.load(id);
-  }
-  function loadEnd(p, v, error2, key) {
-    if (pr === p) {
-      pr = null;
-      key !== undefined && (resolved = true);
-      if ((p === initP || v === initP) && options.onHydrated)
-        queueMicrotask(() => options.onHydrated(key, {
-          value: v
-        }));
-      initP = NO_INIT;
-      if (Transition && p && loadedUnderTransition) {
-        Transition.promises.delete(p);
-        loadedUnderTransition = false;
-        runUpdates(() => {
-          Transition.running = true;
-          completeLoad(v, error2);
-        }, false);
-      } else
-        completeLoad(v, error2);
-    }
-    return v;
-  }
-  function completeLoad(v, err) {
-    runUpdates(() => {
-      if (err === undefined)
-        setValue(() => v);
-      setState(err !== undefined ? "errored" : resolved ? "ready" : "unresolved");
-      setError(err);
-      for (const c of contexts.keys())
-        c.decrement();
-      contexts.clear();
-    }, false);
-  }
-  function read() {
-    const c = SuspenseContext && useContext(SuspenseContext), v = value(), err = error();
-    if (err !== undefined && !pr)
-      throw err;
-    if (Listener && !Listener.user && c) {
-      createComputed(() => {
-        track();
-        if (pr) {
-          if (c.resolved && Transition && loadedUnderTransition)
-            Transition.promises.add(pr);
-          else if (!contexts.has(c)) {
-            c.increment();
-            contexts.add(c);
-          }
-        }
-      });
-    }
-    return v;
-  }
-  function load(refetching = true) {
-    if (refetching !== false && scheduled)
-      return;
-    scheduled = false;
-    const lookup = dynamic ? dynamic() : source;
-    loadedUnderTransition = Transition && Transition.running;
-    if (lookup == null || lookup === false) {
-      loadEnd(pr, untrack(value));
-      return;
-    }
-    if (Transition && pr)
-      Transition.promises.delete(pr);
-    let error2;
-    const p = initP !== NO_INIT ? initP : untrack(() => {
-      try {
-        return fetcher(lookup, {
-          value: value(),
-          refetching
-        });
-      } catch (fetcherError) {
-        error2 = fetcherError;
-      }
-    });
-    if (error2 !== undefined) {
-      loadEnd(pr, undefined, castError(error2), lookup);
-      return;
-    } else if (!isPromise(p)) {
-      loadEnd(pr, p, undefined, lookup);
-      return p;
-    }
-    pr = p;
-    if ("v" in p) {
-      if (p.s === 1)
-        loadEnd(pr, p.v, undefined, lookup);
-      else
-        loadEnd(pr, undefined, castError(p.v), lookup);
-      return p;
-    }
-    scheduled = true;
-    queueMicrotask(() => scheduled = false);
-    runUpdates(() => {
-      setState(resolved ? "refreshing" : "pending");
-      trigger();
-    }, false);
-    return p.then((v) => loadEnd(p, v, undefined, lookup), (e) => loadEnd(p, undefined, castError(e), lookup));
-  }
-  Object.defineProperties(read, {
-    state: {
-      get: () => state()
-    },
-    error: {
-      get: () => error()
-    },
-    loading: {
-      get() {
-        const s = state();
-        return s === "pending" || s === "refreshing";
-      }
-    },
-    latest: {
-      get() {
-        if (!resolved)
-          return read();
-        const err = error();
-        if (err && !pr)
-          throw err;
-        return value();
-      }
-    }
-  });
-  let owner = Owner;
-  if (dynamic)
-    createComputed(() => (owner = Owner, load(false)));
-  else
-    load(false);
-  return [read, {
-    refetch: (info) => runWithOwner(owner, () => load(info)),
-    mutate: setValue
-  }];
+function batch(fn) {
+  return runUpdates(fn, false);
 }
 function untrack(fn) {
   if (!ExternalSourceConfig && Listener === null)
@@ -42801,6 +42972,27 @@ function untrack(fn) {
     Listener = listener;
   }
 }
+function on(deps, fn, options) {
+  const isArray = Array.isArray(deps);
+  let prevInput;
+  let defer = options && options.defer;
+  return (prevValue) => {
+    let input;
+    if (isArray) {
+      input = Array(deps.length);
+      for (let i = 0;i < deps.length; i++)
+        input[i] = deps[i]();
+    } else
+      input = deps();
+    if (defer) {
+      defer = false;
+      return prevValue;
+    }
+    const result = untrack(() => fn(input, prevInput, prevValue));
+    prevInput = input;
+    return result;
+  };
+}
 function onMount(fn) {
   createEffect(() => untrack(fn));
 }
@@ -42813,20 +43005,6 @@ function onCleanup(fn) {
     Owner.cleanups.push(fn);
   return fn;
 }
-function runWithOwner(o, fn) {
-  const prev = Owner;
-  const prevListener = Listener;
-  Owner = o;
-  Listener = null;
-  try {
-    return runUpdates(fn, true);
-  } catch (err) {
-    handleError(err);
-  } finally {
-    Owner = prev;
-    Listener = prevListener;
-  }
-}
 function startTransition(fn) {
   if (Transition && Transition.running) {
     fn();
@@ -44312,14 +44490,36 @@ function mapToolLabel(toolId, toolLabel) {
     return toolLabel;
   return "Custom";
 }
+var LOCAL_DATE_TIME_FORMATTER = new Intl.DateTimeFormat(undefined, {
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  hour12: false
+});
+var formatLocalDateTimeParts = (date) => {
+  const parts = LOCAL_DATE_TIME_FORMATTER.formatToParts(date);
+  const get = (type) => parts.find((part) => part.type === type)?.value;
+  const year = get("year");
+  const month = get("month");
+  const day = get("day");
+  const hour = get("hour");
+  const minute = get("minute");
+  if (!year || !month || !day || !hour || !minute) {
+    return LOCAL_DATE_TIME_FORMATTER.format(date);
+  }
+  return `${year}-${month}-${day} ${hour}:${minute}`;
+};
+function formatLocalDateTime(timestampMs) {
+  const date = new Date(timestampMs);
+  if (Number.isNaN(date.getTime())) {
+    return "";
+  }
+  return formatLocalDateTimeParts(date);
+}
 function formatTimestamp(ts) {
-  const date = new Date(ts);
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  const hours = String(date.getHours()).padStart(2, "0");
-  const minutes = String(date.getMinutes()).padStart(2, "0");
-  return `${year}-${month}-${day} ${hours}:${minutes}`;
+  return formatLocalDateTime(ts);
 }
 function buildLastToolUsageLabel(usage) {
   if (!usage)
@@ -44616,6 +44816,98 @@ function Header({
   })();
 }
 
+// src/cli/ui/core/theme.ts
+var colors = {
+  primary: "cyan",
+  secondary: "gray",
+  success: "green",
+  warning: "yellow",
+  error: "red",
+  info: "blue",
+  text: "white",
+  textDim: "gray",
+  textMuted: "gray",
+  selected: "cyan",
+  highlighted: "cyan",
+  disabled: "gray",
+  selectionBackground: "cyan",
+  selectionText: "black",
+  branchFeature: "green",
+  branchBugfix: "yellow",
+  branchHotfix: "red",
+  branchRelease: "magenta",
+  branchMain: "cyan",
+  branchDevelop: "blue",
+  branchOther: "gray",
+  syncUpToDate: "green",
+  syncAhead: "cyan",
+  syncBehind: "yellow",
+  syncDiverged: "red",
+  syncNoUpstream: "gray",
+  worktreeActive: "green",
+  worktreeInaccessible: "red",
+  progressFilled: "green",
+  progressEmpty: "gray",
+  progressPhase: "yellow",
+  progressTime: "magenta"
+};
+var logLevelColors = {
+  TRACE: colors.textDim,
+  DEBUG: colors.info,
+  INFO: colors.success,
+  WARN: colors.warning,
+  ERROR: colors.error,
+  FATAL: colors.error
+};
+var selectionStyle = {
+  fg: colors.selectionText,
+  bg: colors.selectionBackground
+};
+var getLogLevelColor = (label) => {
+  if (!label) {
+    return colors.text;
+  }
+  const normalized = label.toUpperCase();
+  return logLevelColors[normalized] ?? colors.text;
+};
+var icons = {
+  pointer: ">",
+  pointerBold: ">",
+  arrowUp: "^",
+  arrowDown: "v",
+  arrowLeft: "<",
+  arrowRight: ">",
+  success: "OK",
+  error: "X",
+  warning: "!",
+  info: "i",
+  skipped: "-",
+  worktree: "W",
+  worktreeActive: "A",
+  worktreeInaccessible: "X",
+  changes: "C",
+  unpushed: "U",
+  current: "*",
+  pr: "PR",
+  merged: "M",
+  syncUpToDate: "=",
+  syncAhead: ">",
+  syncBehind: "<",
+  syncDiverged: "!",
+  spinnerFrames: ["|", "/", "-", "\\"],
+  bullet: "*",
+  divider: "-",
+  verticalLine: "|",
+  corner: "+",
+  branch: "+"
+};
+var statsItemsConfig = {
+  local: { label: "Local", icon: "L", color: colors.primary },
+  remote: { label: "Remote", icon: "R", color: colors.info },
+  worktree: { label: "Worktrees", icon: icons.worktree, color: colors.success },
+  changes: { label: "Changes", icon: icons.changes, color: colors.warning }
+};
+
 // src/cli/ui/screens/solid/BranchListScreen.tsx
 var VIEW_MODES = ["all", "local", "remote"];
 var getCharWidth = (char) => stringWidth(char);
@@ -44724,8 +45016,8 @@ var fitSegmentsToWidth = (segments, width) => {
 };
 var applySelectionStyle = (segments) => segments.map((segment) => ({
   text: segment.text,
-  fg: "black",
-  bg: "cyan"
+  fg: selectionStyle.fg,
+  bg: selectionStyle.bg
 }));
 var CLEANUP_SPINNER_FRAMES = ["-", "\\", "|", "/"];
 var CURSOR_FRAMES = ["|", " "];
@@ -44805,7 +45097,13 @@ function BranchListScreen(props) {
   const [filterQuery, setFilterQuery] = createSignal("");
   const [filterMode, setFilterMode] = createSignal(false);
   const [viewMode, setViewMode] = createSignal("all");
-  const [selectedIndex, setSelectedIndex] = createSignal(0);
+  const [internalSelectedIndex, setInternalSelectedIndex] = createSignal(props.cursorPosition ?? 0);
+  const selectedIndex = () => props.cursorPosition ?? internalSelectedIndex();
+  const setSelectedIndex = (value) => {
+    const newValue = typeof value === "function" ? value(selectedIndex()) : value;
+    setInternalSelectedIndex(newValue);
+    props.onCursorPositionChange?.(newValue);
+  };
   const [scrollOffset, setScrollOffset] = createSignal(0);
   const [cleanupSpinnerIndex, setCleanupSpinnerIndex] = createSignal(0);
   const [cursorIndex, setCursorIndex] = createSignal(0);
@@ -44833,7 +45131,14 @@ function BranchListScreen(props) {
     return Object.values(props.cleanupUI.indicators).some((indicator) => indicator.isSpinning);
   });
   const hasSpinningFooter = createMemo(() => props.cleanupUI?.footerMessage?.isSpinning ?? false);
-  const cleanupSpinnerActive = createMemo(() => hasSpinningIndicator() || hasSpinningFooter() || props.cleanupUI?.safetyLoading === true);
+  const safetyPendingActive = createMemo(() => {
+    const pending = props.cleanupUI?.safetyPendingBranches;
+    if (pending) {
+      return pending.size > 0;
+    }
+    return props.cleanupUI?.safetyLoading === true;
+  });
+  const cleanupSpinnerActive = createMemo(() => hasSpinningIndicator() || hasSpinningFooter() || safetyPendingActive());
   createEffect(() => {
     let intervalTimer;
     if (cleanupSpinnerActive()) {
@@ -44884,12 +45189,12 @@ function BranchListScreen(props) {
     }
     return maxWidth;
   });
-  createEffect(() => {
-    filterQuery();
-    viewMode();
+  createEffect(on(() => [filterQuery(), viewMode()], () => {
     setSelectedIndex(0);
     setScrollOffset(0);
-  });
+  }, {
+    defer: true
+  }));
   createEffect(() => {
     const total = filteredBranches().length;
     if (total === 0) {
@@ -44937,18 +45242,16 @@ function BranchListScreen(props) {
     if (!timestamp || Number.isNaN(timestamp)) {
       return "---";
     }
-    const date = new Date(timestamp * 1000);
-    const year = date.getFullYear();
-    const month = String(date.getMonth() + 1).padStart(2, "0");
-    const day = String(date.getDate()).padStart(2, "0");
-    const hours = String(date.getHours()).padStart(2, "0");
-    const minutes = String(date.getMinutes()).padStart(2, "0");
-    return `${year}-${month}-${day} ${hours}:${minutes}`;
+    const formatted = formatLocalDateTime(timestamp * 1000);
+    return formatted || "---";
   };
   useKeyboard((key) => {
     if (props.wizardVisible) {
       return;
     }
+    if (props.confirmVisible) {
+      return;
+    }
     if (props.helpVisible) {
       return;
     }
@@ -45054,7 +45357,8 @@ function BranchListScreen(props) {
     } else if (key.name === "p" || key.sequence === "p") {
       props.onOpenProfiles?.();
     } else if (key.name === "l" || key.sequence === "l") {
-      props.onOpenLogs?.();
+      const selected = filteredBranches()[selectedIndex()] ?? null;
+      props.onOpenLogs?.(selected);
     }
   });
   const visibleBranches = createMemo(() => {
@@ -45082,19 +45386,24 @@ function BranchListScreen(props) {
     let worktreeColor = "gray";
     if (branch.worktreeStatus === "active") {
       worktreeIcon = "w";
-      worktreeColor = "green";
+      worktreeColor = "brightGreen";
     } else if (branch.worktreeStatus === "inaccessible") {
       worktreeIcon = "x";
       worktreeColor = "red";
     }
     const isRemoteBranch = branch.type === "remote";
     const safetyLoading = props.cleanupUI?.safetyLoading === true;
+    const safetyPendingBranches = props.cleanupUI?.safetyPendingBranches;
+    const isSafetyPending = safetyPendingBranches ? safetyPendingBranches.has(branch.name) : safetyLoading;
     const spinnerFrame = cleanupSpinnerFrame();
     let safeIcon = " ";
     let safeColor;
     if (isRemoteBranch) {
       safeIcon = " ";
       safeColor = undefined;
+    } else if (isSafetyPending) {
+      safeIcon = spinnerFrame ?? "-";
+      safeColor = undefined;
     } else if (hasUncommitted) {
       safeIcon = "!";
       safeColor = "red";
@@ -45104,12 +45413,9 @@ function BranchListScreen(props) {
     } else if (branch.isUnmerged) {
       safeIcon = "*";
       safeColor = "yellow";
-    } else if (safetyLoading) {
-      safeIcon = spinnerFrame ?? "-";
-      safeColor = undefined;
     } else if (branch.safeToCleanup === true) {
-      safeIcon = " ";
-      safeColor = undefined;
+      safeIcon = "o";
+      safeColor = "brightGreen";
     } else {
       safeIcon = "!";
       safeColor = "red";
@@ -45316,6 +45622,63 @@ function BranchListScreen(props) {
     }
     return fitSegmentsToWidth(segments, layoutWidth());
   });
+  const statusLegendSegments = createMemo(() => {
+    const segments = [];
+    const separator = "  ";
+    appendSegment(segments, {
+      text: "Legend: ",
+      attributes: TextAttributes.DIM
+    });
+    appendSegment(segments, {
+      text: "o",
+      fg: "brightGreen",
+      attributes: TextAttributes.BOLD
+    });
+    appendSegment(segments, {
+      text: " Safe",
+      fg: "brightGreen"
+    });
+    appendSegment(segments, {
+      text: separator,
+      attributes: TextAttributes.DIM
+    });
+    appendSegment(segments, {
+      text: "!",
+      fg: "red",
+      attributes: TextAttributes.BOLD
+    });
+    appendSegment(segments, {
+      text: " Uncommitted",
+      fg: "red"
+    });
+    appendSegment(segments, {
+      text: separator,
+      attributes: TextAttributes.DIM
+    });
+    appendSegment(segments, {
+      text: "!",
+      fg: "yellow",
+      attributes: TextAttributes.BOLD
+    });
+    appendSegment(segments, {
+      text: " Unpushed",
+      fg: "yellow"
+    });
+    appendSegment(segments, {
+      text: separator,
+      attributes: TextAttributes.DIM
+    });
+    appendSegment(segments, {
+      text: "*",
+      fg: "yellow",
+      attributes: TextAttributes.BOLD
+    });
+    appendSegment(segments, {
+      text: " Unmerged",
+      fg: "yellow"
+    });
+    return fitSegmentsToWidth(segments, layoutWidth());
+  });
   const footerSegments = createMemo(() => {
     const segments = [];
     const separator = "  ";
@@ -45411,50 +45774,46 @@ function BranchListScreen(props) {
         }
       }, () => props.loadingIndicatorDelay !== undefined ? {
         delay: props.loadingIndicatorDelay
-      } : {})) : (() => {
-        var _el$7 = createElement("text");
-        insert(_el$7, () => padLine("", layoutWidth()));
-        return _el$7;
-      })();
+      } : {})) : renderSegmentLine(statusLegendSegments());
     })(), null);
     insert(_el$5, (() => {
       var _c$2 = memo2(() => !!props.error);
       return () => _c$2() && [(() => {
+        var _el$7 = createElement("text");
+        setProp(_el$7, "fg", "red");
+        insert(_el$7, () => padLine(`Error: ${props.error.message}`, layoutWidth()));
+        effect((_$p) => setProp(_el$7, "attributes", TextAttributes.BOLD, _$p));
+        return _el$7;
+      })(), memo2(() => memo2(() => !!(process.env.DEBUG && props.error.stack))() && [(() => {
         var _el$8 = createElement("text");
-        setProp(_el$8, "fg", "red");
-        insert(_el$8, () => padLine(`Error: ${props.error.message}`, layoutWidth()));
-        effect((_$p) => setProp(_el$8, "attributes", TextAttributes.BOLD, _$p));
+        insert(_el$8, () => padLine("", layoutWidth()));
+        effect((_$p) => setProp(_el$8, "attributes", TextAttributes.DIM, _$p));
         return _el$8;
-      })(), memo2(() => memo2(() => !!(process.env.DEBUG && props.error.stack))() && [(() => {
+      })(), memo2(() => props.error.stack.split(`
+`).map((line) => (() => {
         var _el$9 = createElement("text");
-        insert(_el$9, () => padLine("", layoutWidth()));
+        setProp(_el$9, "fg", "gray");
+        insert(_el$9, () => padLine(line, layoutWidth()));
         effect((_$p) => setProp(_el$9, "attributes", TextAttributes.DIM, _$p));
         return _el$9;
-      })(), memo2(() => props.error.stack.split(`
-`).map((line) => (() => {
-        var _el$0 = createElement("text");
-        setProp(_el$0, "fg", "gray");
-        insert(_el$0, () => padLine(line, layoutWidth()));
-        effect((_$p) => setProp(_el$0, "attributes", TextAttributes.DIM, _$p));
-        return _el$0;
       })()))])];
     })(), null);
     insert(_el$5, (() => {
       var _c$3 = memo2(() => !!(!props.loading && !props.error && props.branches.length === 0));
       return () => _c$3() && (() => {
-        var _el$1 = createElement("text");
-        insert(_el$1, () => padLine("No branches found", layoutWidth()));
-        effect((_$p) => setProp(_el$1, "attributes", TextAttributes.DIM, _$p));
-        return _el$1;
+        var _el$0 = createElement("text");
+        insert(_el$0, () => padLine("No branches found", layoutWidth()));
+        effect((_$p) => setProp(_el$0, "attributes", TextAttributes.DIM, _$p));
+        return _el$0;
       })();
     })(), null);
     insert(_el$5, (() => {
       var _c$4 = memo2(() => !!(!props.loading && !props.error && props.branches.length > 0 && filteredBranches().length === 0 && filterQuery()));
       return () => _c$4() && (() => {
-        var _el$10 = createElement("text");
-        insert(_el$10, () => padLine("No branches match your filter", layoutWidth()));
-        effect((_$p) => setProp(_el$10, "attributes", TextAttributes.DIM, _$p));
-        return _el$10;
+        var _el$1 = createElement("text");
+        insert(_el$1, () => padLine("No branches match your filter", layoutWidth()));
+        effect((_$p) => setProp(_el$1, "attributes", TextAttributes.DIM, _$p));
+        return _el$1;
       })();
     })(), null);
     insert(_el$5, (() => {
@@ -45465,20 +45824,20 @@ function BranchListScreen(props) {
       })), memo2(() => Array.from({
         length: Math.max(0, contentHeight() - visibleBranches().length)
       }).map(() => (() => {
-        var _el$11 = createElement("text");
-        insert(_el$11, () => padLine("", listWidth()));
-        return _el$11;
+        var _el$10 = createElement("text");
+        insert(_el$10, () => padLine("", listWidth()));
+        return _el$10;
       })()))];
     })(), null);
     insert(_el$4, (() => {
       var _c$6 = memo2(() => !!props.cleanupUI?.footerMessage);
       return () => _c$6() && (() => {
-        var _el$12 = createElement("text");
-        spread(_el$12, mergeProps3(() => props.cleanupUI.footerMessage.color ? {
+        var _el$11 = createElement("text");
+        spread(_el$11, mergeProps3(() => props.cleanupUI.footerMessage.color ? {
           fg: props.cleanupUI.footerMessage.color
         } : {}), true);
-        insert(_el$12, () => padLine(props.cleanupUI.footerMessage.isSpinning && cleanupSpinnerFrame() ? `${cleanupSpinnerFrame()} ${props.cleanupUI.footerMessage.text}` : props.cleanupUI.footerMessage.text, layoutWidth()));
-        return _el$12;
+        insert(_el$11, () => padLine(props.cleanupUI.footerMessage.isSpinning && cleanupSpinnerFrame() ? `${cleanupSpinnerFrame()} ${props.cleanupUI.footerMessage.text}` : props.cleanupUI.footerMessage.text, layoutWidth()));
+        return _el$11;
       })();
     })(), _el$6);
     insert(_el$6, () => padLine(`Worktree: ${selectedWorktreeLabel()}`, layoutWidth()));
@@ -46009,6 +46368,15 @@ function SelectInput(props) {
       },
       get height() {
         return computedHeight();
+      },
+      get selectedBackgroundColor() {
+        return selectionStyle.bg;
+      },
+      get selectedTextColor() {
+        return selectionStyle.fg;
+      },
+      get selectedDescriptionColor() {
+        return selectionStyle.fg;
       }
     }, () => props.selectedIndex !== undefined && {
       selectedIndex: props.selectedIndex
@@ -46040,30 +46408,46 @@ function QuickStartStep(props) {
       props.onChooseDifferent();
     }
   });
-  const latestEntry = createMemo(() => props.history[0] ?? null);
+  const buildSettingsDescription = (entry) => {
+    const parts = [];
+    if (entry.toolLabel) {
+      parts.push(entry.toolLabel);
+    } else if (entry.toolId) {
+      parts.push(entry.toolId);
+    }
+    if (entry.model) {
+      parts.push(entry.model);
+    }
+    if (entry.toolId === "codex-cli" && entry.reasoningLevel) {
+      parts.push(entry.reasoningLevel);
+    }
+    return parts.join(", ");
+  };
   const items = createMemo(() => {
     const result = [];
-    const entry = latestEntry();
-    if (entry) {
-      const reasoningInfo = entry.reasoningLevel ? `, ${entry.reasoningLevel}` : "";
-      const versionInfo = entry.toolVersion ? `@${entry.toolVersion}` : "";
-      const settingsDesc = `${entry.toolLabel}${versionInfo}, ${entry.model}${reasoningInfo}`;
-      const resumeDesc = entry.sessionId ? `${settingsDesc}, session ${entry.sessionId}` : settingsDesc;
-      result.push({
-        label: "Resume session (previous settings)",
-        value: `resume-${entry.toolId}`,
-        description: resumeDesc,
-        action: "resume",
-        entry
-      });
+    props.history.forEach((entry, index) => {
+      if (!entry)
+        return;
+      const settingsDesc = buildSettingsDescription(entry);
+      const sessionId = entry.sessionId && entry.sessionId.trim().length > 0 ? entry.sessionId.trim() : null;
+      const suffix = `${entry.toolId ?? "tool"}-${index}`;
+      if (sessionId) {
+        result.push({
+          label: "Resume session (previous settings)",
+          value: `resume-${suffix}`,
+          description: `${settingsDesc} | Session: ${sessionId}`,
+          action: "resume",
+          entry
+        });
+      }
       result.push({
         label: "Start new (previous settings)",
-        value: `start-new-${entry.toolId}`,
+        value: `start-new-${suffix}`,
         description: settingsDesc,
         action: "start-new",
         entry
       });
-    }
+    });
     result.push({
       label: "Choose different settings...",
       value: "choose-different",
@@ -46327,6 +46711,19 @@ var MODEL_OPTIONS = {
       label: "Flash-Lite (gemini-2.5-flash-lite)",
       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"
+    }
   ]
 };
 function getModelOptions(tool) {
@@ -46356,6 +46753,9 @@ function normalizeModelId(tool, model) {
   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")
@@ -46366,257 +46766,55 @@ function normalizeModelId(tool, model) {
   return trimmed;
 }
 
-// src/utils/npmRegistry.ts
-var DEFAULT_TIMEOUT_MS = 3000;
-var DEFAULT_LIMIT = 10;
-function isPrerelease(version) {
-  return /-(alpha|beta|rc|canary|next|dev|pre)\b/i.test(version);
-}
-async function fetchPackageVersions(packageName, limit = DEFAULT_LIMIT, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  try {
-    const controller = new AbortController;
-    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-    const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}`, {
-      signal: controller.signal,
-      headers: {
-        Accept: "application/json"
-      }
-    });
-    clearTimeout(timeoutId);
-    if (!response.ok) {
-      return [];
-    }
-    const data = await response.json();
-    if (!data.versions || !data.time) {
-      return [];
-    }
-    const versionsWithTime = [];
-    for (const version of Object.keys(data.versions)) {
-      const publishedAt = data.time[version];
-      if (publishedAt) {
-        versionsWithTime.push({ version, publishedAt });
-      }
-    }
-    versionsWithTime.sort((a, b) => {
-      const dateA = new Date(a.publishedAt).getTime();
-      const dateB = new Date(b.publishedAt).getTime();
-      return dateB - dateA;
-    });
-    const topVersions = versionsWithTime.slice(0, limit);
-    return topVersions.map((v) => ({
-      version: v.version,
-      isPrerelease: isPrerelease(v.version),
-      publishedAt: v.publishedAt
-    }));
-  } catch {
-    return [];
-  }
+// src/cli/ui/utils/versionCache.ts
+var versionCache = new Map;
+function getVersionCache(agentId) {
+  const cached = versionCache.get(agentId);
+  return cached !== undefined ? cached : null;
 }
-function parsePackageCommand(command) {
-  if (command.startsWith("@")) {
-    const firstSlash = command.indexOf("/");
-    if (firstSlash === -1) {
-      return { packageName: command, version: null };
-    }
-    const afterScope = command.substring(firstSlash + 1);
-    const atIndex2 = afterScope.indexOf("@");
-    if (atIndex2 === -1) {
-      return { packageName: command, version: null };
-    }
-    const packageName2 = command.substring(0, firstSlash + 1 + atIndex2);
-    const version2 = afterScope.substring(atIndex2 + 1);
-    return { packageName: packageName2, version: version2 };
-  }
-  const atIndex = command.indexOf("@");
-  if (atIndex === -1) {
-    return { packageName: command, version: null };
+async function prefetchAgentVersions(agentIds, fetchFn) {
+  const fetcher = fetchFn ?? (async (agentId) => {
+    const { fetchVersionOptionsForAgent: fetchVersionOptionsForAgent2 } = await Promise.resolve().then(() => (init_versionFetcher(), exports_versionFetcher));
+    return fetchVersionOptionsForAgent2(agentId);
+  });
+  const results = await Promise.allSettled(agentIds.map(async (agentId) => {
+    try {
+      const versions = await fetcher(agentId);
+      versionCache.set(agentId, versions);
+    } catch {}
+  }));
+  for (let i2 = 0;i2 < results.length; i2++) {
+    const result = results[i2];
+    if (result && result.status === "rejected") {}
   }
-  const packageName = command.substring(0, atIndex);
-  const version = command.substring(atIndex + 1);
-  return { packageName, version };
 }
 
-// src/shared/codingAgentConstants.ts
-var CLAUDE_PERMISSION_SKIP_ARGS = [
-  "--dangerously-skip-permissions"
-];
-var CODEX_DEFAULT_ARGS = [
-  "--enable",
-  "web_search_request",
-  "--model=gpt-5.2-codex",
-  "--sandbox",
-  "workspace-write",
-  "-c",
-  "model_reasoning_effort=high",
-  "-c",
-  "model_reasoning_summaries=detailed",
-  "-c",
-  "sandbox_workspace_write.network_access=true",
-  "-c",
-  "shell_environment_policy.inherit=all",
-  "-c",
-  "shell_environment_policy.ignore_default_excludes=true",
-  "-c",
-  "shell_environment_policy.experimental_use_profile=true"
-];
-
-// src/config/builtin-coding-agents.ts
-var CLAUDE_CODE_TOOL = {
-  id: "claude-code",
-  displayName: "Claude Code",
-  type: "bunx",
-  command: "@anthropic-ai/claude-code",
-  modeArgs: {
-    normal: [],
-    continue: ["-c"],
-    resume: ["-r"]
-  },
-  permissionSkipArgs: Array.from(CLAUDE_PERMISSION_SKIP_ARGS),
-  env: {
-    ENABLE_LSP_TOOL: "true"
-  }
-};
-var CODEX_CLI_TOOL = {
-  id: "codex-cli",
-  displayName: "Codex",
-  type: "bunx",
-  command: "@openai/codex",
-  defaultArgs: Array.from(CODEX_DEFAULT_ARGS),
-  modeArgs: {
-    normal: [],
-    continue: ["resume", "--last"],
-    resume: ["resume"]
-  }
-};
-var GEMINI_CLI_TOOL = {
-  id: "gemini-cli",
-  displayName: "Gemini",
-  type: "bunx",
-  command: "@google/gemini-cli",
-  modeArgs: {
-    normal: [],
-    continue: ["-r", "latest"],
-    resume: ["-r", "latest"]
-  },
-  permissionSkipArgs: ["-y"]
-};
-var OPENCODE_TOOL = {
-  id: "opencode",
-  displayName: "OpenCode",
-  type: "bunx",
-  command: "opencode-ai",
-  modeArgs: {
-    normal: [],
-    continue: ["-c"],
-    resume: ["-s"]
-  }
-};
-var BUILTIN_CODING_AGENTS = [
-  CLAUDE_CODE_TOOL,
-  CODEX_CLI_TOOL,
-  GEMINI_CLI_TOOL,
-  OPENCODE_TOOL
-];
+// src/cli/ui/components/solid/WizardSteps.tsx
+init_versionFetcher();
 
-// src/utils/command.ts
-init_execa();
-import { existsSync as existsSync3 } from "fs";
-import { homedir } from "os";
-import { join as join2 } from "path";
-var KNOWN_INSTALL_PATHS = {
-  claude: {
-    unix: [
-      join2(homedir(), ".bun", "bin", "claude"),
-      join2(homedir(), ".local", "bin", "claude"),
-      "/usr/local/bin/claude"
-    ],
-    win32: [
-      join2(process.env.LOCALAPPDATA ?? "", "Programs", "claude", "claude.exe"),
-      join2(homedir(), ".bun", "bin", "claude.exe")
-    ]
-  },
-  codex: {
-    unix: [
-      join2(homedir(), ".bun", "bin", "codex"),
-      join2(homedir(), ".local", "bin", "codex"),
-      "/usr/local/bin/codex"
-    ],
-    win32: [join2(homedir(), ".bun", "bin", "codex.exe")]
-  },
-  gemini: {
-    unix: [
-      join2(homedir(), ".bun", "bin", "gemini"),
-      join2(homedir(), ".local", "bin", "gemini"),
-      "/usr/local/bin/gemini"
-    ],
-    win32: [join2(homedir(), ".bun", "bin", "gemini.exe")]
-  },
-  opencode: {
-    unix: [
-      join2(homedir(), ".bun", "bin", "opencode"),
-      join2(homedir(), ".local", "bin", "opencode"),
-      "/usr/local/bin/opencode"
-    ],
-    win32: [join2(homedir(), ".bun", "bin", "opencode.exe")]
-  }
-};
-var commandLookupCache = new Map;
-async function getCommandVersion(commandPath) {
-  try {
-    const result = await execa(commandPath, ["--version"], {
-      timeout: 3000,
-      stdin: "ignore",
-      stdout: "pipe",
-      stderr: "ignore"
-    });
-    const match = result.stdout.match(/(\d+\.\d+(?:\.\d+)?(?:-[\w.]+)?)/);
-    return match ? `v${match[1]}` : null;
-  } catch {
-    return null;
-  }
+// src/cli/ui/utils/installedVersionCache.ts
+init_versionFetcher();
+var installedVersionCache = new Map;
+function getInstalledVersionCache(agentId) {
+  const cached = installedVersionCache.get(agentId);
+  return cached ?? null;
 }
-async function findCommand(commandName) {
-  const cached = commandLookupCache.get(commandName);
-  if (cached) {
-    return cached;
-  }
-  let lookupResult = null;
-  try {
-    const lookupCommand = process.platform === "win32" ? "where" : "which";
-    const execResult = await execa(lookupCommand, [commandName], {
-      shell: true,
-      stdin: "ignore",
-      stdout: "pipe",
-      stderr: "ignore"
-    });
-    const foundPath = execResult.stdout.trim().split(`
-`)[0];
-    if (foundPath) {
-      lookupResult = { available: true, path: foundPath, source: "installed" };
-    }
-  } catch {}
-  if (!lookupResult) {
-    const knownPaths = KNOWN_INSTALL_PATHS[commandName];
-    if (knownPaths) {
-      const pathsToCheck = process.platform === "win32" ? knownPaths.win32 : knownPaths.unix;
-      for (const p of pathsToCheck) {
-        if (p && existsSync3(p)) {
-          lookupResult = { available: true, path: p, source: "installed" };
-          break;
-        }
-      }
+function setInstalledVersionCache(agentId, installed) {
+  installedVersionCache.set(agentId, installed);
+}
+async function prefetchInstalledVersions(agentIds, fetchFn) {
+  const fetcher = fetchFn ?? (async (agentId) => fetchInstalledVersionForAgent(agentId));
+  const results = await Promise.allSettled(agentIds.map(async (agentId) => {
+    try {
+      const installed = await fetcher(agentId);
+      setInstalledVersionCache(agentId, installed);
+    } catch {
+      setInstalledVersionCache(agentId, null);
     }
+  }));
+  for (const result of results) {
+    if (result.status === "rejected") {}
   }
-  if (!lookupResult) {
-    lookupResult = { available: true, path: null, source: "bunx" };
-  }
-  if (lookupResult.source === "installed" && lookupResult.path) {
-    lookupResult.version = await getCommandVersion(lookupResult.path);
-  } else {
-    lookupResult.version = null;
-  }
-  commandLookupCache.set(commandName, lookupResult);
-  return lookupResult;
 }
 
 // src/cli/ui/components/solid/WizardSteps.tsx
@@ -46929,9 +47127,16 @@ function AgentSelectStep(props) {
       return isSelected() ? (() => {
         var _el$39 = createElement("text"), _el$40 = createTextNode(`> `);
         insertNode(_el$39, _el$40);
-        setProp(_el$39, "bg", "cyan");
-        setProp(_el$39, "fg", "black");
         insert(_el$39, () => agent.label, null);
+        effect((_p$) => {
+          var _v$9 = selectionStyle.bg, _v$0 = selectionStyle.fg;
+          _v$9 !== _p$.e && (_p$.e = setProp(_el$39, "bg", _v$9, _p$.e));
+          _v$0 !== _p$.t && (_p$.t = setProp(_el$39, "fg", _v$0, _p$.t));
+          return _p$;
+        }, {
+          e: undefined,
+          t: undefined
+        });
         return _el$39;
       })() : (() => {
         var _el$41 = createElement("text"), _el$42 = createTextNode(`  `);
@@ -47023,9 +47228,9 @@ function ModelSelectStep(props) {
     insertNode(_el$48, createTextNode(` `));
     insertNode(_el$50, createTextNode(`[Enter] Select [Esc] Back`));
     effect((_p$) => {
-      var _v$9 = TextAttributes.BOLD, _v$0 = TextAttributes.DIM;
-      _v$9 !== _p$.e && (_p$.e = setProp(_el$44, "attributes", _v$9, _p$.e));
-      _v$0 !== _p$.t && (_p$.t = setProp(_el$50, "attributes", _v$0, _p$.t));
+      var _v$1 = TextAttributes.BOLD, _v$10 = TextAttributes.DIM;
+      _v$1 !== _p$.e && (_p$.e = setProp(_el$44, "attributes", _v$1, _p$.e));
+      _v$10 !== _p$.t && (_p$.t = setProp(_el$50, "attributes", _v$10, _p$.t));
       return _p$;
     }, {
       e: undefined,
@@ -47034,6 +47239,61 @@ function ModelSelectStep(props) {
     return _el$43;
   })();
 }
+function ModelInputStep(props) {
+  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) => {
+    const trimmed = next.trim();
+    if (!trimmed) {
+      return;
+    }
+    props.onSubmit(trimmed);
+  };
+  return (() => {
+    var _el$52 = createElement("box"), _el$53 = createElement("text"), _el$55 = createElement("text"), _el$57 = createElement("text"), _el$59 = createElement("text");
+    insertNode(_el$52, _el$53);
+    insertNode(_el$52, _el$55);
+    insertNode(_el$52, _el$57);
+    insertNode(_el$52, _el$59);
+    setProp(_el$52, "flexDirection", "column");
+    insertNode(_el$53, createTextNode(`Enter custom model:`));
+    setProp(_el$53, "fg", "cyan");
+    insertNode(_el$55, createTextNode(` `));
+    insert(_el$52, createComponent2(TextInput, {
+      get value() {
+        return value();
+      },
+      onChange: setValue,
+      onSubmit: handleSubmit,
+      placeholder,
+      get focused() {
+        return props.focused ?? true;
+      }
+    }), _el$57);
+    insertNode(_el$57, createTextNode(` `));
+    insertNode(_el$59, createTextNode(`[Enter] Submit [Esc] Back`));
+    effect((_p$) => {
+      var _v$11 = TextAttributes.BOLD, _v$12 = TextAttributes.DIM;
+      _v$11 !== _p$.e && (_p$.e = setProp(_el$53, "attributes", _v$11, _p$.e));
+      _v$12 !== _p$.t && (_p$.t = setProp(_el$59, "attributes", _v$12, _p$.t));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined
+    });
+    return _el$52;
+  })();
+}
 var REASONING_LEVELS = [{
   label: "low",
   value: "low",
@@ -47071,16 +47331,16 @@ function ReasoningLevelStep(props) {
     }
   };
   return (() => {
-    var _el$52 = createElement("box"), _el$53 = createElement("text"), _el$55 = createElement("text"), _el$57 = createElement("text"), _el$59 = createElement("text");
-    insertNode(_el$52, _el$53);
-    insertNode(_el$52, _el$55);
-    insertNode(_el$52, _el$57);
-    insertNode(_el$52, _el$59);
-    setProp(_el$52, "flexDirection", "column");
-    insertNode(_el$53, createTextNode(`Select reasoning level:`));
-    setProp(_el$53, "fg", "cyan");
-    insertNode(_el$55, createTextNode(` `));
-    insert(_el$52, createComponent2(SelectInput, {
+    var _el$61 = createElement("box"), _el$62 = createElement("text"), _el$64 = createElement("text"), _el$66 = createElement("text"), _el$68 = createElement("text");
+    insertNode(_el$61, _el$62);
+    insertNode(_el$61, _el$64);
+    insertNode(_el$61, _el$66);
+    insertNode(_el$61, _el$68);
+    setProp(_el$61, "flexDirection", "column");
+    insertNode(_el$62, createTextNode(`Select reasoning level:`));
+    setProp(_el$62, "fg", "cyan");
+    insertNode(_el$64, createTextNode(` `));
+    insert(_el$61, createComponent2(SelectInput, {
       items: REASONING_LEVELS,
       onSelect: (item) => props.onSelect(item.value),
       onChange: handleChange,
@@ -47088,19 +47348,19 @@ function ReasoningLevelStep(props) {
         return props.focused ?? true;
       },
       selectRef: setSelectRef
-    }), _el$57);
-    insertNode(_el$57, createTextNode(` `));
-    insertNode(_el$59, createTextNode(`[Enter] Select [Esc] Back`));
+    }), _el$66);
+    insertNode(_el$66, createTextNode(` `));
+    insertNode(_el$68, createTextNode(`[Enter] Select [Esc] Back`));
     effect((_p$) => {
-      var _v$1 = TextAttributes.BOLD, _v$10 = TextAttributes.DIM;
-      _v$1 !== _p$.e && (_p$.e = setProp(_el$53, "attributes", _v$1, _p$.e));
-      _v$10 !== _p$.t && (_p$.t = setProp(_el$59, "attributes", _v$10, _p$.t));
+      var _v$13 = TextAttributes.BOLD, _v$14 = TextAttributes.DIM;
+      _v$13 !== _p$.e && (_p$.e = setProp(_el$62, "attributes", _v$13, _p$.e));
+      _v$14 !== _p$.t && (_p$.t = setProp(_el$68, "attributes", _v$14, _p$.t));
       return _p$;
     }, {
       e: undefined,
       t: undefined
     });
-    return _el$52;
+    return _el$61;
   })();
 }
 var EXECUTION_MODES = [{
@@ -47136,16 +47396,16 @@ function ExecutionModeStep(props) {
     }
   };
   return (() => {
-    var _el$61 = createElement("box"), _el$62 = createElement("text"), _el$64 = createElement("text"), _el$66 = createElement("text"), _el$68 = createElement("text");
-    insertNode(_el$61, _el$62);
-    insertNode(_el$61, _el$64);
-    insertNode(_el$61, _el$66);
-    insertNode(_el$61, _el$68);
-    setProp(_el$61, "flexDirection", "column");
-    insertNode(_el$62, createTextNode(`Select execution mode:`));
-    setProp(_el$62, "fg", "cyan");
-    insertNode(_el$64, createTextNode(` `));
-    insert(_el$61, createComponent2(SelectInput, {
+    var _el$70 = createElement("box"), _el$71 = createElement("text"), _el$73 = createElement("text"), _el$75 = createElement("text"), _el$77 = createElement("text");
+    insertNode(_el$70, _el$71);
+    insertNode(_el$70, _el$73);
+    insertNode(_el$70, _el$75);
+    insertNode(_el$70, _el$77);
+    setProp(_el$70, "flexDirection", "column");
+    insertNode(_el$71, createTextNode(`Select execution mode:`));
+    setProp(_el$71, "fg", "cyan");
+    insertNode(_el$73, createTextNode(` `));
+    insert(_el$70, createComponent2(SelectInput, {
       items: EXECUTION_MODES,
       onSelect: (item) => props.onSelect(item.value),
       onChange: handleChange,
@@ -47153,19 +47413,19 @@ function ExecutionModeStep(props) {
         return props.focused ?? true;
       },
       selectRef: setSelectRef
-    }), _el$66);
-    insertNode(_el$66, createTextNode(` `));
-    insertNode(_el$68, createTextNode(`[Enter] Select [Esc] Back`));
+    }), _el$75);
+    insertNode(_el$75, createTextNode(` `));
+    insertNode(_el$77, createTextNode(`[Enter] Select [Esc] Back`));
     effect((_p$) => {
-      var _v$11 = TextAttributes.BOLD, _v$12 = TextAttributes.DIM;
-      _v$11 !== _p$.e && (_p$.e = setProp(_el$62, "attributes", _v$11, _p$.e));
-      _v$12 !== _p$.t && (_p$.t = setProp(_el$68, "attributes", _v$12, _p$.t));
+      var _v$15 = TextAttributes.BOLD, _v$16 = TextAttributes.DIM;
+      _v$15 !== _p$.e && (_p$.e = setProp(_el$71, "attributes", _v$15, _p$.e));
+      _v$16 !== _p$.t && (_p$.t = setProp(_el$77, "attributes", _v$16, _p$.t));
       return _p$;
     }, {
       e: undefined,
       t: undefined
     });
-    return _el$61;
+    return _el$70;
   })();
 }
 var SKIP_OPTIONS = [{
@@ -47197,16 +47457,16 @@ function SkipPermissionsStep(props) {
     }
   };
   return (() => {
-    var _el$70 = createElement("box"), _el$71 = createElement("text"), _el$73 = createElement("text"), _el$75 = createElement("text"), _el$77 = createElement("text");
-    insertNode(_el$70, _el$71);
-    insertNode(_el$70, _el$73);
-    insertNode(_el$70, _el$75);
-    insertNode(_el$70, _el$77);
-    setProp(_el$70, "flexDirection", "column");
-    insertNode(_el$71, createTextNode(`Skip permission prompts?`));
-    setProp(_el$71, "fg", "cyan");
-    insertNode(_el$73, createTextNode(` `));
-    insert(_el$70, createComponent2(SelectInput, {
+    var _el$79 = createElement("box"), _el$80 = createElement("text"), _el$82 = createElement("text"), _el$84 = createElement("text"), _el$86 = createElement("text");
+    insertNode(_el$79, _el$80);
+    insertNode(_el$79, _el$82);
+    insertNode(_el$79, _el$84);
+    insertNode(_el$79, _el$86);
+    setProp(_el$79, "flexDirection", "column");
+    insertNode(_el$80, createTextNode(`Skip permission prompts?`));
+    setProp(_el$80, "fg", "cyan");
+    insertNode(_el$82, createTextNode(` `));
+    insert(_el$79, createComponent2(SelectInput, {
       items: SKIP_OPTIONS,
       onSelect: (item) => props.onSelect(item.value === "true"),
       onChange: handleChange,
@@ -47214,19 +47474,19 @@ function SkipPermissionsStep(props) {
         return props.focused ?? true;
       },
       selectRef: setSelectRef
-    }), _el$75);
-    insertNode(_el$75, createTextNode(` `));
-    insertNode(_el$77, createTextNode(`[Enter] Select [Esc] Back`));
+    }), _el$84);
+    insertNode(_el$84, createTextNode(` `));
+    insertNode(_el$86, createTextNode(`[Enter] Select [Esc] Back`));
     effect((_p$) => {
-      var _v$13 = TextAttributes.BOLD, _v$14 = TextAttributes.DIM;
-      _v$13 !== _p$.e && (_p$.e = setProp(_el$71, "attributes", _v$13, _p$.e));
-      _v$14 !== _p$.t && (_p$.t = setProp(_el$77, "attributes", _v$14, _p$.t));
+      var _v$17 = TextAttributes.BOLD, _v$18 = TextAttributes.DIM;
+      _v$17 !== _p$.e && (_p$.e = setProp(_el$80, "attributes", _v$17, _p$.e));
+      _v$18 !== _p$.t && (_p$.t = setProp(_el$86, "attributes", _v$18, _p$.t));
       return _p$;
     }, {
       e: undefined,
       t: undefined
     });
-    return _el$70;
+    return _el$79;
   })();
 }
 var LATEST_OPTION = {
@@ -47234,60 +47494,20 @@ var LATEST_OPTION = {
   value: "latest",
   description: "Always fetch latest version"
 };
-function getPackageNameForAgent(agentId) {
-  const agent = BUILTIN_CODING_AGENTS.find((a2) => a2.id === agentId);
-  if (!agent || agent.type !== "bunx") {
-    return null;
-  }
-  const {
-    packageName
-  } = parsePackageCommand(agent.command);
-  return packageName;
-}
-async function fetchVersionOptions(agentId) {
-  const packageName = getPackageNameForAgent(agentId);
-  if (!packageName) {
-    return [];
-  }
-  const versions = await fetchPackageVersions(packageName);
-  return versions.map((v) => {
-    const item = {
-      label: v.isPrerelease ? `${v.version} (pre)` : v.version,
-      value: v.version
-    };
-    if (v.publishedAt) {
-      item.description = new Date(v.publishedAt).toLocaleDateString();
-    }
-    return item;
-  });
-}
-var AGENT_COMMAND_MAP = {
-  "claude-code": "claude",
-  "codex-cli": "codex",
-  "gemini-cli": "gemini",
-  opencode: "opencode"
-};
-async function fetchInstalledOption(agentId) {
-  const commandName = AGENT_COMMAND_MAP[agentId];
-  if (!commandName) {
-    return null;
-  }
-  const result = await findCommand(commandName);
-  if (result.source !== "installed" || !result.path) {
-    return null;
-  }
-  const version = result.version?.replace(/^v/, "") ?? "unknown";
-  return {
-    label: `installed@${version}`,
-    value: "installed",
-    description: result.path
-  };
-}
 function VersionSelectStep(props) {
   const [selectedIndex, setSelectedIndex] = createSignal(0);
   const [selectRef, setSelectRef] = createSignal(undefined);
-  const [versionOptions] = createResource(() => props.agentId, fetchVersionOptions);
-  const [installedOption] = createResource(() => props.agentId, fetchInstalledOption);
+  const cachedVersions = () => {
+    const cached = getVersionCache(props.agentId);
+    if (!cached) {
+      return [];
+    }
+    return cached.map(versionInfoToSelectItem);
+  };
+  const installedOption = () => {
+    const installed = getInstalledVersionCache(props.agentId);
+    return installed ? createInstalledOption(installed) : null;
+  };
   const allOptions = () => {
     const options = [];
     const installed = installedOption();
@@ -47295,8 +47515,8 @@ function VersionSelectStep(props) {
       options.push(installed);
     }
     options.push(LATEST_OPTION);
-    const dynamic = versionOptions() ?? [];
-    options.push(...dynamic);
+    const cached = cachedVersions();
+    options.push(...cached);
     return options;
   };
   useEnsureSelectionVisible({
@@ -47327,34 +47547,32 @@ function VersionSelectStep(props) {
     }
   };
   const statusText = () => {
-    if (versionOptions.loading) {
-      return "Fetching versions...";
-    }
-    if (versionOptions.error) {
-      return "Could not fetch versions";
+    const cached = cachedVersions();
+    if (cached.length === 0) {
+      return "Version list unavailable (using latest)";
     }
     return null;
   };
   return (() => {
-    var _el$79 = createElement("box"), _el$80 = createElement("text"), _el$82 = createElement("text"), _el$84 = createElement("text"), _el$86 = createElement("text");
-    insertNode(_el$79, _el$80);
-    insertNode(_el$79, _el$82);
-    insertNode(_el$79, _el$84);
-    insertNode(_el$79, _el$86);
-    setProp(_el$79, "flexDirection", "column");
-    insertNode(_el$80, createTextNode(`Select version:`));
-    setProp(_el$80, "fg", "cyan");
-    insert(_el$79, (() => {
+    var _el$88 = createElement("box"), _el$89 = createElement("text"), _el$91 = createElement("text"), _el$93 = createElement("text"), _el$95 = createElement("text");
+    insertNode(_el$88, _el$89);
+    insertNode(_el$88, _el$91);
+    insertNode(_el$88, _el$93);
+    insertNode(_el$88, _el$95);
+    setProp(_el$88, "flexDirection", "column");
+    insertNode(_el$89, createTextNode(`Select version:`));
+    setProp(_el$89, "fg", "cyan");
+    insert(_el$88, (() => {
       var _c$ = memo2(() => !!statusText());
       return () => _c$() && (() => {
-        var _el$88 = createElement("text");
-        insert(_el$88, statusText);
-        effect((_$p) => setProp(_el$88, "attributes", TextAttributes.DIM, _$p));
-        return _el$88;
+        var _el$97 = createElement("text");
+        insert(_el$97, statusText);
+        effect((_$p) => setProp(_el$97, "attributes", TextAttributes.DIM, _$p));
+        return _el$97;
       })();
-    })(), _el$82);
-    insertNode(_el$82, createTextNode(` `));
-    insert(_el$79, createComponent2(SelectInput, {
+    })(), _el$91);
+    insertNode(_el$91, createTextNode(` `));
+    insert(_el$88, createComponent2(SelectInput, {
       get items() {
         return allOptions();
       },
@@ -47364,19 +47582,19 @@ function VersionSelectStep(props) {
         return props.focused ?? true;
       },
       selectRef: setSelectRef
-    }), _el$84);
-    insertNode(_el$84, createTextNode(` `));
-    insertNode(_el$86, createTextNode(`[Enter] Select [Esc] Back`));
+    }), _el$93);
+    insertNode(_el$93, createTextNode(` `));
+    insertNode(_el$95, createTextNode(`[Enter] Select [Esc] Back`));
     effect((_p$) => {
-      var _v$15 = TextAttributes.BOLD, _v$16 = TextAttributes.DIM;
-      _v$15 !== _p$.e && (_p$.e = setProp(_el$80, "attributes", _v$15, _p$.e));
-      _v$16 !== _p$.t && (_p$.t = setProp(_el$86, "attributes", _v$16, _p$.t));
+      var _v$19 = TextAttributes.BOLD, _v$20 = TextAttributes.DIM;
+      _v$19 !== _p$.e && (_p$.e = setProp(_el$89, "attributes", _v$19, _p$.e));
+      _v$20 !== _p$.t && (_p$.t = setProp(_el$95, "attributes", _v$20, _p$.t));
       return _p$;
     }, {
       e: undefined,
       t: undefined
     });
-    return _el$79;
+    return _el$88;
   })();
 }
 
@@ -47392,7 +47610,9 @@ function WizardController(props) {
   const [selectedModel, setSelectedModel] = createSignal("");
   const [reasoningLevel, setReasoningLevel] = createSignal(undefined);
   const [executionMode, setExecutionMode] = createSignal("normal");
-  const [isInitialFrame, setIsInitialFrame] = createSignal(true);
+  const [versionSelectionReady, setVersionSelectionReady] = createSignal(false);
+  const [isTransitioning, setIsTransitioning] = createSignal(true);
+  let versionSelectionTimer = null;
   function getInitialStep() {
     if (props.history.length > 0) {
       return "quick-start";
@@ -47411,20 +47631,23 @@ function WizardController(props) {
     setReasoningLevel(undefined);
     setExecutionMode("normal");
   };
+  const startTransition2 = () => {
+    setIsTransitioning(true);
+    setTimeout(() => setIsTransitioning(false), 50);
+  };
   let prevVisible = false;
   createEffect(() => {
     const visible = props.visible;
     if (visible && !prevVisible) {
       resetWizard();
-      setIsInitialFrame(true);
-      setTimeout(() => setIsInitialFrame(false), 150);
+      startTransition2();
     }
     prevVisible = visible;
   });
   useKeyboard((key) => {
     if (!props.visible)
       return;
-    if (isInitialFrame() && key.name === "return") {
+    if (isTransitioning() && key.name === "return") {
       return;
     }
     if (key.name === "escape") {
@@ -47434,6 +47657,7 @@ function WizardController(props) {
   const goToStep = (nextStep) => {
     setStepHistory((prev) => [...prev, step()]);
     setStep(nextStep);
+    startTransition2();
   };
   const goBack = () => {
     const history = stepHistory();
@@ -47444,7 +47668,28 @@ function WizardController(props) {
     const previousStep = history[history.length - 1] ?? "agent-select";
     setStepHistory(history.slice(0, -1));
     setStep(previousStep);
+    startTransition2();
   };
+  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);
+    }
+  });
   const needsReasoningLevel = createMemo(() => {
     return selectedAgent() === "codex-cli";
   });
@@ -47479,10 +47724,18 @@ function WizardController(props) {
     goToStep("version-select");
   };
   const handleVersionSelect = (version) => {
-    setSelectedVersion(version === "installed" ? null : version);
+    if (!versionSelectionReady() || step() !== "version-select") {
+      return;
+    }
+    setSelectedVersion(version);
     goToStep("model-select");
   };
   const handleModelSelect = (model) => {
+    const agent = selectedAgent();
+    if (agent === "opencode" && model === "__custom__") {
+      goToStep("model-input");
+      return;
+    }
     setSelectedModel(model);
     if (needsReasoningLevel()) {
       goToStep("reasoning-level");
@@ -47490,6 +47743,18 @@ function WizardController(props) {
       goToStep("execution-mode");
     }
   };
+  const handleModelInputSubmit = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return;
+    }
+    setSelectedModel(trimmed);
+    if (needsReasoningLevel()) {
+      goToStep("reasoning-level");
+    } else {
+      goToStep("execution-mode");
+    }
+  };
   const handleReasoningLevelSelect = (level) => {
     setReasoningLevel(level);
     goToStep("execution-mode");
@@ -47526,7 +47791,7 @@ function WizardController(props) {
   };
   const renderStep = () => {
     const currentStep = step();
-    const focused = !isInitialFrame();
+    const focused = !isTransitioning();
     if (currentStep === "action-select") {
       return createComponent2(ActionSelectStep, {
         get branchName() {
@@ -47593,6 +47858,16 @@ function WizardController(props) {
         focused
       });
     }
+    if (currentStep === "model-input") {
+      return createComponent2(ModelInputStep, {
+        get agentId() {
+          return selectedAgent() ?? "claude-code";
+        },
+        onSubmit: handleModelInputSubmit,
+        onBack: goBack,
+        focused
+      });
+    }
     if (currentStep === "reasoning-level") {
       return createComponent2(ReasoningLevelStep, {
         onSelect: handleReasoningLevelSelect,
@@ -47780,6 +48055,10 @@ function useScrollableList(options) {
 
 // src/cli/ui/screens/solid/SelectorScreen.tsx
 var clamp2 = (value, min, max) => Math.min(Math.max(value, min), max);
+var padLine2 = (value, width) => {
+  const padding = Math.max(0, width - stringWidth(value));
+  return padding > 0 ? `${value}${" ".repeat(padding)}` : value;
+};
 function SelectorScreen({
   title,
   description,
@@ -47898,30 +48177,34 @@ function SelectorScreen({
         insert(_el$5, () => list.visibleItems().map((item, index) => {
           const absoluteIndex = list.scrollOffset() + index;
           const isSelected = absoluteIndex === selectedIndex();
+          const descriptionText = showDescription && item.description ? ` - ${item.description}` : "";
+          const fullLine = `${item.label}${descriptionText}`;
           return (() => {
-            var _el$6 = createElement("box"), _el$7 = createElement("text");
-            insertNode(_el$6, _el$7);
+            var _el$6 = createElement("box");
             setProp(_el$6, "flexDirection", "row");
-            spread(_el$7, mergeProps3(() => isSelected ? {
-              fg: "cyan",
-              attributes: TextAttributes.BOLD
-            } : {}), true);
-            insert(_el$7, () => item.label);
-            insert(_el$6, (() => {
-              var _c$2 = memo2(() => !!(showDescription && item.description));
-              return () => _c$2() ? (() => {
-                var _el$8 = createElement("text");
-                spread(_el$8, mergeProps3({
-                  get attributes() {
-                    return TextAttributes.DIM;
-                  }
-                }, isSelected ? {
-                  fg: "cyan"
-                } : {}), true);
-                insert(_el$8, () => ` - ${item.description}`);
-                return _el$8;
-              })() : null;
-            })(), null);
+            insert(_el$6, isSelected ? (() => {
+              var _el$7 = createElement("text");
+              insert(_el$7, () => padLine2(fullLine, terminal().columns));
+              effect((_p$) => {
+                var _v$ = selectionStyle.fg, _v$2 = selectionStyle.bg;
+                _v$ !== _p$.e && (_p$.e = setProp(_el$7, "fg", _v$, _p$.e));
+                _v$2 !== _p$.t && (_p$.t = setProp(_el$7, "bg", _v$2, _p$.t));
+                return _p$;
+              }, {
+                e: undefined,
+                t: undefined
+              });
+              return _el$7;
+            })() : [(() => {
+              var _el$8 = createElement("text");
+              insert(_el$8, () => item.label);
+              return _el$8;
+            })(), memo2(() => memo2(() => !!(showDescription && item.description))() ? (() => {
+              var _el$9 = createElement("text");
+              insert(_el$9, () => ` - ${item.description}`);
+              effect((_$p) => setProp(_el$9, "attributes", TextAttributes.DIM, _$p));
+              return _el$9;
+            })() : null)]);
             return _el$6;
           })();
         }));
@@ -47939,53 +48222,237 @@ function SelectorScreen({
 }
 
 // src/cli/ui/screens/solid/LogScreen.tsx
-function LogScreen({
-  entries,
-  loading = false,
-  error = null,
-  onBack,
-  onSelect,
-  onCopy,
-  onPickDate,
-  notification,
-  version,
-  selectedDate,
-  helpVisible = false
-}) {
+var LEVEL_ORDER = ["ALL", "INFO+", "WARN+", "ERROR+"];
+var LEVEL_THRESHOLDS = {
+  ALL: 0,
+  "INFO+": 30,
+  "WARN+": 40,
+  "ERROR+": 50
+};
+var LEVEL_LABEL_VALUES = {
+  TRACE: 10,
+  DEBUG: 20,
+  INFO: 30,
+  WARN: 40,
+  ERROR: 50,
+  FATAL: 60
+};
+var measureWidth2 = (value) => stringWidth(value);
+var truncateToWidth3 = (value, maxWidth) => {
+  if (maxWidth <= 0) {
+    return "";
+  }
+  if (measureWidth2(value) <= maxWidth) {
+    return value;
+  }
+  const ellipsis = "...";
+  const ellipsisWidth = measureWidth2(ellipsis);
+  if (ellipsisWidth >= maxWidth) {
+    return ellipsis.slice(0, maxWidth);
+  }
+  let currentWidth = 0;
+  let result = "";
+  for (const char of Array.from(value)) {
+    const charWidth = measureWidth2(char);
+    if (currentWidth + charWidth + ellipsisWidth > maxWidth) {
+      break;
+    }
+    result += char;
+    currentWidth += charWidth;
+  }
+  return `${result}${ellipsis}`;
+};
+var padToWidth = (value, width) => {
+  if (width <= 0) {
+    return "";
+  }
+  const truncated = truncateToWidth3(value, width);
+  const padding = Math.max(0, width - measureWidth2(truncated));
+  return `${truncated}${" ".repeat(padding)}`;
+};
+var appendSegment2 = (segments, segment) => {
+  if (!segment.text) {
+    return;
+  }
+  segments.push(segment);
+};
+var measureSegmentsWidth2 = (segments) => segments.reduce((total, segment) => total + measureWidth2(segment.text), 0);
+var truncateSegmentsToWidth2 = (segments, maxWidth) => {
+  if (maxWidth <= 0) {
+    return [];
+  }
+  const result = [];
+  let currentWidth = 0;
+  for (const segment of segments) {
+    if (currentWidth >= maxWidth) {
+      break;
+    }
+    const segmentWidth = measureWidth2(segment.text);
+    if (currentWidth + segmentWidth <= maxWidth) {
+      result.push(segment);
+      currentWidth += segmentWidth;
+      continue;
+    }
+    const remaining = maxWidth - currentWidth;
+    const truncated = truncateToWidth3(segment.text, remaining);
+    if (truncated) {
+      result.push({
+        ...segment,
+        text: truncated
+      });
+      currentWidth += measureWidth2(truncated);
+    }
+    break;
+  }
+  return result;
+};
+var segmentsToText = (segments) => segments.map((segment) => segment.text).join("");
+var padLine3 = (value, width) => {
+  const padding = Math.max(0, width - measureWidth2(value));
+  return padding > 0 ? `${value}${" ".repeat(padding)}` : value;
+};
+var resolveEntryLevel = (entry) => {
+  const rawLevel = entry.raw?.level;
+  if (typeof rawLevel === "number") {
+    return rawLevel;
+  }
+  const label = entry.levelLabel?.toUpperCase() ?? "";
+  return LEVEL_LABEL_VALUES[label] ?? 0;
+};
+function LogScreen(props) {
+  const merged = mergeProps({
+    loading: false,
+    error: null,
+    branchLabel: null,
+    sourceLabel: null,
+    tailing: false,
+    helpVisible: false
+  }, props);
   const terminal = useTerminalSize();
+  const [filterQuery, setFilterQuery] = createSignal("");
+  const [filterMode, setFilterMode] = createSignal(false);
+  const [levelMode, setLevelMode] = createSignal("ALL");
+  const filteredEntries = createMemo(() => {
+    let result = merged.entries;
+    const threshold = LEVEL_THRESHOLDS[levelMode()];
+    if (threshold > 0) {
+      result = result.filter((entry) => resolveEntryLevel(entry) >= threshold);
+    }
+    const query = filterQuery().trim().toLowerCase();
+    if (!query) {
+      return result;
+    }
+    return result.filter((entry) => {
+      const target = `${entry.category} ${entry.levelLabel} ${entry.message}`.toLowerCase();
+      return target.includes(query);
+    });
+  });
+  const totalCount = createMemo(() => merged.entries.length);
+  const filteredCount = createMemo(() => filteredEntries().length);
+  const showFilterCount = createMemo(() => filterMode() || filterQuery().trim().length > 0);
+  const levelWidth = createMemo(() => {
+    const MIN = 5;
+    return Math.max(MIN, ...filteredEntries().map((entry) => measureWidth2(entry.levelLabel)));
+  });
+  const categoryWidth = createMemo(() => {
+    const MIN = 4;
+    const MAX = 20;
+    const maxWidth = Math.max(MIN, ...filteredEntries().map((entry) => measureWidth2(entry.category)));
+    return Math.min(MAX, maxWidth);
+  });
   const listHeight = createMemo(() => {
     const headerRows = 2;
-    const infoRows = 1;
+    const infoRows = 3;
     const footerRows = 1;
-    const notificationRows = notification ? 1 : 0;
+    const notificationRows = merged.notification ? 1 : 0;
     const reserved = headerRows + infoRows + footerRows + notificationRows;
     return Math.max(1, terminal().rows - reserved);
   });
   const list = useScrollableList({
-    items: () => entries,
+    items: filteredEntries,
     visibleCount: listHeight
   });
-  const currentEntry = createMemo(() => entries[list.selectedIndex()]);
+  const currentEntry = createMemo(() => filteredEntries()[list.selectedIndex()]);
+  createEffect(() => {
+    filterQuery();
+    levelMode();
+    list.setSelectedIndex(0);
+    list.setScrollOffset(0);
+  });
   const updateSelectedIndex = (value) => {
     list.setSelectedIndex(value);
   };
   useKeyboard((key) => {
-    if (helpVisible) {
+    if (merged.helpVisible) {
+      return;
+    }
+    if (filterMode()) {
+      if (key.name === "down") {
+        updateSelectedIndex((prev) => prev + 1);
+        return;
+      }
+      if (key.name === "up") {
+        updateSelectedIndex((prev) => prev - 1);
+        return;
+      }
+      if (key.name === "escape") {
+        if (filterQuery()) {
+          setFilterQuery("");
+        } else {
+          setFilterMode(false);
+        }
+        return;
+      }
+      if (key.name === "backspace") {
+        setFilterQuery((prev) => prev.slice(0, -1));
+        return;
+      }
+      if (key.name === "return" || key.name === "linefeed") {
+        setFilterMode(false);
+        return;
+      }
+      if (key.sequence && key.sequence.length === 1 && !key.ctrl && !key.meta && !key.super && !key.hyper) {
+        setFilterQuery((prev) => prev + key.sequence);
+      }
       return;
     }
     if (key.name === "escape" || key.name === "q") {
-      onBack();
+      merged.onBack();
       return;
     }
     if (key.name === "c") {
       const entry = currentEntry();
       if (entry) {
-        onCopy(entry);
+        merged.onCopy(entry);
       }
       return;
     }
     if (key.name === "d") {
-      onPickDate?.();
+      merged.onPickDate?.();
+      return;
+    }
+    if (key.name === "f") {
+      setFilterMode(true);
+      return;
+    }
+    if (key.name === "v") {
+      setLevelMode((prev) => {
+        const index = LEVEL_ORDER.indexOf(prev);
+        const nextIndex = (index + 1) % LEVEL_ORDER.length;
+        return LEVEL_ORDER[nextIndex] ?? "ALL";
+      });
+      return;
+    }
+    if (key.name === "r") {
+      merged.onReload?.();
+      return;
+    }
+    if (key.name === "t") {
+      merged.onToggleTail?.();
+      return;
+    }
+    if (key.name === "x") {
+      merged.onReset?.();
       return;
     }
     if (key.name === "down") {
@@ -48009,13 +48476,13 @@ function LogScreen({
       return;
     }
     if (key.name === "end") {
-      updateSelectedIndex(entries.length - 1);
+      updateSelectedIndex(filteredEntries().length - 1);
       return;
     }
     if (key.name === "return" || key.name === "linefeed") {
       const entry = currentEntry();
       if (entry) {
-        onSelect(entry);
+        merged.onSelect(entry);
       }
     }
   });
@@ -48029,92 +48496,227 @@ function LogScreen({
     }, {
       key: "d",
       description: "Date"
+    }, {
+      key: "f",
+      description: "Filter"
+    }, {
+      key: "v",
+      description: "Level"
+    }, {
+      key: "r",
+      description: "Reload"
+    }, {
+      key: "t",
+      description: "Tail"
+    }, {
+      key: "x",
+      description: "Reset"
     }, {
       key: "esc",
       description: "Back"
     }];
     return actions;
   });
+  const formatEntrySegments = (entry) => {
+    const levelText = padToWidth(entry.levelLabel, levelWidth());
+    const categoryText = padToWidth(entry.category, categoryWidth());
+    const segments = [];
+    appendSegment2(segments, {
+      text: `[${entry.timeLabel}] `
+    });
+    appendSegment2(segments, {
+      text: "["
+    });
+    appendSegment2(segments, {
+      text: levelText,
+      fg: getLogLevelColor(entry.levelLabel)
+    });
+    appendSegment2(segments, {
+      text: "] "
+    });
+    appendSegment2(segments, {
+      text: "["
+    });
+    appendSegment2(segments, {
+      text: categoryText
+    });
+    appendSegment2(segments, {
+      text: "] "
+    });
+    appendSegment2(segments, {
+      text: entry.message
+    });
+    const maxWidth = terminal().columns;
+    if (measureSegmentsWidth2(segments) <= maxWidth) {
+      return segments;
+    }
+    return truncateSegmentsToWidth2(segments, maxWidth);
+  };
+  const filterLabel = createMemo(() => {
+    if (filterQuery()) {
+      return filterQuery();
+    }
+    return filterMode() ? "(type to filter)" : "(press f to filter)";
+  });
   return (() => {
-    var _el$ = createElement("box"), _el$2 = createElement("box"), _el$3 = createElement("text"), _el$5 = createElement("text"), _el$6 = createElement("text"), _el$8 = createElement("text"), _el$9 = createElement("box");
+    var _el$ = createElement("box"), _el$2 = createElement("box"), _el$3 = createElement("text"), _el$5 = createElement("text"), _el$6 = createElement("text"), _el$8 = createElement("text"), _el$9 = createElement("box"), _el$0 = createElement("text"), _el$10 = createElement("text"), _el$11 = createElement("text"), _el$13 = createElement("text"), _el$14 = createElement("text"), _el$16 = createElement("text"), _el$17 = createElement("text"), _el$19 = createElement("text"), _el$20 = createElement("box"), _el$21 = createElement("text"), _el$23 = createElement("text"), _el$24 = createElement("box");
     insertNode(_el$, _el$2);
     insertNode(_el$, _el$9);
+    insertNode(_el$, _el$20);
+    insertNode(_el$, _el$24);
     setProp(_el$, "flexDirection", "column");
     insert(_el$, createComponent2(Header, {
       title: "gwt - Log Viewer",
       titleColor: "cyan",
-      version
+      get version() {
+        return merged.version;
+      }
     }), _el$2);
-    insert(_el$, notification ? (() => {
-      var _el$0 = createElement("text");
-      insert(_el$0, () => notification.message);
-      effect((_$p) => setProp(_el$0, "fg", notification.tone === "error" ? "red" : "green", _$p));
-      return _el$0;
-    })() : null, _el$2);
+    insert(_el$, (() => {
+      var _c$ = memo2(() => !!merged.notification);
+      return () => _c$() ? (() => {
+        var _el$25 = createElement("text");
+        insert(_el$25, () => merged.notification.message);
+        effect((_$p) => setProp(_el$25, "fg", merged.notification.tone === "error" ? "red" : "green", _$p));
+        return _el$25;
+      })() : null;
+    })(), _el$2);
     insertNode(_el$2, _el$3);
     insertNode(_el$2, _el$5);
     insertNode(_el$2, _el$6);
     insertNode(_el$2, _el$8);
     setProp(_el$2, "flexDirection", "row");
-    insertNode(_el$3, createTextNode(`Date: `));
-    insert(_el$5, selectedDate ?? "---");
-    insertNode(_el$6, createTextNode(` Total: `));
-    insert(_el$8, () => entries.length);
-    setProp(_el$9, "flexDirection", "column");
-    setProp(_el$9, "flexGrow", 1);
-    insert(_el$9, () => loading ? (() => {
-      var _el$1 = createElement("text");
-      insertNode(_el$1, createTextNode(`Loading logs...`));
-      setProp(_el$1, "fg", "gray");
-      return _el$1;
-    })() : entries.length === 0 ? (() => {
-      var _el$11 = createElement("text");
-      insertNode(_el$11, createTextNode(`No logs available.`));
-      setProp(_el$11, "fg", "gray");
-      return _el$11;
-    })() : (() => {
-      var _el$13 = createElement("box");
-      setProp(_el$13, "flexDirection", "column");
-      insert(_el$13, () => list.visibleItems().map((entry, index) => {
-        const absoluteIndex = list.scrollOffset() + index;
-        const isSelected = absoluteIndex === list.selectedIndex();
-        return (() => {
-          var _el$14 = createElement("text");
-          spread(_el$14, mergeProps3(() => isSelected ? {
-            fg: "cyan",
-            attributes: TextAttributes.BOLD
-          } : {}), true);
-          insert(_el$14, () => entry.summary);
-          return _el$14;
-        })();
-      }));
-      return _el$13;
+    insertNode(_el$3, createTextNode(`Branch: `));
+    insert(_el$5, () => merged.branchLabel ?? "(none)");
+    insertNode(_el$6, createTextNode(` Source: `));
+    insert(_el$8, () => merged.sourceLabel ?? "(none)");
+    insertNode(_el$9, _el$0);
+    insertNode(_el$9, _el$10);
+    insertNode(_el$9, _el$11);
+    insertNode(_el$9, _el$13);
+    insertNode(_el$9, _el$14);
+    insertNode(_el$9, _el$16);
+    insertNode(_el$9, _el$17);
+    insertNode(_el$9, _el$19);
+    setProp(_el$9, "flexDirection", "row");
+    insertNode(_el$0, createTextNode(`Date: `));
+    insert(_el$10, () => merged.selectedDate ?? "---");
+    insertNode(_el$11, createTextNode(` Total: `));
+    insert(_el$13, totalCount);
+    insertNode(_el$14, createTextNode(` Level: `));
+    insert(_el$16, levelMode);
+    insertNode(_el$17, createTextNode(` Tail: `));
+    insert(_el$19, () => merged.tailing ? "ON" : "OFF");
+    insertNode(_el$20, _el$21);
+    insertNode(_el$20, _el$23);
+    setProp(_el$20, "flexDirection", "row");
+    insertNode(_el$21, createTextNode(`Filter: `));
+    insert(_el$23, filterLabel);
+    insert(_el$20, (() => {
+      var _c$2 = memo2(() => !!showFilterCount());
+      return () => _c$2() ? (() => {
+        var _el$26 = createElement("text");
+        insert(_el$26, () => ` (Showing ${filteredCount()} of ${totalCount()})`);
+        effect((_$p) => setProp(_el$26, "attributes", TextAttributes.DIM, _$p));
+        return _el$26;
+      })() : null;
+    })(), null);
+    setProp(_el$24, "flexDirection", "column");
+    setProp(_el$24, "flexGrow", 1);
+    insert(_el$24, (() => {
+      var _c$3 = memo2(() => !!merged.loading);
+      return () => _c$3() ? (() => {
+        var _el$27 = createElement("text");
+        insertNode(_el$27, createTextNode(`Loading logs...`));
+        setProp(_el$27, "fg", "gray");
+        return _el$27;
+      })() : memo2(() => filteredEntries().length === 0)() ? (() => {
+        var _el$29 = createElement("text");
+        insertNode(_el$29, createTextNode(`No logs available.`));
+        setProp(_el$29, "fg", "gray");
+        return _el$29;
+      })() : (() => {
+        var _el$31 = createElement("box");
+        setProp(_el$31, "flexDirection", "column");
+        insert(_el$31, () => list.visibleItems().map((entry, index) => {
+          const absoluteIndex = list.scrollOffset() + index;
+          const isSelected = absoluteIndex === list.selectedIndex();
+          const segments = formatEntrySegments(entry);
+          const lineText = segmentsToText(segments);
+          const selectedContent = padLine3(lineText, terminal().columns);
+          return (() => {
+            var _el$32 = createElement("text");
+            spread(_el$32, mergeProps3(() => isSelected ? {
+              fg: selectionStyle.fg,
+              bg: selectionStyle.bg
+            } : {}, {
+              wrapMode: "none",
+              get width() {
+                return terminal().columns;
+              }
+            }), true);
+            insert(_el$32, () => isSelected ? selectedContent : segments.map((segment) => segment.fg ? (() => {
+              var _el$33 = createElement("span");
+              insert(_el$33, () => segment.text);
+              effect((_$p) => setProp(_el$33, "style", {
+                fg: segment.fg
+              }, _$p));
+              return _el$33;
+            })() : segment.text));
+            return _el$32;
+          })();
+        }));
+        return _el$31;
+      })();
+    })(), null);
+    insert(_el$24, (() => {
+      var _c$4 = memo2(() => !!merged.error);
+      return () => _c$4() ? (() => {
+        var _el$34 = createElement("text");
+        setProp(_el$34, "fg", "red");
+        insert(_el$34, () => merged.error);
+        return _el$34;
+      })() : null;
     })(), null);
-    insert(_el$9, error ? (() => {
-      var _el$15 = createElement("text");
-      setProp(_el$15, "fg", "red");
-      insert(_el$15, error);
-      return _el$15;
-    })() : null, null);
     insert(_el$, createComponent2(Footer, {
       get actions() {
         return footerActions();
       }
     }), null);
     effect((_p$) => {
-      var _v$ = terminal().rows, _v$2 = TextAttributes.DIM, _v$3 = TextAttributes.BOLD, _v$4 = TextAttributes.DIM, _v$5 = TextAttributes.BOLD;
+      var _v$ = terminal().rows, _v$2 = TextAttributes.DIM, _v$3 = TextAttributes.BOLD, _v$4 = TextAttributes.DIM, _v$5 = TextAttributes.BOLD, _v$6 = TextAttributes.DIM, _v$7 = TextAttributes.BOLD, _v$8 = TextAttributes.DIM, _v$9 = TextAttributes.BOLD, _v$0 = TextAttributes.DIM, _v$1 = TextAttributes.BOLD, _v$10 = TextAttributes.DIM, _v$11 = TextAttributes.BOLD, _v$12 = TextAttributes.DIM, _v$13 = TextAttributes.BOLD;
       _v$ !== _p$.e && (_p$.e = setProp(_el$, "height", _v$, _p$.e));
       _v$2 !== _p$.t && (_p$.t = setProp(_el$3, "attributes", _v$2, _p$.t));
       _v$3 !== _p$.a && (_p$.a = setProp(_el$5, "attributes", _v$3, _p$.a));
       _v$4 !== _p$.o && (_p$.o = setProp(_el$6, "attributes", _v$4, _p$.o));
       _v$5 !== _p$.i && (_p$.i = setProp(_el$8, "attributes", _v$5, _p$.i));
+      _v$6 !== _p$.n && (_p$.n = setProp(_el$0, "attributes", _v$6, _p$.n));
+      _v$7 !== _p$.s && (_p$.s = setProp(_el$10, "attributes", _v$7, _p$.s));
+      _v$8 !== _p$.h && (_p$.h = setProp(_el$11, "attributes", _v$8, _p$.h));
+      _v$9 !== _p$.r && (_p$.r = setProp(_el$13, "attributes", _v$9, _p$.r));
+      _v$0 !== _p$.d && (_p$.d = setProp(_el$14, "attributes", _v$0, _p$.d));
+      _v$1 !== _p$.l && (_p$.l = setProp(_el$16, "attributes", _v$1, _p$.l));
+      _v$10 !== _p$.u && (_p$.u = setProp(_el$17, "attributes", _v$10, _p$.u));
+      _v$11 !== _p$.c && (_p$.c = setProp(_el$19, "attributes", _v$11, _p$.c));
+      _v$12 !== _p$.w && (_p$.w = setProp(_el$21, "attributes", _v$12, _p$.w));
+      _v$13 !== _p$.m && (_p$.m = setProp(_el$23, "attributes", _v$13, _p$.m));
       return _p$;
     }, {
       e: undefined,
       t: undefined,
       a: undefined,
       o: undefined,
-      i: undefined
+      i: undefined,
+      n: undefined,
+      s: undefined,
+      h: undefined,
+      r: undefined,
+      d: undefined,
+      l: undefined,
+      u: undefined,
+      c: undefined,
+      w: undefined,
+      m: undefined
     });
     return _el$;
   })();
@@ -48473,9 +49075,16 @@ function ConfirmScreen({
   yesLabel = "Yes",
   noLabel = "No",
   defaultNo = false,
-  helpVisible = false
+  helpVisible = false,
+  width
 }) {
   const [selectedIndex, setSelectedIndex] = createSignal(defaultNo ? 1 : 0);
+  const terminal = useTerminalSize();
+  const contentWidth = () => Math.max(0, width ?? terminal().columns);
+  const padLine4 = (value, width2) => {
+    const padding = Math.max(0, width2 - stringWidth(value));
+    return padding > 0 ? `${value}${" ".repeat(padding)}` : value;
+  };
   const confirm = (confirmed) => {
     onConfirm(confirmed);
   };
@@ -48502,25 +49111,34 @@ function ConfirmScreen({
       confirm(selectedIndex() === 0);
     }
   });
-  const renderOption = (label, isSelected) => (() => {
+  const renderOption = (label, isSelected) => isSelected ? (() => {
     var _el$ = createElement("text");
-    spread(_el$, mergeProps3(() => isSelected ? {
-      fg: "cyan",
-      attributes: TextAttributes.BOLD
-    } : {}), true);
-    insert(_el$, label);
+    insert(_el$, () => padLine4(label, contentWidth()));
+    effect((_p$) => {
+      var _v$ = selectionStyle.fg, _v$2 = selectionStyle.bg;
+      _v$ !== _p$.e && (_p$.e = setProp(_el$, "fg", _v$, _p$.e));
+      _v$2 !== _p$.t && (_p$.t = setProp(_el$, "bg", _v$2, _p$.t));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined
+    });
     return _el$;
+  })() : (() => {
+    var _el$2 = createElement("text");
+    insert(_el$2, label);
+    return _el$2;
   })();
   return (() => {
-    var _el$2 = createElement("box"), _el$3 = createElement("text"), _el$4 = createElement("box");
-    insertNode(_el$2, _el$3);
-    insertNode(_el$2, _el$4);
-    setProp(_el$2, "flexDirection", "column");
-    insert(_el$3, message);
-    setProp(_el$4, "flexDirection", "column");
-    insert(_el$4, () => renderOption(yesLabel, selectedIndex() === 0), null);
-    insert(_el$4, () => renderOption(noLabel, selectedIndex() === 1), null);
-    return _el$2;
+    var _el$3 = createElement("box"), _el$4 = createElement("text"), _el$5 = createElement("box");
+    insertNode(_el$3, _el$4);
+    insertNode(_el$3, _el$5);
+    setProp(_el$3, "flexDirection", "column");
+    insert(_el$4, message);
+    setProp(_el$5, "flexDirection", "column");
+    insert(_el$5, () => renderOption(yesLabel, selectedIndex() === 0), null);
+    insert(_el$5, () => renderOption(noLabel, selectedIndex() === 1), null);
+    return _el$3;
   })();
 }
 
@@ -48535,6 +49153,10 @@ function EnvironmentScreen({
   helpVisible = false
 }) {
   const terminal = useTerminalSize();
+  const padLine4 = (value, width) => {
+    const padding = Math.max(0, width - stringWidth(value));
+    return padding > 0 ? `${value}${" ".repeat(padding)}` : value;
+  };
   const listHeight = createMemo(() => {
     const headerRows = 2;
     const footerRows = 1;
@@ -48630,27 +49252,36 @@ function EnvironmentScreen({
           const absoluteIndex = list.scrollOffset() + index;
           const isSelected = absoluteIndex === list.selectedIndex();
           const isHighlighted = highlightSet().has(variable.key);
-          const attributes = isSelected ? TextAttributes.BOLD : undefined;
-          const keyColor = isSelected ? "cyan" : isHighlighted ? "yellow" : undefined;
-          const valueColor = isSelected ? "cyan" : undefined;
+          const keyColor = isHighlighted ? "yellow" : undefined;
           return (() => {
-            var _el$6 = createElement("box"), _el$7 = createElement("text"), _el$8 = createElement("text"), _el$9 = createTextNode(`=`);
-            insertNode(_el$6, _el$7);
-            insertNode(_el$6, _el$8);
+            var _el$6 = createElement("box");
             setProp(_el$6, "flexDirection", "row");
-            spread(_el$7, mergeProps3(keyColor ? {
-              fg: keyColor
-            } : {}, attributes !== undefined ? {
-              attributes
-            } : {}), true);
-            insert(_el$7, () => variable.key);
-            insertNode(_el$8, _el$9);
-            spread(_el$8, mergeProps3(valueColor ? {
-              fg: valueColor
-            } : {}, attributes !== undefined ? {
-              attributes
-            } : {}), true);
-            insert(_el$8, () => variable.value, null);
+            insert(_el$6, isSelected ? (() => {
+              var _el$7 = createElement("text");
+              insert(_el$7, () => padLine4(`${variable.key}=${variable.value}`, terminal().columns));
+              effect((_p$) => {
+                var _v$ = selectionStyle.fg, _v$2 = selectionStyle.bg;
+                _v$ !== _p$.e && (_p$.e = setProp(_el$7, "fg", _v$, _p$.e));
+                _v$2 !== _p$.t && (_p$.t = setProp(_el$7, "bg", _v$2, _p$.t));
+                return _p$;
+              }, {
+                e: undefined,
+                t: undefined
+              });
+              return _el$7;
+            })() : [(() => {
+              var _el$8 = createElement("text");
+              spread(_el$8, keyColor ? {
+                fg: keyColor
+              } : {}, true);
+              insert(_el$8, () => variable.key);
+              return _el$8;
+            })(), (() => {
+              var _el$9 = createElement("text"), _el$0 = createTextNode(`=`);
+              insertNode(_el$9, _el$0);
+              insert(_el$9, () => variable.value, null);
+              return _el$9;
+            })()]);
             return _el$6;
           })();
         }));
@@ -48752,6 +49383,10 @@ function ProfileEnvScreen({
   helpVisible = false
 }) {
   const terminal = useTerminalSize();
+  const padLine4 = (value, width) => {
+    const padding = Math.max(0, width - stringWidth(value));
+    return padding > 0 ? `${value}${" ".repeat(padding)}` : value;
+  };
   const listHeight = createMemo(() => {
     const headerRows = 2;
     const footerRows = 1;
@@ -48882,26 +49517,32 @@ function ProfileEnvScreen({
         insert(_el$5, () => list.visibleItems().map((variable, index) => {
           const absoluteIndex = list.scrollOffset() + index;
           const isSelected = absoluteIndex === list.selectedIndex();
-          const attributes = isSelected ? TextAttributes.BOLD : undefined;
-          const color = isSelected ? "cyan" : undefined;
           return (() => {
-            var _el$6 = createElement("box"), _el$7 = createElement("text"), _el$8 = createElement("text"), _el$9 = createTextNode(`=`);
-            insertNode(_el$6, _el$7);
-            insertNode(_el$6, _el$8);
+            var _el$6 = createElement("box");
             setProp(_el$6, "flexDirection", "row");
-            spread(_el$7, mergeProps3(color ? {
-              fg: color
-            } : {}, attributes !== undefined ? {
-              attributes
-            } : {}), true);
-            insert(_el$7, () => variable.key);
-            insertNode(_el$8, _el$9);
-            spread(_el$8, mergeProps3(color ? {
-              fg: color
-            } : {}, attributes !== undefined ? {
-              attributes
-            } : {}), true);
-            insert(_el$8, () => variable.value, null);
+            insert(_el$6, isSelected ? (() => {
+              var _el$7 = createElement("text");
+              insert(_el$7, () => padLine4(`${variable.key}=${variable.value}`, terminal().columns));
+              effect((_p$) => {
+                var _v$ = selectionStyle.fg, _v$2 = selectionStyle.bg;
+                _v$ !== _p$.e && (_p$.e = setProp(_el$7, "fg", _v$, _p$.e));
+                _v$2 !== _p$.t && (_p$.t = setProp(_el$7, "bg", _v$2, _p$.t));
+                return _p$;
+              }, {
+                e: undefined,
+                t: undefined
+              });
+              return _el$7;
+            })() : [(() => {
+              var _el$8 = createElement("text");
+              insert(_el$8, () => variable.key);
+              return _el$8;
+            })(), (() => {
+              var _el$9 = createElement("text"), _el$0 = createTextNode(`=`);
+              insertNode(_el$9, _el$0);
+              insert(_el$9, () => variable.value, null);
+              return _el$9;
+            })()]);
             return _el$6;
           })();
         }));
@@ -49000,7 +49641,8 @@ function createLogger(config = {}) {
   if (config.sync) {
     const destinationStream2 = import_pino.default.destination({
       dest: destination,
-      sync: true
+      sync: true,
+      append: true
     });
     return import_pino.default(options, destinationStream2);
   }
@@ -49024,7 +49666,8 @@ function createLogger(config = {}) {
   }
   const destinationStream = import_pino.default.destination({
     dest: destination,
-    sync: false
+    sync: false,
+    append: true
   });
   return import_pino.default(options, destinationStream);
 }
@@ -49819,6 +50462,9 @@ async function listWorktrees() {
     throw new WorktreeError("Failed to list worktrees", error);
   }
 }
+async function listAllWorktrees() {
+  return listWorktrees();
+}
 async function listAdditionalWorktrees() {
   try {
     const [allWorktrees, repoRoot] = await Promise.all([
@@ -49962,7 +50608,8 @@ async function getWorktreesWithPRStatus() {
 }
 async function getOrphanedLocalBranchStatuses({
   baseBranch,
-  repoRoot
+  repoRoot,
+  onProgress
 }) {
   try {
     const [localBranches, worktrees] = await Promise.all([
@@ -49991,8 +50638,7 @@ async function getOrphanedLocalBranchStatuses({
           hasUnpushed = true;
         }
         const { upstream, hasUpstream } = await resolveUpstreamStatus(localBranch.name, repoRoot);
-        const comparisonBase = upstream ?? baseBranch;
-        const hasUniqueCommits = await branchHasUniqueCommitsComparedToBase(localBranch.name, comparisonBase, repoRoot);
+        const hasUniqueCommits = await branchHasUniqueCommitsComparedToBase(localBranch.name, baseBranch, repoRoot);
         const reasons = buildCleanupReasons({
           hasUniqueCommits,
           hasUncommitted: false,
@@ -50002,7 +50648,7 @@ async function getOrphanedLocalBranchStatuses({
         if (process.env.DEBUG_CLEANUP) {
           console.log(source_default.gray(`Debug: Checking orphaned branch ${localBranch.name} -> reasons: ${reasons.join(", ")}`));
         }
-        statuses.push({
+        const status = {
           worktreePath: null,
           branch: localBranch.name,
           hasUncommittedChanges: false,
@@ -50013,7 +50659,9 @@ async function getOrphanedLocalBranchStatuses({
           hasUpstream,
           upstream,
           reasons
-        });
+        };
+        statuses.push(status);
+        onProgress?.(status);
       }
     }
     if (process.env.DEBUG_CLEANUP) {
@@ -50028,7 +50676,9 @@ async function getOrphanedLocalBranchStatuses({
     return [];
   }
 }
-async function getCleanupStatus() {
+async function getCleanupStatus({
+  onProgress
+} = {}) {
   const [config, repoRoot, worktreesWithPR] = await Promise.all([
     getConfig(),
     getRepositoryRoot(),
@@ -50037,7 +50687,8 @@ async function getCleanupStatus() {
   const baseBranch = config.defaultBaseBranch || GIT_CONFIG.DEFAULT_BASE_BRANCH;
   const orphanedStatuses = await getOrphanedLocalBranchStatuses({
     baseBranch,
-    repoRoot
+    repoRoot,
+    ...onProgress ? { onProgress } : {}
   });
   const statuses = [];
   if (process.env.DEBUG_CLEANUP) {
@@ -50066,8 +50717,7 @@ async function getCleanupStatus() {
       }
     }
     const { upstream, hasUpstream } = await resolveUpstreamStatus(worktree.branch, repoRoot);
-    const comparisonBase = upstream ?? baseBranch;
-    const hasUniqueCommits = await branchHasUniqueCommitsComparedToBase(worktree.branch, comparisonBase, repoRoot);
+    const hasUniqueCommits = await branchHasUniqueCommitsComparedToBase(worktree.branch, baseBranch, repoRoot);
     const reasons = buildCleanupReasons({
       hasUniqueCommits,
       hasUncommitted,
@@ -50077,7 +50727,7 @@ async function getCleanupStatus() {
     if (process.env.DEBUG_CLEANUP) {
       console.log(source_default.gray(`Debug: Cleanup reasons for ${worktree.branch}: ${reasons.length > 0 ? reasons.join(", ") : "none"}`));
     }
-    statuses.push({
+    const status = {
       worktreePath: worktree.worktreePath,
       branch: worktree.branch,
       hasUncommittedChanges: hasUncommitted,
@@ -50090,7 +50740,9 @@ async function getCleanupStatus() {
       isAccessible,
       reasons,
       ...isAccessible ? {} : { invalidReason: "Path not accessible in current environment" }
-    });
+    };
+    statuses.push(status);
+    onProgress?.(status);
   }
   statuses.push(...orphanedStatuses);
   if (process.env.DEBUG_CLEANUP) {
@@ -50101,22 +50753,643 @@ async function getCleanupStatus() {
   return statuses;
 }
 
-// src/config/tools.ts
-import { homedir as homedir4 } from "os";
+// src/utils/session/common.ts
+import path14 from "path";
+import { readdir, readFile as readFile2, stat } from "fs/promises";
+var UUID_REGEX = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+function isValidUuidSessionId(id) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
+}
+function pickSessionIdFromObject(obj) {
+  if (!obj || typeof obj !== "object")
+    return null;
+  const candidate = obj;
+  const keys = ["sessionId", "session_id", "id", "conversation_id"];
+  for (const key of keys) {
+    const value = candidate[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      const trimmed = value.trim();
+      if (isValidUuidSessionId(trimmed)) {
+        return trimmed;
+      }
+    }
+  }
+  return null;
+}
+function pickCwdFromObject(obj) {
+  if (!obj || typeof obj !== "object")
+    return null;
+  const candidate = obj;
+  const keys = [
+    "cwd",
+    "workingDirectory",
+    "workdir",
+    "directory",
+    "projectPath"
+  ];
+  for (const key of keys) {
+    const value = candidate[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  const payload = candidate["payload"];
+  if (payload && typeof payload === "object") {
+    const nested = pickCwdFromObject(payload);
+    if (nested)
+      return nested;
+  }
+  return null;
+}
+function pickSessionIdFromText(content) {
+  try {
+    const parsed = JSON.parse(content);
+    const fromObject = pickSessionIdFromObject(parsed);
+    if (fromObject)
+      return fromObject;
+  } catch {}
+  const lines = content.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      const parsedLine = JSON.parse(trimmed);
+      const fromLine = pickSessionIdFromObject(parsedLine);
+      if (fromLine)
+        return fromLine;
+    } catch {}
+    const match2 = trimmed.match(UUID_REGEX);
+    if (match2)
+      return match2[0];
+  }
+  const match = content.match(UUID_REGEX);
+  return match ? match[0] : null;
+}
+async function collectFilesIterative(dir, filter) {
+  const results = [];
+  const queue = [dir];
+  while (queue.length > 0) {
+    const currentDir = queue.shift();
+    if (!currentDir)
+      break;
+    try {
+      const entries = await readdir(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path14.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          queue.push(fullPath);
+        } else if (entry.isFile() && filter(entry.name)) {
+          try {
+            const info = await stat(fullPath);
+            results.push({ fullPath, mtime: info.mtimeMs });
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+  return results;
+}
+async function readSessionIdFromFile(filePath) {
+  try {
+    const basename2 = path14.basename(filePath);
+    const filenameWithoutExt = basename2.replace(/\.(json|jsonl)$/i, "");
+    if (isValidUuidSessionId(filenameWithoutExt)) {
+      return filenameWithoutExt;
+    }
+    const content = await readFile2(filePath, "utf-8");
+    const fromContent = pickSessionIdFromText(content);
+    if (fromContent)
+      return fromContent;
+    const filenameMatch = basename2.match(UUID_REGEX);
+    return filenameMatch ? filenameMatch[0] : null;
+  } catch {
+    return null;
+  }
+}
+async function readSessionInfoFromFile(filePath) {
+  try {
+    const content = await readFile2(filePath, "utf-8");
+    try {
+      const parsed = JSON.parse(content);
+      const id = pickSessionIdFromObject(parsed);
+      const cwd = pickCwdFromObject(parsed);
+      if (id || cwd)
+        return { id, cwd };
+    } catch {}
+    const lines = content.split(/\r?\n/);
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed)
+        continue;
+      try {
+        const parsedLine = JSON.parse(trimmed);
+        const id = pickSessionIdFromObject(parsedLine);
+        const cwd = pickCwdFromObject(parsedLine);
+        if (id || cwd)
+          return { id, cwd };
+      } catch {}
+    }
+    const filenameMatch = path14.basename(filePath).match(UUID_REGEX);
+    if (filenameMatch)
+      return { id: filenameMatch[0], cwd: null };
+  } catch {}
+  return { id: null, cwd: null };
+}
+async function findNewestSessionIdFromDir(dir, recursive, options = {}) {
+  try {
+    const files = [];
+    const queue = [dir];
+    while (queue.length > 0) {
+      const currentDir = queue.shift();
+      if (!currentDir)
+        break;
+      try {
+        const entries = await readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path14.join(currentDir, entry.name);
+          if (entry.isDirectory()) {
+            if (recursive) {
+              queue.push(fullPath);
+            }
+            continue;
+          }
+          if (!entry.isFile())
+            continue;
+          if (!entry.name.endsWith(".json") && !entry.name.endsWith(".jsonl"))
+            continue;
+          try {
+            const info = await stat(fullPath);
+            files.push({ fullPath, mtime: info.mtimeMs });
+          } catch {}
+        }
+      } catch {}
+    }
+    const filtered = files.filter((f) => {
+      if (options.since !== undefined && f.mtime < options.since)
+        return false;
+      if (options.until !== undefined && f.mtime > options.until)
+        return false;
+      return true;
+    });
+    if (!filtered.length)
+      return null;
+    let pool = filtered.sort((a2, b) => b.mtime - a2.mtime);
+    const ref = options.preferClosestTo;
+    if (typeof ref === "number") {
+      const window = options.windowMs ?? 30 * 60 * 1000;
+      const withinWindow = pool.filter((f) => Math.abs(f.mtime - ref) <= window);
+      if (withinWindow.length) {
+        pool = withinWindow.sort((a2, b) => b.mtime - a2.mtime);
+      }
+    }
+    for (const file of pool) {
+      const id = await readSessionIdFromFile(file.fullPath);
+      if (id)
+        return { id, mtime: file.mtime };
+    }
+  } catch {}
+  return null;
+}
+async function readFileContent(filePath) {
+  return readFile2(filePath, "utf-8");
+}
+async function checkFileStat(filePath) {
+  try {
+    const info = await stat(filePath);
+    return { mtimeMs: info.mtimeMs };
+  } catch {
+    return null;
+  }
+}
+function normalizePath(p) {
+  return path14.normalize(p).replace(/\\/g, "/");
+}
+function isPathPrefix(prefix, full) {
+  if (!full.startsWith(prefix))
+    return false;
+  if (full.length === prefix.length)
+    return true;
+  return full[prefix.length] === "/";
+}
+function matchesCwd(sessionCwd, targetCwd) {
+  if (!sessionCwd)
+    return false;
+  const normalizedSession = normalizePath(sessionCwd);
+  const normalizedTarget = normalizePath(targetCwd);
+  return normalizedSession === normalizedTarget || isPathPrefix(normalizedTarget, normalizedSession) || isPathPrefix(normalizedSession, normalizedTarget);
+}
+function resolveBranchFromCwd(sessionCwd, worktrees) {
+  if (!sessionCwd)
+    return null;
+  const normalizedSession = normalizePath(sessionCwd);
+  let bestMatch = 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;
+}
+// src/utils/session/parsers/claude.ts
 import path15 from "path";
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, rename as rename2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+function encodeClaudeProjectPath(cwd) {
+  const normalized = cwd.replace(/\\/g, "/").replace(/:/g, "");
+  return normalized.replace(/_/g, "-").replace(/\//g, "-");
+}
+function generateClaudeProjectPathCandidates(cwd) {
+  const base2 = encodeClaudeProjectPath(cwd);
+  const dotToDash = cwd.replace(/\\/g, "/").replace(/:/g, "").replace(/\./g, "-").replace(/_/g, "-").replace(/\//g, "-");
+  const collapsed = dotToDash.replace(/-+/g, "-");
+  const candidates = [base2, dotToDash, collapsed];
+  return Array.from(new Set(candidates));
+}
+function getClaudeRootCandidates() {
+  const roots = [];
+  if (process.env.CLAUDE_CONFIG_DIR) {
+    roots.push(process.env.CLAUDE_CONFIG_DIR);
+  }
+  roots.push(path15.join(homedir3(), ".claude"), path15.join(homedir3(), ".config", "claude"));
+  return roots;
+}
+async function findLatestClaudeSession(cwd, options = {}) {
+  const rootCandidates = getClaudeRootCandidates();
+  const branchFilter = typeof options.branch === "string" && options.branch.trim().length > 0 ? options.branch.trim() : null;
+  let cwdCandidates = [];
+  if (branchFilter) {
+    let worktrees = [];
+    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 = path15.join(claudeRoot, "projects", encoded);
+        const sessionsDir = path15.join(projectDir, "sessions");
+        const session = await findNewestSessionIdFromDir(sessionsDir, false, options);
+        if (session)
+          return session;
+        const rootSession = await findNewestSessionIdFromDir(projectDir, true, options);
+        if (rootSession)
+          return rootSession;
+      }
+    }
+  }
+  try {
+    const historyPath = path15.join(homedir3(), ".claude", "history.jsonl");
+    const historyStat = await checkFileStat(historyPath);
+    if (!historyStat)
+      return null;
+    const content = await readFileContent(historyPath);
+    const lines = content.split(/\r?\n/).filter(Boolean);
+    for (let i2 = lines.length - 1;i2 >= 0; i2 -= 1) {
+      try {
+        const line = lines[i2] ?? "";
+        const parsed = JSON.parse(line);
+        const project = typeof parsed.project === "string" ? parsed.project : null;
+        const sessionId = typeof parsed.sessionId === "string" ? parsed.sessionId : null;
+        const matchesProject = uniqueCwds.some((candidate) => matchesCwd(project, candidate));
+        if (project && sessionId && matchesProject) {
+          return { id: sessionId, mtime: historyStat.mtimeMs };
+        }
+      } catch {}
+    }
+  } catch {}
+  return null;
+}
+// src/utils/session/parsers/codex.ts
+import path16 from "path";
+import { homedir as homedir4 } from "os";
+async function findLatestCodexSession(options = {}) {
+  const codexHome = process.env.CODEX_HOME ?? path16.join(homedir4(), ".codex");
+  const baseDir = path16.join(codexHome, "sessions");
+  const candidates = await collectFilesIterative(baseDir, (name) => name.endsWith(".json") || name.endsWith(".jsonl"));
+  if (!candidates.length)
+    return null;
+  let pool = candidates;
+  const sinceVal = options.since;
+  const untilVal = options.until;
+  if (sinceVal !== undefined) {
+    pool = pool.filter((c3) => c3.mtime >= sinceVal);
+  }
+  if (untilVal !== undefined) {
+    pool = pool.filter((c3) => c3.mtime <= untilVal);
+  }
+  if (!pool.length)
+    return null;
+  const ref = options.preferClosestTo;
+  const window = options.windowMs ?? 30 * 60 * 1000;
+  const ordered = [...pool].sort((a2, b) => {
+    if (typeof ref === "number") {
+      const da = Math.abs(a2.mtime - ref);
+      const db = Math.abs(b.mtime - ref);
+      if (da === db)
+        return b.mtime - a2.mtime;
+      if (da <= window || db <= window)
+        return da - db;
+    }
+    return b.mtime - a2.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 = [];
+  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) {
+    const filenameMatch = path16.basename(file.fullPath).match(UUID_REGEX);
+    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;
+      }
+    }
+    if (shouldCheckCwd && options.cwd) {
+      if (!matchesCwd(sessionCwd, options.cwd)) {
+        continue;
+      }
+    }
+    const sessionId = idFromName ?? info?.id ?? null;
+    if (sessionId) {
+      return { id: sessionId, mtime: file.mtime };
+    }
+  }
+  return null;
+}
+// src/utils/session/parsers/gemini.ts
+import path17 from "path";
+import { homedir as homedir5 } from "os";
+async function findLatestGeminiSession(options = {}) {
+  const baseDir = path17.join(homedir5(), ".gemini", "tmp");
+  const files = await collectFilesIterative(baseDir, (name) => name.endsWith(".json") || name.endsWith(".jsonl"));
+  if (!files.length)
+    return null;
+  let pool = files;
+  const sinceVal = options.since;
+  if (sinceVal !== undefined) {
+    pool = pool.filter((f) => f.mtime >= sinceVal);
+  }
+  const untilVal = options.until;
+  if (untilVal !== undefined) {
+    pool = pool.filter((f) => f.mtime <= untilVal);
+  }
+  if (!pool.length)
+    return null;
+  const ref = options.preferClosestTo;
+  const window = options.windowMs ?? 30 * 60 * 1000;
+  pool = pool.slice().sort((a2, b) => {
+    if (typeof ref === "number") {
+      const da = Math.abs(a2.mtime - ref);
+      const db = Math.abs(b.mtime - ref);
+      if (da === db)
+        return b.mtime - a2.mtime;
+      if (da <= window || db <= window)
+        return da - db;
+    }
+    return b.mtime - a2.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 = [];
+  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;
+    const sessionCwd = info.cwd ?? null;
+    if (shouldCheckBranch) {
+      const resolvedBranch = resolveBranchFromCwd(sessionCwd, worktrees);
+      if (resolvedBranch !== branchFilter) {
+        continue;
+      }
+    }
+    if (shouldCheckCwd && options.cwd) {
+      if (!matchesCwd(sessionCwd, options.cwd)) {
+        continue;
+      }
+    }
+    return { id: info.id, mtime: file.mtime };
+  }
+  return null;
+}
+// src/utils/session/parsers/opencode.ts
+import path18 from "path";
+import { homedir as homedir6 } from "os";
+function getOpenCodeSessionDir() {
+  return path18.join(homedir6(), ".local", "share", "opencode", "storage", "session");
+}
+async function findLatestOpenCodeSession(options = {}) {
+  const baseDir = getOpenCodeSessionDir();
+  const files = await collectFilesIterative(baseDir, (name) => name.endsWith(".json") || name.endsWith(".jsonl"));
+  if (!files.length)
+    return null;
+  let pool = files;
+  const sinceVal = options.since;
+  if (sinceVal !== undefined) {
+    pool = pool.filter((f) => f.mtime >= sinceVal);
+  }
+  const untilVal = options.until;
+  if (untilVal !== undefined) {
+    pool = pool.filter((f) => f.mtime <= untilVal);
+  }
+  if (!pool.length)
+    return null;
+  const ref = options.preferClosestTo;
+  const window = options.windowMs ?? 30 * 60 * 1000;
+  pool = pool.slice().sort((a2, b) => {
+    if (typeof ref === "number") {
+      const da = Math.abs(a2.mtime - ref);
+      const db = Math.abs(b.mtime - ref);
+      if (da === db)
+        return b.mtime - a2.mtime;
+      if (da <= window || db <= window)
+        return da - db;
+    }
+    return b.mtime - a2.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 = [];
+  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;
+    const sessionCwd = info.cwd ?? null;
+    if (shouldCheckBranch) {
+      const resolvedBranch = resolveBranchFromCwd(sessionCwd, worktrees);
+      if (resolvedBranch !== branchFilter) {
+        continue;
+      }
+    }
+    if (shouldCheckCwd && options.cwd) {
+      if (!matchesCwd(sessionCwd, options.cwd)) {
+        continue;
+      }
+    }
+    return { id: info.id, mtime: file.mtime };
+  }
+  return null;
+}
+// src/cli/ui/utils/continueSession.ts
+function findLatestBranchSessionsByTool(history, branch, worktreePath) {
+  const byBranch = history.filter((entry) => entry && entry.branch === branch);
+  if (!byBranch.length)
+    return [];
+  const source = worktreePath ? byBranch.filter((entry) => entry.worktreePath === worktreePath) : byBranch;
+  if (!source.length)
+    return [];
+  const latestByTool = new Map;
+  for (const entry of source) {
+    if (!entry.toolId)
+      continue;
+    const current = latestByTool.get(entry.toolId);
+    const currentTs = current?.timestamp ?? 0;
+    const entryTs = entry.timestamp ?? 0;
+    if (!current || entryTs >= currentTs) {
+      latestByTool.set(entry.toolId, entry);
+    }
+  }
+  return Array.from(latestByTool.values()).sort((a2, b) => (b.timestamp ?? 0) - (a2.timestamp ?? 0));
+}
+async function refreshQuickStartEntries(entries, context, lookups = {}) {
+  if (!entries.length)
+    return entries;
+  const worktreePath = context.worktreePath ?? null;
+  if (!worktreePath)
+    return entries;
+  const lookupWorktrees = lookups.listAllWorktrees ?? listAllWorktrees;
+  let resolvedWorktrees = null;
+  try {
+    const allWorktrees = await lookupWorktrees();
+    resolvedWorktrees = allWorktrees.filter((entry) => entry?.path && entry?.branch).map((entry) => ({ path: entry.path, branch: entry.branch }));
+  } catch {
+    resolvedWorktrees = null;
+  }
+  const searchOptions = {
+    branch: context.branch,
+    ...resolvedWorktrees && resolvedWorktrees.length > 0 ? { worktrees: resolvedWorktrees } : {}
+  };
+  const lookupCodex = lookups.findLatestCodexSession ?? findLatestCodexSession;
+  const lookupClaude = lookups.findLatestClaudeSession ?? findLatestClaudeSession;
+  const lookupGemini = lookups.findLatestGeminiSession ?? findLatestGeminiSession;
+  const lookupOpenCode = lookups.findLatestOpenCodeSession ?? findLatestOpenCodeSession;
+  const updated = await Promise.all(entries.map(async (entry) => {
+    let latest = null;
+    switch (entry.toolId) {
+      case "codex-cli":
+        latest = await lookupCodex(searchOptions);
+        break;
+      case "claude-code":
+        latest = await lookupClaude(worktreePath, searchOptions);
+        break;
+      case "gemini-cli":
+        latest = await lookupGemini(searchOptions);
+        break;
+      case "opencode":
+        latest = await lookupOpenCode(searchOptions);
+        break;
+      default:
+        return entry;
+    }
+    if (!latest?.id)
+      return entry;
+    const updatedTimestamp = Math.max(entry.timestamp ?? 0, latest.mtime);
+    return {
+      ...entry,
+      sessionId: latest.id,
+      timestamp: updatedTimestamp
+    };
+  }));
+  return updated.sort((a2, b) => (b.timestamp ?? 0) - (a2.timestamp ?? 0));
+}
+
+// src/config/tools.ts
+init_builtin_coding_agents();
+import { homedir as homedir8 } from "os";
+import path20 from "path";
+import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir3, rename as rename2 } from "fs/promises";
 
 // src/config/profiles.ts
 import {
   mkdir as mkdir2,
   open,
-  readFile as readFile2,
+  readFile as readFile3,
   rename,
-  stat,
+  stat as stat2,
   unlink,
   writeFile as writeFile2
 } from "fs/promises";
-import path14 from "path";
+import path19 from "path";
 
 // node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -50165,7 +51438,7 @@ var $visit = visit.visit;
 var $visitAsync = visit.visitAsync;
 
 // src/config/profiles.ts
-import { homedir as homedir3 } from "os";
+import { homedir as homedir7 } from "os";
 
 // src/types/profiles.ts
 var DEFAULT_PROFILES_CONFIG = Object.freeze({
@@ -50180,11 +51453,11 @@ function isValidProfileName(name) {
 
 // src/config/profiles.ts
 function getConfigDir() {
-  const worktreeHome = process.env.GWT_HOME && process.env.GWT_HOME.trim().length > 0 ? process.env.GWT_HOME : homedir3();
-  return path14.join(worktreeHome, ".gwt");
+  const worktreeHome = process.env.GWT_HOME && process.env.GWT_HOME.trim().length > 0 ? process.env.GWT_HOME : homedir7();
+  return path19.join(worktreeHome, ".gwt");
 }
 function getProfilesConfigPath() {
-  return path14.join(getConfigDir(), "profiles.yaml");
+  return path19.join(getConfigDir(), "profiles.yaml");
 }
 var LOCK_RETRY_INTERVAL_MS = 50;
 var LOCK_TIMEOUT_MS = 3000;
@@ -50194,7 +51467,7 @@ function getProfilesLockPath() {
 }
 async function withProfilesLock(fn) {
   const lockPath = getProfilesLockPath();
-  await mkdir2(path14.dirname(lockPath), { recursive: true });
+  await mkdir2(path19.dirname(lockPath), { recursive: true });
   const startedAt = Date.now();
   while (true) {
     try {
@@ -50213,7 +51486,7 @@ async function withProfilesLock(fn) {
         throw error;
       }
       try {
-        const lockStat = await stat(lockPath);
+        const lockStat = await stat2(lockPath);
         const isStale = Date.now() - lockStat.mtimeMs > LOCK_STALE_MS;
         if (isStale) {
           await unlink(lockPath).catch(() => {});
@@ -50243,7 +51516,7 @@ var PROFILES_CONFIG_PATH = getProfilesConfigPath();
 async function loadProfiles() {
   try {
     const configPath = getProfilesConfigPath();
-    const content = await readFile2(configPath, "utf-8");
+    const content = await readFile3(configPath, "utf-8");
     const config = $parse(content);
     if (!config.version || typeof config.version !== "string") {
       throw new Error("version field is required and must be a string");
@@ -50328,9 +51601,9 @@ async function deleteProfile(name) {
 
 // src/config/tools.ts
 var logger3 = createLogger({ category: "config" });
-var WORKTREE_HOME = process.env.GWT_HOME && process.env.GWT_HOME.trim().length > 0 ? process.env.GWT_HOME : homedir4();
-var CONFIG_DIR = path15.join(WORKTREE_HOME, ".gwt");
-var TOOLS_CONFIG_PATH = path15.join(CONFIG_DIR, "tools.json");
+var WORKTREE_HOME = process.env.GWT_HOME && process.env.GWT_HOME.trim().length > 0 ? process.env.GWT_HOME : homedir8();
+var CONFIG_DIR = path20.join(WORKTREE_HOME, ".gwt");
+var TOOLS_CONFIG_PATH = path20.join(CONFIG_DIR, "tools.json");
 var TEMP_CONFIG_PATH = `${TOOLS_CONFIG_PATH}.tmp`;
 var DEFAULT_CONFIG2 = {
   version: "1.0.0",
@@ -50339,7 +51612,7 @@ var DEFAULT_CONFIG2 = {
 };
 async function loadCodingAgentsConfig() {
   try {
-    const content = await readFile3(TOOLS_CONFIG_PATH, "utf-8");
+    const content = await readFile4(TOOLS_CONFIG_PATH, "utf-8");
     const config = JSON.parse(content);
     const legacyConfig = config;
     if (!config.customCodingAgents && legacyConfig.customTools) {
@@ -50423,7 +51696,7 @@ function validateCodingAgent(agent) {
     throw new Error(`Invalid type: "${a2.type}"
 ` + `Type must be one of: ${validTypes.join(", ")}`);
   }
-  if (a2.type === "path" && !path15.isAbsolute(a2.command)) {
+  if (a2.type === "path" && !path20.isAbsolute(a2.command)) {
     throw new Error(`For type="path", command must be an absolute path: "${a2.command}"`);
   }
   if (!a2.modeArgs.normal && !a2.modeArgs.continue && !a2.modeArgs.resume) {
@@ -50450,14 +51723,45 @@ async function getAllCodingAgents() {
 
 // src/logging/reader.ts
 import fs4 from "fs/promises";
-import path16 from "path";
+import path21 from "path";
 import os4 from "os";
+var LOG_FILENAME_PATTERN = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
 function resolveLogDir(cwd = process.cwd()) {
-  const cwdBase = path16.basename(cwd) || "workspace";
-  return path16.join(os4.homedir(), ".gwt", "logs", cwdBase);
+  const cwdBase = path21.basename(cwd) || "workspace";
+  return path21.join(os4.homedir(), ".gwt", "logs", cwdBase);
 }
-function buildLogFilePath(logDir, date) {
-  return path16.join(logDir, `${date}.jsonl`);
+function resolveLogTarget(branch, workingDirectory = process.cwd()) {
+  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" };
 }
 function getTodayLogDate() {
   return formatDate(new Date);
@@ -50475,6 +51779,111 @@ async function readLogFileLines(filePath) {
     throw error;
   }
 }
+async function listLogFiles(logDir) {
+  try {
+    const entries = await fs4.readdir(logDir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+      if (!entry.isFile())
+        continue;
+      if (!LOG_FILENAME_PATTERN.test(entry.name))
+        continue;
+      const date = entry.name.replace(/\.jsonl$/, "");
+      const fullPath = path21.join(logDir, entry.name);
+      try {
+        const stat3 = await fs4.stat(fullPath);
+        files.push({ date, path: fullPath, mtimeMs: stat3.mtimeMs });
+      } catch {}
+    }
+    return files.sort((a2, b) => b.mtimeMs - a2.mtimeMs);
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+var getLatestLogMtimeWithContent = async (logDir) => {
+  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;
+};
+async function selectLogTargetByRecency(primary, fallback) {
+  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;
+}
+async function clearLogFiles(logDir) {
+  const files = await listLogFiles(logDir);
+  let cleared = 0;
+  for (const file of files) {
+    try {
+      await fs4.truncate(file.path, 0);
+      cleared += 1;
+    } catch (error) {
+      const err = error;
+      if (err.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  return cleared;
+}
+async function readLogLinesForDate(logDir, preferredDate) {
+  const files = await listLogFiles(logDir);
+  if (files.length === 0) {
+    return null;
+  }
+  const ordered = [];
+  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: [] };
+}
 
 // src/logging/formatter.ts
 var LEVEL_LABELS = {
@@ -50485,15 +51894,29 @@ var LEVEL_LABELS = {
   50: "ERROR",
   60: "FATAL"
 };
+var LOCAL_TIME_FORMATTER = new Intl.DateTimeFormat(undefined, {
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit",
+  hour12: false
+});
+var formatLocalTimeParts = (date) => {
+  const parts = LOCAL_TIME_FORMATTER.formatToParts(date);
+  const get = (type) => 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}`;
+};
 var formatTimeLabel = (value) => {
   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()
       };
     }
@@ -50577,17 +52000,17 @@ async function copyToClipboard(text, options = {}) {
 }
 
 // src/utils.ts
-import path17 from "path";
+import path22 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 function getCurrentDirname() {
-  return path17.dirname(fileURLToPath4(import.meta.url));
+  return path22.dirname(fileURLToPath4(import.meta.url));
 }
 async function getPackageVersion() {
   try {
     const currentDir = getCurrentDirname();
-    const packageJsonPath = path17.resolve(currentDir, "..", "package.json");
-    const packageJsonContent = await readFile4(packageJsonPath, "utf-8");
+    const packageJsonPath = path22.resolve(currentDir, "..", "package.json");
+    const packageJsonContent = await readFile5(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
     return packageJson.version || null;
   } catch {
@@ -50597,9 +52020,12 @@ async function getPackageVersion() {
 
 // src/cli/ui/App.solid.tsx
 init_constants();
+init_versionFetcher();
 var logger4 = createLogger({
   category: "app"
 });
+var UNSAFE_SELECTION_MESSAGE = "Unsafe branch selected. Select anyway?";
+var SAFETY_PENDING_MESSAGE = "Safety check in progress. Select anyway?";
 var DEFAULT_SCREEN = "branch-list";
 var buildStats = (branches) => calculateStatistics(branches);
 var applyCleanupStatus = (items, statusByBranch) => items.map((branch) => {
@@ -50630,6 +52056,23 @@ var applyCleanupStatus = (items, statusByBranch) => items.map((branch) => {
     worktree
   } : base2;
 });
+var buildCleanupSafetyPending = (items) => {
+  const pending = new Set;
+  for (const branch of items) {
+    if (branch.type === "remote") {
+      continue;
+    }
+    if (branch.worktree) {
+      pending.add(branch.name);
+      continue;
+    }
+    if (isProtectedBranchName(branch.name)) {
+      continue;
+    }
+    pending.add(branch.name);
+  }
+  return pending;
+};
 var toLocalBranchName = (name) => {
   const segments = name.split("/");
   if (segments.length <= 1) {
@@ -50645,6 +52088,7 @@ var toSelectedBranchState = (branch) => {
     displayName: branch.name,
     branchType: branch.type,
     branchCategory: branch.branchType,
+    worktreePath: branch.worktree?.path ?? null,
     ...isRemote ? {
       remoteBranch: branch.name
     } : {}
@@ -50652,6 +52096,7 @@ var toSelectedBranchState = (branch) => {
 };
 function AppSolid(props) {
   const renderer = useRenderer();
+  const terminal = useTerminalSize();
   let hasExited = false;
   const exitApp = (result) => {
     if (hasExited)
@@ -50668,6 +52113,7 @@ function AppSolid(props) {
   const [stats, setStats] = createSignal(props.stats ?? buildStats(props.branches ?? []));
   const [loading, setLoading] = createSignal(!props.branches);
   const [error, setError] = createSignal(null);
+  const [branchCursorPosition, setBranchCursorPosition] = createSignal(0);
   const [toolItems, setToolItems] = createSignal([]);
   const [toolError, setToolError] = createSignal(null);
   const [version, setVersion] = createSignal(props.version ?? null);
@@ -50676,11 +52122,16 @@ function AppSolid(props) {
   const [selectedTool, setSelectedTool] = createSignal(null);
   const [selectedMode, setSelectedMode] = createSignal("normal");
   const [selectedBranches, setSelectedBranches] = createSignal([]);
+  const [unsafeSelectionConfirmVisible, setUnsafeSelectionConfirmVisible] = createSignal(false);
+  const [unsafeConfirmInputLocked, setUnsafeConfirmInputLocked] = createSignal(false);
+  const [unsafeSelectionTarget, setUnsafeSelectionTarget] = createSignal(null);
+  const [unsafeSelectionMessage, setUnsafeSelectionMessage] = createSignal(UNSAFE_SELECTION_MESSAGE);
   const [branchFooterMessage, setBranchFooterMessage] = createSignal(null);
   const [branchInputLocked, setBranchInputLocked] = createSignal(false);
   const [cleanupIndicators, setCleanupIndicators] = createSignal({});
   const [cleanupStatusByBranch, setCleanupStatusByBranch] = createSignal(new Map);
   const [cleanupSafetyLoading, setCleanupSafetyLoading] = createSignal(false);
+  const [cleanupSafetyPending, setCleanupSafetyPending] = createSignal(new Set);
   const [isNewBranch, setIsNewBranch] = createSignal(false);
   const [newBranchBaseRef, setNewBranchBaseRef] = createSignal(null);
   const [creationSource, setCreationSource] = createSignal(null);
@@ -50689,20 +52140,59 @@ function AppSolid(props) {
   });
   const [suppressCreateKey, setSuppressCreateKey] = createSignal(null);
   const [defaultBaseBranch, setDefaultBaseBranch] = createSignal("main");
+  const suppressBranchInputOnce = () => {
+    setUnsafeConfirmInputLocked(true);
+    queueMicrotask(() => {
+      setUnsafeConfirmInputLocked(false);
+    });
+  };
+  const unsafeConfirmBoxWidth = createMemo(() => {
+    const columns = terminal().columns || 80;
+    return Math.max(1, Math.floor(columns * 0.6));
+  });
+  const unsafeConfirmContentWidth = createMemo(() => Math.max(0, unsafeConfirmBoxWidth() - 4));
   const [sessionHistory, setSessionHistory] = createSignal([]);
+  const [quickStartHistory, setQuickStartHistory] = createSignal([]);
   const historyForBranch = createMemo(() => {
     const history = sessionHistory();
     const branch = selectedBranch();
     if (!branch)
       return [];
-    return history.filter((entry) => entry.branch === branch.name).sort((a2, b) => (b.timestamp ?? 0) - (a2.timestamp ?? 0));
+    return findLatestBranchSessionsByTool(history, branch.name, branch.worktreePath ?? null);
+  });
+  createEffect(() => {
+    setQuickStartHistory(historyForBranch());
+  });
+  createEffect(() => {
+    const branch = selectedBranch();
+    const baseHistory = historyForBranch();
+    if (!wizardVisible() || !branch || baseHistory.length === 0) {
+      return;
+    }
+    const worktreePath = branch.worktreePath ?? null;
+    if (!worktreePath) {
+      return;
+    }
+    const branchName = branch.name;
+    (async () => {
+      const refreshed = await refreshQuickStartEntries(baseHistory, {
+        branch: branchName,
+        worktreePath
+      });
+      if (selectedBranch()?.name !== branchName) {
+        return;
+      }
+      setQuickStartHistory(refreshed);
+    })();
   });
   const [logEntries, setLogEntries] = createSignal([]);
   const [logLoading, setLogLoading] = createSignal(false);
   const [logError2, setLogError] = createSignal(null);
   const [logSelectedEntry, setLogSelectedEntry] = createSignal(null);
-  const [logSelectedDate, _setLogSelectedDate] = createSignal(getTodayLogDate());
+  const [logSelectedDate, setLogSelectedDate] = createSignal(getTodayLogDate());
   const [logNotification, setLogNotification] = createSignal(null);
+  const [logTailEnabled, setLogTailEnabled] = createSignal(false);
+  const [logTargetBranch, setLogTargetBranch] = createSignal(null);
   const [profileItems, setProfileItems] = createSignal([]);
   const [activeProfile, setActiveProfileName] = createSignal(null);
   const [profileError, setProfileError] = createSignal(null);
@@ -50717,7 +52207,31 @@ function AppSolid(props) {
   const [profileInputSuppressKey, setProfileInputSuppressKey] = createSignal(null);
   const [profileEnvKey, setProfileEnvKey] = createSignal(null);
   const [profileConfirmMode, setProfileConfirmMode] = createSignal("delete-profile");
-  const logDir = createMemo(() => resolveLogDir(workingDirectory()));
+  const [logEffectiveTarget, setLogEffectiveTarget] = createSignal(null);
+  const logPrimaryTarget = createMemo(() => resolveLogTarget(logTargetBranch(), workingDirectory()));
+  const logFallbackTarget = createMemo(() => resolveLogTarget(null, workingDirectory()));
+  const logActiveTarget = createMemo(() => logEffectiveTarget() ?? logPrimaryTarget());
+  const logBranchLabel = createMemo(() => logTargetBranch()?.label ?? null);
+  const logSourceLabel = createMemo(() => {
+    const target = logActiveTarget();
+    if (!target.sourcePath) {
+      return "(none)";
+    }
+    if (target.reason === "current-working-directory" || target.reason === "working-directory") {
+      return `${target.sourcePath} (cwd)`;
+    }
+    if (target.reason === "working-directory-fallback") {
+      return `${target.sourcePath} (cwd fallback)`;
+    }
+    if (target.reason === "worktree-inaccessible") {
+      return `${target.sourcePath} (inaccessible)`;
+    }
+    return target.sourcePath;
+  });
+  createEffect(() => {
+    logPrimaryTarget();
+    setLogEffectiveTarget(null);
+  });
   const selectedProfileConfig = createMemo(() => {
     const name = selectedProfileName();
     const config = profilesConfig();
@@ -50746,15 +52260,42 @@ function AppSolid(props) {
   let cleanupSafetyRequestId = 0;
   const refreshCleanupSafety = async () => {
     const requestId = ++cleanupSafetyRequestId;
-    setCleanupSafetyLoading(true);
+    const pendingBranches = buildCleanupSafetyPending(branchItems());
+    setCleanupSafetyPending(pendingBranches);
+    setCleanupSafetyLoading(pendingBranches.size > 0);
+    const statusByBranch = new Map;
+    const applyProgress = (status) => {
+      if (requestId !== cleanupSafetyRequestId) {
+        return;
+      }
+      statusByBranch.set(status.branch, status);
+      batch(() => {
+        setCleanupStatusByBranch(new Map(statusByBranch));
+        setBranchItems((items) => applyCleanupStatus(items, statusByBranch));
+        setCleanupSafetyPending((prev) => {
+          if (!prev.has(status.branch)) {
+            return prev;
+          }
+          const next = new Set(prev);
+          next.delete(status.branch);
+          return next;
+        });
+      });
+    };
     try {
-      const cleanupStatuses = await getCleanupStatus();
+      const cleanupStatuses = await getCleanupStatus({
+        onProgress: applyProgress
+      });
       if (requestId !== cleanupSafetyRequestId) {
         return;
       }
-      const statusByBranch = new Map(cleanupStatuses.map((status) => [status.branch, status]));
-      setCleanupStatusByBranch(statusByBranch);
-      setBranchItems((items) => applyCleanupStatus(items, statusByBranch));
+      if (cleanupStatuses.length > statusByBranch.size) {
+        cleanupStatuses.forEach((status) => {
+          if (!statusByBranch.has(status.branch)) {
+            applyProgress(status);
+          }
+        });
+      }
     } catch (err) {
       if (requestId !== cleanupSafetyRequestId) {
         return;
@@ -50763,15 +52304,19 @@ function AppSolid(props) {
         err
       }, "Failed to refresh cleanup safety indicators");
       const empty = new Map;
-      setCleanupStatusByBranch(empty);
-      setBranchItems((items) => applyCleanupStatus(items, empty));
+      batch(() => {
+        setCleanupStatusByBranch(empty);
+        setBranchItems((items) => applyCleanupStatus(items, empty));
+      });
     } finally {
       if (requestId === cleanupSafetyRequestId) {
         setCleanupSafetyLoading(false);
+        setCleanupSafetyPending(new Set);
       }
     }
   };
   let logNotificationTimer = null;
+  let logTailTimer = null;
   let branchFooterTimer = null;
   const BRANCH_LOAD_TIMEOUT_MS = 3000;
   const BRANCH_FULL_LOAD_TIMEOUT_MS = 8000;
@@ -50838,9 +52383,23 @@ function AppSolid(props) {
     setLogLoading(true);
     setLogError(null);
     try {
-      const filePath = buildLogFilePath(logDir(), targetDate);
-      const lines = await readLogFileLines(filePath);
-      const parsed = parseLogLines(lines, {
+      const primaryTarget = logPrimaryTarget();
+      const fallbackTarget = logFallbackTarget();
+      const target = await selectLogTargetByRecency(primaryTarget, fallbackTarget);
+      setLogEffectiveTarget(target);
+      if (!target.logDir) {
+        setLogEntries([]);
+        setLogSelectedDate(targetDate);
+        return;
+      }
+      const result = await readLogLinesForDate(target.logDir, targetDate);
+      if (!result) {
+        setLogEntries([]);
+        setLogSelectedDate(targetDate);
+        return;
+      }
+      setLogSelectedDate(result.date);
+      const parsed = parseLogLines(result.lines, {
         limit: 100
       });
       setLogEntries(parsed);
@@ -50851,10 +52410,39 @@ function AppSolid(props) {
       setLogLoading(false);
     }
   };
+  const clearLogTailTimer = () => {
+    if (logTailTimer) {
+      clearInterval(logTailTimer);
+      logTailTimer = null;
+    }
+  };
+  const toggleLogTail = () => {
+    setLogTailEnabled((prev) => !prev);
+  };
+  const resetLogFiles = async () => {
+    const target = logActiveTarget();
+    if (!target.logDir) {
+      showLogNotification("No logs available.", "error");
+      return;
+    }
+    try {
+      const cleared = await clearLogFiles(target.logDir);
+      if (cleared === 0) {
+        showLogNotification("No logs to reset.", "error");
+      } else {
+        showLogNotification("Logs cleared.", "success");
+      }
+      await loadLogEntries(logSelectedDate());
+    } catch (err) {
+      logger4.warn({
+        err
+      }, "Failed to clear log files");
+      showLogNotification("Failed to reset logs.", "error");
+    }
+  };
   const refreshBranches = async () => {
     setLoading(true);
     setError(null);
-    refreshCleanupSafety();
     try {
       const repoRoot = await getRepositoryRoot();
       const worktreesPromise = listAdditionalWorktrees();
@@ -50873,7 +52461,11 @@ function AppSolid(props) {
       const initialItems = applyCleanupStatus(initial.items, cleanupStatusByBranch());
       setBranchItems(initialItems);
       setStats(buildStats(initialItems));
+      refreshCleanupSafety();
       (async () => {
+        await withTimeout(fetchAllRemotes({
+          cwd: repoRoot
+        }), BRANCH_FULL_LOAD_TIMEOUT_MS).catch(() => {});
         const [branches, latestWorktrees] = await Promise.all([withTimeout(getAllBranches(repoRoot), BRANCH_FULL_LOAD_TIMEOUT_MS).catch(() => localBranches), withTimeout(listAdditionalWorktrees(), BRANCH_FULL_LOAD_TIMEOUT_MS).catch(() => worktrees)]);
         const full = buildBranchList(branches, latestWorktrees, lastToolUsageMap);
         const fullItems = applyCleanupStatus(full.items, cleanupStatusByBranch());
@@ -50954,15 +52546,32 @@ function AppSolid(props) {
       setToolError(err instanceof Error ? err : new Error(String(err)));
     });
   });
+  onMount(() => {
+    const bunxAgentIds = getBunxAgentIds();
+    prefetchAgentVersions(bunxAgentIds).catch(() => {});
+    prefetchInstalledVersions(bunxAgentIds).catch(() => {});
+  });
   createEffect(() => {
     if (currentScreen() === "log-list") {
+      logPrimaryTarget();
       loadLogEntries(logSelectedDate());
     }
   });
+  createEffect(() => {
+    if (currentScreen() !== "log-list" || !logTailEnabled()) {
+      clearLogTailTimer();
+      return;
+    }
+    clearLogTailTimer();
+    logTailTimer = setInterval(() => {
+      loadLogEntries(logSelectedDate());
+    }, 1500);
+  });
   onCleanup(() => {
     if (logNotificationTimer) {
       clearTimeout(logNotificationTimer);
     }
+    clearLogTailTimer();
     if (branchFooterTimer) {
       clearTimeout(branchFooterTimer);
     }
@@ -51058,6 +52667,10 @@ function AppSolid(props) {
     });
   };
   const handleWizardResume = (entry) => {
+    if (!entry.sessionId) {
+      handleWizardStartNew(entry);
+      return;
+    }
     setWizardVisible(false);
     const branch = selectedBranch();
     if (!branch) {
@@ -51166,24 +52779,10 @@ function AppSolid(props) {
             skipCounts.remote += 1;
             continue;
           }
-          if (isProtectedBranchName(branch.name)) {
-            skipCounts.protected += 1;
-            continue;
-          }
           if (branch.isCurrent) {
             skipCounts.current += 1;
             continue;
           }
-          const hasUncommitted = branch.worktree?.hasUncommittedChanges === true;
-          const hasUnpushed = branch.hasUnpushedCommits === true;
-          if (hasUncommitted || hasUnpushed) {
-            skipCounts.unsafe += 1;
-            continue;
-          }
-          if (branch.safeToCleanup !== true) {
-            skipCounts.unsafe += 1;
-            continue;
-          }
           const worktreePath = branch.worktree?.path ?? null;
           const cleanupType = worktreePath ? "worktree-and-branch" : "branch-only";
           const baseTask = {
@@ -51274,7 +52873,7 @@ function AppSolid(props) {
       return;
     }
     const selectionSet = new Set(selection);
-    const targets = branchItems().filter((branch) => selectionSet.has(branch.name) && branch.worktreeStatus === "inaccessible").map((branch) => branch.name);
+    const targets = branchItems().filter((branch) => selectionSet.has(branch.name) && branch.type !== "remote" && branch.worktreeStatus !== undefined).map((branch) => branch.name);
     if (targets.length === 0) {
       showBranchFooterMessage("No worktrees to repair.", "yellow");
       return;
@@ -51485,15 +53084,49 @@ function AppSolid(props) {
     }
   };
   const toggleSelectedBranch = (branchName) => {
-    setSelectedBranches((prev) => {
-      const next = new Set(prev);
-      if (next.has(branchName)) {
-        next.delete(branchName);
-      } else {
-        next.add(branchName);
-      }
-      return Array.from(next);
-    });
+    if (unsafeSelectionConfirmVisible()) {
+      return;
+    }
+    const currentSelection = new Set(selectedBranches());
+    if (currentSelection.has(branchName)) {
+      currentSelection.delete(branchName);
+      setSelectedBranches(Array.from(currentSelection));
+      return;
+    }
+    const branch = branchItems().find((item) => item.name === branchName);
+    const pending = cleanupSafetyPending();
+    const hasSafetyPending = pending.has(branchName);
+    const hasUncommitted = branch?.worktree?.hasUncommittedChanges === true;
+    const hasUnpushed = branch?.hasUnpushedCommits === true;
+    const isUnmerged = branch?.isUnmerged === true;
+    const safeToCleanup = branch?.safeToCleanup === true;
+    const isRemoteBranch = branch?.type === "remote";
+    const isUnsafe = Boolean(branch) && !isRemoteBranch && !hasSafetyPending && (hasUncommitted || hasUnpushed || isUnmerged || !safeToCleanup);
+    if (branch && hasSafetyPending) {
+      setUnsafeSelectionTarget(branch.name);
+      setUnsafeSelectionMessage(SAFETY_PENDING_MESSAGE);
+      setUnsafeSelectionConfirmVisible(true);
+      return;
+    }
+    if (branch && isUnsafe) {
+      setUnsafeSelectionTarget(branch.name);
+      setUnsafeSelectionMessage(UNSAFE_SELECTION_MESSAGE);
+      setUnsafeSelectionConfirmVisible(true);
+      return;
+    }
+    currentSelection.add(branchName);
+    setSelectedBranches(Array.from(currentSelection));
+  };
+  const confirmUnsafeSelection = (confirmed) => {
+    suppressBranchInputOnce();
+    const target = unsafeSelectionTarget();
+    setUnsafeSelectionConfirmVisible(false);
+    setUnsafeSelectionTarget(null);
+    setUnsafeSelectionMessage(UNSAFE_SELECTION_MESSAGE);
+    if (!confirmed || !target) {
+      return;
+    }
+    setSelectedBranches((prev) => prev.includes(target) ? prev : [...prev, target]);
   };
   const handleToolSelect = (item) => {
     setSelectedTool(item.value);
@@ -51544,8 +53177,9 @@ function AppSolid(props) {
       const cleanupUI = {
         indicators: cleanupIndicators(),
         footerMessage: branchFooterMessage(),
-        inputLocked: branchInputLocked(),
-        safetyLoading: cleanupSafetyLoading()
+        inputLocked: branchInputLocked() || unsafeConfirmInputLocked(),
+        safetyLoading: cleanupSafetyLoading(),
+        safetyPendingBranches: cleanupSafetyPending()
       };
       return createComponent2(BranchListScreen, {
         get branches() {
@@ -51580,7 +53214,13 @@ function AppSolid(props) {
         get activeProfile() {
           return activeProfile();
         },
-        onOpenLogs: () => navigateTo("log-list"),
+        onOpenLogs: (branch) => {
+          setLogTargetBranch(branch);
+          setLogSelectedEntry(null);
+          setLogSelectedDate(getTodayLogDate());
+          setLogTailEnabled(false);
+          navigateTo("log-list");
+        },
         onOpenProfiles: () => navigateTo("profile"),
         get selectedBranches() {
           return selectedBranches();
@@ -51593,7 +53233,14 @@ function AppSolid(props) {
         },
         get wizardVisible() {
           return wizardVisible();
-        }
+        },
+        get confirmVisible() {
+          return unsafeSelectionConfirmVisible();
+        },
+        get cursorPosition() {
+          return branchCursorPosition();
+        },
+        onCursorPositionChange: setBranchCursorPosition
       });
     }
     if (screen === "tool-select") {
@@ -51679,6 +53326,9 @@ function AppSolid(props) {
             showLogNotification("Failed to copy to clipboard.", "error");
           }
         },
+        onReload: () => void loadLogEntries(logSelectedDate()),
+        onToggleTail: toggleLogTail,
+        onReset: () => void resetLogFiles(),
         get notification() {
           return logNotification();
         },
@@ -51688,6 +53338,15 @@ function AppSolid(props) {
         get selectedDate() {
           return logSelectedDate();
         },
+        get branchLabel() {
+          return logBranchLabel();
+        },
+        get sourceLabel() {
+          return logSourceLabel();
+        },
+        get tailing() {
+          return logTailEnabled();
+        },
         get helpVisible() {
           return helpVisible();
         }
@@ -51932,7 +53591,35 @@ function AppSolid(props) {
       }
     });
   };
-  return [memo2(renderCurrentScreen), createComponent2(HelpOverlay, {
+  return [memo2(renderCurrentScreen), memo2(() => memo2(() => !!unsafeSelectionConfirmVisible())() && (() => {
+    var _el$ = createElement("box");
+    setProp(_el$, "position", "absolute");
+    setProp(_el$, "top", "30%");
+    setProp(_el$, "left", "20%");
+    setProp(_el$, "zIndex", 110);
+    setProp(_el$, "border", true);
+    setProp(_el$, "borderStyle", "single");
+    setProp(_el$, "borderColor", "yellow");
+    setProp(_el$, "backgroundColor", "black");
+    setProp(_el$, "padding", 1);
+    insert(_el$, createComponent2(ConfirmScreen, {
+      get message() {
+        return unsafeSelectionMessage();
+      },
+      onConfirm: confirmUnsafeSelection,
+      yesLabel: "OK",
+      noLabel: "Cancel",
+      defaultNo: true,
+      get helpVisible() {
+        return helpVisible();
+      },
+      get width() {
+        return unsafeConfirmContentWidth();
+      }
+    }));
+    effect((_$p) => setProp(_el$, "width", unsafeConfirmBoxWidth(), _$p));
+    return _el$;
+  })()), createComponent2(HelpOverlay, {
     get visible() {
       return helpVisible();
     },
@@ -51947,7 +53634,7 @@ function AppSolid(props) {
       return selectedBranch()?.name ?? "";
     },
     get history() {
-      return historyForBranch();
+      return quickStartHistory();
     },
     onClose: handleWizardClose,
     onComplete: handleWizardComplete,