bug(profiles): applying a newly created empty profile wipes models.json and clears every agent's routing

[jonathanludena]

Before submitting

• I searched open and closed issues and did not find a report of this problem.
• I reviewed this report and removed credentials, tokens, private paths, hostnames, and other sensitive data.

Problem

A profile created with c starts empty by design ("Create a new, empty profile"), and /gentle:models never writes into it. Its u action targets the current profile, resolved by resolveCurrentProfileTarget as the repository pin, else the globally active profile. So the natural operator flow — create a profile, configure the models, then select that profile — cannot populate the new profile: every configuration write lands in the previously active profile. The final enter (apply) on the still-empty profile then writes {} to ~/.pi/gentle-ai/models.json and replaces the materialized routing of every discoverable agent with clear entries, so all agents return to inherit. The whole model configuration is destroyed with no confirmation, no warning, and no recovery.

The panel already computes the exact signal for this state and renders it in the detail pane's "Profile routing" section ("No routing entries — every agent inherits its default model"), but enter acts on that state destructively instead of guarding it.

Because writing {} is a successful write, the compensation path already present in runProfilesPanelAction (revertClaim, which restores the previous active marker and the previously active profile's routing) never fires.

Steps to reproduce

1. /gentle:profiles → press c → name the profile (for example hybrid). The store now holds "hybrid": {}.
2. /gentle:models → assign model and effort to the agents → save with ctrl+s, or with u.
3. /gentle:profiles → select hybrid → press enter to apply.

Observed after step 3: ~/.pi/gentle-ai/models.json is {}, ~/.pi/agent/subagents.json holds clear entries for every agent, and no confirmation was shown.

Step 2 is the decisive detail. Whichever save key is used, the just-created profile stays {}; u writes to the pinned profile or the globally active one, never to the new profile. An operator who expects "configure the models into the profile I just created" gets no error and no hint, because the global save succeeds and the panel reports success.

Expected and actual behavior

Expected: applying a profile that has zero routing entries either refuses with an actionable message, or asks for explicit confirmation that names the destructive effect (global routing replaced with {}, every omitted agent returned to inherit). The previous routing and active marker should remain recoverable.

Actual: enter silently replaces the global routing with {} and clears every agent's materialized route. Nothing is restored, reported, or reversible from the UI.

A second, independent behavior amplifies it: c creates the profile without any seed from the current routing, so the empty state is the default first touch of a new profile rather than an exceptional one. Seeding the new profile from the effective routing (the same snapshot s takes) would make the documented create-then-configure flow work.

Two independent occurrences on the same machine left the same artifact signature:

# profiles store backup: an empty profile became active
active: "<profile>", "<profile>": {}

# models.json backup: global routing wiped
{}

# subagents.json backup: materialized routing wiped
{}

This is not fixed as of 3.5.1. The case "apply" and case "create" blocks in extensions/gentle-ai.ts and lib/agent-profiles.ts are byte-identical between the installed 3.3.0 and the 3.5.1 tarball, so upgrading does not change the behavior.

Relevant code paths: runProfilesPanelAction (cases apply and create), resolveCurrentProfileTarget, updateCurrentProfileFromSavedRouting, withOmittedAgentsClearedAsync, writeModelConfigAsync, applyModelConfigAsync; createProfile, setActiveProfile, normalizeProfilesFile in lib/agent-profiles.ts.

Documented keys that feed the trap, from docs/readme-reference.md (Agent-model profiles): enter applies live and "replaces the routing of every agent"; c creates "a new, empty profile"; s snapshots the current routing into the selected profile. The safe sequence exists, but nothing in the UI steers a new profile toward s before enter is ever pressed.

gentle-pi version

3.3.0 (installed from npm; 3.5.1 verified to be identical in the affected code paths)

Pi version

0.86.1

Operating system

macOS

Relevant logs or error output (optional)

# after step 1 — the new profile is empty, active is still the previous profile
~/.pi/gentle-ai/profiles.json
  openai: 23 roles | hybrid: {} | active: "openai"

# after step 3 — the global routing is gone
~/.pi/gentle-ai/models.json
  {}                                  # held 23 routing entries immediately before `enter`

# same signature from an earlier occurrence in the same store
profiles.json.bak-<epoch>  -> active: "nan", "nan": {}
models.json.bak-<epoch>    -> {}
subagents.json.bak-<epoch> -> {}

[jonathanludena]

Adding the general form of this, because it is the same code path and it hits in ordinary use, not only when the applied profile is empty.

General case: any profile switch discards unrouted /gentle:models state

Repro:

1. /gentle:models → change a model or thinking level → save with ctrl+s.
2. /gentle:profiles → select any profile → enter.

Observed: the change from step 1 is gone. models.json holds only the profile's snapshot, and the changed agent's materialized route is replaced by a clear entry.

Cause: a /gentle:models edit has no owner. It lives only in models.json plus whatever it materialized into subagents.json and agent frontmatter, and apply replaces all three layers from the profile snapshot:

• writeModelConfigAsync(cwd, normalized) → models.json becomes the profile content only.
• withOmittedAgentsClearedAsync → a clear entry ({}) for every agent the profile omits.
• applyModelConfigAsync → those clear entries into subagents.json, and updateFrontmatterRouting(content, {}) strips the model: / thinking: lines out of each agent's frontmatter (isClearRoutingEntry treats {} as a clear).

The only durable way to keep a /gentle:models edit is u (updateCurrentProfileFromSavedRouting), and u folds it into the current profile: the pin, else the globally active one (resolveCurrentProfileTarget). There is no path from /gentle:models to a profile the user is not currently on — which is precisely the profile they are about to switch to.

A successful apply is irreversible

The revertClaim compensation in runProfilesPanelAction runs only on failure; it restores the previously active marker and that profile's routing. A successful apply takes no snapshot first, and writeModelConfigAsync is a plain writeFile — no backup and no atomic rename, unlike writeJsonFileAtomicallySync used for the profile store. So the discarded routing is not recoverable from any file the tool writes.

The only recovery is manual: in /gentle:models, x exports to ~/.pi/gentle-ai/models.export.json and r restores it. Nothing does this automatically.

The documentation contradicts the behavior

docs/readme-reference.md (section "Agent-model profiles") says routing materialized "by a previous profile, by /gentle:models, or by a migration never survives a switch silently". But the apply notification only reports:

el Gentleman applied profile "<name>" — N agents updated.
New routing takes effect on the next subagent launch.

It never names which entries were replaced or cleared, nor for which agents. The loss is silent, which is the part the docs promise it is not.

Suggested direction

• Snapshot models.json and the materialized routing before a successful apply, so a switch is always reversible; revertClaim already shows what an undo must touch.
• Report the per-agent replacements and clears, not just the count.
• Guard enter when the profile has zero routing entries — the detail pane already renders "No routing entries — every agent inherits its default model".
• Allow folding a /gentle:models edit into a chosen profile instead of only the pinned-or-active one.

Version note consistent with the report above: the apply / create blocks and lib/agent-profiles.ts are byte-identical between 3.3.0 and the 3.5.1 tarball.