feat(bundle): default Windows hosts to the pwsh shell stack

win32 hosts booting a shipped profile now get pwsh-local as the ctx.bash
executor and tool-pwsh as the shell tool through the base bundle's new
windows.cordis.patch.yml platform layer, injected by the launcher between
the bundle layers and the user layers on win32. bash-sandbox, tool-bash,
permission, and ui-permission are disabled there: the POSIX-only executor
cannot run on Windows, and dsh-permission requires a confining executor.
Overriding the default is a composition decision through the user's
cordis.patch.yml; there is no environment override channel.

apps/cli and dsh-base re-declare dsh-pwsh-local/dsh-tool-pwsh so the
profile module fallback links them for cold starts (the profiles rework
had dropped them from the CLI closure).

Promotes the windows-pwsh-default Agent Note from proposed to implemented
and documents the platform layer in the base bundle README.

apps/cli/package.json

@@ -24,11 +24,13 @@
     "@deepseek-ai/dsh-paths": "workspace:^",
     "@deepseek-ai/dsh-pty": "workspace:^",
     "@deepseek-ai/dsh-pty-local": "workspace:^",
+    "@deepseek-ai/dsh-pwsh-local": "workspace:^",
     "@deepseek-ai/dsh-session-reference": "workspace:^",
     "@deepseek-ai/dsh-tmux-context": "workspace:^",
     "@deepseek-ai/dsh-tool-ask-user": "workspace:^",
     "@deepseek-ai/dsh-tool-bash-persistent": "workspace:^",
     "@deepseek-ai/dsh-tool-cordis": "workspace:^",
+    "@deepseek-ai/dsh-tool-pwsh": "workspace:^",
     "@deepseek-ai/dsh-web-app": "workspace:^",
     "commander": "^15.0.0",
     "cordis": "^4.0.0-rc.7",

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

@@ -27,6 +27,7 @@ import {
 import { resolveDshHome } from '@deepseek-ai/dsh-paths'
 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'
 
@@ -103,6 +104,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. */
@@ -117,16 +120,23 @@ 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_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
- * switch.
+ * `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 switch.
  * @param name - the profile name.
  * @param patchFiles - `--patch` overlay paths, in argv order.
  * @param deriveFlagPatches - launcher hook turning composed rows into flag patches.
@@ -141,14 +151,15 @@ 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)]
   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}. */
@@ -215,6 +226,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,55 @@
+/**
+ * The Windows shell platform layer: on win32 hosts the shipped profile
+ * compositions swap the POSIX-only bash stack for the PowerShell stack
+ * (`@deepseek-ai/dsh-pwsh-local` + `@deepseek-ai/dsh-tool-pwsh`), matching
+ * the Windows-pwsh-default roadmap. 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 { existsSync } from 'node:fs'
+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 that ships no Windows shell patch fails loud — 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)
+  if (!existsSync(label)) {
+    throw new Error(`${binName}: ${BASE_BUNDLE} ships no ${WINDOWS_SHELL_PATCH_FILENAME}`)
+  }
+  return { label, patches: loadOverlayPatches(binName, label) }
+}

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

@@ -0,0 +1,64 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import type { ProfileLayer } 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-local
+      name: '@deepseek-ai/dsh-pwsh-local'
+`
+
+/** 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-local', name: '@deepseek-ai/dsh-pwsh-local' }] },
+    ])
+  })
+
+  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 })
+    expect(() => resolveWindowsShellLayer('win32', [fakeLayer(BASE_BUNDLE, base)], 'dsh'))
+      .toThrow(/@deepseek-ai\/dsh-base ships no windows\.cordis\.patch\.yml/)
+  })
+})