From 0d7484a1d8634e2c37fd6912e8b206fbfe7cb9ce Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Thu, 9 Jul 2026 21:42:12 +0800
Subject: [PATCH 1/9] fix(web): prevent duplicate first prompts and keep goal
 drives from looking idle
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Guard startSessionAndSendPrompt with a per-workspace reentry lock so a
  double-click / repeated Enter during draft-session creation cannot fire
  two concurrent first prompts into the same new session.
- Track goal.active in the agent event projector so turn.ended between
  goal-driven continuation turns keeps the session 'running' instead of
  projecting a false 'idle' that drains the local queue into a still-busy
  core (turn.agent_busy).
- Show a 'starting conversation…' loading state on the empty-session
  landing while the first prompt is being created and submitted.
- Persist the resolved model in startSessionAndActivateSkill so the first
  skill turn on a fresh session does not fail with 'Model not set'.
---
 apps/kimi-web/src/App.vue                     |  1 +
 .../src/api/daemon/agentEventProjector.ts     | 25 ++++++++++-
 .../kimi-web/src/components/chat/Composer.vue | 41 ++++++++++++++++---
 .../src/components/chat/ConversationPane.vue  | 26 +++++++++---
 .../composables/client/useWorkspaceState.ts   | 27 ++++++++++++
 .../src/composables/useKimiWebClient.ts       |  8 ++++
 apps/kimi-web/src/i18n/locales/en/composer.ts |  1 +
 .../src/i18n/locales/en/conversation.ts       |  1 +
 apps/kimi-web/src/i18n/locales/zh/composer.ts |  1 +
 .../src/i18n/locales/zh/conversation.ts       |  1 +
 .../test/agent-event-projector.test.ts        | 27 ++++++++++++
 11 files changed, 147 insertions(+), 12 deletions(-)

