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

Inline comments:
In `@vscode-ghost/media/chat.css`:
- Around line 71-77: The .message CSS uses the deprecated `word-break:
break-word`; replace it with non-deprecated overflow-wrap rules (e.g., set
`overflow-wrap: anywhere;` and ensure `word-break: normal;`) so long words still
wrap; also update the same inline style in the memory panel to use overflow-wrap
instead of `word-break: break-word` to satisfy Stylelint.

In `@vscode-ghost/package.json`:
- Around line 73-76: The package exposes the ghost.autoStart setting but nothing
reads it; update the extension activation logic (activate) to read
workspace.getConfiguration('ghost').get('autoStart') and, if true and Ghost is
not running (use/is-create or existing isGhostRunning() helper), call the
existing startGhostServe() function to start it; also listen for configuration
changes (workspace.onDidChangeConfiguration) for the 'ghost.autoStart' key and
start/stop accordingly so the setting has effect. Ensure you reference the
existing symbols activate, startGhostServe, and isGhostRunning (or the
equivalent start/stop helpers) when implementing this behavior.

In `@vscode-ghost/src/chat-panel.ts`:
- Around line 293-303: addToolIndicator currently keys indicators by tool name
which causes tool_end events to affect all indicators with the same name; change
addToolIndicator(name, status) to accept the tool's unique id (e.g.,
addToolIndicator(id, name, status)), set div.dataset.toolId = id (instead of or
in addition to dataset.toolName), and update any code that marks indicators
finished (the tool_end handling and the similar block at the other location) to
find/update elements by data-tool-id (matching the event.id) rather than by name
to ensure lifecycle events match the exact tool instance.
- Around line 24-26: setClient currently only replaces this.client and leaves
this.session pointing to the old daemon; update setClient (in class ChatPanel)
to clear/reset the active session when swapping backends by
nulling/undefined-ing this.session (or calling a resetSession helper) whenever
the provided GhostClient differs or when ghost.serverUrl/ghost.authToken change
so future sends don't reuse a stale session id; reference setClient,
this.client, this.session and any send/openSession methods to ensure the session
reset is effective.
- Around line 91-98: When a session is created and when usage data arrives you
need to update the status bar: after this.client.createSession(...) and before
postMessage(...) call the GhostStatusBar APIs (e.g. statusBar.setMode(...)) to
set the chat mode and pass any session token info via
statusBar.setTokenInfo(...); likewise, in the block that forwards usage data to
the webview (the usage handling around lines 157-165) call
statusBar.setTokenInfo(...) with the usage/token counts so the status bar shows
tokens. Locate the code using createSession and the usage-forwarding block and
add calls to the existing GhostStatusBar methods (setMode and setTokenInfo) to
keep the status bar in sync with this.session and usage updates.
- Around line 315-320: The Enter keydown handler on inputEl currently calls
send() even during IME composition; update the handler to guard against
composition by checking KeyboardEvent.isComposing (or maintain an isComposing
flag via compositionstart/compositionend listeners) and only call send() when
composition is not active; specifically modify the
inputEl.addEventListener('keydown', ...) callback to return early if
e.isComposing (or if the isComposing flag is true) so pressing Enter to confirm
CJK input does not trigger send().

In `@vscode-ghost/src/extension.ts`:
- Around line 37-44: The command registered in
registerCommand("ghost.sendMessage") posts a message with type
"send_from_command" which chat-panel.ts never handles and will be dropped if the
webview isn't ready; modify the command to either post a message type the
webview already handles (e.g., the existing send message type handled in
chat-panel.ts) or update chat-panel.ts to add a handler for "send_from_command"
in its onDidReceiveMessage/message switch, and ensure the webview is
revealed/created before posting (call/open the chat panel or check
chatProvider.isActive/resolved) so postMessage is not a no-op.
- Around line 47-64: The various commands (ghost.newSession, ghost.setMode,
etc.) create or mutate sessions directly on GhostClient while ChatPanelProvider
keeps its own cached this.session causing divergent session usage; fix by
centralizing the active session (e.g., an exported/shared activeSessionId or an
ExtensionState object) and update the ChatPanelProvider whenever the session
changes: after client.createSession (in the ghost.newSession command) set the
centralized session id and call a new ChatPanelProvider.setSession(session) or
emit an event so the panel updates its this.session and
statusBar.setMode(session.mode); ensure ghost.setMode and other commands
read/update the centralized session (instead of listSessions()[0]) so all parts
of the extension use the same authoritative session id.
- Line 11: Change the immutable client binding so configuration updates actually
replace the instance used everywhere: make the top-level declaration a mutable
variable (replace const client = createClient() with let client =
createClient()), and in the configuration change handler assign the created
newClient back to that variable (client = newClient). Also ensure any long-lived
closures (registered command handlers and the 15-second health poll) reference
the outer mutable client variable (or call a getter that returns the current
client) instead of closing over the original instance so they pick up the
reassigned client.

In `@vscode-ghost/src/ghost-client.ts`:
- Around line 154-208: The stream handler currently discards any remaining
partial data held in the buffer when res emits "end"; on res.on("end") you
should process the leftover buffer (using the same parsing logic that handles
"event: " and "data: " lines and currentEvent) before emitting
emitter.emit("close"), attempting to parse any complete event fragments,
emitting the corresponding typed events via emitter (including
error/approval/done/etc.), and logging or emitting an error for
malformed/partial JSON instead of silently dropping it; refer to the buffer
variable, currentEvent, the res.on("data") parsing switch, and emitter to
integrate this final flush.
- Around line 323-327: The code currently swallows JSON.parse errors by
resolving with "undefined as T" (see the resolve(JSON.parse(data) as T) /
resolve(undefined as T) snippet); change the catch to reject the Promise with
the parse error (include the original data and the parse error message in the
Error) so callers get a failed Promise instead of an unexpected undefined;
update any callers (e.g., health() or other places that await this promise) to
handle the rejected promise or try/catch accordingly.

---

Nitpick comments:
In `@vscode-ghost/src/ghost-client.ts`:
- Around line 288-341: The request helper (private request) currently can hang
indefinitely; add a request timeout constant (e.g., REQUEST_TIMEOUT_MS = 5000)
and wire it into the outgoing request by using
req.setTimeout(REQUEST_TIMEOUT_MS, ...) to abort the request on timeout; in the
timeout callback destroy the request/connection (req.destroy()) and reject the
promise with a clear Error like "Request timed out", and ensure this timeout
path can't also resolve/reject later (i.e., bail out after rejecting). Update
any tests or callers if they expect long-running requests.