Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/opencode/src/cli/cmd/tui/component/dialog-session-list.tsx`:
- Around line 159-177: The delete flow currently clears toDelete only if the
initial delete succeeds and the subsequent sync/refresh/refetch steps also
succeed; move or add a guaranteed cleanup so setToDelete(undefined) always runs
after a successful sdk.client.session.delete (regardless of sync.session.refresh
or refetch failures). Specifically, keep the existing try/catch around
sdk.client.session.delete and deleteError handling, then ensure
setToDelete(undefined) is invoked in a finally-style path (or after awaiting the
refresh/refetch wrapped with its own try/catch) so that even if
sync.session.refresh() or refetch() rejects, deleteError is handled and the
confirmation state is cleared; reference functions: sdk.client.session.delete,
deleteError, setToDelete, sync.session.refresh, refetch, and search.

In `@packages/opencode/src/cli/cmd/tui/component/dialog-session-rename.tsx`:
- Line 22: The call to sdk.client.session.update is fire-and-forget and lacks
localized error handling; attach a .catch handler to sdk.client.session.update
(which is invoked with sessionID: props.session and title: value) to call
toast.error with the error message (e.g., "Failed to rename session:
<err.message>") so failures surface to the user, and then call dialog.clear() as
before; reference sdk.client.session.update, props.session, value, toast.error,
and dialog.clear when making this change.

In `@packages/opencode/src/cli/cmd/tui/component/dialog-workspace-create.tsx`:
- Around line 175-199: The code double-notifies workspace create failures
because sdk.client.experimental.workspace.create's .catch currently calls
toast.show and then the subsequent !workspace branch also toasts; remove the
toast from the .catch handler so the catch only logs the error (using log.error
and errorData) and returns undefined, leaving the single user-facing toast in
the following !workspace branch (references:
sdk.client.experimental.workspace.create, .catch handler, toast.show, result,
workspace, setCreating, log.error, errorData).
- Around line 121-137: The fetch handler currently accepts any JSON and calls
setAdaptors(res) which can crash rendering; update the async IIFE to check the
fetch response status and the parsed JSON shape before setting state: first use
sdk.fetch(url) and inspect the Response (e.g., check response.ok) and only parse
JSON if ok, then verify the parsed value is an array of adaptors
(Array.isArray(parsed) and optionally validate required adaptor fields) before
calling setAdaptors(parsed); on any failure (non-ok response, parse error, or
non-array result) show the existing toast error and do not call setAdaptors.

In `@packages/opencode/src/cli/cmd/tui/component/error-component.tsx`:
- Around line 59-61: The clipboard copy promise started in the error UI
(Clipboard.copy(issueURL.toString()) then setCopied(true)) is unhandled on
failure; wrap the copy call to handle errors (either await in an async handler
with try/catch or append .catch(...)) so failures don't produce unhandled
promise rejections and optionally log or surface the error; modify the code
around Clipboard.copy and the setCopied call in the ErrorComponent (or its click
handler) to catch errors and handle them gracefully.

In `@packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx`:
- Line 83: The global variable stashed currently holds one { prompt: PromptInfo;
cursor: number } and leaks drafts across Prompt instances; replace it with a
keyed stash (e.g., Map<string, { prompt: PromptInfo; cursor:number }>) keyed by
a stable prompt identifier (use PromptInfo.id or another unique identity
available on PromptInfo). Update all places that read/write stashed (the stash
save/restore logic near the current stashed usage and the other block around the
restore/clear code) to use stash.get(id)/stash.set(id, value) and ensure you
clear the specific key on commit/submit/unmount to avoid cross-prompt pollution.
Use the existing symbol names (stashed -> stashedMap or promptStash, PromptInfo,
and the existing save/restore handlers) so callers are updated consistently.

In `@packages/opencode/src/cli/cmd/tui/context/kv.tsx`:
- Around line 46-47: The call to Filesystem.writeJson(filePath, store) is fired
with void and no error handling, so rejected promises are unhandled; update the
persistence in the function that calls setStore to either await
Filesystem.writeJson(filePath, store) inside a try/catch or attach a .catch(...)
handler to it and surface/log the error (use the existing logger or UI error
method) so failures to write (filePath, store) are not silently ignored; ensure
any user-facing state remains consistent if the write fails.

In `@packages/opencode/src/cli/cmd/tui/context/route.tsx`:
- Around line 26-33: The init function's use of JSON.parse on
process.env["OPENCODE_ROUTE"] can throw and crash startup; update init (the
block creating the store via createStore<Route>) to wrap parsing of
OPENCODE_ROUTE in a try/catch: attempt to parse only when
process.env["OPENCODE_ROUTE"] is truthy, and if JSON.parse throws, swallow the
error and fall back to the default route ({ type: "home" }) (preserve behavior
when props.initialRoute is provided). Ensure references to init, createStore,
initialRoute, and OPENCODE_ROUTE are updated accordingly.

In `@packages/opencode/src/cli/cmd/tui/plugin/runtime.ts`:
- Around line 961-973: The dispose function currently awaits the load promise
stored in loaded (task) without handling rejections, which can abort cleanup and
leave runtime state inconsistent; wrap the await of task in a try/catch or
try/finally so that regardless of whether task resolves or rejects you still
clear loaded and dir, capture and preserve the error, set runtime to undefined,
and run the plugin teardown loop (calling deactivatePluginEntry for each plugin
from [...state.plugins].reverse()); after cleanup rethrow the original error if
one occurred so callers still see the rejection. Ensure references: function
dispose, variable loaded/task, variable dir, variable runtime/state, and
function deactivatePluginEntry are used to locate and implement the fix.

In `@packages/opencode/src/cli/cmd/tui/routes/session/dialog-message.tsx`:
- Around line 32-35: The fire-and-forget call to sdk.client.session.revert({
sessionID: props.sessionID, messageID: msg.id }) can produce unhandled promise
rejections; update the call site in dialog-message.tsx to append a terminal
.catch handler (e.g., .catch(() => {}) or .catch(err =>
processLogger?.error('revert failed', err))) so errors from
sdk.client.session.revert(...) are consumed; specifically modify the void
sdk.client.session.revert({...}) invocation to include the .catch(...) chain to
mirror other usages like in pages/session.tsx.

In `@packages/opencode/src/cli/cmd/tui/routes/session/index.tsx`:
- Around line 177-201: The effect can apply results after the user navigates to
a different session; to prevent stale mutations, capture the current
route.sessionID at the start (e.g., const currentSession = route.sessionID) and
after each await (after sdk.client.session.get, after sync.bootstrap, and after
sync.session.sync) check if route.sessionID !== currentSession and bail out
early if so; also, where possible pass an AbortSignal to network calls
(sdk.client.session.get) so in-flight requests can be cancelled when the route
changes, and avoid calling project.workspace.set, sync.bootstrap,
sync.session.sync, or scroll.scrollBy if the session changed.

In `@packages/opencode/src/cli/cmd/tui/routes/session/permission.tsx`:
- Around line 187-190: The three calls to sdk.client.permission.reply (e.g., the
one using props.request.id) currently use void to ignore the promise and lack
rejection handling; update each call (the blocks at the shown locations) to
append a .catch(...) that restores the UI stage via setStore("stage",
"permission") and surfaces/errors reports (e.g., call the existing error
reporting helper or set appropriate store values) so the UI isn’t left stale if
the reply fails; ensure you reference sdk.client.permission.reply,
props.request.id and setStore in the catch handler for consistent behavior
across all three sites.

In `@packages/opencode/src/cli/cmd/tui/routes/session/question.tsx`:
- Around line 48-51: The fire-and-forget RPC calls using void
sdk.client.question.reply({ requestID: props.request.id, answers }) should not
discard rejections; update the call sites (e.g., sdk.client.question.reply in
this file and the other similar usages around lines 55 and 70) to append an
explicit .catch(handler) that surfaces errors to the user (for example by
calling the app's toast/error notification function) and logs the error for
debugging; ensure the handler provides a concise user-facing message (e.g.,
"Failed to submit answer") and still logs the original error object for
diagnostics.

In `@packages/opencode/src/cli/cmd/tui/routes/session/subagent-footer.tsx`:
- Line 62: Remove the unused useTerminalDimensions hook: delete its import from
the top of the file and remove the standalone invocation useTerminalDimensions()
inside the subagent-footer component (the hook is not assigned to a variable and
its return value isn’t used); also verify there are no remaining references to
useTerminalDimensions in this component so unused-import lint errors are
resolved.

In `@packages/opencode/src/cli/cmd/tui/thread.ts`:
- Line 239: Remove the leftover temporary comment "// scratch" from the file
packages/opencode/src/cli/cmd/tui/thread.ts; locate the stray marker (the line
containing exactly "// scratch") and delete it so the source contains no unused
scratch annotations before merging.

In `@packages/opencode/src/cli/cmd/tui/util/terminal.ts`:
- Around line 61-82: The handler in colors() currently parses each incoming
Buffer chunk independently and can match partial OSC 10/11/4 payloads split
across chunks, causing incorrect background/foreground/paletteColors; fix by
accumulating chunks into a local buffer string and only extracting complete OSC
sequences that end with BEL (\x07) or ST (\x1b\\) before parsing; in handler
(and any surrounding colors() state) append data.toString() to a pendingBuffer,
use a regex that captures full sequences like
/\x1b\](?:10|11|4);([^\x07\x1b]*?)(?:\x07|\x1b\\)/g to iterate complete matches,
call parse(...) to set background/foreground/paletteColors (using index for OSC
4) and keep any trailing partial data in pendingBuffer for the next chunk.

In `@packages/opencode/test/cli/tui/_mock-tui-runtime.ts`:
- Around line 8-30: Before overwriting process.env.OPENCODE_PLUGIN_META_FILE,
capture its current value (e.g., const previousPluginMeta =
process.env.OPENCODE_PLUGIN_META_FILE) and then use that saved value inside the
restore() function of _mock-tui-runtime: instead of always deleting
OPENCODE_PLUGIN_META_FILE, restore the saved value (set
process.env.OPENCODE_PLUGIN_META_FILE = previousPluginMeta if defined, otherwise
delete it). Update restore() alongside the existing mocks (cwd.mockRestore(),
get.mockRestore(), wait.mockRestore()) so the environment is returned to its
original state.

In `@packages/opencode/test/cli/tui/terminal.test.ts`:
- Around line 9-11: The BEL-terminated OSC 11 response test currently only
asserts backgroundModeFromResponse("\x1b]11;`#ffffff`\x07") is not undefined;
change it to assert the concrete expected mode (e.g.,
expect(backgroundModeFromResponse("\x1b]11;`#ffffff`\x07")).toBe("light")) so the
parser returns the correct semantic mode for the `#ffffff` color; update the test
in terminal.test.ts referencing the backgroundModeFromResponse function to check
the exact value rather than just non-undefined.