diff --git a/apps/kimi-web/src/App.vue b/apps/kimi-web/src/App.vue
index eb9131b48b..5ceced0eba 100644
--- a/apps/kimi-web/src/App.vue
+++ b/apps/kimi-web/src/App.vue
@@ -738,6 +738,7 @@ function openPr(url: string): void {
       :search-files="client.searchFiles"
       :upload-image="client.uploadImage"
       :sending="client.isSending.value"
+      :starting="client.isStartingFirstPrompt.value"
       :fast-moon="client.fastMoon.value"
       :file-reload-key="client.activeSessionId.value"
       :session-loading="client.sessionLoading.value"
diff --git a/apps/kimi-web/src/api/daemon/agentEventProjector.ts b/apps/kimi-web/src/api/daemon/agentEventProjector.ts
index a63d781cfc..79430c6f3a 100644
--- a/apps/kimi-web/src/api/daemon/agentEventProjector.ts
+++ b/apps/kimi-web/src/api/daemon/agentEventProjector.ts
@@ -125,6 +125,14 @@ interface SessionState {
   // Subagent lifecycle deltas after spawned only carry subagentId. Keep the
   // spawned metadata here so later updates can replace the full AppTask.
   subagentMeta: Map<string, AppTask>;
+
+  // Goal lifecycle. While a goal is `active`, the core keeps `activeTurn` set
+  // across continuation turns (driveGoal), so a turn.ended in that window does
+  // NOT mean the session is idle. Track it here so turn.ended can keep the
+  // session 'running' instead of projecting a false 'idle' — which would let
+  // onSessionIdle drain the local queue into a still-busy core and trip
+  // `turn.agent_busy`.
+  goalActive: boolean;
 }
 
 function createSessionState(): SessionState {
@@ -145,6 +153,7 @@ function createSessionState(): SessionState {
     model: '',
     messages: [],
     subagentMeta: new Map(),
+    goalActive: false,
   };
 }
 
@@ -973,8 +982,18 @@ export function createAgentProjector(): AgentProjector {
         const usageSnapshot = buildUsageSnapshot(s);
         out.push({ type: 'sessionUsageUpdated', sessionId, usage: usageSnapshot });
 
+        // While a goal is still active, this turn.ended is just the boundary
+        // between two goal-driven continuation turns — the core kept
+        // `activeTurn` set, so the session is NOT idle. Projecting 'idle' here
+        // would fire onSessionIdle, drain the local queue, and hit the still-
+        // busy core with `turn.agent_busy`. Keep 'running' until the goal
+        // actually completes (goal.updated clears s.goalActive).
         const newStatus =
-          reason === 'cancelled' || reason === 'failed' || reason === 'filtered' ? 'aborted' : 'idle';
+          reason === 'cancelled' || reason === 'failed' || reason === 'filtered'
+            ? 'aborted'
+            : s.goalActive
+              ? 'running'
+              : 'idle';
         out.push({
           type: 'sessionStatusChanged',
           sessionId,
@@ -1209,6 +1228,10 @@ export function createAgentProjector(): AgentProjector {
 
       case 'goal.updated': {
         const goal = mapGoalSnapshot(p?.snapshot ?? null);
+        // Mirror goal-active into per-session projector state so a later
+        // turn.ended knows whether the core is merely between continuation
+        // turns (goal still driving) or truly idle.
+        s.goalActive = goal?.status === 'active';
         out.push({
           type: 'goalUpdated',
           sessionId,
diff --git a/apps/kimi-web/src/components/chat/Composer.vue b/apps/kimi-web/src/components/chat/Composer.vue
index e8069b0ec4..f3792b63a8 100644
--- a/apps/kimi-web/src/components/chat/Composer.vue
+++ b/apps/kimi-web/src/components/chat/Composer.vue
@@ -33,6 +33,9 @@ import Tooltip from '../ui/Tooltip.vue';
 
 const props = withDefaults(defineProps<{
   running?: boolean;
+  /** True while the empty-composer first prompt is being created + submitted.
+   *  Disables the textarea and swaps the send button for a spinner. */
+  starting?: boolean;
   /** Active session id — scopes the persisted unsent draft (per session). */
   sessionId?: string;
   queued?: QueuedPromptView[];
@@ -56,6 +59,7 @@ const props = withDefaults(defineProps<{
   hideContext?: boolean;
 }>(), {
   running: false,
+  starting: false,
   queued: () => [],
   searchFiles: undefined,
   uploadImage: undefined,
@@ -65,11 +69,13 @@ const props = withDefaults(defineProps<{
 });
 
 const placeholder = computed(() =>
-  props.running
-    ? t('composer.placeholderRunning')
-    : props.goalMode
-      ? t('status.goalPlaceholder')
-      : t('composer.placeholder')
+  props.starting
+    ? t('composer.starting')
+    : props.running
+      ? t('composer.placeholderRunning')
+      : props.goalMode
+        ? t('status.goalPlaceholder')
+        : t('composer.placeholder')
 );
 
 const emit = defineEmits<{
@@ -821,6 +827,7 @@ function selectModel(modelId: string): void {
             v-model="text"
             class="ph"
             :placeholder="placeholder"
+            :disabled="starting"
             rows="1"
             @keydown="handleKeydown"
             @compositionstart="handleCompositionStart"
@@ -997,10 +1004,13 @@ function selectModel(modelId: string): void {
           </Tooltip>
           <button
             class="send"
+            :class="{ 'is-starting': starting }"
             :aria-label="sendLabel"
+            :disabled="starting"
             @click="handleSubmit()"
           >
-            <Icon name="send" size="sm" />
+            <Spinner v-if="starting" size="sm" />
+            <Icon v-else name="send" size="sm" />
           </button>
         </div>
 
@@ -1384,6 +1394,25 @@ function selectModel(modelId: string): void {
   transform: scale(0.92);
 }
 
+.send:disabled {
+  cursor: not-allowed;
+  opacity: 0.88;
+}
+
+.send:disabled:active {
+  transform: none;
+}
+
+/* Spinner-on-accent: recolor the ring so the arc reads on the accent fill.
+   Spinner.vue styles are scoped, so pierce them with :deep(). */
+.send.is-starting :deep(.ui-spinner) {
+  color: var(--color-text-on-accent);
+}
+
+.send.is-starting :deep(.ui-spinner__track) {
+  stroke: rgba(255, 255, 255, 0.32);
+}
+
 .send svg {
   flex: none;
 }
diff --git a/apps/kimi-web/src/components/chat/ConversationPane.vue b/apps/kimi-web/src/components/chat/ConversationPane.vue
index f3f06d05e2..8a65e6ea4f 100644
--- a/apps/kimi-web/src/components/chat/ConversationPane.vue
+++ b/apps/kimi-web/src/components/chat/ConversationPane.vue
@@ -11,6 +11,7 @@ import Composer from './Composer.vue';
 import ChatDock from './ChatDock.vue';
 import ConversationToc, { type ConversationTocItem } from './ConversationToc.vue';
 import Icon from '../ui/Icon.vue';
+import Spinner from '../ui/Spinner.vue';
 import Tooltip from '../ui/Tooltip.vue';
 import { getVisibleWorkspaces } from '../../lib/workspacePicker';
 import { safeRemove, STORAGE_KEYS } from '../../lib/storage';
@@ -45,6 +46,9 @@ const props = defineProps<{
   /** Cache-buster that remounts the chat pane when the active session changes. */
   fileReloadKey?: string | number;
   sending?: boolean;
+  /** True while the empty-composer first prompt is being created + submitted.
+   *  Drives the empty-session "starting conversation…" loading state. */
+  starting?: boolean;
   fastMoon?: boolean;
   /** Mobile shell: compact chrome. */
   mobile?: boolean;
@@ -1050,10 +1054,14 @@ defineExpose({ loadComposerForEdit, focusComposer });
             <!-- Empty session: Composer rendered in the centre of the pane -->
             <div class="empty-spacer" />
             <div class="empty-hint">
-              <span class="empty-hint-title">{{ t('composer.emptyConversationTitle') }}</span>
-              <span class="empty-hint-text">{{ t('composer.emptyConversation') }}</span>
-              <!-- Workspace picker: choose where this new conversation starts. -->
-              <div v-if="hasWorkspaces" class="ws-pick">
+              <span class="empty-hint-title" :class="{ 'is-starting': starting }">
+                <Spinner v-if="starting" size="sm" />
+                <span>{{ starting ? t('conversation.starting') : t('composer.emptyConversationTitle') }}</span>
+              </span>
+              <span v-if="!starting" class="empty-hint-text">{{ t('composer.emptyConversation') }}</span>
+              <!-- Workspace picker: choose where this new conversation starts.
+                   Hidden while starting — a workspace is already committed. -->
+              <div v-if="hasWorkspaces && !starting" class="ws-pick">
                 <Tooltip :text="t('conversation.switchWorkspace')">
                   <button type="button" class="ws-pick-btn" @click.stop="wsPickOpen = !wsPickOpen">
                     <Icon name="folder" size="sm" />
@@ -1094,7 +1102,7 @@ defineExpose({ loadComposerForEdit, focusComposer });
                 </div>
               </div>
               <button
-                v-else
+                v-else-if="!starting"
                 type="button"
                 class="empty-add-workspace"
                 @click="emit('addWorkspace')"
@@ -1120,6 +1128,7 @@ defineExpose({ loadComposerForEdit, focusComposer });
               :models="models"
               :starred-ids="starredIds"
               :skills="skills"
+              :starting="starting"
               hide-context
               @submit="handleComposerSubmit"
               @steer="emit('steer', $event)"
@@ -1343,6 +1352,13 @@ defineExpose({ loadComposerForEdit, focusComposer });
   font-size: calc(var(--ui-font-size) + 16px);
   font-weight: 500;
 }
+.empty-hint-title.is-starting {
+  display: inline-flex;
+  align-items: center;
+  gap: 9px;
+  color: var(--dim);
+  font-weight: 400;
+}
 .empty-hint-text {
   display: inline-block;
   font-size: var(--text-base);
diff --git a/apps/kimi-web/src/composables/client/useWorkspaceState.ts b/apps/kimi-web/src/composables/client/useWorkspaceState.ts
index 9fe107d34c..b437e1e1b9 100644
--- a/apps/kimi-web/src/composables/client/useWorkspaceState.ts
+++ b/apps/kimi-web/src/composables/client/useWorkspaceState.ts
@@ -82,6 +82,17 @@ const pendingQuestionActions = reactive<Record<string, 'answer' | 'dismiss'>>({}
 const pendingApprovalActions = reactive<Record<string, true>>({});
 /** Task ids with an in-flight cancel, keyed by taskId. */
 const pendingTaskCancellations = reactive<Record<string, true>>({});
+/**
+ * Workspace ids whose empty-session first prompt is currently being created +
+ * submitted. The empty-composer path (`startSessionAndSendPrompt`) awaits
+ * `createDraftSession` (addWorkspace + createSession + selectSession) before
+ * the session id exists, so the per-session `inFlightPromptSessions` guard
+ * cannot cover that window — a second Enter / send-button click during it
+ * would otherwise fire a second concurrent POST and trip the daemon's
+ * `turn.agent_busy` race. Module-level singleton — matches the other
+ * `pending*Actions` guards above.
+ */
+const startingFirstPromptWorkspaces = reactive(new Set<string>());
 
 type SyncSessionResult = 'ok' | 'not-found' | 'failed';
 
@@ -815,12 +826,22 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     text: string,
     attachments?: PromptAttachment[],
   ): Promise<void> {
+    // Guard the whole "create draft session + submit first prompt" flow: the
+    // session id doesn't exist until `createDraftSession` resolves, so the
+    // per-session `inFlightPromptSessions` guard can't cover this window. A
+    // second Enter / send-button click in that window would otherwise fire a
+    // concurrent first POST for the same new session and trip the daemon's
+    // `turn.agent_busy` race.
+    if (startingFirstPromptWorkspaces.has(workspaceId)) return;
+    startingFirstPromptWorkspaces.add(workspaceId);
     try {
       const sid = await createDraftSession(workspaceId);
       if (!sid) return;
       await submitPromptInternal(sid, text, attachments);
     } catch (err) {
       pushOperationFailure('startSessionAndSendPrompt', err);
+    } finally {
+      startingFirstPromptWorkspaces.delete(workspaceId);
     }
   }
 
@@ -862,6 +883,7 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
           : rawState.defaultModel) ?? undefined;
       await persistSessionProfile(
         {
+          model,
           planMode,
           swarmMode,
           permissionMode: rawState.permission,
@@ -2186,6 +2208,11 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     searchFiles,
     loadOlderMessages,
     refreshSessionSidecars,
+    /** True while the empty-composer first prompt for `workspaceId` is being
+     *  created + submitted (the window covered by startingFirstPromptWorkspaces).
+     *  Drives the empty-session "starting conversation…" loading state. */
+    isStartingFirstPrompt: (workspaceId: string | null | undefined) =>
+      workspaceId != null && startingFirstPromptWorkspaces.has(workspaceId),
   };
 }
 
diff --git a/apps/kimi-web/src/composables/useKimiWebClient.ts b/apps/kimi-web/src/composables/useKimiWebClient.ts
index 2f7e822fcd..e7dd89fc84 100644
--- a/apps/kimi-web/src/composables/useKimiWebClient.ts
+++ b/apps/kimi-web/src/composables/useKimiWebClient.ts
@@ -1680,6 +1680,13 @@ const isSending = computed<boolean>(() => {
   return rawState.sendingBySession[sid] ?? false;
 });
 
+// True while the empty-composer first prompt for the active workspace is being
+// created + submitted (before the session id exists). Drives the empty-session
+// "starting conversation…" loading state in ConversationPane / Composer.
+const isStartingFirstPrompt = computed<boolean>(() =>
+  workspaceState.isStartingFirstPrompt(rawState.activeWorkspaceId),
+);
+
 const sideChat = useSideChat(rawState, {
   pushOperationFailure,
   nextOptimisticMsgId,
@@ -2479,6 +2486,7 @@ export function useKimiWebClient() {
     questions,
     activity,
     isSending,
+    isStartingFirstPrompt,
     fastMoon: appearance.fastMoon,
 
     // Model + Provider reactive state
diff --git a/apps/kimi-web/src/i18n/locales/en/composer.ts b/apps/kimi-web/src/i18n/locales/en/composer.ts
index 0f9ea66036..8ab8f7b59e 100644
--- a/apps/kimi-web/src/i18n/locales/en/composer.ts
+++ b/apps/kimi-web/src/i18n/locales/en/composer.ts
@@ -3,6 +3,7 @@ export default {
   send: 'Send ↵',
   queueLabel: 'Queue',
   placeholderRunning: 'Press Enter to queue · Ctrl+S to inject into the running turn',
+  starting: 'Sending…',
   queueAutoDrain: 'sends automatically when the current turn ends',
   queueNext: 'Up next',
   queueDragTitle: 'Drag to reorder',
diff --git a/apps/kimi-web/src/i18n/locales/en/conversation.ts b/apps/kimi-web/src/i18n/locales/en/conversation.ts
index c97cb4c4af..431d8d7ad1 100644
--- a/apps/kimi-web/src/i18n/locales/en/conversation.ts
+++ b/apps/kimi-web/src/i18n/locales/en/conversation.ts
@@ -3,6 +3,7 @@ export default {
   toc: 'Conversation outline',
   newMessages: 'Latest messages',
   loading: 'Loading…',
+  starting: 'Starting conversation…',
   emptyWorkspaceHint: 'Send in {name}',
   switchWorkspace: 'Switch workspace',
   addWorkspace: 'New workspace',
diff --git a/apps/kimi-web/src/i18n/locales/zh/composer.ts b/apps/kimi-web/src/i18n/locales/zh/composer.ts
index 6c1ec1926e..001e397530 100644
--- a/apps/kimi-web/src/i18n/locales/zh/composer.ts
+++ b/apps/kimi-web/src/i18n/locales/zh/composer.ts
@@ -3,6 +3,7 @@ export default {
   send: '发送 ↵',
   queueLabel: '队列',
   placeholderRunning: '输入会加入队列 · Ctrl+S 立即插入运行中的回合',
+  starting: '正在发送…',
   queueAutoDrain: '当前回合结束后自动逐条发送',
   queueNext: '下一条',
   queueDragTitle: '拖拽排序',
diff --git a/apps/kimi-web/src/i18n/locales/zh/conversation.ts b/apps/kimi-web/src/i18n/locales/zh/conversation.ts
index 2ae2c2504d..98af571e3a 100644
--- a/apps/kimi-web/src/i18n/locales/zh/conversation.ts
+++ b/apps/kimi-web/src/i18n/locales/zh/conversation.ts
@@ -3,6 +3,7 @@ export default {
   toc: '对话目录',
   newMessages: '最新消息',
   loading: '加载中…',
+  starting: '正在创建对话…',
   emptyWorkspaceHint: '在 {name} 中发送',
   switchWorkspace: '切换工作区',
   addWorkspace: '添加工作区',
diff --git a/apps/kimi-web/test/agent-event-projector.test.ts b/apps/kimi-web/test/agent-event-projector.test.ts
index f6ffa0bdb2..feb9b9b2a3 100644
--- a/apps/kimi-web/test/agent-event-projector.test.ts
+++ b/apps/kimi-web/test/agent-event-projector.test.ts
@@ -134,3 +134,30 @@ describe('classifyFrame cron.fired', () => {
     expect(classifyFrame('event.cron.fired', payload)).toEqual({ route: 'agent', agentType: 'cron.fired' });
   });
 });
+
+describe('turn.ended while a goal is active', () => {
+  it('keeps the session running so a queued prompt is not drained into a still-busy core', () => {
+    const projector = createAgentProjector();
+    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    const events = projector.project('turn.ended', { reason: 'completed' }, 's1');
+    const status = events.find((e) => e.type === 'sessionStatusChanged');
+    expect(status).toMatchObject({ type: 'sessionStatusChanged', status: 'running' });
+  });
+
+  it('projects idle once the goal has completed', () => {
+    const projector = createAgentProjector();
+    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    projector.project('goal.updated', { snapshot: { status: 'complete', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    const events = projector.project('turn.ended', { reason: 'completed' }, 's1');
+    const status = events.find((e) => e.type === 'sessionStatusChanged');
+    expect(status).toMatchObject({ type: 'sessionStatusChanged', status: 'idle' });
+  });
+
+  it('still projects aborted for a cancelled turn even while a goal is active', () => {
+    const projector = createAgentProjector();
+    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    const events = projector.project('turn.ended', { reason: 'cancelled' }, 's1');
+    const status = events.find((e) => e.type === 'sessionStatusChanged');
+    expect(status).toMatchObject({ type: 'sessionStatusChanged', status: 'aborted' });
+  });
+});

From 80e11842c84de2ad24fc7d000fc04f4f114d3664 Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Thu, 9 Jul 2026 21:42:54 +0800
Subject: [PATCH 2/9] chore: add changeset for web first-prompt fixes

---
 .changeset/web-first-prompt-fixes.md | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 .changeset/web-first-prompt-fixes.md

diff --git a/.changeset/web-first-prompt-fixes.md b/.changeset/web-first-prompt-fixes.md
new file mode 100644
index 0000000000..648fe8acde
--- /dev/null
+++ b/.changeset/web-first-prompt-fixes.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+web: Fix an occasional "another turn is active" error when sending the first message of a conversation or while a goal is driving follow-up turns.

From a22d1faad3c509bed4d81523f3df8805ea146eea Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Thu, 9 Jul 2026 22:22:10 +0800
Subject: [PATCH 3/9] fix(web): close remaining first-prompt and goal-settle
 gaps

- Pass the starting guard through the dock composer: draft-session
  creation selects the new session before submit, which swaps the empty
  composer for the dock; disabling both composers closes the last path
  to a concurrent first POST. Also take the workspace lock in
  startSessionAndActivateSkill / startSessionAndOpenSideChat.
- Emit the owed idle when a goal settles (blocked/paused/completed) in
  the inter-turn gap after a turn.ended was projected as 'running', so
  sending state, in-flight flags and queued prompts flush instead of
  the session staying 'running' forever.
---
 .../src/api/daemon/agentEventProjector.ts     | 30 +++++++++++++-
 .../kimi-web/src/components/chat/ChatDock.vue |  5 +++
 .../src/components/chat/ConversationPane.vue  |  1 +
 .../composables/client/useWorkspaceState.ts   | 12 ++++++
 .../test/agent-event-projector.test.ts        | 41 +++++++++++++++++++
 5 files changed, 88 insertions(+), 1 deletion(-)

diff --git a/apps/kimi-web/src/api/daemon/agentEventProjector.ts b/apps/kimi-web/src/api/daemon/agentEventProjector.ts
index 79430c6f3a..c47cb9a780 100644
--- a/apps/kimi-web/src/api/daemon/agentEventProjector.ts
+++ b/apps/kimi-web/src/api/daemon/agentEventProjector.ts
@@ -133,6 +133,13 @@ interface SessionState {
   // onSessionIdle drain the local queue into a still-busy core and trip
   // `turn.agent_busy`.
   goalActive: boolean;
+
+  // True after a turn.ended was projected as 'running' because the goal was
+  // still active — an 'idle' projection is then owed once the goal settles.
+  // A goal can flip to blocked/paused AFTER that turn.ended (driveGoal marks
+  // it in the inter-turn gap), and no further turn.ended will arrive to carry
+  // the idle. goal.updated is where the debt gets paid back.
+  idleOwed: boolean;
 }
 
 function createSessionState(): SessionState {
@@ -154,6 +161,7 @@ function createSessionState(): SessionState {
     messages: [],
     subagentMeta: new Map(),
     goalActive: false,
+    idleOwed: false,
   };
 }
 
@@ -987,13 +995,16 @@ export function createAgentProjector(): AgentProjector {
         // `activeTurn` set, so the session is NOT idle. Projecting 'idle' here
         // would fire onSessionIdle, drain the local queue, and hit the still-
         // busy core with `turn.agent_busy`. Keep 'running' until the goal
-        // actually completes (goal.updated clears s.goalActive).
+        // actually completes (goal.updated clears s.goalActive) — and remember
+        // the owed 'idle' in case the goal settles in the inter-turn gap,
+        // where no further turn.ended will carry it.
         const newStatus =
           reason === 'cancelled' || reason === 'failed' || reason === 'filtered'
             ? 'aborted'
             : s.goalActive
               ? 'running'
               : 'idle';
+        s.idleOwed = newStatus === 'running';
         out.push({
           type: 'sessionStatusChanged',
           sessionId,
@@ -1231,7 +1242,24 @@ export function createAgentProjector(): AgentProjector {
         // Mirror goal-active into per-session projector state so a later
         // turn.ended knows whether the core is merely between continuation
         // turns (goal still driving) or truly idle.
+        const wasActive = s.goalActive;
         s.goalActive = goal?.status === 'active';
+        // The goal just settled (blocked/paused/completed) in an inter-turn
+        // gap after a turn.ended was projected as 'running'. No further
+        // turn.ended will arrive, so emit the owed 'idle' here — otherwise
+        // the session stays 'running' forever and in-flight / sending /
+        // queued state never flushes. A goal settling mid-turn takes the
+        // normal path instead: its upcoming turn.ended projects idle itself
+        // (goalActive already false there), and idleOwed is not set.
+        if (wasActive && !s.goalActive && s.idleOwed) {
+          s.idleOwed = false;
+          out.push({
+            type: 'sessionStatusChanged',
+            sessionId,
+            status: 'idle',
+            previousStatus: 'running',
+          });
+        }
         out.push({
           type: 'goalUpdated',
           sessionId,
diff --git a/apps/kimi-web/src/components/chat/ChatDock.vue b/apps/kimi-web/src/components/chat/ChatDock.vue
index 8da9067d2b..ab84330a3d 100644
--- a/apps/kimi-web/src/components/chat/ChatDock.vue
+++ b/apps/kimi-web/src/components/chat/ChatDock.vue
@@ -20,6 +20,10 @@ import Pill from '../ui/Pill.vue';
 const props = defineProps<{
   sessionId?: string;
   running?: boolean;
+  /** True while the empty-composer first prompt is being created + submitted.
+   *  Covers the gap where draft-session creation already selected the new
+   *  session (empty state → dock) before the first prompt is submitted. */
+  starting?: boolean;
   queued?: QueuedPromptView[];
   searchFiles?: (q: string) => Promise<FileItem[]>;
   uploadImage?: (file: Blob, name?: string) => Promise<{ fileId: string; name: string; mediaType: string } | null>;
@@ -256,6 +260,7 @@ defineExpose({ loadForEdit, loadAttachmentsForEdit, focus });
       :models="models"
       :starred-ids="starredIds"
       :skills="skills"
+      :starting="starting"
       @submit="emit('submit', $event)"
       @steer="emit('steer', $event)"
       @command="emit('command', $event)"
diff --git a/apps/kimi-web/src/components/chat/ConversationPane.vue b/apps/kimi-web/src/components/chat/ConversationPane.vue
index af50d55199..7c7f47511b 100644
--- a/apps/kimi-web/src/components/chat/ConversationPane.vue
+++ b/apps/kimi-web/src/components/chat/ConversationPane.vue
@@ -1295,6 +1295,7 @@ defineExpose({ loadComposerForEdit, focusComposer });
         :style="chatDockStyle"
         :session-id="sessionId"
         :running="running"
+        :starting="starting"
         :queued="queued"
         :search-files="searchFiles"
         :upload-image="uploadImage"
diff --git a/apps/kimi-web/src/composables/client/useWorkspaceState.ts b/apps/kimi-web/src/composables/client/useWorkspaceState.ts
index b437e1e1b9..cf5328dd67 100644
--- a/apps/kimi-web/src/composables/client/useWorkspaceState.ts
+++ b/apps/kimi-web/src/composables/client/useWorkspaceState.ts
@@ -858,6 +858,11 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     skillName: string,
     args?: string,
   ): Promise<void> {
+    // Same reentry window as startSessionAndSendPrompt (see the guard there):
+    // draft-session creation selects the new session before the activation,
+    // so concurrent first actions must be dropped here.
+    if (startingFirstPromptWorkspaces.has(workspaceId)) return;
+    startingFirstPromptWorkspaces.add(workspaceId);
     try {
       const sid = await createDraftSession(workspaceId);
       if (!sid) return;
@@ -894,6 +899,8 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
       await modelProvider.activateSkill(skillName, args, sid);
     } catch (err) {
       pushOperationFailure('startSessionAndActivateSkill', err);
+    } finally {
+      startingFirstPromptWorkspaces.delete(workspaceId);
     }
   }
 
@@ -910,12 +917,17 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     workspaceId: string,
     prompt?: string,
   ): Promise<void> {
+    // Same reentry window as startSessionAndSendPrompt (see the guard there).
+    if (startingFirstPromptWorkspaces.has(workspaceId)) return;
+    startingFirstPromptWorkspaces.add(workspaceId);
     try {
       const sid = await createDraftSession(workspaceId);
       if (!sid) return;
       await sideChat.openSideChatOn(sid, prompt);
     } catch (err) {
       pushOperationFailure('startSessionAndOpenSideChat', err);
+    } finally {
+      startingFirstPromptWorkspaces.delete(workspaceId);
     }
   }
 
diff --git a/apps/kimi-web/test/agent-event-projector.test.ts b/apps/kimi-web/test/agent-event-projector.test.ts
index feb9b9b2a3..019148cd36 100644
--- a/apps/kimi-web/test/agent-event-projector.test.ts
+++ b/apps/kimi-web/test/agent-event-projector.test.ts
@@ -160,4 +160,45 @@ describe('turn.ended while a goal is active', () => {
     const status = events.find((e) => e.type === 'sessionStatusChanged');
     expect(status).toMatchObject({ type: 'sessionStatusChanged', status: 'aborted' });
   });
+
+  it('emits the owed idle when the goal is blocked in the inter-turn gap', () => {
+    const projector = createAgentProjector();
+    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    const ended = projector.project('turn.ended', { reason: 'completed' }, 's1');
+    expect(ended.find((e) => e.type === 'sessionStatusChanged')).toMatchObject({ status: 'running' });
+    // driveGoal marks the goal blocked AFTER the turn.ended above, so no
+    // further turn.ended will carry the idle.
+    const blocked = projector.project('goal.updated', { snapshot: { status: 'blocked', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    const status = blocked.find((e) => e.type === 'sessionStatusChanged');
+    expect(status).toMatchObject({ type: 'sessionStatusChanged', status: 'idle', previousStatus: 'running' });
+  });
+
+  it('emits the owed idle when the goal is paused in the inter-turn gap', () => {
+    const projector = createAgentProjector();
+    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    projector.project('turn.ended', { reason: 'completed' }, 's1');
+    const paused = projector.project('goal.updated', { snapshot: { status: 'paused', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    expect(paused.find((e) => e.type === 'sessionStatusChanged')).toMatchObject({ status: 'idle' });
+  });
+
+  it('does not double-emit idle when the goal settles mid-turn', () => {
+    const projector = createAgentProjector();
+    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    projector.project('turn.started', { turnId: 0 }, 's1');
+    // UpdateGoal('blocked') fires mid-turn: the following turn.ended carries
+    // the idle, so goal.updated must not emit one itself.
+    const blocked = projector.project('goal.updated', { snapshot: { status: 'blocked', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    expect(blocked.filter((e) => e.type === 'sessionStatusChanged')).toHaveLength(0);
+    const ended = projector.project('turn.ended', { reason: 'completed' }, 's1');
+    expect(ended.find((e) => e.type === 'sessionStatusChanged')).toMatchObject({ status: 'idle' });
+  });
+
+  it('stays aborted when the user aborts and the goal is paused afterwards', () => {
+    const projector = createAgentProjector();
+    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    const cancelled = projector.project('turn.ended', { reason: 'cancelled' }, 's1');
+    expect(cancelled.find((e) => e.type === 'sessionStatusChanged')).toMatchObject({ status: 'aborted' });
+    const paused = projector.project('goal.updated', { snapshot: { status: 'paused', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    expect(paused.filter((e) => e.type === 'sessionStatusChanged')).toHaveLength(0);
+  });
 });

From a349247bacb79e7492d2874dfa3c479877bbf442 Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Thu, 9 Jul 2026 22:29:09 +0800
Subject: [PATCH 4/9] style(web): fix eqeqeq lint error in first-prompt guard

---
 apps/kimi-web/src/composables/client/useWorkspaceState.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/apps/kimi-web/src/composables/client/useWorkspaceState.ts b/apps/kimi-web/src/composables/client/useWorkspaceState.ts
index cf5328dd67..561a664f8e 100644
--- a/apps/kimi-web/src/composables/client/useWorkspaceState.ts
+++ b/apps/kimi-web/src/composables/client/useWorkspaceState.ts
@@ -2224,7 +2224,7 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
      *  created + submitted (the window covered by startingFirstPromptWorkspaces).
      *  Drives the empty-session "starting conversation…" loading state. */
     isStartingFirstPrompt: (workspaceId: string | null | undefined) =>
-      workspaceId != null && startingFirstPromptWorkspaces.has(workspaceId),
+      workspaceId !== null && workspaceId !== undefined && startingFirstPromptWorkspaces.has(workspaceId),
   };
 }
 

From 3979f4247105eccb59a54443105b5fa81340750b Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Thu, 9 Jul 2026 22:32:44 +0800
Subject: [PATCH 5/9] fix(web): clear owed idle when a new goal turn starts

The idle debt from a 'running' projection survived turn.started, so an
UpdateGoal('complete'|'blocked') landing mid-turn in the NEXT goal turn
synthesized an early idle. onSessionIdle could then drain queued prompts
into a core that was mid-turn again, re-opening the turn.agent_busy race
for multi-turn goals. Clear the debt on turn.started: from that point the
turn's own turn.ended carries the idle with goalActive already false.
---
 .../src/api/daemon/agentEventProjector.ts     |  8 ++++++
 .../test/agent-event-projector.test.ts        | 25 +++++++++++++++++++
 2 files changed, 33 insertions(+)

diff --git a/apps/kimi-web/src/api/daemon/agentEventProjector.ts b/apps/kimi-web/src/api/daemon/agentEventProjector.ts
index c47cb9a780..e7a66238a8 100644
--- a/apps/kimi-web/src/api/daemon/agentEventProjector.ts
+++ b/apps/kimi-web/src/api/daemon/agentEventProjector.ts
@@ -727,6 +727,14 @@ export function createAgentProjector(): AgentProjector {
         // Fresh turn → fresh per-turn stream offsets.
         s.turnTextLen = 0;
         s.turnThinkLen = 0;
+        // We are mid-turn again, no longer in an inter-turn gap: an idle owed
+        // from the previous boundary must NOT be paid by a goal.updated that
+        // lands during this turn (e.g. UpdateGoal('complete') mid-turn) — its
+        // own turn.ended carries the idle instead, with goalActive already
+        // false. Without this clear, a multi-turn goal would synthesize idle
+        // while the core still runs this turn, and onSessionIdle would drain
+        // queued prompts into it (turn.agent_busy).
+        s.idleOwed = false;
 
         out.push({
           type: 'sessionStatusChanged',
diff --git a/apps/kimi-web/test/agent-event-projector.test.ts b/apps/kimi-web/test/agent-event-projector.test.ts
index 019148cd36..0c37130f6f 100644
--- a/apps/kimi-web/test/agent-event-projector.test.ts
+++ b/apps/kimi-web/test/agent-event-projector.test.ts
@@ -193,6 +193,31 @@ describe('turn.ended while a goal is active', () => {
     expect(ended.find((e) => e.type === 'sessionStatusChanged')).toMatchObject({ status: 'idle' });
   });
 
+  it('clears the owed idle when a new goal turn starts (UpdateGoal mid-turn)', () => {
+    const projector = createAgentProjector();
+    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    // Turn 0 of the goal drive ends: mid-drive, so 'running' and idle is owed.
+    projector.project('turn.ended', { reason: 'completed' }, 's1');
+    // Continuation turn 1 begins; the model calls UpdateGoal('complete') INSIDE
+    // turn 1. The goal.updated must NOT synthesize an idle now — turn 1's own
+    // turn.ended will carry it, and an early idle would drain queued prompts
+    // into a still-busy core (turn.agent_busy).
+    projector.project('turn.started', { turnId: 1 }, 's1');
+    const completed = projector.project('goal.updated', { snapshot: { status: 'complete', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    expect(completed.filter((e) => e.type === 'sessionStatusChanged')).toHaveLength(0);
+    const ended = projector.project('turn.ended', { reason: 'completed' }, 's1');
+    expect(ended.find((e) => e.type === 'sessionStatusChanged')).toMatchObject({ status: 'idle' });
+  });
+
+  it('still pays the owed idle when the goal settles before the next turn starts', () => {
+    const projector = createAgentProjector();
+    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    projector.project('turn.ended', { reason: 'completed' }, 's1');
+    // Goal is blocked in the gap before any continuation turn begins.
+    const blocked = projector.project('goal.updated', { snapshot: { status: 'blocked', goalId: 'g1', objective: 'do stuff' } }, 's1');
+    expect(blocked.find((e) => e.type === 'sessionStatusChanged')).toMatchObject({ status: 'idle' });
+  });
+
   it('stays aborted when the user aborts and the goal is paused afterwards', () => {
     const projector = createAgentProjector();
     projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');

From a0fd3cd0b2615678f8392197cf8f003531bcb970 Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Thu, 9 Jul 2026 22:53:10 +0800
Subject: [PATCH 6/9] fix(web): make first-prompt starting state
 workspace-id-agnostic

isStartingFirstPrompt now reads from the lock set directly (size > 0)
instead of the current activeWorkspaceId. createDraftSession can swap
activeWorkspaceId to a registered id mid-flight; a workspace-keyed read
would then return false while the first prompt is still in the create/
select/submit window, re-enabling the composer and reopening the
duplicate first-submit race.
---
 .../src/composables/client/useWorkspaceState.ts     | 13 ++++++++-----
 apps/kimi-web/src/composables/useKimiWebClient.ts   |  4 +---
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/apps/kimi-web/src/composables/client/useWorkspaceState.ts b/apps/kimi-web/src/composables/client/useWorkspaceState.ts
index 561a664f8e..0c7af88043 100644
--- a/apps/kimi-web/src/composables/client/useWorkspaceState.ts
+++ b/apps/kimi-web/src/composables/client/useWorkspaceState.ts
@@ -2220,11 +2220,14 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     searchFiles,
     loadOlderMessages,
     refreshSessionSidecars,
-    /** True while the empty-composer first prompt for `workspaceId` is being
-     *  created + submitted (the window covered by startingFirstPromptWorkspaces).
-     *  Drives the empty-session "starting conversation…" loading state. */
-    isStartingFirstPrompt: (workspaceId: string | null | undefined) =>
-      workspaceId !== null && workspaceId !== undefined && startingFirstPromptWorkspaces.has(workspaceId),
+    /** True while any empty-composer first prompt is being created + submitted
+     *  (the window covered by startingFirstPromptWorkspaces). Drives the
+     *  empty-session "starting conversation…" loading state. Intentionally
+     *  keyed by the lock set itself rather than the current activeWorkspaceId:
+     *  createDraftSession can swap activeWorkspaceId to a registered id
+     *  mid-flight, and a workspace-keyed read would prematurely re-enable the
+     *  composer and reopen the duplicate first-submit race. */
+    isStartingFirstPrompt: () => startingFirstPromptWorkspaces.size > 0,
   };
 }
 
diff --git a/apps/kimi-web/src/composables/useKimiWebClient.ts b/apps/kimi-web/src/composables/useKimiWebClient.ts
index 98000a0db4..e1af68eb88 100644
--- a/apps/kimi-web/src/composables/useKimiWebClient.ts
+++ b/apps/kimi-web/src/composables/useKimiWebClient.ts
@@ -1688,9 +1688,7 @@ const isSending = computed<boolean>(() => {
 // True while the empty-composer first prompt for the active workspace is being
 // created + submitted (before the session id exists). Drives the empty-session
 // "starting conversation…" loading state in ConversationPane / Composer.
-const isStartingFirstPrompt = computed<boolean>(() =>
-  workspaceState.isStartingFirstPrompt(rawState.activeWorkspaceId),
-);
+const isStartingFirstPrompt = computed<boolean>(() => workspaceState.isStartingFirstPrompt());
 
 const sideChat = useSideChat(rawState, {
   pushOperationFailure,

From acf74ccbcac607fc9e0dd1207977329738b936fd Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Thu, 9 Jul 2026 23:05:24 +0800
Subject: [PATCH 7/9] revert(web): drop goal-aware idle projection from
 agentEventProjector

The goalActive / idleOwed shadow state machine grew through multiple
review rounds and still leaves edge cases (snapshot-seeded turns, mid-
turn goal updates). Roll it back to the simple 'turn.ended projects idle'
behavior. Goal-driven sessions can once again race a queued prompt into a
busy core; this is accepted as a known limitation to be resolved properly
in a follow-up that has the core emit an authoritative idle signal.
---
 .../src/api/daemon/agentEventProjector.ts     | 61 +-----------
 .../test/agent-event-projector.test.ts        | 93 -------------------
 2 files changed, 1 insertion(+), 153 deletions(-)

diff --git a/apps/kimi-web/src/api/daemon/agentEventProjector.ts b/apps/kimi-web/src/api/daemon/agentEventProjector.ts
index e7a66238a8..a63d781cfc 100644
--- a/apps/kimi-web/src/api/daemon/agentEventProjector.ts
+++ b/apps/kimi-web/src/api/daemon/agentEventProjector.ts
@@ -125,21 +125,6 @@ interface SessionState {
   // Subagent lifecycle deltas after spawned only carry subagentId. Keep the
   // spawned metadata here so later updates can replace the full AppTask.
   subagentMeta: Map<string, AppTask>;
-
-  // Goal lifecycle. While a goal is `active`, the core keeps `activeTurn` set
-  // across continuation turns (driveGoal), so a turn.ended in that window does
-  // NOT mean the session is idle. Track it here so turn.ended can keep the
-  // session 'running' instead of projecting a false 'idle' — which would let
-  // onSessionIdle drain the local queue into a still-busy core and trip
-  // `turn.agent_busy`.
-  goalActive: boolean;
-
-  // True after a turn.ended was projected as 'running' because the goal was
-  // still active — an 'idle' projection is then owed once the goal settles.
-  // A goal can flip to blocked/paused AFTER that turn.ended (driveGoal marks
-  // it in the inter-turn gap), and no further turn.ended will arrive to carry
-  // the idle. goal.updated is where the debt gets paid back.
-  idleOwed: boolean;
 }
 
 function createSessionState(): SessionState {
@@ -160,8 +145,6 @@ function createSessionState(): SessionState {
     model: '',
     messages: [],
     subagentMeta: new Map(),
-    goalActive: false,
-    idleOwed: false,
   };
 }
 
@@ -727,14 +710,6 @@ export function createAgentProjector(): AgentProjector {
         // Fresh turn → fresh per-turn stream offsets.
         s.turnTextLen = 0;
         s.turnThinkLen = 0;
-        // We are mid-turn again, no longer in an inter-turn gap: an idle owed
-        // from the previous boundary must NOT be paid by a goal.updated that
-        // lands during this turn (e.g. UpdateGoal('complete') mid-turn) — its
-        // own turn.ended carries the idle instead, with goalActive already
-        // false. Without this clear, a multi-turn goal would synthesize idle
-        // while the core still runs this turn, and onSessionIdle would drain
-        // queued prompts into it (turn.agent_busy).
-        s.idleOwed = false;
 
         out.push({
           type: 'sessionStatusChanged',
@@ -998,21 +973,8 @@ export function createAgentProjector(): AgentProjector {
         const usageSnapshot = buildUsageSnapshot(s);
         out.push({ type: 'sessionUsageUpdated', sessionId, usage: usageSnapshot });
 
-        // While a goal is still active, this turn.ended is just the boundary
-        // between two goal-driven continuation turns — the core kept
-        // `activeTurn` set, so the session is NOT idle. Projecting 'idle' here
-        // would fire onSessionIdle, drain the local queue, and hit the still-
-        // busy core with `turn.agent_busy`. Keep 'running' until the goal
-        // actually completes (goal.updated clears s.goalActive) — and remember
-        // the owed 'idle' in case the goal settles in the inter-turn gap,
-        // where no further turn.ended will carry it.
         const newStatus =
-          reason === 'cancelled' || reason === 'failed' || reason === 'filtered'
-            ? 'aborted'
-            : s.goalActive
-              ? 'running'
-              : 'idle';
-        s.idleOwed = newStatus === 'running';
+          reason === 'cancelled' || reason === 'failed' || reason === 'filtered' ? 'aborted' : 'idle';
         out.push({
           type: 'sessionStatusChanged',
           sessionId,
@@ -1247,27 +1209,6 @@ export function createAgentProjector(): AgentProjector {
 
       case 'goal.updated': {
         const goal = mapGoalSnapshot(p?.snapshot ?? null);
-        // Mirror goal-active into per-session projector state so a later
-        // turn.ended knows whether the core is merely between continuation
-        // turns (goal still driving) or truly idle.
-        const wasActive = s.goalActive;
-        s.goalActive = goal?.status === 'active';
-        // The goal just settled (blocked/paused/completed) in an inter-turn
-        // gap after a turn.ended was projected as 'running'. No further
-        // turn.ended will arrive, so emit the owed 'idle' here — otherwise
-        // the session stays 'running' forever and in-flight / sending /
-        // queued state never flushes. A goal settling mid-turn takes the
-        // normal path instead: its upcoming turn.ended projects idle itself
-        // (goalActive already false there), and idleOwed is not set.
-        if (wasActive && !s.goalActive && s.idleOwed) {
-          s.idleOwed = false;
-          out.push({
-            type: 'sessionStatusChanged',
-            sessionId,
-            status: 'idle',
-            previousStatus: 'running',
-          });
-        }
         out.push({
           type: 'goalUpdated',
           sessionId,
diff --git a/apps/kimi-web/test/agent-event-projector.test.ts b/apps/kimi-web/test/agent-event-projector.test.ts
index 0c37130f6f..f6ffa0bdb2 100644
--- a/apps/kimi-web/test/agent-event-projector.test.ts
+++ b/apps/kimi-web/test/agent-event-projector.test.ts
@@ -134,96 +134,3 @@ describe('classifyFrame cron.fired', () => {
     expect(classifyFrame('event.cron.fired', payload)).toEqual({ route: 'agent', agentType: 'cron.fired' });
   });
 });
-
-describe('turn.ended while a goal is active', () => {
-  it('keeps the session running so a queued prompt is not drained into a still-busy core', () => {
-    const projector = createAgentProjector();
-    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    const events = projector.project('turn.ended', { reason: 'completed' }, 's1');
-    const status = events.find((e) => e.type === 'sessionStatusChanged');
-    expect(status).toMatchObject({ type: 'sessionStatusChanged', status: 'running' });
-  });
-
-  it('projects idle once the goal has completed', () => {
-    const projector = createAgentProjector();
-    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    projector.project('goal.updated', { snapshot: { status: 'complete', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    const events = projector.project('turn.ended', { reason: 'completed' }, 's1');
-    const status = events.find((e) => e.type === 'sessionStatusChanged');
-    expect(status).toMatchObject({ type: 'sessionStatusChanged', status: 'idle' });
-  });
-
-  it('still projects aborted for a cancelled turn even while a goal is active', () => {
-    const projector = createAgentProjector();
-    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    const events = projector.project('turn.ended', { reason: 'cancelled' }, 's1');
-    const status = events.find((e) => e.type === 'sessionStatusChanged');
-    expect(status).toMatchObject({ type: 'sessionStatusChanged', status: 'aborted' });
-  });
-
-  it('emits the owed idle when the goal is blocked in the inter-turn gap', () => {
-    const projector = createAgentProjector();
-    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    const ended = projector.project('turn.ended', { reason: 'completed' }, 's1');
-    expect(ended.find((e) => e.type === 'sessionStatusChanged')).toMatchObject({ status: 'running' });
-    // driveGoal marks the goal blocked AFTER the turn.ended above, so no
-    // further turn.ended will carry the idle.
-    const blocked = projector.project('goal.updated', { snapshot: { status: 'blocked', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    const status = blocked.find((e) => e.type === 'sessionStatusChanged');
-    expect(status).toMatchObject({ type: 'sessionStatusChanged', status: 'idle', previousStatus: 'running' });
-  });
-
-  it('emits the owed idle when the goal is paused in the inter-turn gap', () => {
-    const projector = createAgentProjector();
-    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    projector.project('turn.ended', { reason: 'completed' }, 's1');
-    const paused = projector.project('goal.updated', { snapshot: { status: 'paused', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    expect(paused.find((e) => e.type === 'sessionStatusChanged')).toMatchObject({ status: 'idle' });
-  });
-
-  it('does not double-emit idle when the goal settles mid-turn', () => {
-    const projector = createAgentProjector();
-    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    projector.project('turn.started', { turnId: 0 }, 's1');
-    // UpdateGoal('blocked') fires mid-turn: the following turn.ended carries
-    // the idle, so goal.updated must not emit one itself.
-    const blocked = projector.project('goal.updated', { snapshot: { status: 'blocked', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    expect(blocked.filter((e) => e.type === 'sessionStatusChanged')).toHaveLength(0);
-    const ended = projector.project('turn.ended', { reason: 'completed' }, 's1');
-    expect(ended.find((e) => e.type === 'sessionStatusChanged')).toMatchObject({ status: 'idle' });
-  });
-
-  it('clears the owed idle when a new goal turn starts (UpdateGoal mid-turn)', () => {
-    const projector = createAgentProjector();
-    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    // Turn 0 of the goal drive ends: mid-drive, so 'running' and idle is owed.
-    projector.project('turn.ended', { reason: 'completed' }, 's1');
-    // Continuation turn 1 begins; the model calls UpdateGoal('complete') INSIDE
-    // turn 1. The goal.updated must NOT synthesize an idle now — turn 1's own
-    // turn.ended will carry it, and an early idle would drain queued prompts
-    // into a still-busy core (turn.agent_busy).
-    projector.project('turn.started', { turnId: 1 }, 's1');
-    const completed = projector.project('goal.updated', { snapshot: { status: 'complete', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    expect(completed.filter((e) => e.type === 'sessionStatusChanged')).toHaveLength(0);
-    const ended = projector.project('turn.ended', { reason: 'completed' }, 's1');
-    expect(ended.find((e) => e.type === 'sessionStatusChanged')).toMatchObject({ status: 'idle' });
-  });
-
-  it('still pays the owed idle when the goal settles before the next turn starts', () => {
-    const projector = createAgentProjector();
-    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    projector.project('turn.ended', { reason: 'completed' }, 's1');
-    // Goal is blocked in the gap before any continuation turn begins.
-    const blocked = projector.project('goal.updated', { snapshot: { status: 'blocked', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    expect(blocked.find((e) => e.type === 'sessionStatusChanged')).toMatchObject({ status: 'idle' });
-  });
-
-  it('stays aborted when the user aborts and the goal is paused afterwards', () => {
-    const projector = createAgentProjector();
-    projector.project('goal.updated', { snapshot: { status: 'active', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    const cancelled = projector.project('turn.ended', { reason: 'cancelled' }, 's1');
-    expect(cancelled.find((e) => e.type === 'sessionStatusChanged')).toMatchObject({ status: 'aborted' });
-    const paused = projector.project('goal.updated', { snapshot: { status: 'paused', goalId: 'g1', objective: 'do stuff' } }, 's1');
-    expect(paused.filter((e) => e.type === 'sessionStatusChanged')).toHaveLength(0);
-  });
-});

From f366a41ac5220bb7b9d48b77393b3318457394c4 Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Thu, 9 Jul 2026 23:13:11 +0800
Subject: [PATCH 8/9] chore: align changeset with actual fix scope

---
 .changeset/web-first-prompt-fixes.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.changeset/web-first-prompt-fixes.md b/.changeset/web-first-prompt-fixes.md
index 648fe8acde..fa34159ab4 100644
--- a/.changeset/web-first-prompt-fixes.md
+++ b/.changeset/web-first-prompt-fixes.md
@@ -2,4 +2,4 @@
 "@moonshot-ai/kimi-code": patch
 ---
 
-web: Fix an occasional "another turn is active" error when sending the first message of a conversation or while a goal is driving follow-up turns.
+web: Fix an occasional "another turn is active" error when sending the first message of a new conversation, and show a starting state while it is being sent.

From 37d33cf696ebcde9ef628efdac5de963253400d3 Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Thu, 9 Jul 2026 23:28:55 +0800
Subject: [PATCH 9/9] test(web): update profile-patch expectation for model
 field

---
 apps/kimi-web/test/workspace-state.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/apps/kimi-web/test/workspace-state.test.ts b/apps/kimi-web/test/workspace-state.test.ts
index 045b6c024f..ff28d00168 100644
--- a/apps/kimi-web/test/workspace-state.test.ts
+++ b/apps/kimi-web/test/workspace-state.test.ts
@@ -638,7 +638,7 @@ describe('useWorkspaceState — startSessionAndActivateSkill', () => {
     // Activation must NOT have started while /profile is still pending.
     await new Promise((r) => setTimeout(r, 0));
     expect(persistSessionProfile).toHaveBeenCalledWith(
-      { planMode: true, swarmMode: true, permissionMode: 'auto', thinking: 'high' },
+      { model: undefined, planMode: true, swarmMode: true, permissionMode: 'auto', thinking: 'high' },
       'sess_new',
     );
     expect(activateSkill).not.toHaveBeenCalled();