In `@docs/plans/2026-02-04-ai-conflict-resolution-design.md`:
- Around line 49-59: The docs declare fields on ConflictResolutionConfig
(notably confidenceThreshold and strategy) that the implementation doesn't
expose; update either the code or the docs: either add the missing optional
properties (confidenceThreshold: number, strategy: string|enum, with defaults
and used by functions like whatever resolves AI decisions) to the implementation
where ConflictResolutionConfig is defined and consumed, or remove/mark them as
TODO/futureWork in the doc and ensure the doc comment lines 49–59 and the other
referenced section (219–230) consistently reflect the actual implemented shape
and defaults; reference the ConflictResolutionConfig type and any AI
resolution/decision logic functions to wire or document these fields.
- Around line 20-41: The fenced diagram block in the docs lacks a language tag
and violates MD040; update the opening fence for that block to include a
language tag (e.g., "text") so the block is ```text ... ```; locate the block
near references like run.tsx,
parallelExecutor.setAiResolver(createAiResolver(config)),
createAiResolver(config) → AiResolverCallback, and
ConflictResolver/resolveFile() and change the fence accordingly.

In `@src/parallel/ai-resolver.test.ts`:
- Line 6: Remove the unused `mock` import from the test module import list:
update the import statement that currently reads "import { describe, expect,
test, mock } from 'bun:test';" to only import the symbols actually used
(`describe`, `expect`, `test`) so the `mock` identifier is no longer imported
and TS6133 is resolved.

