From 1c31d7ea4925fd9993bb127abe67b6cfeee06f32 Mon Sep 17 00:00:00 2001
From: marius-kilocode <marius@kilocode.ai>
Date: Tue, 7 Jul 2026 13:22:30 +0200
Subject: [PATCH] fix: address review feedback on reload handler

- Block reload for retry and offline session states, not just busy
  (hasActiveSession rejects any non-idle state)
- Close TOCTOU race by calling store.reload inline instead of deferring
  to a pre-response handler, so the busy check and reload run in the
  same effect
- Avoid double-firing reloadAfterAuthChange: only call it eagerly for
  worktree sessions where the SSE directory check won't match; for the
  workspace root the existing SSE handler already fires it
- Replace err: any with unknown + narrowing
- Add in-flight guard to the CLI /reload plugin to prevent overlapping
  reloads from rapid double-invocation
- Remove the TaskHeader reload button (redundant with /reload slash
  command, avoids chat visual regression baseline churn)
---
 packages/kilo-vscode/src/KiloProvider.ts      | 11 ++++--
 .../src/components/chat/TaskHeader.tsx        |  9 -----
 .../opencode/src/kilocode/plugins/reload.tsx  |  5 +++
 .../httpapi/handlers/instance-reload.ts       | 11 +++---
 .../test/kilocode/instance-reload.test.ts     | 38 +++++++++++++++----
 5 files changed, 49 insertions(+), 25 deletions(-)

