In `@src/plugins/agents/base.test.ts`:
- Around line 312-319: Update the block comment explaining why tests for
BaseAgentPlugin lifecycle and envExclude live in
tests/plugins/agents/base-execute.test.ts so it is evergreen: remove time‑bound
phrases like “have been moved” and “fail in the full test suite” and instead
state the structural rationale — e.g., that tests requiring real process
execution are placed in base-execute.test.ts to isolate them from other tests
that mock node:child_process and avoid mock pollution — and keep the reference
to the Bun issue link if desired.

In `@src/plugins/trackers/builtin/beads-bv/index.test.ts`:
- Around line 6-8: Update the comment that explains why the mock is applied in
beforeAll to remove temporal phrasing: reword it as a stable invariant stating
that the mock must be configured in beforeAll (rather than at module scope) so
it does not affect other tests, and that the module under test is imported only
after this mock is in place to ensure isolation; reference the existing setup
symbols "beforeAll" and "dynamic import" (or "module under test") so readers
know where the invariant applies.

In `@src/plugins/trackers/builtin/beads.test.ts`:
- Around line 5-7: Reword the setup note to state the invariant: the mock is
configured inside beforeAll and the module under test is imported afterwards to
avoid polluting other tests; update the comment near beforeAll and the dynamic
import of the module under test (the lines describing "mock is set up in
beforeAll" and "module under test is dynamically imported") to remove temporal
phrasing like "after the mock is applied" and replace it with a stable statement
that the test imports the module only once the mock has been established.

In `@src/setup/skill-installer-spawn.test.ts`:
- Around line 5-7: Reword the two temporal test comments so they read as
evergreen invariants: state that mocks are applied in beforeAll to avoid
polluting other tests and that the module under test is dynamically imported
only after the mock has been applied; reference the test setup using the
beforeAll hook and the dynamic import of the module under test (no timing
language like "later" or "afterwards").

In `@src/tui/components/EpicLoaderOverlay.tsx`:
- Around line 180-191: EpicLoaderOverlay drops the passed-in error when mode ===
'file-prompt' because FileBrowser is returned without forwarding the error prop;
update the file-prompt branch to pass the error (and optionally an error display
handler) into <FileBrowser> so the user sees PRD load failures — locate the mode
check in EpicLoaderOverlay (the 'file-prompt' branch that returns FileBrowser)
and add the error prop (and wire it to whatever FileBrowser prop shows errors,
or add a new prop like errorMessage/onError) so failed loads surface in the UI.

In `@src/tui/components/FileBrowser.tsx`:
- Around line 116-123: When the FileBrowser becomes visible the existing
useEffect resets navigation state but not the edit state, so add resetting of
the editing flags/inputs inside that same block: when visible is true call your
edit-state setters (e.g. setIsEditing(false) and clear the edit buffer via
setEditInput('') or setEditValue('')) alongside setCurrentPath,
setSelectedIndex, and setShowHidden so the overlay never reopens with stale edit
input.

In `@tests/engine/auto-commit.test.ts`:
- Around line 110-120: The initGitRepo helper currently calls runProcess
multiple times without verifying success; update initGitRepo to fail fast on any
git command error by checking runProcess results or wrapping each await in
try/catch and rethrowing a descriptive Error that includes which command failed
(e.g., "git init", "git config user.email", "git add", "git commit") and the
underlying error/message; ensure failures from writeFile are also propagated so
tests stop immediately rather than proceeding with a broken repo state.
- Around line 21-108: The test duplicates production logic by defining
runProcess, hasUncommittedChanges, and performAutoCommit locally instead of
importing src/engine/auto-commit.ts; replace the local implementations with an
import from the production module (e.g., import { hasUncommittedChanges,
performAutoCommit } from 'src/engine/auto-commit') and adapt the test to either
run without the node child_process mocks or provide a Bun-specific shim only for
the process spawn (keep a small wrapper named runProcess only if necessary), or
alternatively add a clear TODO and CI note in the test header referencing the
production functions so future changes in
hasUncommittedChanges/performAutoCommit are kept in sync.

In `@tests/plugins/agents/base-execute.test.ts`:
- Around line 1-12: Rewrite the header comment to remove temporal phrasing and
describe the rationale in evergreen language: explain that the test file creates
test plugins that override BaseAgentPlugin.execute() to call Bun.spawn directly
to avoid interference from tests that mock node:child_process, because Bun's
mock.restore() does not reliably restore built-in modules, and note that this
preserves isolation for these tests; replace phrases like "ISOLATION FIX" and
"original tests … fail" with this persistent explanation referencing Bun.spawn
and BaseAgentPlugin.execute.
- Around line 72-163: The async runExecution inside the overridden execute
method can throw (Bun.spawn, stream reads, awaits) and currently never resolves
resolvePromise on error; wrap the entire runExecution body in try/catch/finally,
and in the catch build and call resolvePromise with a failed
AgentExecutionResult (use the existing executionId, status: 'failed', a non-zero
exitCode like 1, include any captured stdout/stderr if available or empty
strings, compute duration using startedAt and new Date(), set interrupted:
false, and set startedAt/endedAt ISO strings), and still invoke
options?.onEnd(result) inside a try/catch so onEnd runs for error cases too;
ensure resolvePromise is always called exactly once even when errors occur.

In `@tests/templates/engine.test.ts`:
- Around line 704-721: The tests currently only override process.env.HOME but
installBuiltinTemplates -> getUserConfigDir uses os.homedir() which on Windows
reads USERPROFILE, so extend the sandbox: in the beforeEach that sets testDir
and originalHome, also capture originalUserProfile (e.g. let
originalUserProfile: string | undefined) and when process.platform === 'win32'
set process.env.USERPROFILE = testDir; in afterEach restore USERPROFILE (delete
if undefined, else set back) alongside the existing HOME restore and
cleanupTestDir call so the sandboxed home is consistent across platforms when
running installBuiltinTemplates.

In `@tests/utils/clipboard.test.ts`:
- Around line 5-7: Update the explanatory comment in
tests/utils/clipboard.test.ts to remove temporal phrasing and state the
invariant: explain that the mock is configured inside beforeAll and the module
under test is dynamically imported afterwards to avoid polluting other test
files; reference the beforeAll setup and the dynamic import order so readers
understand the reason without using words like "prevent" tied to time (e.g.,
phrase it as "The mock is configured in beforeAll and the module is imported
afterwards to avoid cross-test pollution").

In `@src/tui/components/FileBrowser.tsx`:
- Around line 158-188: The expandPath / navigateToPath logic resolves typed
relative paths against process.cwd() because expandPath always calls
resolve(expanded); update expandPath (or adjust navigateToPath) to resolve
relative inputs against the current browsing directory (currentPath) instead of
the process CWD: detect absolute paths (path.isAbsolute(expanded) or starting
with '/'), tilde (~) and explicit relative markers (./ or ../) and for plain
relative names call resolve(currentPath, expanded) so that navigateToPath uses
the visible directory context when setting currentPath, while preserving the
existing tilde expansion behavior.

In `@tests/plugins/agents/base-execute.test.ts`:
- Around line 241-323: The runExecution function inside
BunSpawnEnvTestPlugin.execute can throw (e.g., Bun.spawn or readStream) and
currently never resolves/rejects resolvePromise; wrap the body of runExecution
in a try/catch that mirrors BunSpawnTestPlugin behavior: on success build and
call resolvePromise(result) as before, and in catch create a failed
AgentExecutionResult (status 'failed', include error message in stderr,
appropriate exitCode like 1, duration, startedAt/endedAt) then call
resolvePromise (or rejectPromise if existing pattern uses reject) and still call
options?.onEnd inside its own try/catch; ensure readers/proc are awaited/cleaned
up if necessary and reference runExecution, Bun.spawn, readStream,
resolvePromise, and options?.onEnd when making the changes.

In `@tests/engine/auto-commit.test.ts`:
- Around line 5-11: Update the TODO comment to remove future-tense phrasing and
state the current constraint and the follow-up action: note that because Bun's
mock.restore() does not reliably restore builtin modules the test re-implements
hasUncommittedChanges and performAutoCommit locally using Bun.spawn, and
instruct that these should be replaced with imports from
src/engine/auto-commit.ts when Bun's module mock restoration is fixed so tests
stay in sync.

In `@tests/utils/clipboard.test.ts`:
- Around line 88-102: Update the inline comments inside the beforeAll block to
remove temporal wording and state invariants: change "Mock the modules before
importing clipboard" to something like "Ensure node:child_process and node:os
modules are mocked" and "Import after mocking" to "Import clipboard module after
mocks are registered"; keep references to mock.module calls for
'node:child_process' and 'node:os' and the subsequent dynamic import of
'../../src/utils/clipboard.js' that assigns writeToClipboard so the intent
remains clear and evergreen.

In `@src/tui/components/FileBrowser.tsx`:
- Around line 123-131: Normalize initialPath before setting current path when
the FileBrowser becomes visible: call the same normalisation/expansion logic
used by navigateToPath (expand '~' and resolve relative paths) and pass the
resolved path to setCurrentPath (instead of the verbatim initialPath), then
reset transient UI state to avoid stale flashes by also clearing the directory
list, error and loading flags (use the component's setters such as
setSelectedIndex, setShowHidden, setEditingPath, setEditedPath and the
list/error/loading setters — e.g., setEntries, setError, setLoading if present)
so the component immediately shows the fresh loading state and empty list while
the directory reloads.