@golba98/codexa 1.0.1 → 1.0.3

package/src/app.tsx

@@ -17,6 +17,7 @@ import {
 import type { LaunchArgs } from "./config/launchArgs.js";
 import { loadSettings, saveSettings } from "./config/persistence.js";
 import {
+  APP_VERSION,
   type AuthPreference,
   type AvailableBackend,
   type AvailableMode,
@@ -110,15 +111,11 @@ import {
   getPromptWorkspaceGuardMessage,
   getShellWorkspaceGuardMessage,
 } from "./core/workspaceGuard.js";
-import {
-  type ModelSpec,
-} from "./core/models/modelSpecs.js";
-import {
-  contextMetadataToModelSpec,
-  formatContextCompact,
-  formatContextLength,
-  resolveModelContextLength,
-  type ModelContextMetadata,
+import {
+  formatContextCompact,
+  formatContextLength,
+  resolveModelContextLength,
+  type ModelContextMetadata,
 } from "./core/providerRuntime/contextMetadata.js";
 import { captureWorkspaceSnapshot, createWorkspaceActivityTracker, diffWorkspaceSnapshots } from "./core/workspaceActivity.js";
 import { resolveWorkspaceRoot } from "./core/workspaceRoot.js";
@@ -214,10 +211,12 @@ import { ReasoningPicker } from "./ui/ReasoningPicker.js";
 import { AttachmentImportPanel, type PendingImportFile } from "./ui/AttachmentImportPanel.js";
 import { SelectionPanel } from "./ui/SelectionPanel.js";
 import { SettingsPanel } from "./ui/SettingsPanel.js";
+import { UpdatePromptPanel } from "./ui/UpdatePromptPanel.js";
 import { measureTextEntryPanelRows, TextEntryPanel } from "./ui/TextEntryPanel.js";
 import { ThemePicker } from "./ui/ThemePicker.js";
 import { getFocusTargetForScreen, FOCUS_IDS } from "./ui/focus.js";
-import { ThemeProvider, THEMES } from "./ui/theme.js";
+import { ThemeProvider, THEMES } from "./ui/theme.js";
+import { buildActiveRuntimeDisplay, runtimeDisplayToSummary } from "./ui/runtimeDisplay.js";
 import {
   cancelThemeSelection,
   commitThemeSelection,
@@ -228,9 +227,18 @@ import {
 } from "./ui/themeFlow.js";
 import { isBusy as isUiBusy } from "./session/types.js";
 import { AppShell } from "./ui/AppShell.js";
+import { checkForUpdates, formatLocalDevUpdateStatus, formatUpdateInstructions, shouldRunStartupUpdateCheck, type UpdateCheckResult } from "./core/updateCheck.js";
+import { isLocalDevChannel } from "./core/channel.js";
+import {
+  isCacheValid,
+  loadUpdateCheckCache,
+  saveUpdateCheckCache,
+} from "./config/updateCheckCache.js";
+import { DEFAULT_UPDATE_CHECK_SETTINGS } from "./config/persistence.js";
 
 // ─── Module Constants & Helpers ────────────────────────────────────────────────
 
+
 let nextEventId = 0;
 let nextTurnId = 0;
 // 50ms keeps assistant text live while avoiding frame-wide terminal repaint
@@ -299,6 +307,9 @@ export function App({ launchArgs }: AppProps) {
     ? projectInstructionsLoad.instructions
     : null;
   const initialSettings = useRef(loadSettings());
+  const skippedUpdateVersionRef = useRef<string | null>(
+    initialSettings.current.updateCheck.skippedUpdateVersion ?? null,
+  );
   const initialProviderWorkspaceConfig = useRef<ProviderWorkspaceConfig>(loadProviderWorkspaceConfig(workspaceRoot));
   const initialLayeredConfig = useRef<LayeredConfigResult | null>(null);
   if (initialLayeredConfig.current === null) {
@@ -397,6 +408,7 @@ export function App({ launchArgs }: AppProps) {
   const [verboseMode, setVerboseMode] = useState(false);
   const [planFlow, setPlanFlow] = useState<PlanFlowState>(createInitialPlanFlowState);
   const [initialRevisionText, setInitialRevisionText] = useState("");
+  const [updateCheckResult, setUpdateCheckResult] = useState<UpdateCheckResult | null>(null);
   // Mouse reporting defaults to the persisted terminalMouseMode setting.
   // "wheel" (default) enables SGR mouse reporting so the timeline can receive
   // wheel events; native drag-select then requires Shift in Windows Terminal.
@@ -756,16 +768,22 @@ export function App({ launchArgs }: AppProps) {
     [planFlow],
   );
 
-  const currentModelSpec = useMemo<ModelSpec>(() => {
-    return contextMetadataToModelSpec(activeContextMetadata ?? {
-      providerId: activeProviderRoute.providerId,
-      modelId: activeProviderRoute.modelId,
-      contextLength: null,
-      source: "unknown",
-      confidence: "unknown",
-      error: "Context length unavailable for this model.",
-    });
-  }, [activeContextMetadata, activeProviderRoute.modelId, activeProviderRoute.providerId]);
+  const activeRuntimeDisplay = useMemo(() => buildActiveRuntimeDisplay({
+    route: activeProviderRoute,
+    reasoningLevel,
+    mode,
+    tokensUsed: estimateTokens(conversationChars),
+    modelCapability: currentModelCapability,
+    contextMetadata: activeContextMetadata,
+  }), [
+    activeContextMetadata,
+    activeProviderRoute,
+    conversationChars,
+    currentModelCapability,
+    mode,
+    reasoningLevel,
+  ]);
+  const currentModelSpec = activeRuntimeDisplay.modelSpec;
 
   const hasUserPrompt = useMemo(
     () => staticEvents.some((e) => e.type === "user") || activeEvents.some((e) => e.type === "user"),
@@ -1054,6 +1072,7 @@ export function App({ launchArgs }: AppProps) {
         preference: authPreference,
       },
       header: headerConfig,
+      updateCheck: initialSettings.current.updateCheck,
     });
   }, [authPreference, customTheme, showBusyLoader, terminalMouseMode, terminalTitleMode, themeSelection.committedTheme, workspaceDisplayMode]);
 
@@ -1350,6 +1369,54 @@ export function App({ launchArgs }: AppProps) {
     appendSystemEvent("Launch mode", devLaunchNotice);
   }, [appendSystemEvent, launchContext]);
 
+  // Non-blocking background update check — runs once at startup.
+  useEffect(() => {
+    const ucSettings = initialSettings.current.updateCheck ?? DEFAULT_UPDATE_CHECK_SETTINGS;
+    if (!shouldRunStartupUpdateCheck(process.env, ucSettings.enabled)) return;
+
+    const timer = setTimeout(() => {
+      void (async () => {
+        try {
+          const cache = loadUpdateCheckCache();
+          if (cache && isCacheValid(cache, ucSettings.intervalHours, APP_VERSION)) {
+            if (cache.updateAvailable && cache.latestVersion) {
+              setUpdateCheckResult({
+                status: "update-available",
+                currentVersion: cache.currentVersion,
+                latestVersion: cache.latestVersion,
+                checkedAt: cache.lastChecked,
+              });
+              if (cache.latestVersion !== skippedUpdateVersionRef.current) {
+                setScreen("update-prompt");
+              }
+            }
+            return;
+          }
+          const result = await checkForUpdates({ enabled: true });
+          if (result.status !== "error") {
+            setUpdateCheckResult(result);
+            saveUpdateCheckCache({
+              lastChecked: result.checkedAt,
+              currentVersion: result.currentVersion,
+              latestVersion: result.latestVersion,
+              updateAvailable: result.status === "update-available",
+            });
+            if (result.status === "update-available" && result.latestVersion) {
+              if (result.latestVersion !== skippedUpdateVersionRef.current) {
+                setScreen("update-prompt");
+              }
+            }
+          }
+        } catch {
+          // Never crash the TUI on a failed update check.
+        }
+      })();
+    }, 2000);
+
+    return () => clearTimeout(timer);
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
   // Track clear epoch to suppress stale command result events
   useEffect(() => {
     clearEpochRef.current = sessionState.clearEpoch;
@@ -1848,6 +1915,33 @@ export function App({ launchArgs }: AppProps) {
     setScreen("main");
   }, [applyWorkspaceDisplayMode, showBusyLoader, terminalMouseMode, terminalTitleMode, workspaceDisplayMode]);
 
+  const handleSkipUpdateForSession = useCallback(() => {
+    setScreen("main");
+  }, []);
+
+  const handleSkipUpdateVersion = useCallback((version: string) => {
+    initialSettings.current.updateCheck = {
+      ...initialSettings.current.updateCheck,
+      skippedUpdateVersion: version,
+    };
+    saveSettings({
+      ui: {
+        layoutStyle: initialSettings.current.ui.layoutStyle,
+        theme: themeSelection.committedTheme,
+        workspaceDisplayMode,
+        terminalTitleMode,
+        showBusyLoader,
+        terminalMouseMode,
+        customTheme,
+      },
+      auth: { preference: authPreference },
+      header: headerConfig,
+      updateCheck: initialSettings.current.updateCheck,
+    });
+    skippedUpdateVersionRef.current = version;
+    setScreen("main");
+  }, [authPreference, customTheme, headerConfig, showBusyLoader, terminalMouseMode, terminalTitleMode, themeSelection.committedTheme, workspaceDisplayMode]);
+
   const setApprovalPolicyWithNotice = useCallback((nextValue: RuntimeApprovalPolicy) => {
     const gate = guardConfigMutation("mode", busy);
     if (!gate.allowed) {
@@ -3999,6 +4093,38 @@ export function App({ launchArgs }: AppProps) {
             appendSystemEvent("Command", commandResult.message);
           }
           return;
+        case "update": {
+          const arg = commandResult.value ?? "status";
+          if (isLocalDevChannel() && arg !== "check") {
+            appendSystemEvent("Update", formatLocalDevUpdateStatus());
+            return;
+          }
+          void (async () => {
+            let freshResult = updateCheckResult;
+            if (arg === "check" || freshResult === null) {
+              try {
+                freshResult = await checkForUpdates({ enabled: true });
+                setUpdateCheckResult(freshResult);
+                if (freshResult.status !== "error") {
+                  saveUpdateCheckCache({
+                    lastChecked: freshResult.checkedAt,
+                    currentVersion: freshResult.currentVersion,
+                    latestVersion: freshResult.latestVersion,
+                    updateAvailable: freshResult.status === "update-available",
+                  });
+                }
+              } catch {
+                freshResult = null;
+              }
+            }
+            if (freshResult?.status === "update-available" && freshResult.latestVersion) {
+              setScreen("update-prompt");
+            } else {
+              appendSystemEvent("Update", formatUpdateInstructions(freshResult));
+            }
+          })();
+          return;
+        }
         case "help":
         case "unknown":
           if (commandResult.message) {
@@ -4128,32 +4254,19 @@ export function App({ launchArgs }: AppProps) {
     workspaceRoot,
   ]);
 
-  const modelDisplayName = useMemo(() => {
-    if (activeProviderRoute.providerId === "anthropic") {
-      const modelLabel = currentModelCapability?.label ?? activeProviderRoute.modelId;
-      return `Claude Code CLI / ${modelLabel} / reasoning: ${formatReasoningLabel(activeProviderRoute.reasoning ?? reasoningLevel)}`;
-    }
-    if (activeProviderRoute.providerId === "google" && activeProviderRoute.modelSelection) {
-      if (activeProviderRoute.modelSelection.kind === "auto") {
-        return `auto ${activeProviderRoute.modelSelection.family === "gemini-3" ? "Gemini 3" : "Gemini 2.5"}`;
-      }
-    }
-    if (activeProviderRoute.providerId === "local") {
-      return activeProviderRoute.modelId;
-    }
-    return model;
-  }, [
-    activeProviderRoute.modelId,
-    activeProviderRoute.modelSelection,
-    activeProviderRoute.providerId,
-    activeProviderRoute.reasoning,
-    currentModelCapability?.label,
-    model,
-    reasoningLevel,
-  ]);
-  const composerReasoningLevel = activeProviderRoute.providerId === "anthropic"
-    ? ""
-    : activeProviderRoute.reasoning ?? reasoningLevel;
+  const modelDisplayName = activeRuntimeDisplay.modelDisplay;
+  const composerReasoningLevel = "";
+  const headerRuntimeSummary = useMemo(
+    () => runtimeDisplayToSummary(activeRuntimeDisplay, runtimeSummary),
+    [activeRuntimeDisplay, runtimeSummary],
+  );
+  const effectiveHeaderConfig = useMemo<HeaderConfig>(() => ({
+    ...headerConfig,
+    showProvider: true,
+    showModel: false,
+    showReasoning: false,
+    showContext: false,
+  }), [headerConfig]);
 
   // Memoize the composer element so AppShell's memo check (prev.composer ===
   // next.composer) passes during streaming. Without this, a new JSX element is
@@ -4163,7 +4276,7 @@ export function App({ launchArgs }: AppProps) {
     if (planFlow.kind === "awaiting_action") {
       if (!hasVisibleTranscriptPlan) {
         return (
-          <Text color={activeTheme.MUTED}>
+          <Text color={activeTheme.textMuted}>
             Plan could not be displayed. Please ask Codexa to regenerate the plan.
           </Text>
         );
@@ -4200,12 +4313,14 @@ export function App({ launchArgs }: AppProps) {
       <MemoizedBottomComposer
         key={composerInstanceKey}
         layout={terminalLayout}
-        uiState={uiState}
-        mode={mode}
-        model={modelDisplayName}
-        themeName={activeThemeName}
-        reasoningLevel={composerReasoningLevel}
-        planMode={planMode}
+        uiState={uiState}
+        mode={mode}
+        model={modelDisplayName}
+        footerModelDisplay={activeRuntimeDisplay.footerModelDisplay}
+        themeName={activeThemeName}
+        reasoningLevel={composerReasoningLevel}
+        contextDisplay={activeRuntimeDisplay.contextDisplay}
+        planMode={planMode}
         showBusyLoader={showBusyLoader}
         tokensUsed={estimateTokens(conversationChars)}
         modelSpec={currentModelSpec}
@@ -4239,13 +4354,15 @@ export function App({ launchArgs }: AppProps) {
     handleCancel,
     handlePlanFeedbackSubmit,
     hasVisibleTranscriptPlan,
-    activeTheme.MUTED,
+    activeTheme.textMuted,
     composerInstanceKey,
     terminalLayout,
     uiState,
-    mode,
-    modelDisplayName,
-    activeThemeName,
+    mode,
+    modelDisplayName,
+    activeRuntimeDisplay.footerModelDisplay,
+    activeRuntimeDisplay.contextDisplay,
+    activeThemeName,
     composerReasoningLevel,
     planMode,
     showBusyLoader,
@@ -4268,9 +4385,10 @@ export function App({ launchArgs }: AppProps) {
     togglePlanModeWithNotice,
     handleClear,
     cycleModeWithNotice,
-    handleQuit,
-    activeProviderRoute.providerId,
-  ]);
+    handleQuit,
+    activeProviderRoute.providerId,
+    sessionState.externalCliStatus,
+  ]);
 
   // ─── Render ──────────────────────────────────────────────────────────────────
 
@@ -4285,7 +4403,7 @@ export function App({ launchArgs }: AppProps) {
         authState={authStatus.state}
         workspaceLabel={workspaceLabel}
         workspaceRoot={workspaceRoot}
-        runtimeSummary={runtimeSummary}
+        runtimeSummary={headerRuntimeSummary}
         staticEvents={staticEvents}
         activeEvents={activeEvents}
         uiState={uiState}
@@ -4294,7 +4412,12 @@ export function App({ launchArgs }: AppProps) {
         onMouseActivity={resetMouseIdle}
         selectionProfile={selectionProfile}
         clearCount={sessionState.clearCount}
-        headerConfig={headerConfig}
+        headerConfig={effectiveHeaderConfig}
+        updateAvailable={
+          updateCheckResult?.status === "update-available" && updateCheckResult.latestVersion
+            ? { latestVersion: updateCheckResult.latestVersion, currentVersion: updateCheckResult.currentVersion }
+            : null
+        }
         panel={
           <>
             {screen === "backend-picker" && (
@@ -4543,6 +4666,16 @@ export function App({ launchArgs }: AppProps) {
                 onCancel={handleImportCancel}
               />
             )}
+
+            {screen === "update-prompt" && updateCheckResult?.status === "update-available" && updateCheckResult.latestVersion && (
+              <UpdatePromptPanel
+                focusId={FOCUS_IDS.updatePrompt}
+                currentVersion={updateCheckResult.currentVersion}
+                latestVersion={updateCheckResult.latestVersion}
+                onSkip={handleSkipUpdateForSession}
+                onSkipUntilNextVersion={handleSkipUpdateVersion}
+              />
+            )}
           </>
         }
         mainPanel={null}
@@ -4551,7 +4684,7 @@ export function App({ launchArgs }: AppProps) {
         composerRows={composerRows}
         panelHint={screen !== "main" && screen !== "model-picker" ? (
           <Box marginTop={1} paddingX={1}>
-            <Text color={activeTheme.DIM}>Close the active panel with Esc to return to the composer.</Text>
+            <Text color={activeTheme.textDim}>Close the active panel with Esc to return to the composer.</Text>
           </Box>
         ) : null}
       />

package/src/commands/handler.ts

@@ -97,6 +97,7 @@ export type CommandAction =
   | "runtime_personality"
   | "diagnose_github"
   | "diagnose_providers"
+  | "update"
   | "unknown";
 
 export interface CommandResult {
@@ -395,11 +396,12 @@ function buildHelpMessage(context: CommandContext): string {
     `  Current reasoning: ${formatReasoningLabel(context.runtime.reasoningLevel)}`,
     `  Current plan mode: ${context.runtime.planMode ? "Enabled" : "Disabled"}`,
     "  /copy              Copy last response to clipboard",
+    "  /update [check]    Show update status and instructions for updating Codexa",
     "  /help              Show this help",
-    "",
-    "Install on Windows:",
-    "  npm link           Make the codexa command available",
-    "  where codexa       Verify the command resolves",
+    "",
+    "Local development:",
+    "  npm run install:dev-bin  Install the codexa-dev command",
+    "  codexa-dev               Run this repo without replacing codexa",
     "",
     "Shortcuts:",
     "  Ctrl+B    Open backend picker",
@@ -854,6 +856,9 @@ export function handleCommand(text: string, context: CommandContext): CommandRes
       case "help":
         return { action: "help", message: buildHelpMessage(context) };
 
+      case "update":
+        return { action: "update", value: normalizedArg || "status" };
+
       default:
         return {
           action: "unknown",

package/src/config/buildInfo.ts

@@ -0,0 +1,3 @@
+// Generated by scripts/gen-build-info.mjs — do not edit manually.
+export const BUILD_COMMIT = "f4940aa066eae20c0b8decb1fb70f02aca0f2dc0" as const;
+export const APP_VERSION = "1.0.3" as const;

package/src/config/launchArgs.ts

@@ -7,6 +7,7 @@ const FLAG_CONFIG = "--config";
 const FLAG_CONFIG_SHORT = "-c";
 const FLAG_MODEL = "--model";
 const FLAG_MODEL_SHORT = "-m";
+const FLAG_NO_CLEAR = "--no-clear";
 
 export interface LaunchArgs {
   help: boolean;
@@ -17,6 +18,8 @@ export interface LaunchArgs {
   passthroughArgs: string[];
   /** Explicitly set when --model / -m was passed on the command line. Null when no model flag was given. */
   modelOverride: string | null;
+  /** True when --no-clear was passed. Suppresses the startup terminal clear. */
+  noClear: boolean;
 }
 
 export type LaunchArgsParseResult =
@@ -53,6 +56,7 @@ export function parseLaunchArgs(argv: readonly string[]): LaunchArgsParseResult
   const promptArgs: string[] = [];
   let help = false;
   let version = false;
+  let noClear = false;
   let profile: string | null = null;
   let modelOverride: string | null = null;
 
@@ -77,6 +81,11 @@ export function parseLaunchArgs(argv: readonly string[]): LaunchArgsParseResult
       continue;
     }
 
+    if (arg === FLAG_NO_CLEAR) {
+      noClear = true;
+      continue;
+    }
+
     // --profile <value> and --profile=<value> both supported.
     if (arg === FLAG_PROFILE) {
       const value = normalizeProfileValue(argv[index + 1]);
@@ -181,6 +190,7 @@ export function parseLaunchArgs(argv: readonly string[]): LaunchArgsParseResult
       configOverrides,
       passthroughArgs,
       modelOverride,
+      noClear,
     },
   };
 }

package/src/config/persistence.ts

@@ -47,10 +47,22 @@ export interface AuthSettings {
   preference: AuthPreference;
 }
 
+export interface UpdateCheckSettings {
+  enabled: boolean;
+  intervalHours: number;
+  skippedUpdateVersion?: string | null;
+}
+
+export const DEFAULT_UPDATE_CHECK_SETTINGS: UpdateCheckSettings = {
+  enabled: true,
+  intervalHours: 6,
+};
+
 export interface AppSettings {
   ui: UiSettings;
   auth: AuthSettings;
   header: HeaderConfig;
+  updateCheck: UpdateCheckSettings;
 }
 
 // Pick the first string value found under the camelCase or snake_case key.
@@ -106,6 +118,18 @@ function normalizeHeaderConfig(input: Partial<HeaderConfig> | null | undefined):
   };
 }
 
+function normalizeUpdateCheckSettings(
+  input: Partial<UpdateCheckSettings> | null | undefined,
+): UpdateCheckSettings {
+  return {
+    enabled: typeof input?.enabled === "boolean" ? input.enabled : DEFAULT_UPDATE_CHECK_SETTINGS.enabled,
+    intervalHours: typeof input?.intervalHours === "number" && input.intervalHours > 0
+      ? input.intervalHours
+      : DEFAULT_UPDATE_CHECK_SETTINGS.intervalHours,
+    skippedUpdateVersion: input?.skippedUpdateVersion ?? null,
+  };
+}
+
 export function getDefaultSettings(): AppSettings {
   return {
     ui: normalizeUiSettings(null),
@@ -113,6 +137,7 @@ export function getDefaultSettings(): AppSettings {
       preference: DEFAULT_AUTH_PREFERENCE,
     },
     header: normalizeHeaderConfig(null),
+    updateCheck: normalizeUpdateCheckSettings(null),
   };
 }
 
@@ -211,6 +236,12 @@ export function parseSettingsData(data: unknown): AppSettings {
     ? record.header as Record<string, unknown>
     : {};
 
+  const updateCheckSource = typeof record.updateCheck === "object" && record.updateCheck !== null
+    ? record.updateCheck as Record<string, unknown>
+    : typeof record.update_check === "object" && record.update_check !== null
+      ? record.update_check as Record<string, unknown>
+      : {};
+
   return {
     ui: normalizeUiSettings({
       layoutStyle: pickStr(uiSource, "layoutStyle", "layout_style") ?? defaults.ui.layoutStyle,
@@ -233,6 +264,19 @@ export function parseSettingsData(data: unknown): AppSettings {
       showContext: pickBool(headerSource, "showContext", "show_context"),
       showAuthStatus: pickBool(headerSource, "showAuthStatus", "show_auth_status"),
     }),
+    updateCheck: normalizeUpdateCheckSettings({
+      enabled: pickBool(updateCheckSource, "enabled", "enabled"),
+      intervalHours: typeof updateCheckSource.intervalHours === "number"
+        ? updateCheckSource.intervalHours
+        : typeof updateCheckSource.interval_hours === "number"
+          ? updateCheckSource.interval_hours
+          : undefined,
+      skippedUpdateVersion: typeof updateCheckSource.skippedUpdateVersion === "string"
+        ? updateCheckSource.skippedUpdateVersion
+        : typeof updateCheckSource.skipped_update_version === "string"
+          ? updateCheckSource.skipped_update_version
+          : null,
+    }),
   };
 }
 
@@ -259,6 +303,13 @@ export function serializeSettings(settings: AppSettings): Record<string, unknown
       show_context: settings.header.showContext,
       show_auth_status: settings.header.showAuthStatus,
     },
+    update_check: {
+      enabled: settings.updateCheck.enabled,
+      interval_hours: settings.updateCheck.intervalHours,
+      ...(settings.updateCheck.skippedUpdateVersion != null
+        ? { skipped_update_version: settings.updateCheck.skippedUpdateVersion }
+        : {}),
+    },
   };
 }
 

package/src/config/runtimeConfig.ts

@@ -110,8 +110,11 @@ export interface RuntimeStatusContext {
 }
 
 export interface RuntimeSummary {
+  providerLabel: string;
   model: AvailableModel;
+  modelLabel?: string;
   reasoningLabel: string;
+  contextLabel?: string;
   modeLabel: string;
   sandboxLabel: string;
   approvalLabel: string;
@@ -439,6 +442,7 @@ export function formatPersonalityLabel(value: RuntimePersonality): string {
 
 export function buildRuntimeSummary(runtime: ResolvedRuntimeConfig): RuntimeSummary {
   return {
+    providerLabel: formatBackendLabel(runtime.provider),
     model: runtime.model,
     reasoningLabel: formatReasoningLabel(runtime.reasoningLevel),
     modeLabel: formatModeLabel(runtime.mode),

package/src/config/settings.ts

@@ -9,14 +9,14 @@ function smartJoin(base: string, ...parts: string[]): string {
   return isWindowsStylePath(base) ? win32.join(base, ...parts) : join(base, ...parts);
 }
 
+export { APP_VERSION } from "./buildInfo.js";
 export const APP_NAME = "Codexa";
-export const APP_VERSION = "1.0.1";
 export const DEFAULT_BACKEND = "codex-subprocess";
 export const DEFAULT_MODEL = "gpt-5.4";
 export const DEFAULT_MODE = "full-auto";
 export const DEFAULT_REASONING_LEVEL = "high";
 export const DEFAULT_LAYOUT_STYLE = "gemini-shell";
-export const DEFAULT_THEME = "mono";
+export const DEFAULT_THEME = "dark";
 export const DEFAULT_WORKSPACE_DISPLAY_MODE = "dir";
 export const DEFAULT_TERMINAL_TITLE_MODE = "dir";
 export const DEFAULT_SHOW_BUSY_LOADER = true;
@@ -264,21 +264,14 @@ export function formatReasoningLabel(reasoning: string): string {
 }
 
 export const AVAILABLE_THEMES = [
+  { id: "dark", label: "Codexa Dark" },
   { id: "purple", label: "Midnight Purple" },
   { id: "mono", label: "Black & White" },
-  { id: "dark", label: "Modern Dark" },
   { id: "black", label: "Codex the Black" },
-  { id: "emerald", label: "Emerald Night" },
-  { id: "solar", label: "Solar Flare" },
-  { id: "cyber", label: "Cyberpunk Neon" },
-  { id: "ocean", label: "Deep Oceanic" },
   { id: "nordic", label: "Nordic Frost" },
-  { id: "green", label: "Terminal Green" },
-  { id: "amber", label: "Terminal Amber" },
-  { id: "vaporwave", label: "Vaporwave Dream" },
   { id: "dracula", label: "Dracula Night" },
   { id: "gruvbox", label: "Gruvbox Hard" },
-  { id: "synthwave", label: "Synthwave '84" },
+  { id: "ocean", label: "Deep Oceanic" },
   { id: "custom", label: "Customize..." },
 ] as const;
 
@@ -377,8 +370,8 @@ export interface HeaderConfig {
 export const HEADER_CONFIG_DEFAULTS: HeaderConfig = {
   showBrand: true,
   showWorkspace: true,
-  showProvider: false,
-  showModel: false,
+  showProvider: true,
+  showModel: true,
   showReasoning: false,
   showContext: false,
   showAuthStatus: false,