Stale active used after file list may have removed it

loadAgentFiles can set state.agentFileActive = null when the previously active file no longer appears in the refreshed list (e.g., it was deleted externally between the Refresh clicks). However, because active was captured before loadAgentFiles ran, the if (active && ...) guard remains truthy even for a file that was just removed.

This causes an unnecessary agents.files.get call for a non-existent file. Depending on gateway behaviour the call either returns null (harmless, state untouched) or rejects (sets state.agentFilesError with a spurious error message visible to the user).

Suggested fix — guard on whether the file is still present in the refreshed list:

if (active && resolvedAgentId === agentId && state.agentFilesList?.files.some((f) => f.name === active)) {
  await loadAgentFileContent(state, agentId, active, {
    force: true,
    preserveDraft: false,
  });
}

This is a comment left during a code review.
Path: ui/src/ui/app-render.ts
Line: 645-650

Comment:
**Stale `active` used after file list may have removed it**

`loadAgentFiles` can set `state.agentFileActive = null` when the previously active file no longer appears in the refreshed list (e.g., it was deleted externally between the Refresh clicks). However, because `active` was captured *before* `loadAgentFiles` ran, the `if (active && ...)` guard remains truthy even for a file that was just removed.

This causes an unnecessary `agents.files.get` call for a non-existent file. Depending on gateway behaviour the call either returns `null` (harmless, state untouched) or rejects (sets `state.agentFilesError` with a spurious error message visible to the user).

Suggested fix — guard on whether the file is still present in the refreshed list:

```
if (active && resolvedAgentId === agentId && state.agentFilesList?.files.some((f) => f.name === active)) {
  await loadAgentFileContent(state, agentId, active, {
    force: true,
    preserveDraft: false,
  });
}
```

How can I resolve this? If you propose a fix, please make it concise.

Skip reload when refresh cleared the active file

onLoadFiles snapshots state.agentFileActive before await loadAgentFiles(...), then unconditionally uses that snapshot afterward. If an external edit deleted/renamed the active file, loadAgentFiles clears state.agentFileActive, but this code still calls loadAgentFileContent for the stale filename, which surfaces a missing-file error during an otherwise successful refresh and can repopulate stale cached content. Re-check current active file (or refreshed list membership) after the list reload before issuing agents.files.get.

Useful? React with 👍 / 👎.

Guard refresh follow-up with current selected agent

This post-refresh guard uses resolvedAgentId captured when the render callback was created, not the current selection after await loadAgentFiles(...). If a user clicks Refresh for agent A and switches to agent B before the list request returns, this stale check still passes and the code can call loadAgentFileContent for A, repopulating file caches after onSelectAgent cleared them. Since agentFileContents/agentFileDrafts are keyed only by filename in ui/src/ui/controllers/agent-files.ts, selecting the same core filename in B (for example MEMORY.md) can reuse A’s cached content and lead to overwriting B with the wrong text on save.

Useful? React with 👍 / 👎.

Revalidate agent selection after forced content reload

This forced agents.files.get runs asynchronously after the pre-check at onLoadFiles, but the selected agent can still change before the request resolves; onSelectAgent clears agentFileContents/agentFileDrafts and then loadAgentFiles for the new agent is skipped while agentFilesLoading is true, so when the old request completes it repopulates filename-keyed caches with the previous agent’s content. Because loadAgentFileContent short-circuits on Object.hasOwn(state.agentFileContents, name), selecting the same filename (for example MEMORY.md) in the new agent can show stale content and save it to the wrong workspace.

Useful? React with 👍 / 👎.

Avoid deleting new agent cache entries by filename

This cleanup runs after the forced refresh request for the previous agent resolves, and it deletes cache entries solely by active filename when the selected agent changed. Because agentFileContents/agentFileDrafts are filename-keyed, if the newly selected agent has already loaded the same filename (for example MEMORY.md) before this stale request completes, these lines remove the new agent’s valid content and can leave the editor blank; a subsequent save can then write incorrect text. The cleanup should be scoped by agent identity (or per-agent cache keys), not just filename.

Useful? React with 👍 / 👎.

Skip forced content fetch after list refresh errors

After onLoadFiles awaits loadAgentFiles, it always proceeds to loadAgentFileContent for the active file when the previous list is still present. If agents.files.list fails (for example transiently) but agents.files.get succeeds, this follow-up call clears agentFilesError and leaves users with a stale file list while hiding the refresh failure, so they can keep editing against outdated metadata without any visible error.

Useful? React with 👍 / 👎.

Reject stale file payloads after agent switches

This guard only blocks stale agents.files.get responses when state.agentFilesList is already set to a different agent, but onSelectAgent clears state.agentFilesList to null before loading the next agent (ui/src/ui/app-render.ts), so a forced refresh fetch from the previous agent can still land during that window and repopulate filename-keyed caches with old content. In that case, opening/saving the same filename (for example MEMORY.md) under the newly selected agent can use the previous agent’s text.

Useful? React with 👍 / 👎.

Block saves during forced refresh reload

This new refresh path always issues loadAgentFileContent(..., { force: true, preserveDraft: false }) for the active file, but saves are still allowed while that fetch is in flight because save logic does not check agentFilesLoading. If a user refreshes with unsaved edits and clicks Save before the forced agents.files.get returns, the later get response can overwrite agentFileContents/agentFileDrafts with pre-save disk content, so the editor shows stale text and a subsequent save can revert the file. Please gate save actions (or drop stale get responses) while the forced refresh reload is pending.

Useful? React with 👍 / 👎.