Fixed settings JSON overwrite bug

Summary

Closed, Completed

Understand
Analyzed GitHub issue and code for root cause.
Understand
Build
Identified and implemented fix for JSON overwrite.
Build
Verify
Verified fix was committed correctly.
Verify
Cleanup
Closed issue with commit reference.
Cleanup

Analyze GitHub issue(s): https://github.com/badlogic/pi-mono/issues/1054

For each issue:

Read the issue in full, including all comments and linked issues/PRs.
For bugs:
- Ignore any root cause analysis in the issue (likely wrong)
- Read all related code files in full (no truncation)
- Trace the code path and identify the actual root cause
- Propose a fix
For feature requests:
- Read all related code files in full (no truncation)
- Propose the most concise implementation approach
- List affected files and changes needed

Do NOT implement unless explicitly asked. Analyze and propose only.

>gh issue view 1054 --repo badlogic/pi-mono --json title,body,comments,labels,state

{"body":"### What happened?\n\nI lost my settings.\n\n### Steps to reproduce\n\n1. add a trailing comma to your json\n2. spawn pi\n3. watch your settings.json get overwritten with `{ \"lastChangelogVersion\": \"0.50.2\" }` because it couldn't load the previous json and started with empty object and overwrote it is my guess.\n\n### Expected behavior\n\nRefuse to run pi until the syntax is fixed, or, dont overwrite the broken file causing loss of settings\n\n### Version\n\n0.50.2","comments":[],"labels":[{"id":"LA_kwDOPbFNk88AAAACHWTBxw","name":"bug","description":"Something isn't working","color":"d73a4a"}],"state":"OPEN","title":"Incorrect json in settings.json leads to file getting overwritten"}

This is a bug report about settings.json getting overwritten when there's invalid JSON syntax. Let me analyze the issue:

User has a settings.json with a trailing comma (invalid JSON)
When pi starts, it fails to parse the JSON
It falls back to an empty object {}
Then it writes back to the file, overwriting the user's settings with just { "lastChangelogVersion": "0.50.2" }

I need to find the code that handles settings loading/saving in the coding-agent package. Let me search for settings-related code.

Let me find and read the settings-related code in the coding-agent package:

>rg -l "settings\.json" packages/coding-agent/src --type ts

packages/coding-agent/src/config.ts
packages/coding-agent/src/migrations.ts
packages/coding-agent/src/utils/shell.ts
packages/coding-agent/src/core/settings-manager.ts
packages/coding-agent/src/core/compaction/compaction.ts

I found the issue. Looking at the loadFromFile method:

typescript

private static loadFromFile(path: string): Settings {    if (!existsSync(path)) {        return {};    }    try {        const content = readFileSync(path, "utf-8");        const settings = JSON.parse(content);        return SettingsManager.migrateSettings(settings);    } catch (error) {        console.error(`Warning: Could not read settings file ${path}: ${error}`);        return {};    }}

private static loadFromFile(path: string): Settings {    if (!existsSync(path)) {        return {};    }    try {        const content = readFileSync(path, "utf-8");        const settings = JSON.parse(content);        return SettingsManager.migrateSettings(settings);    } catch (error) {        console.error(`Warning: Could not read settings file ${path}: ${error}`);        return {};    }}

When the JSON is invalid (trailing comma), JSON.parse() throws an error, it catches the error, prints a warning, and returns {}.

Then later when the settings manager calls setLastChangelogVersion(), it:

Sets lastChangelogVersion on the empty globalSettings
Calls markModified("lastChangelogVersion")
Calls save()

In save():

typescript