diff --git a/packages/kilo-vscode/src/KiloProvider.ts b/packages/kilo-vscode/src/KiloProvider.ts
index c044c6f637d..8358930f059 100644
--- a/packages/kilo-vscode/src/KiloProvider.ts
+++ b/packages/kilo-vscode/src/KiloProvider.ts
@@ -3620,8 +3620,11 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
     const dir = this.getWorkspaceDirectory(this.currentSession?.id)
     try {
       await this.client.instance.reload({ directory: dir }, { throwOnError: true })
-    } catch (err: any) {
-      const status = err?.response?.status
+    } catch (err) {
+      const status =
+        err && typeof err === "object" && "response" in err
+          ? (err as { response?: { status?: number } }).response?.status
+          : undefined
       if (status === 409) {
         vscode.window.showWarningMessage(
           "Cannot reload while a session is running. Wait for it to finish or abort it first.",
@@ -3633,7 +3636,9 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
       return
     }
     this.clearCommandsCache()
-    await this.reloadAfterAuthChange()
+    if (!sameDirectory(dir, this.getWorkspaceDirectory())) {
+      await this.reloadAfterAuthChange()
+    }
   }
 
   /** Public reload entry point for VS Code commands. */
diff --git a/packages/kilo-vscode/webview-ui/src/components/chat/TaskHeader.tsx b/packages/kilo-vscode/webview-ui/src/components/chat/TaskHeader.tsx
index cccaa7ab721..96ac022f93f 100644
--- a/packages/kilo-vscode/webview-ui/src/components/chat/TaskHeader.tsx
+++ b/packages/kilo-vscode/webview-ui/src/components/chat/TaskHeader.tsx
@@ -212,15 +212,6 @@ export const TaskHeader: Component<TaskHeaderProps> = (props) => {
                 aria-label={language.t("command.session.compact")}
               />
             </Tooltip>
-            <Tooltip value={language.t("common.reload")} placement="bottom">
-              <IconButton
-                icon="reload"
-                size="small"
-                variant="ghost"
-                onClick={() => vscode.postMessage({ type: "reload" })}
-                aria-label={language.t("common.reload")}
-              />
-            </Tooltip>
           </Show>
           <Show when={hasMessages()}>
             <button
diff --git a/packages/opencode/src/kilocode/plugins/reload.tsx b/packages/opencode/src/kilocode/plugins/reload.tsx
index d40782b9f44..420a4fee162 100644
--- a/packages/opencode/src/kilocode/plugins/reload.tsx
+++ b/packages/opencode/src/kilocode/plugins/reload.tsx
@@ -3,6 +3,7 @@ import type { TuiPlugin, TuiPluginModule } from "@kilocode/plugin/tui"
 const id = "internal:reload"
 
 const tui: TuiPlugin = async (api) => {
+  let pending = false
   api.keymap.registerLayer({
     commands: [
       {
@@ -13,11 +14,15 @@ const tui: TuiPlugin = async (api) => {
         category: "System",
         slashName: "reload",
         async run() {
+          if (pending) return
+          pending = true
           try {
             await api.client.instance.reload({}, { throwOnError: true })
             api.ui.toast({ message: "Reloaded", variant: "success" })
           } catch (err) {
             api.ui.toast({ message: String(err), variant: "error", duration: 5000 })
+          } finally {
+            pending = false
           }
         },
       },
diff --git a/packages/opencode/src/kilocode/server/httpapi/handlers/instance-reload.ts b/packages/opencode/src/kilocode/server/httpapi/handlers/instance-reload.ts
index db95453a2a6..4532b945f70 100644
--- a/packages/opencode/src/kilocode/server/httpapi/handlers/instance-reload.ts
+++ b/packages/opencode/src/kilocode/server/httpapi/handlers/instance-reload.ts
@@ -1,15 +1,15 @@
 import * as InstanceState from "@/effect/instance-state"
+import { InstanceStore } from "@/project/instance-store"
 import { SessionStatus } from "@/session/status"
 import { ConflictError } from "@/server/routes/instance/httpapi/errors"
-import { markInstanceForReload } from "@/server/routes/instance/httpapi/lifecycle"
 import { InstanceHttpApi } from "@/server/routes/instance/httpapi/api"
 import { Effect } from "effect"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
 import type { SessionID } from "@/session/schema"
 
-export function hasBusySession(statuses: Map<SessionID, SessionStatus.Info>): boolean {
+export function hasActiveSession(statuses: Map<SessionID, SessionStatus.Info>): boolean {
   for (const info of statuses.values()) {
-    if (info.type === "busy") return true
+    if (info.type !== "idle") return true
   }
   return false
 }
@@ -17,17 +17,18 @@ export function hasBusySession(statuses: Map<SessionID, SessionStatus.Info>): bo
 export const instanceReloadHandlers = HttpApiBuilder.group(InstanceHttpApi, "instance-reload", (handlers) =>
   Effect.gen(function* () {
     const status = yield* SessionStatus.Service
+    const store = yield* InstanceStore.Service
 
     const reload = Effect.fn("InstanceReloadHttpApi.reload")(function* () {
       const ctx = yield* InstanceState.context
-      if (hasBusySession(yield* status.list())) {
+      if (hasActiveSession(yield* status.list())) {
         return yield* Effect.fail(
           new ConflictError({
             message: "Cannot reload while a session is running. Wait for it to finish or abort it first.",
           }),
         )
       }
-      yield* markInstanceForReload(ctx, {
+      yield* store.reload({
         directory: ctx.directory,
         worktree: ctx.worktree,
         project: ctx.project,
diff --git a/packages/opencode/test/kilocode/instance-reload.test.ts b/packages/opencode/test/kilocode/instance-reload.test.ts
index b537811bcc8..9d31a287ce4 100644
--- a/packages/opencode/test/kilocode/instance-reload.test.ts
+++ b/packages/opencode/test/kilocode/instance-reload.test.ts
@@ -1,19 +1,19 @@
 import { describe, expect, it } from "bun:test"
-import { hasBusySession } from "@/kilocode/server/httpapi/handlers/instance-reload"
+import { hasActiveSession } from "@/kilocode/server/httpapi/handlers/instance-reload"
 import type { SessionStatus } from "@/session/status"
 import { SessionID } from "@/session/schema"
 
 const entries = (items: [string, SessionStatus.Info][]) =>
   items.map(([k, v]) => [k as SessionID, v] as [SessionID, SessionStatus.Info])
 
-describe("instance-reload hasBusySession", () => {
+describe("instance-reload hasActiveSession", () => {
   it("returns false for an empty map", () => {
-    expect(hasBusySession(new Map(entries([])))).toBe(false)
+    expect(hasActiveSession(new Map(entries([])))).toBe(false)
   })
 
   it("returns false when all sessions are idle", () => {
     expect(
-      hasBusySession(
+      hasActiveSession(
         new Map(
           entries([
             ["s1", { type: "idle" }],
@@ -24,9 +24,9 @@ describe("instance-reload hasBusySession", () => {
     ).toBe(false)
   })
 
-  it("returns true when any session is busy", () => {
+  it("returns true when a session is busy", () => {
     expect(
-      hasBusySession(
+      hasActiveSession(
         new Map(
           entries([
             ["s1", { type: "idle" }],
@@ -37,7 +37,29 @@ describe("instance-reload hasBusySession", () => {
     ).toBe(true)
   })
 
-  it("returns true when the only session is busy", () => {
-    expect(hasBusySession(new Map(entries([["s1", { type: "busy" }]])))).toBe(true)
+  it("returns true when a session is retrying", () => {
+    expect(
+      hasActiveSession(
+        new Map(
+          entries([
+            ["s1", { type: "idle" }],
+            ["s2", { type: "retry", attempt: 1, message: "retrying", next: 0 }],
+          ]),
+        ),
+      ),
+    ).toBe(true)
+  })
+
+  it("returns true when a session is offline", () => {
+    expect(
+      hasActiveSession(
+        new Map(
+          entries([
+            ["s1", { type: "idle" }],
+            ["s2", { type: "offline", requestID: "q1" as never, message: "waiting" }],
+          ]),
+        ),
+      ),
+    ).toBe(true)
   })
 })