Merge remote-tracking branch 'origin/master' into codex/pr-555-ci-fix

# Conflicts:
#	docs/module-graph.i18n.yaml
#	docs/module-graph.md
#	docs/module-graph.zh.md
#	packages/client/ui-conversation/src/client/input/hub.ts
#	packages/client/ui-conversation/tests/input-bar.spec.tsx
#	packages/client/ui-conversation/tests/service-orchestration.spec.ts

apps/cli/package.json

@@ -34,6 +34,8 @@
     "@deepseek-ai/dsh-plan-mode": "workspace:^",
     "@deepseek-ai/dsh-pty": "workspace:^",
     "@deepseek-ai/dsh-pty-local": "workspace:^",
+    "@deepseek-ai/dsh-pwsh-local": "workspace:^",
+    "@deepseek-ai/dsh-pwsh-sandbox": "workspace:^",
     "@deepseek-ai/dsh-session-reference": "workspace:^",
     "@deepseek-ai/dsh-skill": "workspace:^",
     "@deepseek-ai/dsh-skill-local": "workspace:^",
@@ -47,6 +49,7 @@
     "@deepseek-ai/dsh-tool-fs": "workspace:^",
     "@deepseek-ai/dsh-tool-fs-search": "workspace:^",
     "@deepseek-ai/dsh-tool-goal": "workspace:^",
+    "@deepseek-ai/dsh-tool-pwsh": "workspace:^",
     "@deepseek-ai/dsh-tool-ralph": "workspace:^",
     "@deepseek-ai/dsh-tool-skill": "workspace:^",
     "@deepseek-ai/dsh-tool-str-replace-editor": "workspace:^",

apps/cli/src/dump-config.ts

@@ -15,6 +15,7 @@ import {
   type ConfigDumpLayer,
 } from '@deepseek-ai/dsh-app-boot'
 import { homePatchPath, prepareProfile, PROFILE_ROOT_FILENAME } from './profile-boot.ts'
+import { resolveWindowsShellLayer } from './windows-shell.ts'
 
 const NAME = 'dsh'
 
@@ -33,6 +34,12 @@ export function runDumpConfig(profile: string, defaultOnly: boolean, patches: re
     label: layer.packageName,
     patches: layer.patches,
   }))