---

Outside diff comments:
In `@packages/opencode/src/cli/cmd/tui/context/sdk.tsx`:
- Around line 77-101: The SSE setup can reject and escape the retry loop; wrap
the sdk.global.event(...) call in a try/catch inside the while loop (around the
call at sdk.global.event) and on error log/handle it and continue to the backoff
path instead of letting it bubble to the outer .catch; replace the current sleep
with an abort-aware wait by assigning setTimeout to the existing timer variable
and/or using the abort.signal to reject the sleep so the loop can exit
immediately when abort.signal or ctrl.signal is aborted; ensure timer is cleared
on both success and abort, and keep existing flush(), queue, handleEvent,
retryDelay and maxRetryDelay logic intact so reconnection attempts continue
after transient failures.

In `@packages/opencode/src/cli/cmd/tui/context/sync.tsx`:
- Around line 357-449: bootstrap can run concurrently and older invocations can
overwrite a newer workspace's store; fix by serializing/applying only the latest
run's results: at the start of bootstrap generate a unique run id (or increment
a module-level bootstrapCounter), assign it to a module-level latestBootstrapId,
capture it as localRunId, and use the captured workspace variable; before any
setStore/batch that applies responses (including the non-blocking
Promise.all.then), check that latestBootstrapId === localRunId (or that
syncedWorkspace === workspace) and abort applying results if mismatched; update
the places that clear fullSyncedSessions/syncedWorkspace accordingly so they
only run when the run is still current.