In `@testing/TESTING.md`:
- Around line 272-278: The fenced ASCII diagram block containing the
CONFLICT-001 / CONFLICT-002 / CONFLICT-003 lines is missing a language specifier
which triggers markdownlint MD040; update the fenced code block that surrounds
the CONFLICT-001 ─────┐ ... CONFLICT-003 ─────┘ diagram to include a language
tag such as text or plaintext (e.g., change the opening triple backticks to
```text) so the linter recognizes it as non-executable content while preserving
the diagram.

In `@src/tui/components/ConflictResolutionPanel.tsx`:
- Around line 171-180: The panel shows AI-specific copy regardless of whether AI
conflict resolution is enabled; add a boolean prop aiEnabled to
ConflictResolutionPanelProps and use it inside the ConflictResolutionPanel
component to conditionally render the "AI resolution runs automatically. Merge
completes when all files resolve." text only when aiEnabled is true; update all
callers (notably the places that render ConflictResolutionPanel in RunApp.tsx)
to pass the config flag conflictResolution.enabled into the new aiEnabled prop
so behavior matches configuration.

In `@src/tui/components/ConflictResolutionPanel.tsx`:
- Around line 31-71: When handling the parallel event "conflict:ai-failed"
update the component state to record a failed ConflictResolutionResult for the
target file (instead of only flipping aiResolving) so
getResolutionState(conflicts, resolutions, aiResolving) will detect the failure;
specifically, in the parallel event handler that currently sets aiResolving,
also add or update an entry in the resolutions array with { filePath: <the
conflict filePath>, success: false, /* optional error/message field */ } (or set
an explicit failure flag tied to that file and thread it into
getResolutionState), then set aiResolving = false so the UI shows the retry/skip
controls.

In `@src/commands/run.tsx`:
- Around line 917-918: The comment for the property
parallelCurrentlyResolvingFile contains temporal wording—update it (and the
similar comments around the other occurrence) to an evergreen phrasing without
temporal qualifiers; locate the property parallelCurrentlyResolvingFile and
replace its comment "The file currently being resolved by AI" (and the matching
comment near the other occurrence) with a neutral form such as "The file being
resolved by AI" or "File being resolved by AI".

In `@src/tui/components/ConflictResolutionPanel.tsx`:
- Around line 35-36: Update the JSDoc comment for the currentlyResolvingFile
property in ConflictResolutionPanel.tsx to remove temporal language; replace
"The file currently being resolved by AI" with a timeless phrase such as "The
file being resolved by AI" (or similar) so the comment is evergreen while still
describing the currentlyResolvingFile field.

In `@src/parallel/index.ts`:
- Around line 512-532: The success branch currently always clears
this.pendingConflictOperation and this.pendingConflictWorkerResult, which drops
earlier failed conflicts; instead only clear those fields if they are null or
refer to the same conflict being completed. Update the allResolved path in the
loop so that before setting this.pendingConflictOperation = null and
this.pendingConflictWorkerResult = null you check whether the existing
pendingConflictWorkerResult is either null or has the same identifier as the
current workerResult (e.g., compare workerResult.task.id); only clear them in
that case, otherwise leave the existing pending failure alone so it can be
retried/skipped later. Ensure the rest of the success logic (await
this.tracker.completeTask(...), await this.mergeProgressFile(workerResult),
totals increment) remains unchanged.

In `@src/commands/run.tsx`:
- Around line 1837-1862: onConflictRetry currently sets
parallelState.aiResolving = true and awaits
parallelExecutor.retryConflictResolution() without error handling, which can
leave aiResolving true on exceptions; wrap the await in a try/catch/finally
inside the onConflictRetry handler (referencing onConflictRetry,
parallelState.aiResolving, parallelExecutor.retryConflictResolution, and
triggerRerender) so that failures are caught (log or surface the error
appropriately) and the finally block always resets parallelState.aiResolving =
false and calls triggerRerender?.() to ensure the UI is not left stuck; also
ensure the handler returns a rejected or resolved Promise consistently so
callers that don't await it don't produce unhandled rejections.

In `@src/tui/components/RunApp.tsx`:
- Around line 179-183: Update the temporal comments to state-based descriptions:
replace "The file currently being resolved by AI" with a neutral, state-focused
phrase for parallelCurrentlyResolvingFile (e.g., "The file being resolved by AI
in parallel mode"), change "Whether to show the conflict panel (true during
Phase 2 conflict resolution)" to a state-based comment for parallelShowConflicts
(e.g., "Whether the conflict panel is shown for conflict resolution"), and
similarly revise any other temporal comments around the parallel-mode logic
(including the occurrences noted near the parallel mode code block) so all
comments describe state rather than time-based conditions.

In `@src/parallel/index.ts`:
- Around line 157-183: In retryConflictResolution, preserve the tracker's
in-memory/persistent state before re-running resolution to avoid stale state
(prd.json) overwriting main state: capture the current tracker state (e.g., via
a snapshot/getState method or serialization), then run the
resolution/completeTask/mergeProgressFile steps, and in a finally block restore
the saved tracker state (e.g., setState/restore) so the tracker is returned to
its prior state if the retry mutates it; update retryConflictResolution
(referencing pendingConflictOperation, pendingConflictWorkerResult,
this.tracker.completeTask, and this.mergeProgressFile) to perform save → attempt
resolution/complete/merge → restore.

In `@src/parallel/index.ts`:
- Around line 472-480: Wrap the tracker save/restore around merge and conflict
resolution in try/finally to guarantee restore on errors: when you call
this.saveTrackerState() before this.mergeEngine.enqueue(result) /
this.mergeEngine.processNext(), immediately follow with a try { await
this.mergeEngine.processNext(); } finally { await
this.restoreTrackerState(savedState); } and do the same pattern for the block
that calls this.saveTrackerState() before conflictResolver.resolveConflicts()
(ensure you reference saveTrackerState, restoreTrackerState,
mergeEngine.processNext, and conflictResolver.resolveConflicts so
restoreTrackerState(savedState) always runs even if processing throws).

In `@src/commands/run.tsx`:
- Line 1571: Update the inline comment for the showConflicts property (near
showConflicts: false in src/commands/run.tsx) to remove time‑bound phrasing and
instead describe its behavior and intent; e.g., state that it controls whether
unresolved conflicts are shown (true = show unresolved conflicts, false = hide
when there are none or after they are resolved) so the comment is evergreen and
describes state rather than timing.
- Around line 983-984: The comment for the property parallelShowConflicts
contains temporal wording ("during Phase 2"); update it to be evergreen by
removing the time-bound phrase and describing the intent instead — e.g., change
the JSDoc for parallelShowConflicts to: "Whether to show the conflict panel
(true while resolving conflicts)" or "Whether to show the conflict panel for
conflict resolution" so it documents behavior without referencing phases or
time.

In `@src/parallel/index.ts`:
- Around line 165-195: The finally block calls restoreTrackerState(savedState)
while completion actions (tracker.completeTask, mergeProgressFile, clearing
pendingConflictOperation/pendingConflictWorkerResult, and incrementing
totalConflictsResolved/totalMergesCompleted) run before it, which can let
restoreTrackerState overwrite the completion; change the flow in the method
containing saveTrackerState/restoreTrackerState and
conflictResolver.resolveConflicts so that restoreTrackerState(savedState) is
always called in the finally and all post-success completion work (clear
pendingConflictOperation and pendingConflictWorkerResult, await
tracker.completeTask(workerResult.task.id) with try/catch, await
mergeProgressFile(workerResult), and increment totalConflictsResolved and
totalMergesCompleted) runs after the finally (i.e., after restore) only when
allResolved is true, following the Phase 2 resolution pattern used elsewhere.