+  // The win32 shell platform layer rides between bundles and user layers,
+  // exactly where the boot applies it.
+  const windowsShellLayer = resolveWindowsShellLayer(process.platform, loaded.layers, NAME)
+  if (windowsShellLayer !== undefined) {
+    layers.push({ label: windowsShellLayer.label, patches: windowsShellLayer.patches })
+  }
   if (!defaultOnly) {
     if (existsSync(loaded.patchPath)) {
       layers.push({ label: loaded.patchPath, patches: loaded.patches })

apps/cli/src/profile-boot.ts

@@ -35,6 +35,7 @@ const USER_PRESET_DIR = '.agent-presets'
 import { DSH_ENVIRONMENT_KEY, type EnvironmentSnapshot } from '@deepseek-ai/dsh-environment'
 import type { HeadlessIo } from '@deepseek-ai/dsh-headless'
 import { createProcessShutdown, type ProcessShutdown } from './process-shutdown.ts'
+import { resolveWindowsShellLayer } from './windows-shell.ts'
 
 const NAME = 'dsh'
 
@@ -111,6 +112,8 @@ interface ComposedProfile {
   profile: Profile
   /** Bundle layers concatenated — the part below the user layers on a live reload. */
   bundlePatches: PatchOptions[]
+  /** The win32 shell platform layer (the base bundle's `windows.cordis.patch.yml`), between bundles and user layers. */
+  windowsShellPatches: PatchOptions[]
   /** The home-level user layer (`$DSH_HOME/cordis.patch.yml`), applied after the profile's own. */
   homePatches: PatchOptions[]
   /** Layers above the user layers on a live reload: --patch overlays, flag patches, the telemetry switch. */
@@ -125,12 +128,19 @@ interface ComposedProfile {
 
 /** The full patch stack of one composed profile, in application order. */
 function allPatches(composed: ComposedProfile): PatchOptions[] {
-  return [...composed.bundlePatches, ...composed.profile.patches, ...composed.homePatches, ...composed.overlayAndFlags]
+  return [
+    ...composed.bundlePatches,
+    ...composed.windowsShellPatches,
+    ...composed.profile.patches,
+    ...composed.homePatches,
+    ...composed.overlayAndFlags,
+  ]
 }
 
 /**
  * Load `name` and compose its effective patch stack: bundle layers in
- * `dsh.profile.bundles` order, the profile's user layer, the home-level user layer
+ * `dsh.profile.bundles` order, the win32 shell platform layer (when the host
+ * is Windows), the profile's user layer, the home-level user layer
  * (`$DSH_HOME/cordis.patch.yml` — machine-local preferences that apply to
  * every profile, so it outranks the per-profile layer), `--patch` overlays,
  * then flag patches derived from the composed rows, then the telemetry
@@ -149,8 +159,9 @@ function composeProfile(
   const homePatches = loadOptionalPatches(NAME, homePatchPath()) ?? []
   const overlays = patchFiles.flatMap(file => loadOverlayPatches(NAME, resolve(file)))
   const bundlePatches = profile.layers.flatMap(layer => layer.patches)
+  const windowsShellPatches = resolveWindowsShellLayer(process.platform, profile.layers, NAME)?.patches ?? []
   const rows = new Map<string, { name?: string; config?: unknown }>()
-  for (const row of composeEntries([bundlePatches, profile.patches, homePatches, overlays])) {
+  for (const row of composeEntries([bundlePatches, windowsShellPatches, profile.patches, homePatches, overlays])) {
     if (typeof row.id === 'string') rows.set(row.id, row)
   }
   const overlayAndFlags = [...overlays, ...deriveFlagPatches(rows)]
@@ -174,7 +185,7 @@ function composeProfile(
   }
   const telemetryPatch = resolveTelemetryPatch(process.env.DSH_TELEMETRY_DISABLED, rows.has(TELEMETRY_ROW_ID))
   if (telemetryPatch !== undefined) overlayAndFlags.push(telemetryPatch)
-  return { profile, bundlePatches, homePatches, overlayAndFlags, rows }
+  return { profile, bundlePatches, windowsShellPatches, homePatches, overlayAndFlags, rows }
 }
 
 /** Options for {@link runProfile}. */
@@ -232,7 +243,7 @@ export async function runProfile(options: RunProfileOptions): Promise<{ ctx: Con
     shutdown.interrupt(code)
   }
   // Signals own teardown throughout the startup window, not only after boot()
-  // settles: an inserted front door can publish readiness before sibling rows
+  // settles: an inserted entry point can publish readiness before sibling rows
   // finish mounting.
   process.on('SIGTERM', () => { interrupt(options.task === undefined ? 0 : 143) })
   process.on('SIGINT', () => { interrupt(130) })
@@ -253,6 +264,7 @@ export async function runProfile(options: RunProfileOptions): Promise<{ ctx: Con
   // removing the override could never revert the row to the bundle default.
   const composeLive = (): PatchOptions[] => structuredClone([
     ...composed.bundlePatches,
+    ...composed.windowsShellPatches,
     ...loadOptionalPatches(NAME, composed.profile.patchPath) ?? [],
     ...loadOptionalPatches(NAME, homePatchPath()) ?? [],
     ...composed.overlayAndFlags,

apps/cli/src/windows-shell.ts

@@ -0,0 +1,52 @@
+/**
+ * The Windows shell platform layer: on win32 hosts the shipped profile
+ * compositions swap the POSIX-only bash stack for the sandbox-confined
+ * PowerShell stack (`@deepseek-ai/dsh-pwsh-sandbox` +
+ * `@deepseek-ai/dsh-tool-pwsh`). The layer is the base bundle's
+ * `windows.cordis.patch.yml`, injected by the launcher between the bundle
+ * layers and the user layers so a user patch can still override it — the
+ * only override channel is composition config, like every other roster
+ * decision. POSIX hosts never receive the layer.
+ * @module @deepseek-ai/dsh/windows-shell
+ */
+
+import { join } from 'node:path'
+import type { PatchOptions } from '@cordisjs/plugin-include'
+import { loadOverlayPatches, type ProfileLayer } from '@deepseek-ai/dsh-app-boot'
+
+/** The base bundle whose package carries the Windows shell patch. */
+export const BASE_BUNDLE = '@deepseek-ai/dsh-base'
+
+/** The Windows shell patch filename inside the base bundle package. */
+export const WINDOWS_SHELL_PATCH_FILENAME = 'windows.cordis.patch.yml'
+
+/** One Windows shell platform layer: its patch file and parsed patches. */
+export interface WindowsShellLayer {
+  /** The patch file path, used as the config-dump provenance label. */
+  label: string
+  /** The parsed patch entries, applied after the bundle layers. */
+  patches: PatchOptions[]
+}
+
+/**
+ * Resolve the Windows shell platform layer for a profile composition.
+ * @param platform - the host platform (`process.platform` at call sites).
+ * @param layers - the profile's bundle layers, in application order.
+ * @param binName - the diagnostic prefix on thrown errors (`dsh`).
+ * @returns the pwsh layer on win32, else `undefined`. A custom profile that
+ *   mounts no base bundle is skipped (it owns its shell stack); a base
+ *   bundle whose Windows shell patch is missing fails loud in
+ *   {@link loadOverlayPatches} — the shipped package always carries it, so
+ *   a miss is a broken installation.
+ */
+export function resolveWindowsShellLayer(
+  platform: NodeJS.Platform,
+  layers: readonly ProfileLayer[],
+  binName: string,
+): WindowsShellLayer | undefined {
+  if (platform !== 'win32') return undefined
+  const base = layers.find(layer => layer.packageName === BASE_BUNDLE)
+  if (base === undefined) return undefined
+  const label = join(base.packageDir, WINDOWS_SHELL_PATCH_FILENAME)
+  return { label, patches: loadOverlayPatches(binName, label) }
+}

apps/cli/tests/windows-shell.spec.ts

@@ -0,0 +1,139 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync, readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import type { ProfileLayer } from '@deepseek-ai/dsh-app-boot'
+import { composeEntries, initProfile, loadProfile, PROFILES_DIR } from '@deepseek-ai/dsh-app-boot'
+import {
+  BASE_BUNDLE,
+  resolveWindowsShellLayer,
+  WINDOWS_SHELL_PATCH_FILENAME,
+} from '../src/windows-shell.ts'
+
+const WINDOWS_PATCH = `- id: bash-sandbox
+  disabled: true
+- insert:
+    - id: pwsh-sandbox
+      name: '@deepseek-ai/dsh-pwsh-sandbox'
+`
+
+/** One fake bundle layer rooted in a temp directory. */
+function fakeLayer(packageName: string, dir: string): ProfileLayer {
+  return { packageName, packageDir: dir, patchPath: join(dir, 'cordis.patch.yml'), patches: [] }
+}
+
+/** A base bundle layer whose package carries the Windows shell patch. */
+function baseLayerWithPatch(dir: string): ProfileLayer {
+  writeFileSync(join(dir, WINDOWS_SHELL_PATCH_FILENAME), WINDOWS_PATCH)
+  return fakeLayer(BASE_BUNDLE, dir)
+}
+
+describe('resolveWindowsShellLayer', () => {
+  let base: string
+  afterEach(() => { if (base !== undefined) rmSync(base, { recursive: true, force: true }) })
+  const tempBase = (): string => {
+    base = mkdtempSync(join(tmpdir(), 'dsh-windows-shell-'))
+    return base
+  }
+
+  it('never applies on POSIX hosts', () => {
+    expect(resolveWindowsShellLayer('linux', [baseLayerWithPatch(tempBase())], 'dsh')).toBeUndefined()
+    expect(resolveWindowsShellLayer('darwin', [baseLayerWithPatch(tempBase())], 'dsh')).toBeUndefined()
+  })
+
+  it('defaults Windows hosts to the pwsh platform layer', () => {
+    const layer = resolveWindowsShellLayer('win32', [baseLayerWithPatch(tempBase())], 'dsh')
+    expect(layer).toBeDefined()
+    expect(layer?.label.endsWith(WINDOWS_SHELL_PATCH_FILENAME)).toBe(true)
+    expect(layer?.patches).toEqual([
+      { id: 'bash-sandbox', disabled: true },
+      { insert: [{ id: 'pwsh-sandbox', name: '@deepseek-ai/dsh-pwsh-sandbox' }] },
+    ])
+  })
+
+  it('skips custom profiles without a base bundle', () => {
+    const other = fakeLayer('@deepseek-ai/dsh-custom', tempBase())
+    expect(resolveWindowsShellLayer('win32', [other], 'dsh')).toBeUndefined()
+  })
+
+  it('fails loud when the base bundle ships no Windows shell patch', () => {
+    const base = tempBase()
+    mkdirSync(base, { recursive: true })
+    // The overlay loader owns the fail-loud contract: the caller named this
+    // file, so its absence is a misconfiguration, not "no overlay".
+    expect(() => resolveWindowsShellLayer('win32', [fakeLayer(BASE_BUNDLE, base)], 'dsh'))
+      .toThrow(/dsh: failed to read overlay .*windows\.cordis\.patch\.yml/)
+  })
+})
+
+describe('the shipped Windows composition (real bundle layers)', () => {
+  let home: string
+  afterEach(() => { if (home !== undefined) rmSync(home, { recursive: true, force: true }) })
+  // The app installation anchor, mirroring profile-boot.ts: the bundle layers
+  // resolve from the REAL dsh-base/dsh-web-app packages through it, so this
+  // suite composes the shipped patch files, not test fixtures.
+  const anchor = fileURLToPath(new URL('../package.json', import.meta.url))
+
+  it('composes the win32 confined roster through the real patch layers', () => {
+    home = mkdtempSync(join(tmpdir(), 'dsh-windows-home-'))
+    initProfile(join(home, PROFILES_DIR, 'web'), ['@deepseek-ai/dsh-base', '@deepseek-ai/dsh-web-app'])
+    const profile = loadProfile('dsh', 'web', anchor, home)
+    const warnings: string[] = []
+    const win32 = resolveWindowsShellLayer('win32', profile.layers, 'dsh')
+    expect(win32).toBeDefined()
+    const rows = composeEntries(
+      [...profile.layers.map(layer => layer.patches), win32!.patches],
+      message => warnings.push(message),
+    )
+    const byId = new Map(rows.map(row => [row.id, row]))
+    // Only the POSIX bash stack leaves the roster: the permission surface
+    // (sandbox/sandbox-policy/fs-sandbox, permission, approval) stays enabled
+    // exactly as on POSIX — the confined pwsh executor is what changes.
+    for (const id of ['bash-sandbox', 'tool-bash']) {
+      expect(byId.get(id)?.disabled, `row ${id}`).toBe(true)
+    }
+    for (const id of ['permission', 'ui-permission', 'sandbox', 'sandbox-policy', 'fs-sandbox', 'approval']) {
+      expect(byId.get(id)?.disabled, `row ${id}`).not.toBe(true)
+    }
+    for (const id of ['pwsh-sandbox', 'tool-pwsh']) {
+      expect(byId.has(id), `inserted row ${id}`).toBe(true)
+    }
+    // The launcher's cold-start module fallback BFS-links the apps/cli
+    // dependency closure into the profile's node_modules (the pwsh-local
+    // precedent), so every inserted bare plugin must resolve from there.
+    const cliManifest = JSON.parse(readFileSync(anchor, 'utf8')) as { dependencies?: Record<string, string> }
+    for (const name of ['@deepseek-ai/dsh-pwsh-sandbox', '@deepseek-ai/dsh-tool-pwsh']) {
+      expect(cliManifest.dependencies?.[name], `cold-start closure must reach ${name}`).toBeDefined()
+    }
+    // The patch touches only base-owned rows plus inserts, so the full web
+    // profile composes without any no-match warning.
+    expect(warnings).toEqual([])
+  })
+
+  it('leaves POSIX untouched and base-only profiles compose without warnings', () => {
+    home = mkdtempSync(join(tmpdir(), 'dsh-windows-home-'))
+    initProfile(join(home, PROFILES_DIR, 'web'), ['@deepseek-ai/dsh-base', '@deepseek-ai/dsh-web-app'])
+    const profile = loadProfile('dsh', 'web', anchor, home)
+    // POSIX: no platform layer, the bash stack stays enabled.
+    const posixRows = composeEntries(profile.layers.map(layer => layer.patches))
+    const posixById = new Map(posixRows.map(row => [row.id, row]))
+    expect(posixById.get('bash-sandbox')?.disabled).not.toBe(true)
+    expect(posixById.has('pwsh-local')).toBe(false)
+    expect(posixById.has('pwsh-sandbox')).toBe(false)
+
+    // A base-only custom profile (the DEFAULT_PROFILE_BUNDLES template): the
+    // patch touches only base-owned rows (bash-sandbox/tool-bash) plus its
+    // inserts, so the composition produces no no-match warning.
+    initProfile(join(home, PROFILES_DIR, 'base-only'), ['@deepseek-ai/dsh-base'])
+    const baseOnly = loadProfile('dsh', 'base-only', anchor, home)
+    const baseWarnings: string[] = []
+    const win32 = resolveWindowsShellLayer('win32', baseOnly.layers, 'dsh')
+    expect(win32).toBeDefined()
+    composeEntries(
+      [...baseOnly.layers.map(layer => layer.patches), win32!.patches],
+      message => baseWarnings.push(message),
+    )
+    expect(baseWarnings).toEqual([])
+  })
+})

apps/web/tests/snapshots/queue-actions/collapsed.expected.md

@@ -16,7 +16,7 @@
 - paragraph: partial
 - status: Deep diving...
 - button "2 queued messages"
-- textbox "Message the agent"
+- textbox "Cmd/Ctrl+Enter steers all queued messages"
 - button "Commands":
   - img
 - 'button "Access mode, current: Workspace Write"': Workspace Write

apps/web/tests/snapshots/queue-actions/editing.expected.md

@@ -32,7 +32,7 @@
     - tooltip "Save queued message"
     - button "Cancel editing":
       - img
-- textbox "Message the agent"
+- textbox "Cmd/Ctrl+Enter steers all queued messages"
 - button "Commands":
   - img
 - 'button "Access mode, current: Workspace Write"': Workspace Write

apps/web/tests/snapshots/queue-actions/layout.expected.md

@@ -31,7 +31,7 @@
 - button "Clear goal":
   - img
 - button "2 queued messages"
-- textbox "Message the agent"
+- textbox "Cmd/Ctrl+Enter steers all queued messages"
 - button "Commands":
   - img
 - 'button "Access mode, current: Workspace Write"': Workspace Write

apps/web/tests/snapshots/queue-actions/ui.expected.md

@@ -25,7 +25,7 @@
       - img
     - button "Steer queued message":
       - img
-- textbox "Message the agent"
+- textbox "Cmd/Ctrl+Enter steers all queued messages"
 - button "Commands":
   - img
 - 'button "Access mode, current: Workspace Write"': Workspace Write

apps/web/tests/snapshots/steer-all/mid-steer.expected.md

@@ -0,0 +1,35 @@
+- banner:
+  - navigation "Session hierarchy":
+    - button "Use the ask_user_question tool to" [disabled]
+  - img
+  - text: 标准模式
+  - tablist:
+    - tab "Chat" [selected]
+    - tab "Trajectory"
+- text: Use the ask_user_question tool to ask me exactly one question with id "checkpoint", question "Ready to continue?", header "Checkpoint", and options labeled "Yes" and "No". After I answer, reply with one short sentence acknowledging my answer and stop. {{clock}}
+- button "Copy":
+  - img
+- button "Context injection @deepseek-ai/dsh-system-prompt":
+  - img
+  - img
+  - text: Context injection @deepseek-ai/dsh-system-prompt
+- text: Running
+- button "Think The user wants me to ask them a checkpoint question first, then continue with whatever they interject. Let me do exactly that.":
+  - img
+  - img
+  - text: Think The user wants me to ask them a checkpoint question first, then continue with whatever they interject. Let me do exactly that.
+- status: Deep diving...
+- text: "Interjection Interjection: include the word BANANA in your final reply."
+- button "Copy":
+  - img
+- text: "Interjection Interjection: include the word ORANGE in your final reply."
+- button "Copy":
+  - img
+- textbox "Message the agent"
+- button "Commands":
+  - img
+- 'button "Access mode, current: Workspace Write"': Workspace Write
+- button "Select model, current DeepSeek-V4-Flash":
+  - text: DeepSeek-V4-Flash
+  - img
+- button "Stop generating"

apps/web/tests/snapshots/steer-all/replay.override.json

@@ -0,0 +1,47 @@
+[
+  {
+    "kind": "chunks",
+    "chunks": [
+      { "type": "block-start", "index": 0, "blockType": "reasoning" },
+      { "type": "reasoning-delta", "index": 0, "text": "The user wants me to ask them a checkpoint question first, then continue with whatever they interject. Let me do exactly that." },
+      { "type": "block-start", "index": 1, "blockType": "tool-call" },
+      {
+        "type": "tool-call-delta",
+        "index": 1,
+        "id": "call_00_steer_all",
+        "name": "ask_user_question",
+        "argumentsDelta": "{\"questions\": [{\"id\": \"checkpoint\", \"question\": \"Ready to continue?\", \"header\": \"Checkpoint\", \"options\": [{\"label\": \"Yes\"}, {\"label\": \"No\"}]}]}"
+      },
+      {
+        "type": "block-end",
+        "index": 0,
+        "block": {
+          "type": "reasoning",
+          "text": "The user wants me to ask them a checkpoint question first, then continue with whatever they interject. Let me do exactly that."
+        }
+      },
+      {
+        "type": "block-end",
+        "index": 1,
+        "block": {
+          "type": "tool-call",
+          "id": "call_00_steer_all",
+          "name": "ask_user_question",
+          "arguments": "{\"questions\": [{\"id\": \"checkpoint\", \"question\": \"Ready to continue?\", \"header\": \"Checkpoint\", \"options\": [{\"label\": \"Yes\"}, {\"label\": \"No\"}]}]}"
+        }
+      },
+      { "type": "usage", "usage": { "inputTokens": 10, "outputTokens": 10, "cacheReadTokens": 0, "reasoningTokens": 0 } },
+      { "type": "finish", "reason": { "kind": "tool-calls" } }
+    ]
+  },
+  {
+    "kind": "chunks",
+    "chunks": [
+      { "type": "block-start", "index": 0, "blockType": "text" },
+      { "type": "text-delta", "index": 0, "text": "Got it: BANANA and ORANGE." },
+      { "type": "block-end", "index": 0, "block": { "type": "text", "text": "Got it: BANANA and ORANGE." } },
+      { "type": "usage", "usage": { "inputTokens": 10, "outputTokens": 10, "cacheReadTokens": 0, "reasoningTokens": 0 } },
+      { "type": "finish", "reason": { "kind": "stop" } }
+    ]
+  }
+]

apps/web/tests/snapshots/steer-all/settled.expected.md

@@ -0,0 +1,45 @@
+- banner:
+  - navigation "Session hierarchy":
+    - button "Use the ask_user_question tool to" [disabled]
+  - img
+  - text: 标准模式
+  - tablist:
+    - tab "Chat" [selected]
+    - tab "Trajectory"
+- text: Use the ask_user_question tool to ask me exactly one question with id "checkpoint", question "Ready to continue?", header "Checkpoint", and options labeled "Yes" and "No". After I answer, reply with one short sentence acknowledging my answer and stop. {{clock}}
+- button "Copy":
+  - img
+- button "Context injection @deepseek-ai/dsh-system-prompt":
+  - img
+  - img
+  - text: Context injection @deepseek-ai/dsh-system-prompt
+- button "Think The user wants me to ask them a checkpoint question first, then continue with whatever they interject. Let me do exactly that.":
+  - img
+  - img
+  - text: Think The user wants me to ask them a checkpoint question first, then continue with whatever they interject. Let me do exactly that.
+- button "Ask question 1/1 answered":
+  - img
+  - img
+  - text: Ask question 1/1 answered
+- text: "Interjection Interjection: include the word BANANA in your final reply. {{clock}}"
+- button "Copy":
+  - img
+- text: "Interjection Interjection: include the word ORANGE in your final reply. {{clock}}"
+- button "Copy":
+  - img
+- paragraph: "Got it: BANANA and ORANGE."
+- button "Copy":
+  - img
+- button "Branch into a new conversation":
+  - img
+- text: {{clock}} Ran for {{duration}} TTFT {{duration}} {{throughput}} tok/s
+- textbox "Message the agent"
+- button "Commands":
+  - img
+- 'button "Access mode, current: Workspace Write"': Workspace Write
+- button "Select model, current DeepSeek-V4-Flash":
+  - text: DeepSeek-V4-Flash
+  - img
+- button "0% of context used"
+- button "Send message" [disabled]
+- text: 1 turns · 2 steps LLM {{duration}} · Tool call {{duration}} TTFT avg {{duration}} · {{throughput}} tok/s Cache hit 0% Input 20 tok · Output 20 tok

apps/web/tests/steering.e2e.ts

@@ -34,6 +34,18 @@ const REPLAY_PACE_MS = 100
 const PROMPT = 'Use the ask_user_question tool to ask me exactly one question with id "checkpoint", question "Ready to continue?", header "Checkpoint", and options labeled "Yes" and "No". After I answer, reply with one short sentence acknowledging my answer and stop.'
 const STEER = 'Interjection: include the word BANANA in your final reply.'
 
+// Empty-draft flush scenario: an override-only fixture. The whole-script
+// replacement answers both model calls of a FRESH session (no recorded
+// session.jsonl exists — call 0 keeps the turn open with a question-tool
+// call, call 1 is the reply after both steerings drain).
+const STEER_ALL_DIR = fileURLToPath(new URL('./snapshots/steer-all', import.meta.url))
+const STEER_ALL_FIXTURE = join(STEER_ALL_DIR, 'session.jsonl')
+const STEER_ALL_OVERRIDE = join(STEER_ALL_DIR, 'replay.override.json')
+const STEER_ALL_MID = join(STEER_ALL_DIR, 'mid-steer.expected.md')
+const STEER_ALL_SETTLED = join(STEER_ALL_DIR, 'settled.expected.md')
+const STEER_ONE = 'Interjection: include the word BANANA in your final reply.'
+const STEER_TWO = 'Interjection: include the word ORANGE in your final reply.'
+
 /** Concatenated assistant text deltas — the model-visible reply body. */
 function assistantText(events: SessionEvent[]): string {
   return events
@@ -278,3 +290,103 @@ describe('web e2e: composer shortcut follows the swapped busy behavior', () => {
     expect(tripwire.warnings).toEqual([])
   }, 90_000)
 })
+
+describe('web e2e: empty-draft Cmd+Enter steers the whole queue', () => {
+  let scaffold: WebScaffold
+  let browser: Browser
+  let page: Page
+  let tripwire: ReturnType<typeof watchConsole>
+  const sessionEvents: SessionEvent[] = []
+
+  beforeAll(async () => {
+    // The scenario boots a fresh session against the override-only fixture;
+    // the replay.override.json sidecar replaces the derived script, so the
+    // (deliberately absent) session.jsonl is never read.
+    scaffold = await launchWebScaffold({
+      replayFixture: STEER_ALL_FIXTURE,
+      replayOverride: STEER_ALL_OVERRIDE,
+      paceMs: REPLAY_PACE_MS,
+    })
+    scaffold.ctx.on('session/event', (_session, event) => { sessionEvents.push(event) })
+    browser = await chromium.launch()
+    page = await newEnglishPage(browser)
+    tripwire = watchConsole(page)
+    await page.goto(scaffold.baseUrl, { waitUntil: 'load' })
+    await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
+    await connectFreshWorkspace(page, scaffold.workspaceCwd)
+    await page.getByText('标准模式', { exact: true }).waitFor({ timeout: 10_000 })
+  }, 120_000)
+
+  afterAll(async () => {
+    await browser?.close()
+    await scaffold?.close()
+  })
+
+  it.skipIf(MODE === 'record')('queues two messages, then flushes both with an empty-draft Cmd+Enter', async () => {
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-steer-all'))
+    const input = page.locator('textarea').first()
+    await input.waitFor({ timeout: 10_000 })
+    const settled = scaffold.whenTurnSettled(30_000)
+
+    // Call 0 streams a question-tool call; the fills must land inside the
+    // first replay window, before the question composer replaces the textarea.
+    await input.fill(PROMPT)
+    await input.press('Enter')
+    await input.fill(STEER_ONE)
+    await input.press('Enter')
+    await input.fill(STEER_TWO)
+    await input.press('Enter')
+    const dock = page.locator('[data-queue-dock]')
+    // Both messages queued: the two-row dock shows a collapsed count header,
+    // and Playwright text matching skips the hidden rows — expand the list,
+    // then assert each row's content.
+    await dock.getByText('2 queued messages').waitFor({ timeout: 10_000 })
+    await dock.getByRole('button').click()
+    await dock.getByText(STEER_ONE, { exact: true }).waitFor({ timeout: 10_000 })
+    await dock.getByText(STEER_TWO, { exact: true }).waitFor({ timeout: 10_000 })
+    expect(await page.locator('[data-pending-steering]').count()).toBe(0)
+
+    // Empty draft + Cmd+Enter: both queued rows steer in FIFO order, the dock
+    // empties, and the pending steering renders at the conversation tail.
+    await input.press('Meta+Enter')
+    await expect.poll(
+      () => page.locator('[data-pending-steering]').filter({ hasText: /BANANA|ORANGE/ }).count(),
+      { timeout: 10_000 },
+    ).toBe(2)
+    expect(await page.locator('[data-queue-dock]').count()).toBe(0)
+    // The reasoning row streams independently of the steering handoff; wait
+    // for it so the mid snapshot pins the assistant step, not the pre-render
+    // gap a fast machine can catch between steering acceptance and the block.
+    await page.locator('[data-variant="think"]').first().waitFor({ timeout: 10_000 })
+    const mid = await captureStableAria(page, '[class*="centerCol"]', scaffold.workspaceCwd)
+    await compareOrRefreshGolden(STEER_ALL_MID, mid, MODE)
+
+    // Answer the question; the step closes, the loop drains both steerings
+    // into one next-step request, and the final reply obeys both markers.
+    const composer = page.locator('[data-question-key]')
+    await composer.waitFor({ timeout: 30_000 })
+    await composer.getByRole('radio', { name: 'Yes' }).click()
+    await composer.getByRole('radio', { name: 'Yes' }).press('Enter')
+    await settled
+
+    const first = claimedMessages(sessionEvents, STEER_ONE)
+    const second = claimedMessages(sessionEvents, STEER_TWO)
+    expect(first).toHaveLength(1)
+    expect(second).toHaveLength(1)
+    expect(assistantText(sessionEvents)).toContain('BANANA')
+    expect(assistantText(sessionEvents)).toContain('ORANGE')
+    await expect.poll(() => page.getByText(STEER_ONE, { exact: true }).count(), { timeout: 15_000 }).toBe(1)
+    await expect.poll(() => page.getByText(STEER_TWO, { exact: true }).count(), { timeout: 15_000 }).toBe(1)
+    expect(await page.locator('[data-pending-steering]').count()).toBe(0)
+    const snapshot = await captureStableAria(page, '[class*="centerCol"]', scaffold.workspaceCwd)
+    await compareOrRefreshGolden(STEER_ALL_SETTLED, snapshot, MODE)
+    expect(tripwire.pageErrors).toEqual([])
+    expect(tripwire.warnings).toEqual([])
+  }, 200_000)
+
+  it.skipIf(MODE === 'record')('keeps the fixture inventory closed', async () => {
+    await assertFixtureInventory(STEER_ALL_DIR, [
+      'replay.override.json', 'mid-steer.expected.md', 'settled.expected.md',
+    ])
+  })
+})