In `@packages/opencode/src/cli/cmd/tui/context/theme.tsx`:
- Around line 396-410: The theme renderer subscription was commented out so
store.mode no longer updates on renderer changes; re-enable the listener by
restoring the renderer.on(CliRenderEvents.THEME_MODE, handle) subscription after
the handle definition so theme changes propagate automatically (the handle
already guards with store.lock), and keep the existing
renderer.off(CliRenderEvents.THEME_MODE, handle) in onCleanup; ensure this
behavior complements unlock()/free() which perform a one-time sync but rely on
the active subscription for subsequent updates.

In `@packages/opencode/src/cli/cmd/tui/plugin/runtime.ts`:
- Around line 975-1028: The code sets the module-level runtime variable to a
partially initialized RuntimeState (next) before Instance.provide completes,
risking consumers seeing a broken state if provide throws; move the assignment
so runtime is only set after Instance.provide finishes successfully (i.e.,
remove or delay runtime = next before the try and assign runtime = next after
the await Instance.provide(...) completes), keeping the rest of load (creating
next, calling Instance.provide, loading internal/external plugins,
applyInitialPluginEnabledState, and activating plugins) unchanged; refer to the
load function, the runtime variable, the local next RuntimeState, and
Instance.provide to locate where to change the assignment.

In `@packages/opencode/src/cli/cmd/tui/ui/toast.tsx`:
- Around line 59-64: The toast auto-dismiss timeout is reading duration directly
from options and can be undefined (causing immediate dismissal); update the
handler in the toast display code to normalize duration (e.g., use a
DEFAULT_TOAST_DURATION constant or fallback like duration ??
DEFAULT_TOAST_DURATION and ensure it's a positive number) before calling
setTimeout; locate the toast creation logic around the variables options,
duration, setStore("currentToast", ...), and timeoutHandle, and replace the
destructuring or timeout argument so missing caller-supplied durations (e.g.,
toast.error calls) use the default instead of hiding immediately.

In `@packages/opencode/test/cli/tui/sync-provider.test.tsx`:
- Around line 90-107: The new createFetch helper exposes a rejectPaths injection
but the tests never use it; either update the failing-test(s) to drive the
failure via mount(log, { rejectPaths: ['/...'] }) (so createFetch will throw for
that pathname) or remove the unused rejectPaths branch. Specifically, in the
tests that currently stub project.workspace.sync, pass the rejectPaths array
into mount (or the test harness that calls createFetch) so the forced fetch
error path is exercised (reference createFetch, mount, and
project.workspace.sync to locate the change).

---

Nitpick comments:
In `@packages/opencode/test/cli/tui/plugin-loader-entrypoint.test.ts`:
- Around line 47-56: The repeated inline TuiConfig.Info test scaffolding should
be centralized using the tmpdir helper's config option instead of duplicating
objects; replace each inline config (the object with plugin and plugin_origins
referencing tmp.extra.spec/tmp.extra.marker and tmp.path) by calling tmpdir({
config: <partial TuiConfig.Info> }) so tmpdir writes the opencode.json (or tui
config) during setup, and update tests that reference tmp.path/tui.json to
depend on the tmpdir-produced config; locate occurrences by the TuiConfig.Info
literal and replace them with the shared tmpdir({ config }) fixture creation to
keep setup uniform.

In `@packages/opencode/test/cli/tui/plugin-toggle.test.ts`:
- Around line 42-54: Tests currently construct TuiConfig.Info inline (the const
config: TuiConfig.Info block) causing duplication; instead, update the tmpdir
setup calls in this test (and the similar block at lines 119-131) to pass a
config option to tmpdir, e.g. tmpdir({ config: { plugin: [[tmp.extra.spec, {
marker: tmp.extra.marker }]], plugin_enabled: { "demo.toggle": false },
plugin_origins: [...] } }), so the opencode.json is written by the fixture;
remove the inline TuiConfig.Info construction and any manual writes, keeping
references to tmp.extra.spec, tmp.extra.marker, and tmp.path.plugin_origins
intact.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/opencode/src/cli/cmd/tui/routes/session/permission.tsx`:
- Around line 286-292: The title for the "list" permission can end up empty when
data.path is missing; inside the permission === "list" branch (where raw =
data.path, dir = typeof raw === "string" ? raw : "" and title uses
normalizePath(dir)), update the title to fall back to a default label when
normalizePath(dir) is empty (e.g., "List (root)" or "List /") so it never
renders as "List " — modify the return object's title expression to use the
fallback.

---

Outside diff comments:
In `@packages/opencode/src/cli/cmd/tui/component/error-component.tsx`:
- Around line 19-25: The handleExit async function can throw and is invoked
fire-and-forget, leading to unhandled rejections; update handleExit (and any
other exit invocations at the same spot) to catch and handle errors from
props.onBeforeExit and props.onExit by wrapping awaits in a try/catch (or
surrounding the whole body in try/catch), ensure renderer.destroy() and
win32FlushInputBuffer() still run in finally if needed, and log or swallow the
error instead of letting the promise reject unobserved; reference the handleExit
function, props.onBeforeExit, props.onExit, renderer.destroy, and
win32FlushInputBuffer when locating the code to modify.

---

Nitpick comments:
In `@packages/opencode/src/cli/cmd/tui/routes/session/index.tsx`:
- Around line 1913-1929: The current inline casts in CodeSearch and WebSearch
(metadata as { results?: number } / { numResults?: number }) are fragile; update
these components to derive metadata types from the tool definitions (use the
metadata type exported or inferred from CodeSearchTool and WebSearchTool)
instead of using ad-hoc assertions, or add a small runtime type guard that
checks typeof metadata.results === 'number' / typeof metadata.numResults ===
'number' before rendering; adjust the props typing for CodeSearch and WebSearch
to use the extracted metadata type (or perform the guard) so the JSX uses a
correctly typed metadata value and avoids brittle casts.

In `@packages/opencode/src/cli/cmd/tui/routes/session/permission.tsx`:
- Around line 199-204: Several callsites repeat the pattern void
sdk.client.permission.reply({...}).catch(error => handleReplyError("Failed to
update permission", error)); extract a small helper (e.g., sendPermissionReply)
that accepts requestID and reply string, calls sdk.client.permission.reply({
reply, requestID }) and attaches the common .catch handler to call
handleReplyError with the same message; then replace the four direct calls with
sendPermissionReply(props.request.id, "always") (and other reply values) to
centralize behavior and reduce duplication.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/opencode/src/cli/cmd/tui/context/sdk.tsx`:
- Around line 78-91: The backoff counter `attempt` is never reset, causing
future reconnects to use large delays; after a successful call to `await
sdk.global.event(...)` (i.e., when `events` is set), reset `attempt` back to 0
so subsequent disconnects start from `retryDelay` again; apply the same change
to the other analogous loop (the block around the second `sdk.global.event`
usage referred to in the comment) and ensure the reset occurs before the loop
continues or waits for the next connection attempt.
- Around line 92-100: The backoff Promise is adding abort.signal and ctrl.signal
listeners each iteration but never removing them when the timeout resolves
normally; modify the Promise in the reconnect sleep (the block creating timer,
stop(), and adding abort.signal.addEventListener and
ctrl.signal.addEventListener) to remove those listeners after the timer resolves
— e.g., ensure the resolve path clears the timeout and also calls
removeEventListener for both abort.signal and ctrl.signal (and clean up any
references to stop) so listeners are not retained; apply the same change to the
duplicate block around the 116-124 region.

In `@packages/opencode/src/cli/cmd/tui/context/sync.tsx`:
- Around line 486-489: The getter ready returns true when OPENCODE_FAST_BOOT is
set but related data getters (e.g., config, provider) are returned unguarded,
letting plugins access incomplete state; update each data property getter (the
same ones alongside the existing vcs property) to mirror vcs's conditional
pattern and only return their underlying store values when store.status !==
"loading" (or otherwise not loading), otherwise return null/undefined so
consumers cannot read incomplete data even when OPENCODE_FAST_BOOT is enabled.

In `@packages/opencode/test/cli/tui/theme-provider.test.tsx`:
- Around line 55-60: Replace the broad await wait(() => onCalls.length > 0) with
a wait for the specific THEME_MODE listener and readiness of the mode accessor:
wait until onCalls contains an entry whose first element equals
CliRenderEvents.THEME_MODE and until mode is assigned/usable, then find the hit
via onCalls.find(call => call[0] === CliRenderEvents.THEME_MODE), assert hit
exists and that hit[1] is a function, invoke it with "light", and finally assert
mode() returns "light"; reference the symbols onCalls,
CliRenderEvents.THEME_MODE, hit, and mode to locate and update the test.

In `@packages/opencode/test/config/config.test.ts`:
- Around line 839-879: Narrow the critical section guarded by withConfigDepsLock
and remove the fixed 1s sleep: convert the test to use it.live(...) (since it
touches real filesystem/locks), acquire withConfigDepsLock only around the parts
that need the shared config dependency (e.g., the setup that writes to
process.env.OPENCODE_CONFIG_DIR and the Instance.provide() call that initializes
Config via Config.Service.use / Config.Service.waitForDependencies), then
release the lock before awaiting background work or asserting Filesystem reads;
delete the setTimeout-based delay and instead wait deterministically for the
condition (e.g., poll Filesystem.exists/readText or await the Instance.provide
scope completion) so the lock isn’t held during that wait and flakes are
avoided.

---

Duplicate comments:
In `@packages/opencode/src/cli/cmd/tui/plugin/runtime.ts`:
- Around line 973-981: The early return when runtime is undefined suppresses a
previously-captured loadError; update the dispose logic in runtime.ts so
loadError is propagated even if no state exists — e.g., check and throw
loadError before returning when state is falsy (or change the !state branch to
first throw loadError if present, then return). Refer to the local variables
runtime, state and loadError and the surrounding dispose flow that later
iterates plugins and calls deactivatePluginEntry(state, plugin, false).

---

Nitpick comments:
In `@packages/opencode/test/cli/tui/permission-title.test.ts`:
- Around line 1-12: Add optional edge-case tests to ensure
formatListPermissionTitle handles undefined and non-empty relative paths: update
the test suite in permission-title.test.ts to call
formatListPermissionTitle(undefined) and expect "List directory", and add
another test calling formatListPermissionTitle("src") (or another relative path)
expecting "List src"; reference the existing tests (formatListPermissionTitle in
this file) to mirror structure and assertions so coverage includes undefined
input and normal relative-path formatting.

In `@packages/opencode/test/cli/tui/toast.test.ts`:
- Around line 14-16: Add unit tests that exercise the non-finite branches by
calling normalizeToastDuration with NaN and with Infinity (and optionally
-Infinity) and asserting the returned value is a finite, valid duration;
specifically, in toast.test.ts import normalizeToastDuration and add
expectations like Number.isFinite(normalizeToastDuration(NaN)) and
Number.isFinite(normalizeToastDuration(Infinity)) and that those values match
the normalized fallback (e.g., compare to normalizeToastDuration(undefined) or
another known valid normalized value) so the non-finite branches in
normalizeToastDuration are covered.