fix(shell): use PowerShell EncodedCommand for reliable UTF-8 output on Windows

On Windows, PowerShell commands were passed via -Command flag, causing
encoding corruption when the active console code page is not UTF-8
(e.g. GBK/CP936 on zh-CN systems, Shift-JIS/CP932 on ja-JP systems).
The UTF-8 preamble added by previous attempts runs too late because
-Command parses the string in the current code page before execution.

This change switches to -EncodedCommand with Base64(UTF-16LE) encoding,
which guarantees the command string survives transport intact regardless
of the console code page. The original command is base64-encoded (UTF-8)
and embedded in the payload, then decoded at runtime via
[scriptblock]::Create() after the UTF-8 preamble has already taken
effect. This avoids prepending statements before the user command,
which would break param() blocks and #requires directives.

The encoding logic is extracted into a shared module
(core/shell/powershell.ts) used by all three PowerShell execution paths:
- packages/core/src/tool/bash.ts (core bash tool)
- packages/opencode/src/tool/shell.ts (opencode shell tool)
- packages/opencode/src/shell/shell.ts (TUI direct shell mode)

Closes #23636
Closes #31187
Closes #30205
Closes #31830
Closes #26882

Co-Authored-By: Claude <noreply@anthropic.com>

Author: senguangd

packages/core/src/shell/powershell.ts

@@ -0,0 +1,18 @@
+export * as PowerShell from "./powershell"
+
+export function args(command: string) {
+  return ["-NoLogo", "-NoProfile", "-NonInteractive", "-EncodedCommand", encoded(command)]
+}
+
+function encoded(command: string) {
+  const payload = Buffer.from(command, "utf8").toString("base64")
+  return Buffer.from(
+    `
+[Console]::InputEncoding = [System.Text.UTF8Encoding]::new($false);
+[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false);
+$OutputEncoding = [Console]::OutputEncoding;
+& ([scriptblock]::Create([System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String('${payload}'))))
+`,
+    "utf16le",
+  ).toString("base64")
+}

packages/core/src/tool/bash.ts

@@ -10,6 +10,7 @@ import { LocationMutation } from "../location-mutation"
 import { AppProcess } from "../process"
 import { PermissionV2 } from "../permission"
 import { PositiveInt } from "../schema"
+import { PowerShell } from "../shell/powershell"
 import { Tool } from "./tool"
 import { Tools } from "./tools"
 
@@ -49,6 +50,31 @@ const Output = Schema.Struct({
 type Output = typeof Output.Type
 
 const defaultShell = () => (process.platform === "win32" ? (process.env.COMSPEC ?? "cmd.exe") : "/bin/sh")
+const POWERSHELL_SHELLS = new Set(["powershell", "powershell.exe", "pwsh", "pwsh.exe"])
+
+const isPowerShell = (shell: string) => {
+  const name = path.basename(shell.trim().replace(/^["']|["']$/g, "")).toLowerCase()
+  return POWERSHELL_SHELLS.has(name)
+}
+
+function makeShellCommand(command: string, shell: string, cwd: string) {
+  if (process.platform === "win32" && isPowerShell(shell)) {
+    return ChildProcess.make(shell, PowerShell.args(command), {
+      cwd,
+      stdin: "ignore",
+      detached: false,
+      forceKillAfter: Duration.seconds(3),
+    })
+  }
+
+  return ChildProcess.make(command, [], {
+    cwd,
+    shell,
+    stdin: "ignore",
+    detached: process.platform !== "win32",
+    forceKillAfter: Duration.seconds(3),
+  })
+}
 
 const compactOutput = (stdout: string, stderr: string) => {
   const output = stdout && stderr ? `${stdout}\n\nstderr:\n${stderr}` : stderr ? `stderr:\n${stderr}` : stdout
@@ -156,13 +182,7 @@ export const layer = Layer.effectDiscard(
               const shell =
                 Object.assign({}, ...entries.flatMap((entry) => (entry.type === "document" ? [entry.info] : [])))
                   .shell ?? defaultShell()
-              const command = ChildProcess.make(input.command, [], {
-                cwd: target.canonical,
-                shell,
-                stdin: "ignore",
-                detached: process.platform !== "win32",
-                forceKillAfter: Duration.seconds(3),
-              })
+              const command = makeShellCommand(input.command, shell, target.canonical)
               const timeout = input.timeout ?? DEFAULT_TIMEOUT_MS
               const result = yield* appProcess
                 .run(command, {

packages/opencode/src/shell/shell.ts

@@ -1,4 +1,5 @@
 import { Flag } from "@opencode-ai/core/flag/flag"
+import { PowerShell } from "@opencode-ai/core/shell/powershell"
 import { lazy } from "@/util/lazy"
 import { Filesystem } from "@/util/filesystem"
 import { which } from "@opencode-ai/core/util/which"
@@ -188,7 +189,7 @@ export function args(file: string, command: string, cwd: string) {
     ]
   }
   if (n === "cmd") return ["/c", command]
-  if (ps(file)) return ["-NoProfile", "-Command", command]
+  if (ps(file)) return PowerShell.args(command)
   return ["-c", command]
 }
 

packages/opencode/src/tool/shell.ts

@@ -298,7 +298,7 @@ const ask = Effect.fn("ShellTool.ask")(function* (
 
 function cmd(shell: string, command: string, cwd: string, env: NodeJS.ProcessEnv) {
   if (process.platform === "win32" && Shell.ps(shell)) {
-    return ChildProcess.make(shell, ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", command], {
+    return ChildProcess.make(shell, Shell.args(shell, command, cwd), {
       cwd,
       env,
       stdin: "ignore",