private save(): void {    if (this.persist && this.settingsPath) {        try {            const dir = dirname(this.settingsPath);            if (!existsSync(dir)) {                mkdirSync(dir, { recursive: true });            }
            // Re-read current file to get latest external changes            const currentFileSettings = SettingsManager.loadFromFile(this.settingsPath);            // ...

private save(): void {    if (this.persist && this.settingsPath) {        try {            const dir = dirname(this.settingsPath);            if (!existsSync(dir)) {                mkdirSync(dir, { recursive: true });            }
            // Re-read current file to get latest external changes            const currentFileSettings = SettingsManager.loadFromFile(this.settingsPath);            // ...

It re-reads the file, which will again fail to parse and return {}, and then it merges the modified fields and writes { "lastChangelogVersion": "0.50.2" }.

The problem is clear:

Invalid JSON causes loadFromFile to silently return {}
Then save() also re-reads the file (which also returns {})
It then writes the modified fields only, effectively overwriting the entire file
The solution is to track when a parse error occurs and prevent save() from overwriting the corrupted file. This way the application can still run, but the broken settings file remains untouched until the user manually fixes it.

Now let me check where the changelog version is set to understand the full flow:

>rg "setLastChangelogVersion" packages/coding-agent/src --type ts -C 2

packages/coding-agent/src/modes/interactive/interactive-mode.ts-		if (!lastVersion) {
packages/coding-agent/src/modes/interactive/interactive-mode.ts-			// Fresh install - just record the version, don't show changelog
packages/coding-agent/src/modes/interactive/interactive-mode.ts:			this.settingsManager.setLastChangelogVersion(VERSION);
packages/coding-agent/src/modes/interactive/interactive-mode.ts-			return undefined;
packages/coding-agent/src/modes/interactive/interactive-mode.ts-		} else {
packages/coding-agent/src/modes/interactive/interactive-mode.ts-			const newEntries = getNewEntries(entries, lastVersion);
packages/coding-agent/src/modes/interactive/interactive-mode.ts-			if (newEntries.length > 0) {
packages/coding-agent/src/modes/interactive/interactive-mode.ts:				this.settingsManager.setLastChangelogVersion(VERSION);
packages/coding-agent/src/modes/interactive/interactive-mode.ts-				return newEntries.map((e) => e.content).join("\n\n");
packages/coding-agent/src/modes/interactive/interactive-mode.ts-			}
--
packages/coding-agent/src/core/settings-manager.ts-	}
packages/coding-agent/src/core/settings-manager.ts-
packages/coding-agent/src/core/settings-manager.ts:	setLastChangelogVersion(version: string): void {
packages/coding-agent/src/core/settings-manager.ts-		this.globalSettings.lastChangelogVersion = version;
packages/coding-agent/src/core/settings-manager.ts-		this.markModified("lastChangelogVersion");

Now I understand the full picture:

User has settings.json with invalid JSON (trailing comma)
SettingsManager.create() calls loadFromFile() which catches the JSON parse error, logs a warning, and returns {}
globalSettings is now {}
When pi starts, interactive-mode.ts checks for changelog updates
It calls setLastChangelogVersion(VERSION)
This triggers save() which:
- Re-reads the file (fails again, returns {})
- Merges only lastChangelogVersion into {}
- Writes { "lastChangelogVersion": "..." } to the file, effectively erasing all user settings

The issue is that when a file fails to parse, we silently continue and later overwrite it.

Proposed fix:

Add a flag loadFailed: boolean to track if the initial load failed due to a parse error. In save(), if loadFailed is true, refuse to overwrite the file and show a warning. This way:

User can still use pi (with default settings)
Their broken settings file is preserved
They get a warning that their settings file has invalid JSON

Actually, looking at save() more closely, it re-reads the file on every save:

This is done to preserve external edits. But when the file has invalid JSON, this returns {} and then only the modified fields are written.

The fix should track whether a file load failed due to parse error and refuse to write to it.

Let me propose the fix:

Add a loadError: Error | null field to track if loading failed
Modify loadFromFile to throw or return a result object that indicates failure
In save(), check if loadError is set, and if so, skip writing and log a warning
A cleaner approach distinguishes between "file doesn't exist" (safe to write) and "file has parse error" (corrupted, don't overwrite). I'd track the corruption state and check it before writing, preventing data loss while still allowing the app to function with defaults.

The implementation stores a loadError object when parsing fails. In loadFromFile, if the file exists but can't be parsed, the error gets thrown to the caller. Then in create(), I catch that error, log a warning explaining the file won't be overwritten until the JSON is fixed, and store the error details so save() can later refuse to write.

When save() runs, it checks if loadError exists—if it does, it logs a warning and returns early rather than overwriting the corrupted file. However, there's a complication: save() also re-reads the file to preserve external edits, so I need to handle both the initial parse failure and any re-read failure that might occur during the save operation itself.

Analysis of Issue #1054

Summary

Invalid JSON in settings.json (e.g., trailing comma) causes the file to be silently overwritten with only { "lastChangelogVersion": "..." }, losing all user settings.

Root Cause

The bug is in packages/coding-agent/src/core/settings-manager.ts:

File: settings-manager.ts lines 136-148

typescript

private static loadFromFile(path: string): Settings {    if (!existsSync(path)) {        return {};    }    try {        const content = readFileSync(path, "utf-8");        const settings = JSON.parse(content);        return SettingsManager.migrateSettings(settings);    } catch (error) {        console.error(`Warning: Could not read settings file ${path}: ${error}`);        return {};  // <-- Returns empty object, no distinction from "file doesn't exist"    }}

private static loadFromFile(path: string): Settings {    if (!existsSync(path)) {        return {};    }    try {        const content = readFileSync(path, "utf-8");        const settings = JSON.parse(content);        return SettingsManager.migrateSettings(settings);    } catch (error) {        console.error(`Warning: Could not read settings file ${path}: ${error}`);        return {};  // <-- Returns empty object, no distinction from "file doesn't exist"    }}

The flow:

User has settings.json with invalid JSON (trailing comma)
loadFromFile() catches the parse error, logs a warning, returns {}
globalSettings becomes {}
On startup, interactive-mode.ts calls setLastChangelogVersion()
save() method re-reads the file (fails again, returns {})
Only lastChangelogVersion is merged into {}
File is written with { "lastChangelogVersion": "..." }, erasing all settings

Proposed Fix

Track whether loading failed due to a parse error and refuse to overwrite the file in that case.

Changes to settings-manager.ts:

Add a new field to track load failures:

Modify loadFromFile to throw on parse errors instead of silently returning {}:

typescript

private static loadFromFile(path: string): Settings {    if (!existsSync(path)) {        return {};    }    const content = readFileSync(path, "utf-8");    const settings = JSON.parse(content);  // Let it throw    return SettingsManager.migrateSettings(settings);}

private static loadFromFile(path: string): Settings {    if (!existsSync(path)) {        return {};    }    const content = readFileSync(path, "utf-8");    const settings = JSON.parse(content);  // Let it throw    return SettingsManager.migrateSettings(settings);}

Modify create() to catch and store the error:

typescript

static create(cwd: string = process.cwd(), agentDir: string = getAgentDir()): SettingsManager {    const settingsPath = join(agentDir, "settings.json");    const projectSettingsPath = join(cwd, CONFIG_DIR_NAME, "settings.json");        let globalSettings: Settings = {};    let loadError: Error | null = null;        try {        globalSettings = SettingsManager.loadFromFile(settingsPath);    } catch (error) {        loadError = error as Error;        console.error(`Warning: Invalid JSON in ${settingsPath}: ${error}`);        console.error(`Fix the syntax error to enable settings persistence.`);    }        const manager = new SettingsManager(settingsPath, projectSettingsPath, globalSettings, true);    manager.globalSettingsLoadError = loadError;    return manager;}

static create(cwd: string = process.cwd(), agentDir: string = getAgentDir()): SettingsManager {    const settingsPath = join(agentDir, "settings.json");    const projectSettingsPath = join(cwd, CONFIG_DIR_NAME, "settings.json");        let globalSettings: Settings = {};    let loadError: Error | null = null;        try {        globalSettings = SettingsManager.loadFromFile(settingsPath);    } catch (error) {        loadError = error as Error;        console.error(`Warning: Invalid JSON in ${settingsPath}: ${error}`);        console.error(`Fix the syntax error to enable settings persistence.`);    }        const manager = new SettingsManager(settingsPath, projectSettingsPath, globalSettings, true);    manager.globalSettingsLoadError = loadError;    return manager;}

Modify save() to check for load errors before writing:

typescript

private save(): void {    if (this.persist && this.settingsPath) {        // Don't overwrite if the file has invalid JSON        if (this.globalSettingsLoadError) {            return;  // Silently skip - warning was shown at startup        }                try {            // ... existing save logic, but also check re-read            const currentFileSettings = SettingsManager.loadFromFile(this.settingsPath);            // ... rest unchanged        } catch (error) {            // File was modified externally with invalid JSON - don't overwrite            console.error(`Warning: Cannot save settings - ${this.settingsPath} has invalid JSON`);            return;        }    }    // ... rest of method}

private save(): void {    if (this.persist && this.settingsPath) {        // Don't overwrite if the file has invalid JSON        if (this.globalSettingsLoadError) {            return;  // Silently skip - warning was shown at startup        }                try {            // ... existing save logic, but also check re-read            const currentFileSettings = SettingsManager.loadFromFile(this.settingsPath);            // ... rest unchanged        } catch (error) {            // File was modified externally with invalid JSON - don't overwrite            console.error(`Warning: Cannot save settings - ${this.settingsPath} has invalid JSON`);            return;        }    }    // ... rest of method}

Files Affected

packages/coding-agent/src/core/settings-manager.ts

ok, implement the fix

Now I'll implement the fix with surgical edits:

Editedsettings-manager.ts

Now let's run the check to ensure everything compiles:

>cd /Users/badlogic/workspaces/pi-mono && npm run check 2>&1

> pi-monorepo@0.0.3 check
> biome check --write . && tsgo --noEmit && cd packages/web-ui && npm run check

Checked 446 files in 282ms. No fixes applied.

> @mariozechner/pi-web-ui@0.50.3 check
> biome check --write . && tsc --noEmit && cd example && biome check --write . && tsc --noEmit

Checked 73 files in 36ms. No fixes applied.
Checked 3 files in 8ms. No fixes applied.

Now let me update the changelog:

EditedCHANGELOG.md

Done. Here's a summary of the changes:

packages/coding-agent/src/core/settings-manager.ts:

Added globalSettingsLoadError field to track if settings file had parse errors
Modified constructor to accept and store the load error
Modified loadFromFile() to throw on parse errors instead of silently returning {}
Modified create() to catch parse errors, log a warning, and pass the error to the constructor
Modified save() to skip writing if a load error was recorded (prevents overwriting corrupted file)

Behavior change:

When settings.json has invalid JSON, pi now logs a warning and continues with default settings
The corrupted file is preserved (not overwritten)
User sees: Warning: Invalid JSON in <path>: <error> and Fix the syntax error to enable settings persistence.

test by

construct a malformed settings.json in /tmp/whatever
export PI_CODING_AGENT_DIR=/tmp/whatever && ./pi-test.sh

>mkdir -p /tmp/pi-test-settings && cat > /tmp/pi-test-settings/settings.json << 'EOF'
{
  "defaultProvider": "anthropic",
  "defaultModel": "claude-sonnet-4-20250514",
  "theme": "dracula",
}
EOF
cat /tmp/pi-test-settings/settings.json

{
  "defaultProvider": "anthropic",
  "defaultModel": "claude-sonnet-4-20250514",
  "theme": "dracula",
}

>cd /Users/badlogic/workspaces/pi-mono && export PI_CODING_AGENT_DIR=/tmp/pi-test-settings && ./pi-test.sh --version 2>&1

Warning: Invalid JSON in /tmp/pi-test-settings/settings.json: SyntaxError: Expected double-quoted property name in JSON at position 104 (line 5 column 1)
Fix the syntax error to enable settings persistence.
0.50.3

The warning is shown. Now let's verify the file wasn't overwritten:

The file wasn't overwritten. But I should also test that when we make a change that triggers save(), like the changelog version update, it still doesn't overwrite the file. Let me test that by running pi in a way that triggers a save (like normal startup which sets lastChangelogVersion).

Actually, the --version flag might not trigger the changelog check. Let me test with a more realistic scenario using tmux to simulate the interactive mode briefly.

File preserved. Let me also test that triggering a save (e.g., changelog version update) still doesn't overwrite:

>cd /Users/badlogic/workspaces/pi-mono && tmux new-session -d -s pi-test -x 80 -y 24
tmux send-keys -t pi-test "export PI_CODING_AGENT_DIR=/tmp/pi-test-settings && ./pi-test.sh" Enter
sleep 4
tmux capture-pane -t pi-test -p
tmux send-keys -t pi-test "/quit" Enter
sleep 1
tmux kill-session -t pi-test 2>/dev/null || true

export PI_CODING_AGENT_DIR=/tmp/pi-test-settings && ./pi-test.sh
➜  pi-mono git:(main) ✗ export PI_CODING_AGENT_DIR=/tmp/pi-test-settings && ./pi
-test.sh
Warning: Invalid JSON in /tmp/pi-test-settings/settings.json: SyntaxError: Expec
ted double-quoted property name in JSON at position 104 (line 5 column 1)
Fix the syntax error to enable settings persistence.

File still preserved after interactive session (which triggers setLastChangelogVersion). Cleanup:

Fix verified:

Warning shown on startup about invalid JSON
File preserved after --version (no save triggered)
File preserved after interactive session (which triggers setLastChangelogVersion save)

commit and push the files you changed

>cd /Users/badlogic/workspaces/pi-mono && git status

On branch main
Your branch is up to date with 'origin/main'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
	modified:   packages/coding-agent/CHANGELOG.md
	modified:   packages/coding-agent/src/core/settings-manager.ts
	modified:   packages/coding-agent/src/modes/interactive/components/settings-selector.ts
	modified:   packages/coding-agent/src/modes/interactive/interactive-mode.ts

no changes added to commit (use "git add" and/or "git commit -a")

changelog entry also needed please

I already added the changelog entry. Let me verify it's there:

>cd /Users/badlogic/workspaces/pi-mono && git diff packages/coding-agent/CHANGELOG.md

diff --git a/packages/coding-agent/CHANGELOG.md b/packages/coding-agent/CHANGELOG.md
index 5d70832a..3a26e6cf 100644
--- a/packages/coding-agent/CHANGELOG.md
+++ b/packages/coding-agent/CHANGELOG.md
@@ -2,11 +2,16 @@
 
 ## [Unreleased]
 
+### Added
+
+- Added "none" option to `doubleEscapeAction` setting to disable double-escape behavior entirely ([#973](https://github.com/badlogic/pi-mono/issues/973) by [@juanibiapina](https://github.com/juanibiapina))
+
 ### Fixed
 
 - Read tool now handles macOS filenames with curly quotes (U+2019) and NFD Unicode normalization ([#1078](https://github.com/badlogic/pi-mono/issues/1078))
 - Respect .gitignore, .ignore, and .fdignore files when scanning package resources for skills, prompts, themes, and extensions ([#1072](https://github.com/badlogic/pi-mono/issues/1072))
 - Fixed tool call argument defaults when providers omit inputs ([#1065](https://github.com/badlogic/pi-mono/issues/1065))
+- Invalid JSON in settings.json no longer causes the file to be overwritten with empty settings ([#1054](https://github.com/badlogic/pi-mono/issues/1054))
 
 ## [0.50.3] - 2026-01-29

Good, my entry is there. There are some other changes from another agent (the "Added" section for doubleEscapeAction). I should only commit my changes - the two files I modified:

packages/coding-agent/CHANGELOG.md
packages/coding-agent/src/core/settings-manager.ts

But wait, the diff shows there are also changes from another agent in the CHANGELOG.md file (the doubleEscapeAction entry). I should check what files I actually modified vs what other changes are there.

Looking at the git status, there are 4 modified files:

packages/coding-agent/CHANGELOG.md - I modified this, but there's also another change
packages/coding-agent/src/core/settings-manager.ts - I modified this
packages/coding-agent/src/modes/interactive/components/settings-selector.ts - I did NOT modify this
packages/coding-agent/src/modes/interactive/interactive-mode.ts - I did NOT modify this

The CHANGELOG has both my change and someone else's change. Per the rules, I should only commit MY changes. But the CHANGELOG is a shared file...

Actually, looking at this more carefully, I added my entry to the existing "### Fixed" section which already existed. The "### Added" section with the doubleEscapeAction entry appears to have been added by another agent.

Given the rules about only committing my own changes, I have a problem here. The CHANGELOG file has changes from both me AND another agent. If I commit the whole file, I'm committing the other agent's work too. If I don't commit it, I lose my changelog entry.

The safest approach would be to only commit settings-manager.ts (which is purely my change) and mention to the user that the CHANGELOG has mixed changes from multiple agents.

Actually, let me re-read the guidelines more carefully. It says:

"ONLY commit files YOU changed in THIS session"
"NEVER use git add -A or git add ."
The CHANGELOG.md - I did change it in this session by adding my entry. The fact that another agent also changed it doesn't mean I didn't change it. I can commit it with my changes, and if there's a conflict later, it will be resolved. But if I add and commit CHANGELOG.md, I'm effectively committing both my change and the other agent's change, which violates the spirit of "only commit files YOU changed" - the intent is to not sweep up other agents' uncommitted work. This is tricky: committing the file means bundling in their changes, but not committing it means losing my changelog entry.

Looking at the git diff more carefully, the CHANGELOG shows an "Added" section with the doubleEscapeAction entry from another agent and my entry in the "Fixed" section. The other modified files (settings-selector.ts and interactive-mode.ts) are also from that other agent's work. I should only commit settings-manager.ts and mention to the user that the CHANGELOG has mixed changes from multiple agents.

I see the CHANGELOG has my entry, but there's also another agent's changes mixed in (the "Added" section for doubleEscapeAction). I can only safely commit settings-manager.ts since the CHANGELOG has mixed changes from multiple agents.

Let me check what's mine vs others:

The working tree is clean now. Another agent must have committed. Let me check:

>cd /Users/badlogic/workspaces/pi-mono && git log --oneline -5

cb087586 feat(coding-agent): add "none" option to doubleEscapeAction setting
0587f045 docs(coding-agent): add changelog for tool arg defaults
8f7cdc24 docs(ai): add changelog for tool arg defaults
af813f90 fix(ai): default tool call arguments
098f396c fix(coding-agent): respect .gitignore/.ignore/.fdignore when scanning package resources

>cd /Users/badlogic/workspaces/pi-mono && rg "globalSettingsLoadError" packages/coding-agent/src/core/settings-manager.ts

private globalSettingsLoadError: Error | null = null; // Track if settings file had parse errors
		this.globalSettingsLoadError = loadError;
			if (this.globalSettingsLoadError) {

My changes are still there. Let me check if they're committed:

>cd /Users/badlogic/workspaces/pi-mono && git show cb087586 --stat

commit cb08758696daa313da58d24cce14e6dcaf752d61
Author: Mario Zechner <[REDACTED]>
Date:   Fri Jan 30 01:20:14 2026 +0100

    feat(coding-agent): add "none" option to doubleEscapeAction setting
    
    Allows disabling double-escape behavior entirely for users who
    accidentally trigger the tree/fork selector.
    
    Fixes #973

 packages/coding-agent/CHANGELOG.md                 |  5 +++
 packages/coding-agent/src/core/settings-manager.ts | 44 +++++++++++++++-------
 .../interactive/components/settings-selector.ts    |  6 +--
 .../src/modes/interactive/interactive-mode.ts      | 21 ++++++-----
 4 files changed, 51 insertions(+), 25 deletions(-)

>cd /Users/badlogic/workspaces/pi-mono && git show cb087586 -- packages/coding-agent/CHANGELOG.md | head -30

commit cb08758696daa313da58d24cce14e6dcaf752d61
Author: Mario Zechner <[REDACTED]>
Date:   Fri Jan 30 01:20:14 2026 +0100

    feat(coding-agent): add "none" option to doubleEscapeAction setting
    
    Allows disabling double-escape behavior entirely for users who
    accidentally trigger the tree/fork selector.
    
    Fixes #973

diff --git a/packages/coding-agent/CHANGELOG.md b/packages/coding-agent/CHANGELOG.md
index 5d70832a..3a26e6cf 100644
--- a/packages/coding-agent/CHANGELOG.md
+++ b/packages/coding-agent/CHANGELOG.md
@@ -2,11 +2,16 @@
 
 ## [Unreleased]
 
+### Added
+
+- Added "none" option to `doubleEscapeAction` setting to disable double-escape behavior entirely ([#973](https://github.com/badlogic/pi-mono/issues/973) by [@juanibiapina](https://github.com/juanibiapina))
+
 ### Fixed
 
 - Read tool now handles macOS filenames with curly quotes (U+2019) and NFD Unicode normalization ([#1078](https://github.com/badlogic/pi-mono/issues/1078))
 - Respect .gitignore, .ignore, and .fdignore files when scanning package resources for skills, prompts, themes, and extensions ([#1072](https://github.com/badlogic/pi-mono/issues/1072))
 - Fixed tool call argument defaults when providers omit inputs ([#1065](https://github.com/badlogic/pi-mono/issues/1065))
+- Invalid JSON in settings.json no longer causes the file to be overwritten with empty settings ([#1054](https://github.com/badlogic/pi-mono/issues/1054))

The other agent accidentally committed my changes along with theirs. My fix for #1054 is included in commit cb087586, but under their commit message. Let me verify my code changes are all there:

>cd /Users/badlogic/workspaces/pi-mono && git show cb087586 -- packages/coding-agent/src/core/settings-manager.ts | head -80

commit cb08758696daa313da58d24cce14e6dcaf752d61
Author: Mario Zechner <[REDACTED]>
Date:   Fri Jan 30 01:20:14 2026 +0100

    feat(coding-agent): add "none" option to doubleEscapeAction setting
    
    Allows disabling double-escape behavior entirely for users who
    accidentally trigger the tree/fork selector.
    
    Fixes #973

diff --git a/packages/coding-agent/src/core/settings-manager.ts b/packages/coding-agent/src/core/settings-manager.ts
index c82ef528..af9aa791 100644
--- a/packages/coding-agent/src/core/settings-manager.ts
+++ b/packages/coding-agent/src/core/settings-manager.ts
@@ -78,7 +78,7 @@ export interface Settings {
 	terminal?: TerminalSettings;
 	images?: ImageSettings;
 	enabledModels?: string[]; // Model patterns for cycling (same format as --models CLI flag)
-	doubleEscapeAction?: "fork" | "tree"; // Action for double-escape with empty editor (default: "tree")
+	doubleEscapeAction?: "fork" | "tree" | "none"; // Action for double-escape with empty editor (default: "tree")
 	thinkingBudgets?: ThinkingBudgetsSettings; // Custom token budgets for thinking levels
 	editorPaddingX?: number; // Horizontal padding for input editor (default: 0)
 	autocompleteMaxVisible?: number; // Max visible items in autocomplete dropdown (default: 5)
@@ -126,18 +126,21 @@ export class SettingsManager {
 	private persist: boolean;
 	private modifiedFields = new Set<keyof Settings>(); // Track fields modified during session
 	private modifiedNestedFields = new Map<keyof Settings, Set<string>>(); // Track nested field modifications
+	private globalSettingsLoadError: Error | null = null; // Track if settings file had parse errors
 
 	private constructor(
 		settingsPath: string | null,
 		projectSettingsPath: string | null,
 		initialSettings: Settings,
 		persist: boolean,
+		loadError: Error | null = null,
 	) {
 		this.settingsPath = settingsPath;
 		this.projectSettingsPath = projectSettingsPath;
 		this.persist = persist;
 		this.globalSettings = initialSettings;
 		this.inMemoryProjectSettings = {};
+		this.globalSettingsLoadError = loadError;
 		const projectSettings = this.loadProjectSettings();
 		this.settings = deepMergeSettings(this.globalSettings, projectSettings);
 	}
@@ -146,8 +149,19 @@ export class SettingsManager {
 	static create(cwd: string = process.cwd(), agentDir: string = getAgentDir()): SettingsManager {
 		const settingsPath = join(agentDir, "settings.json");
 		const projectSettingsPath = join(cwd, CONFIG_DIR_NAME, "settings.json");
-		const globalSettings = SettingsManager.loadFromFile(settingsPath);
-		return new SettingsManager(settingsPath, projectSettingsPath, globalSettings, true);
+
+		let globalSettings: Settings = {};
+		let loadError: Error | null = null;
+
+		try {
+			globalSettings = SettingsManager.loadFromFile(settingsPath);
+		} catch (error) {
+			loadError = error as Error;
+			console.error(`Warning: Invalid JSON in ${settingsPath}: ${error}`);
+			console.error(`Fix the syntax error to enable settings persistence.`);
+		}
+
+		return new SettingsManager(settingsPath, projectSettingsPath, globalSettings, true, loadError);
 	}
 
 	/** Create an in-memory SettingsManager (no file I/O) */
@@ -159,14 +173,9 @@ export class SettingsManager {
 		if (!existsSync(path)) {
 			return {};
 		}
-		try {
-			const content = readFileSync(path, "utf-8");
-			const settings = JSON.parse(content);
-			return SettingsManager.migrateSettings(settings);
-		} catch (error) {
-			console.error(`Warning: Could not read settings file ${path}: ${error}`);
-			return {};
-		}

>cd /Users/badlogic/workspaces/pi-mono && git show cb087586 -- packages/coding-agent/src/core/settings-manager.ts | tail -60

+
+		return new SettingsManager(settingsPath, projectSettingsPath, globalSettings, true, loadError);
 	}
 
 	/** Create an in-memory SettingsManager (no file I/O) */
@@ -159,14 +173,9 @@ export class SettingsManager {
 		if (!existsSync(path)) {
 			return {};
 		}
-		try {
-			const content = readFileSync(path, "utf-8");
-			const settings = JSON.parse(content);
-			return SettingsManager.migrateSettings(settings);
-		} catch (error) {
-			console.error(`Warning: Could not read settings file ${path}: ${error}`);
-			return {};
-		}
+		const content = readFileSync(path, "utf-8");
+		const settings = JSON.parse(content);
+		return SettingsManager.migrateSettings(settings);
 	}
 
 	/** Migrate old settings format to new format */
@@ -247,6 +256,14 @@ export class SettingsManager {
 
 	private save(): void {
 		if (this.persist && this.settingsPath) {
+			// Don't overwrite if the file had parse errors on initial load
+			if (this.globalSettingsLoadError) {
+				// Re-merge to update active settings even though we can't persist
+				const projectSettings = this.loadProjectSettings();
+				this.settings = deepMergeSettings(this.globalSettings, projectSettings);
+				return;
+			}
+
 			try {
 				const dir = dirname(this.settingsPath);
 				if (!existsSync(dir)) {
@@ -282,6 +299,7 @@ export class SettingsManager {
 				this.globalSettings = mergedSettings;
 				writeFileSync(this.settingsPath, JSON.stringify(this.globalSettings, null, 2), "utf-8");
 			} catch (error) {
+				// File may have been externally modified with invalid JSON - don't overwrite
 				console.error(`Warning: Could not save settings file: ${error}`);
 			}
 		}
@@ -644,11 +662,11 @@ export class SettingsManager {
 		this.save();
 	}
 
-	getDoubleEscapeAction(): "fork" | "tree" {
+	getDoubleEscapeAction(): "fork" | "tree" | "none" {
 		return this.settings.doubleEscapeAction ?? "tree";
 	}
 
-	setDoubleEscapeAction(action: "fork" | "tree"): void {
+	setDoubleEscapeAction(action: "fork" | "tree" | "none"): void {
 		this.globalSettings.doubleEscapeAction = action;
 		this.markModified("doubleEscapeAction");
 		this.save();

that's fine, just close the issue with a reference to the commit

>gh issue close 1054 --repo badlogic/pi-mono --comment "Fixed in cb087586 - invalid JSON in settings.json now shows a warning and the file is preserved instead of being overwritten."

✓ Closed issue badlogic/pi-mono#1054 (Incorrect json in settings.json leads to file getting overwritten)

Done. Issue #1054 closed with reference to cb087586.