terminal-bash: persistent shell stalls for the full 300 s timeout on CJK input (C-locale readline reads UTF-8 bytes as Meta bindings)

[jasonjason121231]

The persistent bash tool occasionally hangs for exactly the configured timeout (300 s with the shipped minimal preset) and then fails with Your command timed out after 300 seconds … The persistent bash shell was reset. The model and the shell are both healthy — the stall happens between them.

dsh-terminal-bash spawns /bin/bash --noprofile --norc -i with an environment built from scratch (childEnvironment()) that carries no LANG/LC_*. On macOS /bin/bash is 3.2.57, so the interactive shell enables readline in the C locale, and readline interprets high-bit input bytes as Meta (ESC-prefixed) key bindings. Specific CJK byte sequences in a command then trigger digit-argument/completion machinery, and bash ends up either waiting on Display all 127 possibilities? (y or n) or sitting at a PS2 continuation prompt with a mangled line. The prompt marker never returns, and the tool call burns the whole timeout before the shell is killed and reset.

Environment

• @deepseek-ai/dsh 0.1.0-rc.7 (global npm install), dsh web
• macOS 26.5.2 (25F84), arm64
• /bin/bash → GNU bash 3.2.57(1)-release
• node v24.16.0
• affected sessions ran the shipped minimal preset (persistent bash tool)

What it looks like in real sessions

Measured across 12 sessions / 744 bash tool calls in ~/.dsh/sessions:

• median bash call: 0.6 s; model time-to-first-token p50 1.3–5.2 s (not a model issue)
• 22 calls stalled 303.2–303.5 s and then failed with Your command timed out after 300 seconds … The persistent bash shell was reset (the 300 s is timeoutMs: 300000 on the preset's terminal-bash row)
• 21 of the 22 stalled commands contained CJK characters — but 417 other CJK-containing commands completed normally. Whether a given command stalls depends on which readline bindings its specific byte values land on, which is why it looks random.

Root cause

packages/terminal/terminal-bash (published lib/index.js in rc.7), childEnvironment():

function childEnvironment(spec) {
	return {
		TERM: "dumb",
		PAGER: "cat",
		GIT_PAGER: "cat",
		PS1: CONTROLLED_PROMPT,
		PROMPT_COMMAND: `printf "\\033]133;D;%s\\007" "$?"; PS1='${CONTROLLED_PROMPT}'`,
		BASH_SILENCE_DEPRECATION_WARNING: "1",
		DSH_SHELL: "1",
		DSH_SESSION_ID: spec.owner.id,
		DSH_PTY_SESSION_ID: spec.sessionId
	};
}

No LANG/LC_* is set, so the PTY bash runs in the C locale. Combined with the default argv:

shellPath: z.string().default("/bin/bash"),
shellArgs: z.array(z.string()).default(["--noprofile", "--norc", "-i"]),

the interactive bash turns readline on, and in the C locale readline maps high-bit bytes to Meta bindings. The stall is input-dependent: echo "=== 相关进程 ===" reliably wedges the shell.

Notes on scope:

• The non-persistent path is immune: bash -c '<cmd>' is non-interactive (no readline), so the same command always works there. The same command in Terminal.app also works, because a normal terminal inherits a UTF-8 LANG.
• The mechanism (C-locale readline mapping high-bit bytes to Meta bindings) is not bash-3.2-specific; any host where the child ends up without a UTF-8 locale is likely affected. I have only verified macOS.

Reproduction

Self-contained script using the same node-pty the harness ships, dsh's exact argv + env contract, one CJK command (adjust the install path, or npm i node-pty in a scratch dir):

// repro.mjs — node repro.mjs
import { createRequire } from "node:module";
const require = createRequire(import.meta.url);
const pty = require("/Users/lailai/.npm-global/lib/node_modules/@deepseek-ai/dsh/node_modules/node-pty"); // adjust

const PROMPT = "dsh> ";
const env = { // exact childEnvironment() contract — note: no LANG / LC_*
  TERM: "dumb", PAGER: "cat", GIT_PAGER: "cat",
  PS1: PROMPT,
  PROMPT_COMMAND: `printf "\\033]133;D;%s\\007" "$?"; PS1='${PROMPT}'`,
  BASH_SILENCE_DEPRECATION_WARNING: "1", DSH_SHELL: "1",
  PATH: process.env.PATH,
};
const term = pty.spawn("/bin/bash", ["--noprofile", "--norc", "-i"], {
  name: "dumb", cols: 160, rows: 40, cwd: "/tmp", env,
});
let out = "";
term.onData((c) => (out += c));
const wait = (ms) => new Promise((r) => setTimeout(r, ms));
await wait(500);                        // first prompt
out = "";
term.write('echo "=== 相关进程 ==="\r'); // the command that wedges the shell
await wait(5000);
console.log(`bytes: ${Buffer.byteLength(out)}`);
console.log(out);
term.kill();

Results on my machine (A = as shipped; B/C = the two one-line fixes):

A  default argv, dsh env (no LANG)   -> NO PROMPT after 5013ms, 3339 bytes emitted
    output tail:
      | dsh-restart.out    hb_repro3.py    smoke.log
      | dsh-restart.sh     hb_repro4.py    sse_test.log
      | dsh> echo === ==="
      | >
B  default argv, + LANG=en_US.UTF-8  -> completed in 26ms, 66 bytes
C  + --noediting, dsh env (no LANG)  -> completed in 25ms, 66 bytes

(A's tail shows this run landing on a completion listing plus a mangled line left at the PS2 > continuation prompt. Other runs of the same command land on Display all 127 possibilities? (y or n) instead. Either way the prompt marker never returns and the shell sits until the tool timeout kills it.)

Suggested fixes (both validated: 5/5 CJK commands, ~25 ms each)

1. Give the child a UTF-8 locale in childEnvironment() — e.g. LANG: process.env.LANG ?? "en_US.UTF-8". Explicit defaulting is the robust form: on macOS a GUI-launched process typically has no LANG to inherit in the first place.
2. And/or ship --noediting in the default shellArgs. The persistent shell is driven programmatically, so readline line editing is never used, and disabling it removes the entire class of Meta-binding stalls. The OSC 133;D + PS1 prompt-detection contract is unaffected (verified with the exact env above).
3. Optionally add an env field to the plugin's Config schema, so users can inject locale variables without a shellPath wrapper script.

Workaround for users today

Patch the terminal-bash row in the agent preset composition (e.g. config/agent-presets/minimal/agent.cordis.yml, or a user preset under ~/.dsh/.agent-presets/). Preset composition files are picked up by newly created sessions without a restart:

- id: terminal-bash
  name: '@deepseek-ai/dsh-terminal-bash'
  config:
    timeoutMs: 300000
    shellArgs: [--noprofile, --norc, --noediting, -i]

Note: a terminal-bash: section in ~/.dsh/settings.yaml has no effect — this plugin registers no settings namespace, so its config can only come from the loader entry (the preset composition row).

[denial123789]

Thank you for the unusually strong A/B reproduction. It changes the diagnosis materially: a completion listing, mangled command, or PS2 prompt supports a C-locale readline Meta-binding trap, while the earlier visible character-replacement report must remain a separate PTY transport branch.

We corrected the community runbook against rc.8 and preserved both mechanisms instead of collapsing them into a generic Unicode timeout. It now includes the exact --noediting preset workaround, a four-way evidence matrix, the settings-namespace caveat, and regression gates:

https://sandbaseai.github.io/deepseek-harness-handbook/macos-bash-nonascii.html

The source-backed canonical version is here:
https://github.com/sandbaseai/deepseek-harness-handbook/blob/main/docs/en/troubleshooting/macos-bash-nonascii-pty.md

The report remains the primary evidence and is linked directly. Results from Linux or a current Bash with an empty locale would help narrow the platform boundary further.