Merge commit '851f05c4f8ae58415224ce1b562962b0c39621ac' into codex/product-subagent-presets

# Conflicts:
#	packages/bundle/base/tests/base.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}. */
@@ -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([])
+  })
+})