fix(install): keep unreadable Claude settings instead of overwriting them (#627)

installStatusLine caught any error from loadClaudeSettings (a JSON parse
failure such as a trailing comma, EACCES/EBUSY, or a read racing Claude
Code's own write), printed a warning, fell back to {} and then saved a
settings.json containing only statusLine. Permissions, hooks, env, model
and every other key were lost: the .bak written by saveClaudeSettings is
immediately overwritten by the widget-hook sync, and the .orig backup is
overwritten by the next install.

loadClaudeSettings already returns {} when the file does not exist, so
any error it throws means the file exists but cannot be read or parsed.
In that case install now aborts with an error naming the file and the
reason, leaving it (and any previous .orig) untouched; the .orig backup
is taken only after a successful read. This matches uninstallStatusLine,
which already refuses to modify unreadable settings. The TUI shows the
error text in an "Install Failed" notice instead of a 2-second flash.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: elhoim

src/tui/App.tsx

@@ -717,12 +717,15 @@ export const App: React.FC = () => {
                                 color: 'green'
                             });
                         }
-                    } catch {
-                        setFlashMessage({
-                            text: '✗ Install failed',
-                            color: 'red'
+                    } catch (err) {
+                        setFlashMessage(null);
+                        setFlowNotice({
+                            title: 'Install Failed',
+                            message: err instanceof Error ? err.message : String(err),
+                            color: 'red',
+                            continueScreen: 'install'
                         });
-                        setScreen('install');
+                        setScreen('flowNotice');
                     }
                     setConfirmDialog(null);
                 }

src/utils/__tests__/claude-settings.test.ts

@@ -518,25 +518,16 @@ describe('backup and error handling behavior', () => {
         }
     });
 
-    it('installStatusLine should warn and recover when existing settings are invalid', async () => {
+    it('installStatusLine should abort without touching existing settings that cannot be parsed', async () => {
         writeRawClaudeSettings('{ invalid json');
-        const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
-        try {
-            await installStatusLine({ commandMode: 'auto-npx' });
+        const settingsPath = getClaudeSettingsPath();
 
-            const settingsPath = getClaudeSettingsPath();
-            const installed = JSON.parse(fs.readFileSync(settingsPath, 'utf-8')) as { statusLine?: { command?: string; padding?: number } };
-            expect(installed.statusLine?.command).toBe(buildStatusLineCommand('auto-npx'));
-            expect(installed.statusLine?.padding).toBe(0);
-            expect(fs.existsSync(`${settingsPath}.orig`)).toBe(true);
-            expect(fs.readFileSync(`${settingsPath}.orig`, 'utf-8')).toBe('{ invalid json');
+        const installPromise = installStatusLine({ commandMode: 'auto-npx' });
+        await expect(installPromise).rejects.toThrow(settingsPath);
 
-            expect(consoleErrorSpy).toHaveBeenCalledWith(
-                `Warning: Could not read existing Claude settings. A backup exists at ${settingsPath}.orig.`
-            );
-        } finally {
-            consoleErrorSpy.mockRestore();
-        }
+        expect(fs.readFileSync(settingsPath, 'utf-8')).toBe('{ invalid json');
+        expect(fs.existsSync(`${settingsPath}.bak`)).toBe(false);
+        expect(fs.existsSync(`${settingsPath}.orig`)).toBe(false);
     });
 
     it('uninstallStatusLine should warn and return without modifying invalid settings', async () => {

src/utils/claude-settings.ts

@@ -405,15 +405,18 @@ export async function installStatusLine({
 }: InstallStatusLineOptions): Promise<void> {
     let settings: ClaudeSettings;
 
-    const backupPath = await backupClaudeSettings('.orig');
+    // A missing settings file loads as {}; any error here means the file exists
+    // but could not be read or parsed. Abort rather than overwrite it with only
+    // our statusLine, which would discard the user's other Claude Code settings.
     try {
         settings = await loadClaudeSettings({ logErrors: false });
-    } catch {
-        const fallbackBackupPath = `${getClaudeSettingsPath()}.orig`;
-        console.error(`Warning: Could not read existing Claude settings. A backup exists at ${backupPath ?? fallbackBackupPath}.`);
-        settings = {};
+    } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not read existing Claude settings at ${getClaudeSettingsPath()} (${reason}). The file was left unchanged; fix or remove it, then install again.`, { cause: error });
     }
 
+    await backupClaudeSettings('.orig');
+
     // Update settings with our status line (confirmation already handled in TUI)
     const existingRefreshInterval = settings.statusLine?.refreshInterval;
     settings.statusLine = {