dsh-gitbash-shell 0.26.0 → 0.27.0

package/CHANGELOG.md

@@ -3,6 +3,66 @@
 > 倒序排列,新版本条目在最上面。条目格式:`## vX.Y.Z — YYYY-MM-DD` + 类型(feat / fix / docs / chore)+ 要点 + 相关链接。
 > 纪律见 AGENTS.md「变更记录纪律」:发版前先更新本文件并随版本提交;事故复盘、复现与真机验证记录也记在这里。
 
+## v0.27.0 — 2026-09-25
+
+**类型**:feat(新设置「子代理/队员是否也使用 Git Bash」,默认开启 —— 用户 2026-09-25 追加需求)
+
+### 需求与语义
+用户原话:「gitbash 插件也是专门给个设置是否让子代理或者子队员使用 gitbash,默认启动。」
+
+- **开关 `subagentDialect`(本插件行 Config 的 volatile 布尔,**默认 `true`**;旧宿主 ≤0.1.6 在 settings 命名空间 `gitbash-shell` 声明同名字段,**缺键 = true**)。
+- **开(默认)**:委托代理 —— 子代理(`subagent`/`subagent_fork`)、团队队员(`spawn_teammate` 走 continuable-subagent 的 `spawn`/`fork`)、**嵌套子代理** —— 与主代理享受同一条方言链路。
+- **关**:方言只对主代理生效,委托出去的请求回退官方 shell 语义(提示词不改写、路径参数不翻译、结果/报错不回显为 MSYS、`run_code` 程序字面量不翻译、不下发 `DSH_PATH_DIALECT`)。
+
+### 委托身份的判据(先查清链路,再动代码)
+- 用**会话头**判定:`origin === 'subagent' || delegationDepth > 0` —— 与 dsh 自己的 `packages/deliverables/workspace-changes/src/index.ts:59-60` 同一对字段;由子代理驱动在 `packages/subagent/subagent/src/child-agent.ts:139-155` (`childSessionMeta`) 打上,`spawn`/`fork` 两种 provider 与嵌套深度都走它。
+- 纯函数 `isDelegatedAgent(agent)` + 唯一判定点 `dialectApplies(dialect, agent)`;条件挂在 `assembleContext.agent`(`packages/core/agent/src/dispatch.ts:174` 的 `assembleContextFor` 传 `{ agent, scope }`)与 `exec.agent` / `execution.agent` 上。
+- **未知形状一律视为"非委托"**(保留方言):判定不出来时按主代理处理。
+
+### 覆盖到的五个消费点(全部接同一个 gate,避免"半方言")
+① `system-prompt/assemble` 的源头改写与 run_code 句;② 指令 context 的 `text(context)` provider;③ `tools/execute` 的入参翻译 + 成功面回显;④ `tools/post-execute` 的失败面 `content`/`error.message`;⑤ `shellEnv.resolve(execution)` 的 `DSH_PATH_DIALECT` 事实。
+
+### 能力边界(如实写明,写进 README/AGENTS)
+dsh **每个进程只有一个 shell 执行器**(`ctx.shell` 是单例服务),所以 **Git Bash 二进制本身仍是全局的**,本开关管的是**方言/翻译层**;关闭后委托代理见到与写出的是 Windows 形式路径,而 Git Bash 同样接受 `C:/...`,行为自洽。
+
+### 测试与证据
+- 冒烟 **86/86 绿**:新增 3 条(① `isDelegatedAgent`/`dialectApplies` 矩阵:origin、depth 1/2、root、未知/抛错/`agent` 缺失,以及卡片写入断言;② OFF 时主代理保留、委托代理被挡 + 五个消费点都接 gate 的源码断言;③ 旧宿主/老配置**缺键 = true** 的回退);`tests/align-official.mjs` 四变体仍全绿(本版不动组合)。
+- **真机两态(隔离 `DSH_HOME` + 新建 profile + 插件副本 `link:` 安装,真实 dsh 0.1.7-rc.2,本机 macOS)**:探针用 `ctx.agents.create()` 造**真**的 root / child(`origin:'subagent', delegationDepth:1`)/ nested(depth 2)三个 agent(实测会话头 `undefined` / `"subagent":1` / `"subagent":2`),再对每个 agent 调**真的** `ctx.systemPrompt.assemble({ agent, scope: agent })`:
+
+  | 开关 | main(root) | subagent | nested |
+  | --- | --- | --- | --- |
+  | **默认 ON** | 方言指令 = yes | **yes** | **yes** |
+  | **OFF**(行 Config `subagentDialect: false`) | yes | **no** | **no** |
+
+  ⇒ 两态下委托代理的方言确实不同(指令 context 出现/消失即 gate 的可观测面),主代理两态都保留。
+  **平台说明**:macOS 上方言/执行器面本来被 `process.platform === 'win32'` 门控,本次把**插件副本**的两处组装门(`system-prompt/assemble` 与指令 context)强制打开以取得请求级证据(报告中如实标注);**win32 真机仍未覆盖**(执行器是单例,与方言开关无关,不受本版影响)。
+- 设置卡:方言区新增一行(21 语言 `sub.label`/`sub.hint`),写入本行 `subagentDialect`;文案明确"二进制仍全局、此开关管方言/翻译层"。
+
+- 相关:用户需求(2026-09-25 追加);实现不变量见 AGENTS.md §4g,验证装置见「验证清单」第 8 条。
+
+## v0.26.1 — 2026-09-25
+
+**类型**:fix(v0.26.0 的 workflow 互斥按「意图」而非「生效态」收敛:后端不可用时用户会白丢 workflow 能力)
+
+> v0.26.0 把互斥条件写成「对方能力报 `pythonRuntime: true`」——那是**用户意图**。当对方的 preflight 失败(包被移除、解释器不合格、Windows),`!!js` 兜底与组合实际仍跑 Node,而本插件却已经把四个变体的 `workflow-ptc`/`tool-workflow` 关掉了:用户白丢一项能力,且卡片显示"已开启"与实际不符。dsh-ptc-cordis-preset **v0.15.1** 在能力服务上加了**加法字段** `pythonBackend: 'python' | 'node'`(用与 `!!js` 完全相同的合取计算),本版据此收敛。
+
+- **① 互斥只在真正生效时发生**:新增纯函数 `pythonBackendActive(capability)` = 「意图 `pythonRuntime` 为真 **且** 生效态为 `'python'`」;`pluginsFor({ …, pythonActive })` 的形参由 `pythonRuntime` 改名 **`pythonActive`**,语义写明「run_code 实际会用的后端」——`workflowOn = kind !== 'ptc' && pythonActive !== true`。
+- **② 旧 peer 回退(兼容硬要求)**:`peerBackend()` 对缺字段 / 类型不符 / getter 抛错一律返回 `undefined`(绝不把"没报"读成 `'node'`),`pythonBackendActive` 此时**用意图顶替** ⇒ 对方 < 0.15.1 的行为与 v0.26.0 **完全一致**,不会因缺字段崩溃或改变既有联动。
+- **③ 日志把"真换了"与"想换但没生效"分开**:生效 → `peer reports the experimental CPython run_code backend: workflow rows go off in every variant`;意图 on 但未生效 → `peer has the CPython switch on but the effective backend is node|unreported (older peer: the intent stands in): workflow rows stay on (reason in the host log)`。
+- **④ 卡片显示真实状态(防御性实现,当前不可达)**:从**同一份 peer 快照**读可选的 `pythonBackend`;意图 on + 生效 `node` ⇒ 状态值显示「Python(实验性) · **后端不可用,当前仍为 Node(原因见宿主启动日志)**」并另起一行红字;新增第 7 个词典键 `python.degraded`(**21 门语言**同齐)。字段缺省(旧 peer)⇒ 卡片与 v0.26.0 **逐字节一致**(不显示降级态)。
+  - **可达性拆分(Lead 裁决 A,2026-09-25)**:**「意图 on + 生效 node」这个状态本身是可达的** —— ptc 侧不拒绝把意图落成 true(Lead 明确不授权任何"单方面回写用户 settings 表单值"的行为,即不做"点开关被拒绝")。**不可达的是本插件这行降级显示**:浏览器侧只能读 `configForms.get('ptc-cordis').getSnapshot().value`(该行 **Config / settings 表单**),而 `pythonBackend` 只挂在**能力服务**上(宿主侧,浏览器读不到),ptc v0.15.1 的 Config schema 里没有该字段。因此现状是:ptc 卡显示 on + 红字原因,**本插件卡只显示 on**(hint 已指向宿主日志)。
+  - **后续项(本轮不做,避免再开一轮发布)**:由对方用**加法只读字段**把 `pythonBackend`/`pythonIssue` **投影进行 Config 快照**(不动用户意图字段 `pythonRuntime`);那一刻本插件**无需改动**即自动亮起(读的就是同一个键)。已记入最终报告的「已知限制/后续项」。
+- **测试**:冒烟 **83/83 绿**(改写 2 条到 `pythonActive` 语义 + 新增 3 条:①生效态矩阵含旧 peer 回退与闭集校验 ②降级意图只上报不驱动 ③卡片降级态与 21 语言文案);`tests/align-official.mjs` 四个变体仍全绿(本版不动组合的官方行形态)。
+- **真机 A/B/C(隔离 `DSH_HOME` + 新建 profile + `link:` 安装 + 探针能力,dsh 0.1.7-rc.2,本机 macOS,端口 3262-3264,收尾已清理)**:探针分别报三种能力形态,读数(`readDocument()` 的 `disabled`)与日志三例全部符合预期:
+
+  | 探针能力 | 日志 | 四变体的 `workflow-ptc`/`tool-workflow` |
+  | --- | --- | --- |
+  | `{pythonRuntime:true, pythonBackend:'python'}` | `peer reports the experimental CPython run_code backend: workflow rows go off in every variant` + 四条 `retired … (peer CPython backend changed; rows are rebuilt)` | **`disabled: true`**(互斥生效) |
+  | `{pythonRuntime:true, pythonBackend:'node'}` | `peer has the CPython switch on but the effective backend is node: workflow rows stay on (reason in the host log)`(**无**重建日志,行未变) | **保持启用**(`standard/cordis-gitbash` 不丢 workflow;`code-gitbash` 本就关) |
+  | `{pythonRuntime:true}`(旧 peer,缺生效字段) | 与第一行相同(意图顶替) | `disabled: true` —— 与 v0.26.0 行为**逐字节一致** |
+
+- 协作边界:v0.15.1 的 `pythonBackend` 是**加法字段**,本插件零形状破坏;`pythonRuntime` 仍是两侧卡片读写的权威**意图**字段。发布后由 contract-rc2 在 task-10 复验两条通道一致性。
+
 ## v0.26.0 — 2026-09-25
 
 **类型**:feat(run_code 的实验性 Python 后端开关,与 dsh-ptc-cordis-preset 双向联动)+ fix(issue #10:JSON 转义的 Windows 路径多出前导斜杠)+ chore(dsh 0.1.7-rc.2 增量对齐复核)
@@ -39,6 +99,8 @@
   - **B(探针报 `pythonRuntime: true`)**:出现上面两行日志,四个变体**全部重建**,读数变为两行 `disabled: true`。
   - **两态都做真实挂载**:`agentPresets.acquireScope('<variant>')` 四个变体各返回 `MOUNT OK`(挂载审计无 failed 行),证明显式注册的组合在 rc.2 上确实可挂载,而不只是"注册成功"。
   - **Windows 专属面**:win32 分支(卡片禁用态、宿主拒绝写入、python 后端构造抛错)在 macOS 上**无法真机验证**,按实现 + 单测/模拟记录;本插件的执行器与路径方言层按 `process.platform === 'win32'` 门控,而 python 后端仅 POSIX,两者在各自平台上互不重叠。
+- **独立验证(发布后补记,2026-09-25,task-8,由另一位成员执行)**:用 **npm 已发布的 `dsh-gitbash-shell@0.26.0`** + `dsh-ptc-cordis-preset@0.15.0` 在隔离 `DSH_HOME` 上复验 —— **ptc → gitbash 方向联动通过**:把对方的行 Config `pythonRuntime` 置 `true` 后 boot,本插件打出 `peer reports the experimental CPython run_code backend: workflow rows go off in every variant` 以及四条 `retired … (peer CPython switch changed; rows are rebuilt)`;关态 boot **没有**这些行 ⇒ 能力感知 + 变体重建按设计工作(完整报告:`_rc2-contract/PYTHON-SWITCH-VERIFY.md`)。
+  - 仍未覆盖(留给集成阶段/真机):**反方向「在 gitbash 卡上改 → ptc 跟随」与两张卡的 UI 即时同步**(headless 无法操作设置卡,需真实 web 实例人工点选;两侧写的是同一个 `configForms` 字段,机制与 v0.25.0 已验证的 dedupe 镜像同构)以及 **win32 真机**(本机无 Windows;静态核对确认 ptc 侧平台表达式与 python 后端 `ptc-runtime-python/src/index.ts:837-839` 的「win32 构造即抛」一致,本插件侧按 `python.blocked` + 不画按钮实现平台限制)。
 - 相关:issue #10 https://github.com/KannaKuron/dsh-gitbash-shell/issues/10 ;对方仓库 dsh-ptc-cordis-preset v0.15.0(能力字段与运行行)
 
 ## v0.25.1 — 2026-09-24

package/README.md

@@ -101,6 +101,22 @@ dsh-ptc-cordis-preset 报告它的 `PTC 创造模式` 已经是 Git Bash 版。
 0.24.x 的四个变体逐字不变;判定细节、生效时机与两侧同步方式见下方
 [「与 dsh-ptc-cordis-preset 联动」](#与-dsh-ptc-cordis-preset-联动)。
 
+### 子代理/队员是否也用 Git Bash:`subagentDialect`(默认开,v0.27.0)
+
+```yaml
+- id: gitbash-shell
+  config:
+    subagentDialect: true   # 默认;false = 方言只对主代理生效
+```
+
+默认开启时,子代理、团队队员(含嵌套子代理)与主代理走**同一条**方言链路:提示词里的路径同样是 `/c/...` 形式、
+路径参数同样被翻译、结果与报错同样回显为 MSYS 形式、`run_code` 程序里的路径字面量同样被翻译,`DSH_PATH_DIALECT` 环境事实也照常下发。
+关闭后这些**只对主代理生效**:委托出去的请求保持官方 shell 语义(提示词不改写、路径参数原样传递),适合"子代理要跑原生 Windows 工具链"的场景。
+
+> 能力边界(如实说明):dsh **每个进程只有一个 shell 执行器**(`ctx.shell` 是单例服务),所以 Git Bash **二进制本身仍是全局的**,
+> 这个开关管的是**方言/翻译层**,不是"换一个 shell"。关闭后委托代理见到与写出的是 Windows 形式路径(`C:/...`),Git Bash 同样接受,行为自洽。
+> 委托身份的判据用会话头的 `origin === 'subagent'` / `delegationDepth > 0`(与 dsh 自身一致),判定不出来时按主代理处理(保留方言)。
+
 配合 `agent-presets` 的 `default`,新会话直接落在 Git Bash 模式,免去每次在
 模式选择器里翻找(原版 shipped 模式无法替换或隐藏——部署级、只读):
 
@@ -204,6 +220,13 @@ Config 的布尔字段 `pythonRuntime`(默认 `false`),由它在 profile 组合
   `language`/`executionInstructions` 决定,组合文本不变)。
 - **生效时机**:**重启 dsh 之后生效**(后端行的替换在 profile 组合期求值);设置卡上的状态
   两侧即时同步,只有后端切换需要重启。若开启后没有生效,原因见 dsh 启动日志。
+- **"想开"与"真的开了"是两件事**:后端不可用(包被移除 / 解释器低于 3.10 / Windows)时,开关的
+  意图仍可为"开",但组合**照旧跑 Node** —— 此时 **workflow 侧不再被连带禁用**(v0.26.1:互斥只看
+  实际生效的后端;v0.26.0 只看意图,会让用户白丢 workflow 能力),**原因见 dsh 启动日志**。
+  > 关于卡片上的"后端不可用,当前仍为 Node"这行提示:本插件已实现该降级文案(21 语言),但它要等
+  > **对方把生效态投影进行 Config 快照**后才会亮起 —— 浏览器只读得到那份快照,而生效态目前只在
+  > 宿主侧的能力服务里(见 AGENTS.md §4f)。在此之前:对方卡片显示"已开启 + 原因",本插件卡片
+  > 显示"已开启"(hint 指向宿主日志)。
 - **平台**:该后端**仅支持 POSIX**——它在 Windows 上构造即抛错,所以 Windows 上开关显示为
   禁用并注明原因,宿主侧也会拒绝写入。
 - **与 workflow 互斥**:`workflow-ptc` 硬要求 TypeScript 后端(`ctx.ptcRuntime.language ===

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-external/dsh-gitbash-shell",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "main": "./src/index.js",
   "description": "Windows 全模式 Git Bash:用 Git for Windows bash 替换 PowerShell 执行器,并物化 standard/minimal/code/cordis 的 Git Bash 变体 preset。双 era 适配 dsh <= 0.1.1(内置 id 'code')与 >= 0.1.2(改名 'ptc'),启动探测自动选择,preset id 永不变。联动:dsh-ptc-cordis-preset(两者同装时 PTC 创造模式自动物化为 Git Bash 版)+ dsh-better-sidebar(终端 UI 标签与模型 terminal_* 工具自动切到 Git Bash)。",
   "engines": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-gitbash-shell",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "Windows 上让 agent 的每条 shell 命令改经 Git for Windows bash 执行;物化四个内置预设的 Git Bash 变体,统一 MSYS 盘根路径方言,侧栏终端接管可开关。· Run every agent shell command through Git for Windows bash on Windows; materialize Git Bash variants of the built-in presets, unify the MSYS drive-root path dialect, and adopt the sidebar terminal behind a switch.",
   "type": "module",
   "repository": {

package/src/client.js

@@ -55,6 +55,11 @@ window.__ModuleLoader__.load({
 		   both cards read and write this one form field, so either side changes
 		   both. Absent on a peer that predates the switch ⇒ no row is drawn. */
 		var PEER_PYTHON_FIELD = "pythonRuntime";
+		/** The peer's EFFECTIVE backend on the same snapshot ('python' | 'node'),
+		   when its version reports one: 'node' while the intent is on means the
+		   preflight failed (package missing / interpreter too old / Windows), so
+		   the card shows the degraded state instead of claiming Python. */
+		var PEER_PYTHON_BACKEND_FIELD = "pythonBackend";
 
 		// ── dictionaries ────────────────────────────────────────────────────────
 		// zh/en stay inline; the third languages live in LOCALES below, one entry
@@ -82,6 +87,8 @@ window.__ModuleLoader__.load({
 			"split.hint": "glob 的绝对 pattern(/c/.../*.md)自动拆为 path + 相对 pattern;关闭则原样传递。",
 			"code.label": "run_code 程序内路径",
 			"code.hint": "run_code 程序里写的 /c/... 等路径字面量在执行前按同一张挂载表翻译;注释、插值模板、$VAR 与非路径字符串不动,扫描有任何不确定就整份不改。 并给程序补 TEMP/TMP:空 env 下 Windows 的 os.tmpdir() 会得到 undefined\\temp,程序会静默写错地方。",
+			"sub.label": "子代理/队员使用 Git Bash",
+			"sub.hint": "默认开启:子代理与团队队员(含嵌套子代理)的提示词方言、路径参数翻译、结果回显与 DSH_PATH_DIALECT 环境事实与主代理一致。关闭后这些只对主代理生效,子代理按官方 shell 语义运行(提示词不改写、路径参数不翻译);注意 dsh 每个进程只有一个 shell 执行器,所以 Git Bash 二进制本身仍是全局的,此开关管的是方言/翻译层。",
 			"eol.label": "Git 行尾(与 Linux 一致)",
 			"eol.hint": "模型跑的 git 命令按 Linux 行为:core.autocrlf=input、core.eol=lf。你自己终端的 git 与仓库里的 .gitattributes 都不受影响。",
 			"bash.label": "Git Bash 路径",
@@ -98,6 +105,7 @@ window.__ModuleLoader__.load({
 			"python.on": "Python(实验性)",
 			"python.off": "Node / TypeScript(默认)",
 			"python.hint": "默认关闭时 run_code 用官方 Node/TypeScript 后端,与官方 ptc 组合逐字节一致;开启后改用 dsh 实验性 CPython 后端(@deepseek-ai/dsh-experimental-ptc-runtime-python),run_code 的语言、生成的 SDK 提示词与工具呈现随之切到 Python。要求 POSIX 平台与 CPython ≥ 3.10(Windows 不可用);与 workflow 工具互斥——官方 Python 组合同样禁用 workflow,因此开启期间本插件四个变体的 workflow 侧强制关闭(你的工作流设置值保留,关掉后恢复)。改动需重启 dsh 后生效;此开关就是 dsh-ptc-cordis-preset 设置卡上的同一个开关——两侧共享同一份状态,任一侧改动两侧同步。仅在已安装 dsh-ptc-cordis-preset 时显示。若置为开启后未生效,原因见宿主启动日志。",
+			"python.degraded": "后端不可用,当前仍为 Node(原因见宿主启动日志)",
 			"python.blocked": "本机是 Windows:实验性 Python 后端仅支持 POSIX,此开关不可用。",
 		};
 
@@ -121,6 +129,8 @@ window.__ModuleLoader__.load({
 			"split.hint": "An absolute glob pattern (/c/.../*.md) splits into path + relative pattern; off passes it through verbatim.",
 			"code.label": "run_code program paths",
 			"code.hint": "Path literals inside a run_code program are translated through the same mount table before it runs; comments, interpolated templates, $VARs and non-path strings stay untouched, and any uncertainty leaves the whole program as written. It also seeds TEMP/TMP for the program: with an empty env Windows' os.tmpdir() returns undefined\\temp and writes land in a bogus folder.",
+			"sub.label": "Subagents/teammates use Git Bash",
+			"sub.hint": "On (default): subagents and team members — nested ones included — get the same prompt dialect, path-argument translation, result echo and DSH_PATH_DIALECT fact as the main agent. Off: those apply to the main agent only, and delegated agents run with the official shell semantics (no prompt rewrite, no path translation). Note that dsh has exactly one shell executor per process, so the Git Bash binary stays global; this switch governs the dialect/translation layers.",
 			"eol.label": "Git line endings (Linux match)",
 			"eol.hint": "Git commands the model runs behave like Linux: core.autocrlf=input, core.eol=lf. Your own terminal's git and a repository's .gitattributes are unaffected.",
 			"bash.label": "Git Bash path",
@@ -137,6 +147,7 @@ window.__ModuleLoader__.load({
 			"python.on": "Python (experimental)",
 			"python.off": "Node / TypeScript (default)",
 			"python.hint": "While off (default) run_code uses the official Node/TypeScript backend, byte-identical to the shipped ptc composition; turning it on switches to dsh's experimental CPython backend (@deepseek-ai/dsh-experimental-ptc-runtime-python), which also switches run_code's language, generated SDK prompt and tool presentation to Python. Requires a POSIX platform and CPython ≥ 3.10 (unavailable on Windows) and is mutually exclusive with the workflow tool — the official Python composition disables workflow too, so the workflow side of all four variants is forced off while this is on (your workflow setting is kept and restored when you turn it back off). Takes effect after restarting dsh; this is the very same switch on dsh-ptc-cordis-preset's card — both sides share one state, so either side updates both. Shown only while dsh-ptc-cordis-preset is installed. If turning it on does not take effect, the dsh startup log states why.",
+			"python.degraded": "backend unavailable, still Node (reason in the dsh startup log)",
 			"python.blocked": "This host is Windows: the experimental Python backend supports POSIX only, so this switch is unavailable.",
 		};
 
@@ -170,6 +181,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "نمط glob المطلق يُقسم إلى path + نمط نسبي؛ الإيقاف يمرره كما هو.",
 				"code.label": "مسارات برامج run_code",
 				"code.hint": "تُترجم السلاسل النصية للمسارات المكتوبة داخل برنامج run_code عبر جدول التحميل نفسه قبل التشغيل؛ وتبقى التعليقات والقوالب ذات الإدراج و$VAR والسلاسل غير المسارية كما هي، وأي التباس يُبقي البرنامج كاملًا دون تغيير. وتُهيَّأ أيضًا TEMP/TMP للبرنامج: مع بيئة فارغة يعيد os.tmpdir() على ويندوز القيمة undefined\\temp فيُكتب في مكان خاطئ.",
+				"sub.label": "استخدام الوكلاء الفرعيين لـ Git Bash",
+				"sub.hint": "مُفعَّل (افتراضيًا): يحصل الوكلاء الفرعيون وأعضاء الفريق — بما في ذلك المتداخلون — على لهجة المطالبة وترجمة مسارات الوسائط وصدى النتائج وحقيقة DSH_PATH_DIALECT نفسها التي يحصل عليها الوكيل الرئيسي. عند الإيقاف تُطبَّق هذه على الوكيل الرئيسي فقط ويعمل الوكلاء المفوَّضون بدلالات الصدفة الرسمية (دون إعادة كتابة المطالبة أو ترجمة المسارات). لاحظ أن dsh يملك مُنفِّذ صدفة واحدًا لكل عملية، لذا يبقى ثنائي Git Bash عامًّا؛ هذا المفتاح يحكم طبقتي اللهجة والترجمة.",
 				"eol.label": "نهايات أسطر Git (مطابقة لينكس)",
 				"eol.hint": "أوامر git التي يشغّلها النموذج تتبع سلوك لينكس: core.autocrlf=input و core.eol=lf؛ لا يتأثر طرفيتك ولا ملف .gitattributes للمستودع.",
 				"bash.label": "مسار Git Bash",
@@ -186,6 +199,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python (تجريبي)",
 				"python.off": "Node / TypeScript (افتراضي)",
 				"python.hint": "عند الإيقاف (افتراضيًا) يستخدم run_code الخلفية الرسمية Node/TypeScript، مطابقة تمامًا لتركيبة ptc الرسمية؛ وعند التشغيل يتحول إلى خلفية CPython التجريبية في dsh (@deepseek-ai/dsh-experimental-ptc-runtime-python)، فتتحول لغة run_code ومطالبة SDK المولَّدة وعرض الأداة إلى Python. يتطلب نظام POSIX و CPython ≥ 3.10 (غير متاح على Windows)، وهو متعارض مع أداة workflow — فالتركيبة الرسمية لـ Python تعطّل workflow أيضًا، لذا يبقى جانب workflow مُعطَّلًا في المتغيّرات الأربعة أثناء التشغيل (قيمتك محفوظة وتعود عند الإيقاف). يسري التغيير بعد إعادة تشغيل dsh؛ هذا هو المفتاح نفسه على بطاقة dsh-ptc-cordis-preset — الجانبان يتشاركان حالة واحدة. يظهر فقط عند تثبيت dsh-ptc-cordis-preset. إذا لم يسري التشغيل، فسبب ذلك مذكور في سجل تشغيل dsh.",
+				"python.degraded": "الخلفية غير متاحة، لا يزال Node (السبب في سجل بدء التشغيل)",
 				"python.blocked": "هذا المضيف يعمل بـ Windows: الخلفية التجريبية Python تدعم POSIX فقط، لذا لا يتوفر هذا المفتاح.",
 			},
 			/* locale: de */
@@ -209,6 +223,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "Ein absolutes Glob-Muster zerfällt in Pfad + relatives Muster; aus übergibt es unverändert.",
 				"code.label": "Pfade in run_code-Programmen",
 				"code.hint": "Pfadliterale in einem run_code-Programm werden vor dem Start über dieselbe Mount-Tabelle übersetzt; Kommentare, interpolierte Templates, $VARs und Nicht-Pfad-Strings bleiben unangetastet, und bei Unklarheit bleibt das ganze Programm unverändert. Zusätzlich werden TEMP/TMP für das Programm gesetzt: bei leerer Umgebung liefert os.tmpdir() unter Windows undefined\\temp und schreibt an einen falschen Ort.",
+				"sub.label": "Subagenten/Teammitglieder nutzen Git Bash",
+				"sub.hint": "An (Standard): Subagenten und Teammitglieder — auch verschachtelte — erhalten denselben Prompt-Dialekt, dieselbe Pfadargument-Übersetzung, dieselbe Ergebnisanzeige und dieselbe DSH_PATH_DIALECT-Tatsache wie der Hauptagent. Aus: Das gilt nur für den Hauptagenten, delegierte Agenten laufen mit den offiziellen Shell-Semantiken (keine Prompt-Umschreibung, keine Pfadübersetzung). Beachte: dsh hat genau einen Shell-Executor pro Prozess, das Git-Bash-Binary bleibt also global; dieser Schalter steuert die Dialekt-/Übersetzungsschichten.",
 				"eol.label": "Git-Zeilenenden (Linux-gleich)",
 				"eol.hint": "Vom Modell ausgeführte git-Befehle verhalten sich wie unter Linux: core.autocrlf=input, core.eol=lf. Dein eigenes Terminal und die .gitattributes eines Repos bleiben unberührt.",
 				"bash.label": "Git-Bash-Pfad",
@@ -225,6 +241,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python (experimentell)",
 				"python.off": "Node / TypeScript (Standard)",
 				"python.hint": "Aus (Standard): run_code nutzt das offizielle Node/TypeScript-Backend, byte-identisch zur ausgelieferten ptc-Komposition; an: dsh wechselt auf das experimentelle CPython-Backend (@deepseek-ai/dsh-experimental-ptc-runtime-python), womit Sprache, generierter SDK-Prompt und Darstellung von run_code auf Python umstellen. Erfordert POSIX und CPython ≥ 3.10 (unter Windows nicht verfügbar) und ist mit dem workflow-Tool unvereinbar — die offizielle Python-Komposition deaktiviert workflow ebenfalls, deshalb bleibt die workflow-Seite aller vier Varianten so lange aus (dein Workflow-Wert bleibt erhalten und kehrt nach dem Ausschalten zurück). Wirkt nach einem Neustart von dsh; dies ist derselbe Schalter auf der Karte von dsh-ptc-cordis-preset — beide Seiten teilen einen Zustand. Nur sichtbar, solange dsh-ptc-cordis-preset installiert ist. Bleibt das Einschalten ohne Wirkung, nennt das dsh-Startprotokoll den Grund.",
+				"python.degraded": "Backend nicht verfügbar, weiterhin Node (Grund im dsh-Startprotokoll)",
 				"python.blocked": "Dieser Host ist Windows: Das experimentelle Python-Backend unterstützt nur POSIX, der Schalter ist nicht verfügbar.",
 			},
 			/* locale: fr */
@@ -248,6 +265,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "Un motif glob absolu se scinde en chemin + motif relatif ; désactivé le passe tel quel.",
 				"code.label": "chemins dans les programmes run_code",
 				"code.hint": "Les littéraux de chemin écrits dans un programme run_code sont traduits via la même table de montage avant exécution; commentaires, gabarits interpolés, $VAR et chaînes non-chemin restent intacts, et la moindre incertitude laisse le programme tel quel. TEMP/TMP sont aussi fournis au programme : avec un env vide, os.tmpdir() sous Windows renvoie undefined\\temp et écrit au mauvais endroit.",
+				"sub.label": "Les sous-agents utilisent Git Bash",
+				"sub.hint": "Activé (par défaut) : les sous-agents et membres d'équipe — y compris imbriqués — reçoivent le même dialecte de prompt, la même traduction des chemins d'arguments, le même écho de résultat et le même fait DSH_PATH_DIALECT que l'agent principal. Désactivé : ces éléments ne s'appliquent qu'à l'agent principal et les agents délégués suivent les sémantiques de shell officielles (pas de réécriture du prompt, pas de traduction des chemins). À noter : dsh n'a qu'un seul exécuteur de shell par processus, le binaire Git Bash reste donc global ; cet interrupteur régit les couches de dialecte et de traduction.",
 				"eol.label": "fins de ligne Git (comme Linux)",
 				"eol.hint": "Les commandes git lancées par le modèle suivent le comportement Linux : core.autocrlf=input, core.eol=lf. Votre terminal et les .gitattributes du dépôt ne sont pas touchés.",
 				"bash.label": "Chemin Git Bash",
@@ -264,6 +283,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python (expérimental)",
 				"python.off": "Node / TypeScript (par défaut)",
 				"python.hint": "Désactivé (par défaut), run_code utilise le backend officiel Node/TypeScript, identique octet pour octet à la composition ptc livrée ; activé, dsh bascule sur le backend CPython expérimental (@deepseek-ai/dsh-experimental-ptc-runtime-python) : la langue, l'invite SDK générée et la présentation de run_code passent en Python. Exige POSIX et CPython ≥ 3.10 (indisponible sous Windows) et est incompatible avec l'outil workflow — la composition Python officielle désactive aussi workflow, donc le côté workflow des quatre variantes reste désactivé tant que l'option est active (ta valeur est conservée et revient à la désactivation). Prend effet après un redémarrage de dsh ; c'est le même interrupteur que sur la carte de dsh-ptc-cordis-preset — les deux côtés partagent un seul état. Affiché uniquement si dsh-ptc-cordis-preset est installé. Si l'activation reste sans effet, le journal de démarrage de dsh en indique la raison.",
+				"python.degraded": "backend indisponible, toujours Node (raison dans le journal de démarrage de dsh)",
 				"python.blocked": "Cet hôte est sous Windows : le backend Python expérimental n'est disponible que sur POSIX, l'interrupteur est indisponible.",
 			},
 			/* locale: hi */
@@ -287,6 +307,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "एब्सोल्यूट glob पैटर्न path + रिलेटिव पैटर्न में विभाजित होता है; बंद इसे वैसे ही पास करता है।",
 				"code.label": "run_code प्रोग्राम पथ",
 				"code.hint": "run_code प्रोग्राम में लिखे पथ लिटरल चलने से पहले उसी माउंट तालिका से अनूदित होते हैं; टिप्पणियाँ, इंटरपोलेटेड टेम्पलेट, $VAR और गैर-पथ स्ट्रिंग अछूते रहते हैं, और किसी भी अनिश्चितता पर पूरा प्रोग्राम अपरिवर्तित रहता है। साथ ही प्रोग्राम के लिए TEMP/TMP भर दिए जाते हैं: खाली env में Windows पर os.tmpdir() undefined\\temp देता है और गलत जगह लिखता है।",
+				"sub.label": "सबएजेंट/टीम सदस्य Git Bash इस्तेमाल करें",
+				"sub.hint": "चालू (डिफ़ॉल्ट): सबएजेंट और टीम सदस्य — नेस्टेड सहित — मुख्य एजेंट जैसा ही प्रॉम्प्ट डायलेक्ट, पाथ आर्ग्युमेंट अनुवाद, परिणाम इको और DSH_PATH_DIALECT तथ्य पाते हैं। बंद: ये केवल मुख्य एजेंट पर लागू होते हैं और प्रतिनिधित एजेंट आधिकारिक शेल अर्थ में चलते हैं (प्रॉम्प्ट नहीं बदलता, पाथ अनुवाद नहीं होता)। ध्यान दें: dsh में प्रति प्रोसेस एक ही शेल एक्ज़ीक्यूटर होता है, इसलिए Git Bash बाइनरी वैश्विक रहती है; यह स्विच डायलेक्ट/अनुवाद परतों को नियंत्रित करता है।",
 				"eol.label": "Git पंक्ति-अंत (Linux जैसा)",
 				"eol.hint": "मॉडल द्वारा चलाए git कमांड Linux व्यवहार अपनाते हैं: core.autocrlf=input, core.eol=lf। आपका टर्मिनल और रेपो का .gitattributes अछूते रहते हैं।",
 				"bash.label": "Git Bash पथ",
@@ -303,6 +325,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python (प्रयोगात्मक)",
 				"python.off": "Node / TypeScript (डिफ़ॉल्ट)",
 				"python.hint": "बंद (डिफ़ॉल्ट) रहने पर run_code आधिकारिक Node/TypeScript बैकएंड इस्तेमाल करता है, जो भेजे गए ptc संयोजन से पूरी तरह मेल खाता है; चालू करने पर dsh का प्रयोगात्मक CPython बैकएंड (@deepseek-ai/dsh-experimental-ptc-runtime-python) चलता है और run_code की भाषा, बना SDK प्रॉम्प्ट तथा प्रस्तुति Python में बदल जाती है। इसके लिए POSIX और CPython ≥ 3.10 चाहिए (Windows पर उपलब्ध नहीं), और यह workflow टूल से परस्पर अनन्य है — आधिकारिक Python संयोजन भी workflow बंद करता है, इसलिए चालू रहने तक चारों वेरिएंट का workflow पक्ष बंद रहता है (आपकी workflow सेटिंग सुरक्षित रहती है और बंद करने पर लौट आती है)। बदलाव dsh को फिर से शुरू करने के बाद लागू होता है; यह dsh-ptc-cordis-preset के कार्ड पर मौजूद वही स्विच है — दोनों ओर एक ही स्थिति साझा होती है। यह केवल तभी दिखता है जब dsh-ptc-cordis-preset इंस्टॉल हो। चालू करने पर असर न हो तो कारण dsh के स्टार्टअप लॉग में मिलेगा।",
+				"python.degraded": "बैकएंड उपलब्ध नहीं, अब भी Node (कारण dsh स्टार्टअप लॉग में)",
 				"python.blocked": "यह होस्ट Windows है: प्रयोगात्मक Python बैकएंड केवल POSIX पर चलता है, इसलिए यह स्विच उपलब्ध नहीं है।",
 			},
 			/* locale: id */
@@ -326,6 +349,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "Pattern glob absolut dipecah menjadi path + pattern relatif; nonaktif meneruskannya apa adanya.",
 				"code.label": "jalur dalam program run_code",
 				"code.hint": "Literal jalur yang ditulis di program run_code diterjemahkan lewat tabel mount yang sama sebelum dijalankan; komentar, template berinterpolasi, $VAR, dan string non-jalur dibiarkan, dan bila ada keraguan seluruh program tidak diubah. TEMP/TMP juga diisi untuk program: dengan env kosong, os.tmpdir() di Windows mengembalikan undefined\\temp dan menulis ke lokasi salah.",
+				"sub.label": "Subagen/teman tim memakai Git Bash",
+				"sub.hint": "Aktif (bawaan): subagen dan anggota tim — termasuk yang bersarang — mendapat dialek prompt, terjemahan argumen path, gema hasil, dan fakta DSH_PATH_DIALECT yang sama seperti agen utama. Nonaktif: semuanya hanya berlaku untuk agen utama dan agen yang didelegasikan berjalan dengan semantik shell resmi (prompt tidak ditulis ulang, path tidak diterjemahkan). Catatan: dsh hanya punya satu eksekutor shell per proses, jadi biner Git Bash tetap global; sakelar ini mengatur lapisan dialek/terjemahan.",
 				"eol.label": "akhir baris Git (sama seperti Linux)",
 				"eol.hint": "Perintah git yang dijalankan model mengikuti perilaku Linux: core.autocrlf=input, core.eol=lf. Terminal Anda dan .gitattributes repo tidak terpengaruh.",
 				"bash.label": "Path Git Bash",
@@ -342,6 +367,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python (eksperimental)",
 				"python.off": "Node / TypeScript (bawaan)",
 				"python.hint": "Saat nonaktif (bawaan), run_code memakai backend resmi Node/TypeScript, identik byte demi byte dengan komposisi ptc resmi; saat aktif, dsh memakai backend CPython eksperimental (@deepseek-ai/dsh-experimental-ptc-runtime-python) sehingga bahasa run_code, prompt SDK yang dihasilkan, dan penyajiannya beralih ke Python. Memerlukan POSIX dan CPython ≥ 3.10 (tidak tersedia di Windows) serta saling eksklusif dengan alat workflow — komposisi Python resmi juga menonaktifkan workflow, jadi sisi workflow keempat varian tetap mati selama ini aktif (nilai workflow-mu dipertahankan dan kembali saat dimatikan). Berlaku setelah dsh dimulai ulang; ini sakelar yang sama di kartu dsh-ptc-cordis-preset — kedua sisi berbagi satu status. Hanya tampil saat dsh-ptc-cordis-preset terpasang. Jika diaktifkan tetapi tidak berpengaruh, alasannya ada di log mulai dsh.",
+				"python.degraded": "backend tidak tersedia, masih Node (alasan di log mulai dsh)",
 				"python.blocked": "Host ini Windows: backend Python eksperimental hanya mendukung POSIX, sakelar ini tidak tersedia.",
 			},
 			/* locale: it */
@@ -365,6 +391,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "Un pattern glob assoluto si divide in percorso + pattern relativo; off lo passa invariato.",
 				"code.label": "percorsi nei programmi run_code",
 				"code.hint": "I letterali di percorso scritti in un programma run_code vengono tradotti con la stessa tabella di mount prima dell'esecuzione; commenti, template interpolati, $VAR e stringhe non di percorso restano intatti e qualsiasi incertezza lascia il programma invariato. Inoltre TEMP/TMP vengono forniti al programma: con env vuoto, os.tmpdir() su Windows restituisce undefined\\temp e scrive nel posto sbagliato.",
+				"sub.label": "Subagenti/compagni usano Git Bash",
+				"sub.hint": "Attivo (predefinito): subagenti e membri del team — anche annidati — ricevono lo stesso dialetto del prompt, la stessa traduzione dei percorsi negli argomenti, lo stesso eco dei risultati e lo stesso fatto DSH_PATH_DIALECT dell'agente principale. Disattivo: valgono solo per l'agente principale e gli agenti delegati usano le semantiche di shell ufficiali (nessuna riscrittura del prompt, nessuna traduzione dei percorsi). Nota: dsh ha un solo esecutore di shell per processo, quindi il binario Git Bash resta globale; questo interruttore governa gli strati di dialetto e traduzione.",
 				"eol.label": "fine riga Git (come Linux)",
 				"eol.hint": "I comandi git eseguiti dal modello seguono il comportamento Linux: core.autocrlf=input, core.eol=lf. Il tuo terminale e i .gitattributes del repo non vengono toccati.",
 				"bash.label": "Percorso Git Bash",
@@ -381,6 +409,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python (sperimentale)",
 				"python.off": "Node / TypeScript (predefinito)",
 				"python.hint": "Disattivato (predefinito) run_code usa il backend ufficiale Node/TypeScript, identico byte per byte alla composizione ptc distribuita; attivandolo dsh passa al backend CPython sperimentale (@deepseek-ai/dsh-experimental-ptc-runtime-python): lingua, prompt SDK generato e presentazione di run_code passano a Python. Richiede POSIX e CPython ≥ 3.10 (non disponibile su Windows) ed è incompatibile con lo strumento workflow — anche la composizione Python ufficiale disattiva workflow, quindi il lato workflow di tutte e quattro le varianti resta spento finché è attivo (il tuo valore viene conservato e torna alla disattivazione). Ha effetto dopo il riavvio di dsh; è lo stesso interruttore sulla scheda di dsh-ptc-cordis-preset — entrambi i lati condividono un unico stato. Visibile solo quando dsh-ptc-cordis-preset è installato. Se l'attivazione non ha effetto, il motivo è nel log di avvio di dsh.",
+				"python.degraded": "backend non disponibile, resta Node (motivo nel log di avvio di dsh)",
 				"python.blocked": "Questo host è Windows: il backend Python sperimentale supporta solo POSIX, l'interruttore non è disponibile.",
 			},
 			/* locale: ja */
@@ -404,6 +433,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "絶対 glob パターンを path + 相対パターンに分割;オフならそのまま渡します。",
 				"code.label": "run_code プログラム内のパス",
 				"code.hint": "run_code プログラム内に書いた /c/... などのパスリテラルは実行前に同じマウント表で変換されます。コメント・補間テンプレート・$VAR・パス以外の文字列は変更せず、解析に不確かさがあればプログラム全体をそのまま実行します。 さらにプログラムに TEMP/TMP を渡します: 空の env では Windows の os.tmpdir() が undefined\\temp を返し、誤った場所に書き込みます。",
+				"sub.label": "サブエージェント/チームメンバーも Git Bash を使う",
+				"sub.hint": "オン(既定):サブエージェントとチームメンバー(ネスト含む)は、メインエージェントと同じプロンプト方言・パス引数の翻訳・結果エコー・DSH_PATH_DIALECT の事実を受け取ります。オフ:これらはメインエージェントのみに適用され、委譲されたエージェントは公式の shell セマンティクスで動作します(プロンプト改写なし、パス翻訳なし)。なお dsh はプロセスごとに shell 実行器を 1 つだけ持つため、Git Bash バイナリ自体は常に全体共通です。このスイッチが制御するのは方言/翻訳の層です。",
 				"eol.label": "Git の行末(Linux と同じ)",
 				"eol.hint": "モデルが実行する git コマンドは Linux と同じ挙動になります: core.autocrlf=input、core.eol=lf。あなたのターミナルやリポジトリの .gitattributes は影響を受けません。",
 				"bash.label": "Git Bash パス",
@@ -420,6 +451,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python(実験的)",
 				"python.off": "Node / TypeScript(既定)",
 				"python.hint": "オフ(既定)では run_code は公式の Node/TypeScript バックエンドを使い、公式 ptc 構成とバイト単位で一致します。オンにすると dsh の実験的 CPython バックエンド(@deepseek-ai/dsh-experimental-ptc-runtime-python)に切り替わり、run_code の言語・生成される SDK プロンプト・提示が Python に変わります。POSIX と CPython ≥ 3.10 が必要(Windows では利用不可)で、workflow ツールとは排他です —— 公式 Python 構成も workflow を無効化するため、オン期間中は 4 変体すべてで workflow 側が強制的にオフになります(ワークフロー設定値は保持され、オフに戻すと復帰)。変更は dsh の再起動後に有効です。これは dsh-ptc-cordis-preset のカードにある同じスイッチで、両側が同一状態を共有します。dsh-ptc-cordis-preset がインストールされているときだけ表示されます。 オンにしても効かない場合の理由は dsh の起動ログにあります。",
+				"python.degraded": "バックエンド利用不可・現在も Node(理由は dsh の起動ログ)",
 				"python.blocked": "このホストは Windows です。実験的 Python バックエンドは POSIX 専用のため、このスイッチは利用できません。",
 			},
 			/* locale: ko */
@@ -443,6 +475,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "절대 glob 패턴을 path + 상대 패턴으로 분할; 끄면 그대로 전달.",
 				"code.label": "run_code 프로그램 경로",
 				"code.hint": "run_code 프로그램에 쓴 /c/... 경로 리터럴은 실행 전에 같은 마운트 표로 변환됩니다. 주석, 보간 템플릿, $VAR, 경로가 아닌 문자열은 그대로 두고, 스캔이 불확실하면 프로그램 전체를 그대로 둡니다. 또한 프로그램에 TEMP/TMP를 채워 줍니다: 빈 env에서 Windows의 os.tmpdir()는 undefined\\temp를 반환해 엉뚱한 곳에 씁니다.",
+				"sub.label": "서브에이전트/팀원도 Git Bash 사용",
+				"sub.hint": "켬(기본): 서브에이전트와 팀원(중첩 포함)은 메인 에이전트와 동일한 프롬프트 방언, 경로 인자 번역, 결과 에코, DSH_PATH_DIALECT 사실을 받습니다. 끔: 이것들은 메인 에이전트에만 적용되고 위임된 에이전트는 공식 shell 의미로 동작합니다(프롬프트 재작성 없음, 경로 번역 없음). 참고로 dsh는 프로세스당 shell 실행기가 하나뿐이라 Git Bash 바이너리 자체는 항상 전역입니다. 이 스위치는 방언/번역 계층을 제어합니다.",
 				"eol.label": "Git 줄바꿈(Linux와 동일)",
 				"eol.hint": "모델이 실행하는 git 명령은 Linux 동작을 따릅니다: core.autocrlf=input, core.eol=lf. 사용자의 터미널과 저장소의 .gitattributes는 영향을 받지 않습니다.",
 				"bash.label": "Git Bash 경로",
@@ -459,6 +493,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python(실험적)",
 				"python.off": "Node / TypeScript(기본)",
 				"python.hint": "끄면(기본) run_code는 공식 Node/TypeScript 백엔드를 사용해 공식 ptc 구성과 바이트 단위로 일치합니다. 켜면 dsh의 실험적 CPython 백엔드(@deepseek-ai/dsh-experimental-ptc-runtime-python)로 바뀌어 run_code의 언어, 생성되는 SDK 프롬프트, 도구 표시가 Python으로 전환됩니다. POSIX와 CPython ≥ 3.10이 필요하며(Windows에서는 사용 불가) workflow 도구와 상호 배타적입니다 — 공식 Python 구성도 workflow를 끄므로 켜져 있는 동안 네 변형 모두 workflow 쪽이 강제로 꺼집니다(워크플로 설정값은 유지되고 끄면 복구됩니다). 변경은 dsh 재시작 후 적용됩니다. 이 스위치는 dsh-ptc-cordis-preset 카드에 있는 바로 그 스위치이며 양쪽이 같은 상태를 공유합니다. dsh-ptc-cordis-preset이 설치되어 있을 때만 표시됩니다. 켠 뒤에도 적용되지 않으면 그 이유는 dsh 시작 로그에 있습니다.",
+				"python.degraded": "백엔드 사용 불가, 여전히 Node(이유는 dsh 시작 로그)",
 				"python.blocked": "이 호스트는 Windows입니다. 실험적 Python 백엔드는 POSIX만 지원하므로 이 스위치를 쓸 수 없습니다.",
 			},
 			/* locale: nl */
@@ -482,6 +517,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "Een absoluut glob-patroon splitst in pad + relatief patroon; uit geeft het ongewijzigd door.",
 				"code.label": "paden in run_code-programma's",
 				"code.hint": "Pad-literalen in een run_code-programma worden vóór uitvoering via dezelfde mounttabel vertaald; opmerkingen, geïnterpoleerde templates, $VAR's en niet-pad-strings blijven ongemoeid, en bij twijfel blijft het hele programma ongewijzigd. Ook worden TEMP/TMP voor het programma gezet: met een lege env geeft os.tmpdir() op Windows undefined\\temp en schrijft het op de verkeerde plek.",
+				"sub.label": "Subagenten/teammaten gebruiken Git Bash",
+				"sub.hint": "Aan (standaard): subagenten en teamleden — ook geneste — krijgen hetzelfde promptdialect, dezelfde padargument-vertaling, dezelfde resultaat-echo en hetzelfde DSH_PATH_DIALECT-feit als de hoofdagent. Uit: die gelden alleen voor de hoofdagent en gedelegeerde agenten draaien met de officiële shell-semantiek (geen promptherschrijving, geen padvertaling). Let op: dsh heeft één shell-uitvoerder per proces, dus het Git Bash-binary blijft globaal; deze schakelaar beheert de dialect-/vertaallagen.",
 				"eol.label": "Git regeleinden (zoals Linux)",
 				"eol.hint": "Git-opdrachten die het model uitvoert volgen Linux-gedrag: core.autocrlf=input, core.eol=lf. Je eigen terminal en de .gitattributes van een repo blijven onaangetast.",
 				"bash.label": "Git Bash-pad",
@@ -498,6 +535,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python (experimenteel)",
 				"python.off": "Node / TypeScript (standaard)",
 				"python.hint": "Uit (standaard) gebruikt run_code de officiële Node/TypeScript-backend, byte voor byte gelijk aan de meegeleverde ptc-compositie; aan schakelt dsh over op de experimentele CPython-backend (@deepseek-ai/dsh-experimental-ptc-runtime-python), waardoor taal, gegenereerde SDK-prompt en weergave van run_code naar Python gaan. Vereist POSIX en CPython ≥ 3.10 (niet beschikbaar op Windows) en is onverenigbaar met de workflow-tool — de officiële Python-compositie schakelt workflow ook uit, dus de workflow-kant van alle vier varianten blijft uit zolang dit aan staat (je workflow-waarde blijft bewaard en keert terug als je het uitzet). Werkt na een herstart van dsh; dit is dezelfde schakelaar op de kaart van dsh-ptc-cordis-preset — beide kanten delen één status. Alleen zichtbaar zolang dsh-ptc-cordis-preset is geïnstalleerd. Werkt het aanzetten niet, dan staat de reden in het opstartlogboek van dsh.",
+				"python.degraded": "backend niet beschikbaar, nog steeds Node (reden in het dsh-opstartlogboek)",
 				"python.blocked": "Deze host is Windows: de experimentele Python-backend ondersteunt alleen POSIX, deze schakelaar is niet beschikbaar.",
 			},
 			/* locale: pl */
@@ -521,6 +559,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "Absolutny wzorzec glob dzieli się na ścieżkę + wzorzec względny; wył. przekazuje bez zmian.",
 				"code.label": "ścieżki w programach run_code",
 				"code.hint": "Literały ścieżek w programie run_code są tłumaczone przez tę samą tabelę montowania przed uruchomieniem; komentarze, szablony z interpolacją, $VAR i ciągi niebędące ścieżkami pozostają nietknięte, a każda niepewność pozostawia program bez zmian. Dodatkowo ustawiane są TEMP/TMP dla programu: przy pustym env Windows zwraca z os.tmpdir() undefined\\temp i zapisuje w złym miejscu.",
+				"sub.label": "Subagenci/członkowie zespołu używają Git Bash",
+				"sub.hint": "Wł. (domyślnie): subagenci i członkowie zespołu — także zagnieżdżeni — otrzymują ten sam dialekt podpowiedzi, tłumaczenie argumentów ścieżek, echo wyników i fakt DSH_PATH_DIALECT co agent główny. Wył.: dotyczy to tylko agenta głównego, a agenci delegowani działają według oficjalnej semantyki powłoki (bez przepisywania podpowiedzi i tłumaczenia ścieżek). Uwaga: dsh ma jeden executor powłoki na proces, więc binarka Git Bash pozostaje globalna; ten przełącznik steruje warstwami dialektu i tłumaczenia.",
 				"eol.label": "końce linii Git (jak w Linuksie)",
 				"eol.hint": "Polecenia git uruchamiane przez model działają jak w Linuksie: core.autocrlf=input, core.eol=lf. Twój terminal i .gitattributes repozytorium pozostają nietknięte.",
 				"bash.label": "Ścieżka Git Bash",
@@ -537,6 +577,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python (eksperymentalny)",
 				"python.off": "Node / TypeScript (domyślnie)",
 				"python.hint": "Wyłączony (domyślnie) run_code używa oficjalnego backendu Node/TypeScript, identycznego co do bajtu z dostarczaną kompozycją ptc; włączenie przełącza dsh na eksperymentalny backend CPython (@deepseek-ai/dsh-experimental-ptc-runtime-python), więc język, generowany prompt SDK i prezentacja run_code przechodzą na Python. Wymaga POSIX i CPython ≥ 3.10 (niedostępny w Windows) i jest wykluczający z narzędziem workflow — oficjalna kompozycja Python również wyłącza workflow, więc strona workflow wszystkich czterech wariantów pozostaje wyłączona, dopóki to jest włączone (twoje ustawienie workflow jest zachowane i wraca po wyłączeniu). Zmiana działa po restarcie dsh; to ten sam przełącznik na karcie dsh-ptc-cordis-preset — obie strony dzielą jeden stan. Widoczny tylko, gdy dsh-ptc-cordis-preset jest zainstalowany. Jeśli włączenie nie przyniesie skutku, powód znajdziesz w logu startowym dsh.",
+				"python.degraded": "backend niedostępny, nadal Node (powód w logu startowym dsh)",
 				"python.blocked": "Ten host to Windows: eksperymentalny backend Python obsługuje tylko POSIX, przełącznik jest niedostępny.",
 			},
 			/* locale: pt */
@@ -560,6 +601,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "Um padrão glob absoluto divide em caminho + padrão relativo; desligado passa-o inalterado.",
 				"code.label": "caminhos em programas run_code",
 				"code.hint": "Literais de caminho escritos num programa run_code são traduzidos pela mesma tabela de montagem antes da execução; comentários, modelos interpolados, $VAR e strings que não são caminhos ficam intactos, e qualquer incerteza deixa o programa como está. Também são definidos TEMP/TMP para o programa: com env vazio, os.tmpdir() no Windows devolve undefined\\temp e grava no lugar errado.",
+				"sub.label": "Subagentes/membros da equipa usam Git Bash",
+				"sub.hint": "Ligado (padrão): subagentes e membros da equipa — incluindo aninhados — recebem o mesmo dialeto de prompt, tradução de caminhos nos argumentos, eco de resultados e o mesmo facto DSH_PATH_DIALECT que o agente principal. Desligado: isso aplica-se apenas ao agente principal e os agentes delegados correm com a semântica oficial da shell (sem reescrita do prompt nem tradução de caminhos). Nota: o dsh tem um único executor de shell por processo, pelo que o binário Git Bash continua global; este interruptor governa as camadas de dialeto e tradução.",
 				"eol.label": "fins de linha do Git (como no Linux)",
 				"eol.hint": "Os comandos git executados pelo modelo seguem o comportamento do Linux: core.autocrlf=input, core.eol=lf. O seu terminal e os .gitattributes do repositório não são afetados.",
 				"bash.label": "Caminho do Git Bash",
@@ -576,6 +619,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python (experimental)",
 				"python.off": "Node / TypeScript (padrão)",
 				"python.hint": "Desligado (padrão), o run_code usa o backend oficial Node/TypeScript, idêntico byte a byte à composição ptc distribuída; ligado, o dsh passa para o backend CPython experimental (@deepseek-ai/dsh-experimental-ptc-runtime-python), e a linguagem, o prompt SDK gerado e a apresentação do run_code passam para Python. Exige POSIX e CPython ≥ 3.10 (indisponível no Windows) e é incompatível com a ferramenta workflow — a composição Python oficial também desativa workflow, pelo que o lado workflow das quatro variantes fica desligado enquanto isto estiver ligado (o teu valor é mantido e regressa ao desligar). Produz efeito após reiniciar o dsh; é o mesmo interruptor no cartão do dsh-ptc-cordis-preset — os dois lados partilham um único estado. Só aparece quando o dsh-ptc-cordis-preset está instalado. Se ligar não tiver efeito, o motivo está no registo de arranque do dsh.",
+				"python.degraded": "backend indisponível, continua Node (motivo no registo de arranque do dsh)",
 				"python.blocked": "Este anfitrião é Windows: o backend Python experimental só suporta POSIX, pelo que este interruptor não está disponível.",
 			},
 			/* locale: ru */
@@ -599,6 +643,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "Абсолютный glob-шаблон разбивается на path + относительный шаблон; выкл передаёт как есть.",
 				"code.label": "пути в программах run_code",
 				"code.hint": "Строковые литералы путей в программе run_code переводятся по той же таблице монтирования до запуска; комментарии, шаблоны с интерполяцией, $VAR и строки-не-пути не трогаются, а при любой неопределённости программа остаётся без изменений. Также программе задаются TEMP/TMP: при пустом env в Windows os.tmpdir() возвращает undefined\\temp и запись идёт не туда.",
+				"sub.label": "Субагенты и участники команды используют Git Bash",
+				"sub.hint": "Вкл. (по умолчанию): субагенты и участники команды — включая вложенных — получают тот же диалект подсказки, перевод путей в аргументах, эхо результатов и факт DSH_PATH_DIALECT, что и главный агент. Выкл.: это применяется только к главному агенту, а делегированные агенты работают с официальной семантикой оболочки (без перезаписи подсказки и перевода путей). Учтите: в dsh один исполнитель оболочки на процесс, поэтому сам бинарник Git Bash остаётся общим; этот переключатель управляет слоями диалекта и перевода.",
 				"eol.label": "переводы строк Git (как в Linux)",
 				"eol.hint": "Команды git, запускаемые моделью, ведут себя как в Linux: core.autocrlf=input, core.eol=lf. Ваш терминал и .gitattributes репозитория не затрагиваются.",
 				"bash.label": "Путь Git Bash",
@@ -615,6 +661,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python (экспериментальный)",
 				"python.off": "Node / TypeScript (по умолчанию)",
 				"python.hint": "Выключено (по умолчанию) — run_code использует официальный бэкенд Node/TypeScript, побайтово совпадающий с поставляемой композицией ptc; при включении dsh переходит на экспериментальный бэкенд CPython (@deepseek-ai/dsh-experimental-ptc-runtime-python), и язык, сгенерированная подсказка SDK и представление run_code переключаются на Python. Требуются POSIX и CPython ≥ 3.10 (в Windows недоступно), и это несовместимо с инструментом workflow — официальная композиция Python тоже отключает workflow, поэтому сторона workflow всех четырёх вариантов остаётся выключенной, пока это включено (ваша настройка workflow сохраняется и возвращается после выключения). Изменение действует после перезапуска dsh; это тот же переключатель на карточке dsh-ptc-cordis-preset — обе стороны делят одно состояние. Показывается только когда установлен dsh-ptc-cordis-preset. Если включение не подействовало, причина указана в журнале запуска dsh.",
+				"python.degraded": "бэкенд недоступен, по-прежнему Node (причина в журнале запуска dsh)",
 				"python.blocked": "Этот хост — Windows: экспериментальный бэкенд Python поддерживает только POSIX, переключатель недоступен.",
 			},
 			/* locale: sv */
@@ -638,6 +685,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "Ett absolut glob-mönster delas i sökväg + relativt mönster; av skickar det oförändrat.",
 				"code.label": "sökvägar i run_code-program",
 				"code.hint": "Sökvägslitteraler i ett run_code-program översätts via samma monteringstabell före körning; kommentarer, interpolerade mallar, $VAR och strängar som inte är sökvägar lämnas orörda, och vid minsta osäkerhet lämnas hela programmet oförändrat. Dessutom sätts TEMP/TMP för programmet: med tom env ger os.tmpdir() i Windows undefined\\temp och skriver på fel ställe.",
+				"sub.label": "Subagenter/teammedlemmar använder Git Bash",
+				"sub.hint": "På (standard): subagenter och teammedlemmar — även nästlade — får samma promptdialekt, samma sökvägsöversättning i argument, samma resultat-eko och samma DSH_PATH_DIALECT-faktum som huvudagenten. Av: detta gäller bara huvudagenten och delegerade agenter kör med officiell shell-semantik (ingen promptomskrivning, ingen sökvägsöversättning). Obs: dsh har en enda shell-exekutor per process, så Git Bash-binären är fortfarande global; den här växeln styr dialekt-/översättningslagren.",
 				"eol.label": "Git radslut (som Linux)",
 				"eol.hint": "Git-kommandon som modellen kör följer Linux-beteende: core.autocrlf=input, core.eol=lf. Din egen terminal och repots .gitattributes påverkas inte.",
 				"bash.label": "Git Bash-sökväg",
@@ -654,6 +703,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python (experimentell)",
 				"python.off": "Node / TypeScript (standard)",
 				"python.hint": "Av (standard) använder run_code den officiella Node/TypeScript-backenden, byte för byte identisk med den medföljande ptc-kompositionen; på växlar dsh till den experimentella CPython-backenden (@deepseek-ai/dsh-experimental-ptc-runtime-python), vilket även byter run_codes språk, genererade SDK-prompt och presentation till Python. Kräver POSIX och CPython ≥ 3.10 (ej tillgängligt i Windows) och utesluter workflow-verktyget — den officiella Python-kompositionen stänger också av workflow, så workflow-sidan i alla fyra varianter hålls avstängd medan detta är på (ditt workflow-värde behålls och återställs när du stänger av). Gäller efter omstart av dsh; detta är samma växel på dsh-ptc-cordis-presets kort — båda sidor delar ett tillstånd. Visas bara när dsh-ptc-cordis-preset är installerat. Om påslaget inte får effekt står orsaken i dsh:s startlogg.",
+				"python.degraded": "backend otillgänglig, fortfarande Node (orsak i dsh-startloggen)",
 				"python.blocked": "Den här värden är Windows: den experimentella Python-backenden stöder bara POSIX, så växeln är otillgänglig.",
 			},
 			/* locale: th */
@@ -677,6 +727,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "pattern glob สัมบูรณ์แยกเป็น path + pattern สัมพัทธ์; ปิดส่งต่อตามเดิม",
 				"code.label": "พาธในโปรแกรม run_code",
 				"code.hint": "สตริงพาธที่เขียนในโปรแกรม run_code จะถูกแปลผ่านตาราง mount เดียวกันก่อนรัน ความคิดเห็น เทมเพลตที่มีการแทรก $VAR และสตริงที่ไม่ใช่พาธจะไม่ถูกแตะ และหากไม่แน่ใจทั้งโปรแกรมจะไม่ถูกแก้ไข และเติม TEMP/TMP ให้โปรแกรมด้วย: เมื่อ env ว่าง os.tmpdir() บน Windows จะคืน undefined\\temp แล้วเขียนผิดที่",
+				"sub.label": "ซับเอเจนต์/สมาชิกทีมใช้ Git Bash",
+				"sub.hint": "เปิด (ค่าเริ่มต้น): ซับเอเจนต์และสมาชิกทีม — รวมถึงแบบซ้อน — ได้รับไดอาเลกต์พรอมป์ต์ การแปลพาธในอาร์กิวเมนต์ การสะท้อนผลลัพธ์ และข้อเท็จจริง DSH_PATH_DIALECT เหมือนเอเจนต์หลัก ปิด: สิ่งเหล่านี้มีผลกับเอเจนต์หลักเท่านั้น และเอเจนต์ที่ถูกมอบหมายทำงานด้วยความหมาย shell อย่างเป็นทางการ (ไม่เขียนพรอมป์ต์ใหม่ ไม่แปลพาธ) หมายเหตุ dsh มีตัวรัน shell เดียวต่อโปรเซส ไบนารี Git Bash จึงยังเป็นส่วนกลาง สวิตช์นี้ควบคุมชั้นไดอาเลกต์/การแปล",
 				"eol.label": "อักขระขึ้นบรรทัด Git (เหมือน Linux)",
 				"eol.hint": "คำสั่ง git ที่โมเดลรันจะใช้พฤติกรรมแบบ Linux: core.autocrlf=input, core.eol=lf เทอร์มินัลของคุณและ .gitattributes ของ repo ไม่ได้รับผลกระทบ",
 				"bash.label": "เส้นทาง Git Bash",
@@ -693,6 +745,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python (ทดลอง)",
 				"python.off": "Node / TypeScript (ค่าเริ่มต้น)",
 				"python.hint": "เมื่อปิด (ค่าเริ่มต้น) run_code จะใช้แบ็กเอนด์ Node/TypeScript อย่างเป็นทางการ ซึ่งเหมือนกับคอมโพซิชัน ptc ที่จัดส่งทุกไบต์; เมื่อเปิด dsh จะเปลี่ยนไปใช้แบ็กเอนด์ CPython ทดลอง (@deepseek-ai/dsh-experimental-ptc-runtime-python) ภาษา พรอมป์ต์ SDK ที่สร้างขึ้น และการนำเสนอของ run_code จะเปลี่ยนเป็น Python ต้องใช้ POSIX และ CPython ≥ 3.10 (ใช้ไม่ได้บน Windows) และใช้ร่วมกับเครื่องมือ workflow ไม่ได้ — คอมโพซิชัน Python อย่างเป็นทางการก็ปิด workflow เช่นกัน ฝั่ง workflow ของทั้งสี่รูปแบบจึงถูกปิดขณะเปิดอยู่ (ค่าที่คุณตั้งไว้จะถูกเก็บและกลับมาเมื่อปิด) การเปลี่ยนแปลงมีผลหลังรีสตาร์ต dsh; นี่คือสวิตช์เดียวกันบนการ์ดของ dsh-ptc-cordis-preset — ทั้งสองฝั่งใช้สถานะเดียวกัน แสดงเฉพาะเมื่อติดตั้ง dsh-ptc-cordis-preset แล้วเท่านั้น หากเปิดแล้วไม่เกิดผล เหตุผลอยู่ในบันทึกการเริ่มต้นของ dsh",
+				"python.degraded": "แบ็กเอนด์ใช้ไม่ได้ ยังเป็น Node (เหตุผลในบันทึกเริ่มต้นของ dsh)",
 				"python.blocked": "โฮสต์นี้เป็น Windows: แบ็กเอนด์ Python ทดลองรองรับเฉพาะ POSIX สวิตช์นี้จึงใช้ไม่ได้",
 			},
 			/* locale: tr */
@@ -716,6 +769,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "Mutlak glob örüntüsü path + göreli örüntüye ayrılır; kapalı olduğu gibi geçirir.",
 				"code.label": "run_code program yolları",
 				"code.hint": "Bir run_code programında yazılan yol dizeleri çalıştırılmadan önce aynı bağlama tablosuyla çevrilir; yorumlar, enterpolasyonlu şablonlar, $VAR ve yol olmayan dizeler olduğu gibi kalır, herhangi bir belirsizlikte programın tamamı değişmeden bırakılır. Ayrıca programa TEMP/TMP verilir: boş env ile Windows'ta os.tmpdir() undefined\\temp döner ve yanlış yere yazar.",
+				"sub.label": "Alt ajanlar/ekip üyeleri Git Bash kullansın",
+				"sub.hint": "Açık (varsayılan): alt ajanlar ve ekip üyeleri — iç içe olanlar dahil — ana ajanla aynı istem lehçesini, yol argümanı çevirisini, sonuç yankısını ve DSH_PATH_DIALECT gerçeğini alır. Kapalı: bunlar yalnızca ana ajan için geçerlidir ve devredilen ajanlar resmî shell semantiğiyle çalışır (istem yeniden yazılmaz, yollar çevrilmez). Not: dsh'de süreç başına tek bir shell yürütücüsü vardır, bu yüzden Git Bash ikilisi genele aittir; bu anahtar lehçe/çeviri katmanlarını yönetir.",
 				"eol.label": "Git satır sonları (Linux gibi)",
 				"eol.hint": "Modelin çalıştırdığı git komutları Linux davranışını izler: core.autocrlf=input, core.eol=lf. Kendi terminaliniz ve deponun .gitattributes dosyası etkilenmez.",
 				"bash.label": "Git Bash yolu",
@@ -732,6 +787,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python (deneysel)",
 				"python.off": "Node / TypeScript (varsayılan)",
 				"python.hint": "Kapalıyken (varsayılan) run_code resmî Node/TypeScript arka ucunu kullanır ve gönderilen ptc bileşimiyle bayt bayt aynıdır; açıldığında dsh deneysel CPython arka ucuna (@deepseek-ai/dsh-experimental-ptc-runtime-python) geçer; run_code dil, üretilen SDK istemi ve sunum Python'a döner. POSIX ve CPython ≥ 3.10 gerektirir (Windows'ta kullanılamaz) ve workflow aracıyla birbirini dışlar — resmî Python bileşimi de workflow'u kapatır, bu yüzden bu açıkken dört varyantın workflow tarafı kapalı kalır (workflow ayarın korunur ve kapatınca geri gelir). Değişiklik dsh yeniden başlatıldıktan sonra geçerli olur; bu, dsh-ptc-cordis-preset kartındaki aynı anahtardır — iki taraf tek durumu paylaşır. Yalnızca dsh-ptc-cordis-preset kurulu olduğunda görünür. Açmak etkili olmazsa nedeni dsh başlangıç günlüğünde yazar.",
+				"python.degraded": "arka uç kullanılamıyor, hâlâ Node (neden dsh başlangıç günlüğünde)",
 				"python.blocked": "Bu ana makine Windows: deneysel Python arka ucu yalnızca POSIX destekler, bu anahtar kullanılamaz.",
 			},
 			/* locale: vi */
@@ -755,6 +811,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "Pattern glob tuyệt đối tách thành path + pattern tương đối; tắt truyền nguyên văn.",
 				"code.label": "đường dẫn trong chương trình run_code",
 				"code.hint": "Chuỗi đường dẫn viết trong chương trình run_code được dịch qua cùng bảng mount trước khi chạy; chú thích, template nội suy, $VAR và chuỗi không phải đường dẫn được giữ nguyên, và mọi điểm không chắc chắn sẽ khiến cả chương trình không bị sửa. Đồng thời nạp TEMP/TMP cho chương trình: với env rỗng, os.tmpdir() trên Windows trả về undefined\\temp và ghi sai chỗ.",
+				"sub.label": "Subagent/thành viên nhóm dùng Git Bash",
+				"sub.hint": "Bật (mặc định): subagent và thành viên nhóm — kể cả lồng nhau — nhận cùng phương ngữ prompt, cách dịch đường dẫn trong tham số, tiếng vọng kết quả và sự thật DSH_PATH_DIALECT như agent chính. Tắt: những thứ này chỉ áp dụng cho agent chính, còn agent được ủy quyền chạy theo ngữ nghĩa shell chính thức (không viết lại prompt, không dịch đường dẫn). Lưu ý dsh chỉ có một bộ thực thi shell mỗi tiến trình, nên tệp nhị phân Git Bash vẫn là toàn cục; công tắc này điều khiển tầng phương ngữ/dịch.",
 				"eol.label": "kết thúc dòng Git (giống Linux)",
 				"eol.hint": "Các lệnh git do mô hình chạy theo hành vi Linux: core.autocrlf=input, core.eol=lf. Terminal của bạn và .gitattributes của repo không bị ảnh hưởng.",
 				"bash.label": "Đường dẫn Git Bash",
@@ -771,6 +829,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python (thử nghiệm)",
 				"python.off": "Node / TypeScript (mặc định)",
 				"python.hint": "Khi tắt (mặc định), run_code dùng backend Node/TypeScript chính thức, giống từng byte với tổ hợp ptc được phát hành; khi bật, dsh chuyển sang backend CPython thử nghiệm (@deepseek-ai/dsh-experimental-ptc-runtime-python), kéo theo ngôn ngữ, prompt SDK được sinh và cách trình bày của run_code chuyển sang Python. Yêu cầu POSIX và CPython ≥ 3.10 (không dùng được trên Windows) và loại trừ lẫn nhau với công cụ workflow — tổ hợp Python chính thức cũng tắt workflow, nên phía workflow của cả bốn biến thể bị tắt trong lúc bật (giá trị workflow của bạn được giữ và trở lại khi tắt). Thay đổi có hiệu lực sau khi khởi động lại dsh; đây chính là công tắc trên thẻ của dsh-ptc-cordis-preset — hai bên dùng chung một trạng thái. Chỉ hiện khi đã cài dsh-ptc-cordis-preset. Nếu bật mà không có hiệu lực, lý do nằm trong nhật ký khởi động dsh.",
+				"python.degraded": "backend không khả dụng, vẫn là Node (lý do trong nhật ký khởi động dsh)",
 				"python.blocked": "Máy chủ này là Windows: backend Python thử nghiệm chỉ hỗ trợ POSIX, nên công tắc này không dùng được.",
 			},
 			/* locale: zh-hk */
@@ -794,6 +853,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "glob 嘅絕對 pattern 自動拆做 path + 相對 pattern;關閉就原樣傳遞。",
 				"code.label": "run_code 程式內路徑",
 				"code.hint": "run_code 程式內寫的 /c/... 路徑字面量會在執行前按同一張掛載表翻譯;註解、插值模板、$VAR 與非路徑字串不動,掃描有任何不確定就整份不改。 並為程式補上 TEMP/TMP:空 env 下 Windows 的 os.tmpdir() 會得到 undefined\\temp,程式會靜默寫錯位置。",
+				"sub.label": "子代理/隊員用 Git Bash",
+				"sub.hint": "預設開啟:子代理同團隊隊員(連嵌套)嘅提示詞方言、路徑參數翻譯、結果回顯同 DSH_PATH_DIALECT 環境事實都同主代理一致。閂咗就淨係主代理有,子代理跟官方 shell 語義行(提示詞唔改寫、路徑參數唔翻譯);留意 dsh 每個進程只有一個 shell 執行器,所以 Git Bash 本身仍然係全局嘅,呢個開關管嘅係方言/翻譯層。",
 				"eol.label": "Git 行尾(與 Linux 一致)",
 				"eol.hint": "模型執行的 git 指令採 Linux 行為:core.autocrlf=input、core.eol=lf。你自己終端的 git 與倉庫的 .gitattributes 都不受影響。",
 				"bash.label": "Git Bash 路徑",
@@ -810,6 +871,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python(實驗性)",
 				"python.off": "Node / TypeScript(預設)",
 				"python.hint": "閂咗(預設)嗰陣 run_code 用官方 Node/TypeScript 後端,同官方 ptc 組合逐位元組一致;開咗就轉用 dsh 實驗性 CPython 後端(@deepseek-ai/dsh-experimental-ptc-runtime-python),run_code 嘅語言、生成嘅 SDK 提示詞同工具呈現都會轉去 Python。需要 POSIX 平台同 CPython ≥ 3.10(Windows 用唔到),而且同 workflow 工具互斥——官方 Python 組合同樣停用 workflow,所以開住嗰陣本插件四個變體嘅 workflow 側會強制關閉(你嘅工作流設定值會保留,閂咗之後恢復)。改動要重啟 dsh 先生效;呢個開關就係 dsh-ptc-cordis-preset 設定卡上面同一個開關——兩邊共享同一份狀態。只喺已安裝 dsh-ptc-cordis-preset 時顯示。開咗之後唔生效,原因喺 dsh 啟動日誌度。",
+				"python.degraded": "後端用唔到,暫時仍然係 Node(原因喺 dsh 啟動日誌)",
 				"python.blocked": "呢部主機係 Windows:實驗性 Python 後端淨係支援 POSIX,所以呢個開關用唔到。",
 			},
 			/* locale: zh-mo */
@@ -833,6 +895,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "glob 嘅絕對 pattern 自動拆做 path + 相對 pattern;關閉就原樣傳遞。",
 				"code.label": "run_code 程式內路徑",
 				"code.hint": "run_code 程式內寫的 /c/... 路徑字面量會在執行前按同一張掛載表翻譯;註解、插值模板、$VAR 與非路徑字串不動,掃描有任何不確定就整份不改。 並為程式補上 TEMP/TMP:空 env 下 Windows 的 os.tmpdir() 會得到 undefined\\temp,程式會靜默寫錯位置。",
+				"sub.label": "子代理/隊員用 Git Bash",
+				"sub.hint": "預設開啟:子代理同團隊隊員(連嵌套)嘅提示詞方言、路徑參數翻譯、結果回顯同 DSH_PATH_DIALECT 環境事實都同主代理一致。閂咗就淨係主代理有,子代理跟官方 shell 語義行(提示詞唔改寫、路徑參數唔翻譯);留意 dsh 每個進程只有一個 shell 執行器,所以 Git Bash 本身仍然係全局嘅,呢個開關管嘅係方言/翻譯層。",
 				"eol.label": "Git 行尾(與 Linux 一致)",
 				"eol.hint": "模型執行的 git 指令採 Linux 行為:core.autocrlf=input、core.eol=lf。你自己終端的 git 與倉庫的 .gitattributes 都不受影響。",
 				"bash.label": "Git Bash 路徑",
@@ -849,6 +913,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python(實驗性)",
 				"python.off": "Node / TypeScript(預設)",
 				"python.hint": "閂咗(預設)嗰陣 run_code 用官方 Node/TypeScript 後端,同官方 ptc 組合逐位元組一致;開咗就轉用 dsh 實驗性 CPython 後端(@deepseek-ai/dsh-experimental-ptc-runtime-python),run_code 嘅語言、生成嘅 SDK 提示詞同工具呈現都會轉去 Python。需要 POSIX 平台同 CPython ≥ 3.10(Windows 用唔到),而且同 workflow 工具互斥——官方 Python 組合同樣停用 workflow,所以開住嗰陣本插件四個變體嘅 workflow 側會強制關閉(你嘅工作流設定值會保留,閂咗之後恢復)。改動要重啟 dsh 先生效;呢個開關就係 dsh-ptc-cordis-preset 設定卡上面同一個開關——兩邊共享同一份狀態。只喺已安裝 dsh-ptc-cordis-preset 時顯示。開咗之後唔生效,原因喺 dsh 啟動日誌度。",
+				"python.degraded": "後端用唔到,暫時仍然係 Node(原因喺 dsh 啟動日誌)",
 				"python.blocked": "呢部主機係 Windows:實驗性 Python 後端淨係支援 POSIX,所以呢個開關用唔到。",
 			},
 			/* locale: zh-tw */
@@ -872,6 +937,8 @@ window.__ModuleLoader__.load({
 				"split.hint": "glob 的絕對 pattern 自動拆為 path + 相對 pattern;關閉則原樣傳遞。",
 				"code.label": "run_code 程式內路徑",
 				"code.hint": "run_code 程式內寫的 /c/... 路徑字面量會在執行前按同一張掛載表翻譯;註解、插值模板、$VAR 與非路徑字串不動,掃描有任何不確定就整份不改。 並為程式補上 TEMP/TMP:空 env 下 Windows 的 os.tmpdir() 會得到 undefined\\temp,程式會靜默寫錯位置。",
+				"sub.label": "子代理/隊員使用 Git Bash",
+				"sub.hint": "預設開啟:子代理與團隊隊員(含巢狀)的提示詞方言、路徑參數翻譯、結果回顯與 DSH_PATH_DIALECT 環境事實都與主代理一致。關閉後僅對主代理生效,子代理依官方 shell 語意執行(提示詞不改寫、路徑參數不翻譯);請注意 dsh 每個行程只有一個 shell 執行器,因此 Git Bash 本身仍是全域的,這個開關管的是方言/翻譯層。",
 				"eol.label": "Git 行尾(與 Linux 一致)",
 				"eol.hint": "模型執行的 git 指令採 Linux 行為:core.autocrlf=input、core.eol=lf。你自己終端的 git 與倉庫的 .gitattributes 都不受影響。",
 				"bash.label": "Git Bash 路徑",
@@ -888,6 +955,7 @@ window.__ModuleLoader__.load({
 				"python.on": "Python(實驗性)",
 				"python.off": "Node / TypeScript(預設)",
 				"python.hint": "關閉(預設)時 run_code 使用官方 Node/TypeScript 後端,與官方 ptc 組合逐位元組一致;開啟後改用 dsh 實驗性 CPython 後端(@deepseek-ai/dsh-experimental-ptc-runtime-python),run_code 的語言、產生的 SDK 提示詞與工具呈現都會切換到 Python。需要 POSIX 平台與 CPython ≥ 3.10(Windows 無法使用),且與 workflow 工具互斥——官方 Python 組合同樣會停用 workflow,因此開啟期間本外掛四個變體的 workflow 側強制關閉(你的工作流設定值會保留,關閉後恢復)。變更需重新啟動 dsh 後生效;這個開關就是 dsh-ptc-cordis-preset 設定卡上的同一個開關——兩側共用同一份狀態。僅在已安裝 dsh-ptc-cordis-preset 時顯示。若設為開啟後未生效,原因見 dsh 啟動日誌。",
+				"python.degraded": "後端無法使用,目前仍為 Node(原因見 dsh 啟動日誌)",
 				"python.blocked": "此主機是 Windows:實驗性 Python 後端僅支援 POSIX,因此這個開關無法使用。",
 			},
 		};
@@ -1176,6 +1244,9 @@ window.__ModuleLoader__.load({
 			var errs = snap.value.errorDialect !== false;
 			var splits = snap.value.globSplit !== false;
 			var codes = snap.value.codePaths !== false;
+			// v0.27.0: delegated agents (subagents / team members / nested
+			// children) participate in the dialect unless this is switched off.
+			var subagents = snap.value.subagentDialect !== false;
 			var eolOn = snap.value.gitAutocrlf !== false;
 			var dedupe = snap.value.suppressPeerCordis === true;
 
@@ -1227,6 +1298,15 @@ window.__ModuleLoader__.load({
 					E("button", { type: "button", className: "gb-segBtn" + (!codes ? " gb-segActive" : ""), onClick: function () { if (codes) writeField("codePaths", false); } }, t("switch.off")),
 				),
 				E("p", { className: "gb-hint" }, t("code.hint")),
+				E("div", { className: "gb-row" },
+					E("span", { className: "gb-rowLabel" }, t("sub.label") + ":"),
+					E("span", { className: "gb-rowValue" }, subagents ? t("state.on") : t("state.off")),
+				),
+				E("div", { className: "gb-seg" },
+					E("button", { type: "button", className: "gb-segBtn" + (subagents ? " gb-segActive" : ""), onClick: function () { if (!subagents) writeField("subagentDialect", true); } }, t("switch.on")),
+					E("button", { type: "button", className: "gb-segBtn" + (!subagents ? " gb-segActive" : ""), onClick: function () { if (subagents) writeField("subagentDialect", false); } }, t("switch.off")),
+				),
+				E("p", { className: "gb-hint" }, t("sub.hint")),
 				E("div", { className: "gb-row" },
 					E("span", { className: "gb-rowLabel" }, t("eol.label") + ":"),
 					E("span", { className: "gb-rowValue" }, eolOn ? t("state.on") : t("state.off")),
@@ -1300,6 +1380,13 @@ window.__ModuleLoader__.load({
 				&& typeof peerSnap.value === "object"
 				&& Object.prototype.hasOwnProperty.call(peerSnap.value, PEER_PYTHON_FIELD);
 			var pythonOn = pythonOffered && peerSnap.value[PEER_PYTHON_FIELD] === true;
+			var peerPythonBackend = "";
+			if (pythonOffered && typeof peerSnap.value[PEER_PYTHON_BACKEND_FIELD] === "string") {
+				peerPythonBackend = peerSnap.value[PEER_PYTHON_BACKEND_FIELD];
+			}
+			/* Intent on + effective node = the user asked for Python and the host
+			   is still running Node behind the official rows. */
+			var pythonDegraded = pythonOn && peerPythonBackend === "node";
 			function writePython(next) {
 				setError("");
 				if (peer === null || typeof peer.set !== "function") return;
@@ -1322,7 +1409,9 @@ window.__ModuleLoader__.load({
 				E("div", { className: "gb-stack" },
 				E("div", { className: "gb-row" },
 					E("span", { className: "gb-rowLabel" }, t("python.label") + ":"),
-					E("span", { className: "gb-rowValue" }, pythonOn ? t("python.on") : t("python.off")),
+					E("span", { className: "gb-rowValue" }, pythonOn
+						? (pythonDegraded ? t("python.on") + " · " + t("python.degraded") : t("python.on"))
+						: t("python.off")),
 				),
 				winHost ? null : E("div", { className: "gb-seg" },
 					E("button", { type: "button", className: "gb-segBtn" + (pythonOn ? " gb-segActive" : ""), onClick: function () { if (!pythonOn) writePython(true); } }, t("switch.on")),
@@ -1330,6 +1419,7 @@ window.__ModuleLoader__.load({
 				),
 				E("p", { className: "gb-hint" }, t("python.hint")),
 				winHost ? E("p", { className: "gb-error" }, t("python.blocked")) : null,
+				pythonDegraded ? E("p", { className: "gb-error" }, t("python.degraded")) : null,
 				),
 			) : null;
 

package/src/compositions.js

@@ -13,10 +13,11 @@
  * always off (the host executor is this plugin's shell.js — on non-Windows
  * hosts that is the native stack anyway, which is exactly what the old
  * materialized variants encoded). A second, conditional delta exists while
- * dsh-ptc-cordis-preset reports its experimental-CPython switch on: the two
- * workflow rows follow the official Python composition and go off (see
- * `pythonRuntime` below). With that switch off — the default — the rows are
- * the official ones unchanged.
+ * dsh-ptc-cordis-preset reports its experimental-CPython backend ACTIVE: the
+ * two workflow rows follow the official Python composition and go off (see
+ * `pythonActive` below). While that backend is off — the default, and also
+ * whenever the peer's preflight failed — the rows are the official ones
+ * unchanged.
  */
 
 /** Default Git Bash binary — must match src/shell.js and the patch config. */
@@ -48,22 +49,25 @@ When ready, call exit_plan_mode with the complete plan markdown, starting with a
  * @param {boolean} input.gitBash - bash rows always on, pwsh rows always off.
  * @param {string|undefined} input.skillsDir - Creation authoring skills
  *   directory (cordis variant only; resolved beside the agent-preset package).
- * @param {boolean} [input.pythonRuntime] - the peer's experimental-CPython
- *   switch. `workflow-ptc` hard-requires `ctx.ptcRuntime.language ===
- *   'typescript'` (packages/workflow/workflow-ptc/src/index.ts:117) while the
- *   CPython backend reports 'python', and a throwing preset row rejects the
- *   WHOLE mount (agent-preset-registry mount.ts). The official Python
- *   composition disables both workflow rows for exactly this reason
- *   (snapshots/session/ptc-python-turn/cordis.yml), so with the switch on
- *   every variant mirrors that: the two rows go off, the user's own workflow
- *   setting is untouched and returns when the switch goes back off.
+ * @param {boolean} [input.pythonActive] - whether the experimental CPython
+ *   backend is the one run_code will ACTUALLY use (the peer's effective
+ *   backend, not the bare user intent: when its preflight fails the
+ *   composition still runs Node and the workflow rows must stay live).
+ *   `workflow-ptc` hard-requires `ctx.ptcRuntime.language === 'typescript'`
+ *   (packages/workflow/workflow-ptc/src/index.ts:117) while the CPython
+ *   backend reports 'python', and a throwing preset row rejects the WHOLE
+ *   mount (agent-preset-registry mount.ts). The official Python composition
+ *   disables both workflow rows for exactly this reason
+ *   (snapshots/session/ptc-python-turn/cordis.yml), so while CPython is
+ *   active every variant mirrors that: the two rows go off, the user's own
+ *   workflow setting is untouched and returns once it is not.
  * @returns {object[]} the declarative plugins list.
  */
-export function pluginsFor({ kind, gitBash, skillsDir, pythonRuntime = false }) {
+export function pluginsFor({ kind, gitBash, skillsDir, pythonActive = false }) {
   const win = typeof process !== 'undefined' && process.platform === 'win32'
   const bashDisabled = gitBash ? false : win
   const pwshDisabled = gitBash ? true : !win
-  const workflowOn = kind !== 'ptc' && pythonRuntime !== true
+  const workflowOn = kind !== 'ptc' && pythonActive !== true
   const rows = [
     {
       id: 'persona',

package/src/index.js

@@ -104,15 +104,23 @@ export const PEER_COVERED_PRESET_ID = 'cordis-gitbash'
 
 /**
  * Service dsh-ptc-cordis-preset publishes:
- * `{ id, gitBashActive, pythonRuntime }`. `pythonRuntime` (boolean, default
- * false when absent, read from a getter too) is the peer's experimental
- * CPython switch for run_code.
+ * `{ id, gitBashActive, pythonRuntime, pythonBackend? }`. `pythonRuntime` is
+ * the user's INTENT for the experimental CPython run_code backend (the field
+ * the settings card writes); `pythonBackend` ('python' | 'node', v0.15.1+,
+ * additive) is the backend that is ACTUALLY active after the peer's own
+ * preflight — package resolvable, interpreter qualified, POSIX host.
  */
 export const PEER_CAPABILITY = 'ptcCordisPreset'
 
-/** The peer's CPython-switch field, on its capability and on its row Config. */
+/**
+ * The peer's CPython intent field — on its capability AND on its row Config
+ * (the field both settings cards read and write).
+ */
 export const PEER_PYTHON_FIELD = 'pythonRuntime'
 
+/** The peer's EFFECTIVE backend field on the capability ('python' | 'node'). */
+export const PEER_PYTHON_BACKEND_FIELD = 'pythonBackend'
+
 /**
  * Read one boolean fact off the peer's capability object. A getter is honoured
  * so a live peer can report its current switch rather than a boot-time copy;
@@ -133,6 +141,90 @@ export function peerFact(capability, field) {
   }
 }
 
+/**
+ * The peer's EFFECTIVE run_code backend, as the closed two-value vocabulary it
+ * publishes. `undefined` means "the peer does not report one" — an older peer,
+ * a getter that threw, or a value outside the vocabulary — and every caller
+ * must then fall back to the INTENT, which is the pre-v0.15.1 behavior.
+ * @param {object|undefined} capability - the peer's published capability.
+ * @returns {'python'|'node'|undefined} the reported backend.
+ */
+export function peerBackend(capability) {
+  if (capability === null || capability === undefined) return undefined
+  try {
+    const raw = capability[PEER_PYTHON_BACKEND_FIELD]
+    const value = typeof raw === 'function' ? raw.call(capability) : raw
+    return value === 'python' || value === 'node' ? value : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Is the experimental CPython backend ACTUALLY the one run_code will use? The
+ * composition's workflow mutex keys on this, never on the bare intent: when the
+ * peer's preflight fails (package removed, interpreter too old, win32) the
+ * composition still runs Node, so forcing the workflow rows off would cost the
+ * user a capability for nothing.
+ *
+ * An older peer without the effective field reports no backend, and the intent
+ * stands in for it — exactly the pre-v0.15.1 behavior, so the linkage never
+ * changes shape because a field is missing.
+ * @param {object|undefined} capability - the peer's published capability.
+ * @returns {boolean} true only while the CPython backend is the active one.
+ */
+export function pythonBackendActive(capability) {
+  const intent = peerFact(capability, PEER_PYTHON_FIELD)
+  const reported = peerBackend(capability)
+  if (reported === undefined) return intent
+  return intent && reported === 'python'
+}
+
+/**
+ * Is this agent a DELEGATED one — a subagent, a team member, or a nested child
+ * of either? The canonical in-tree signal is the session header pair dsh's own
+ * workspace-changes plugin uses
+ * (`packages/deliverables/workspace-changes/src/index.ts:59-60`), stamped when
+ * the subagent driver creates a child
+ * (`packages/subagent/subagent/src/child-agent.ts:139-155`):
+ * `origin === 'subagent'` or a non-zero `delegationDepth`.
+ *
+ * Unknown shapes read as NOT delegated: applying the dialect is the helpful
+ * direction, and a diagnostic assembly without an agent must keep it.
+ * @param {object|undefined} agent - the assembling/executing agent, when known.
+ * @returns {boolean} true only when the agent is provably delegated.
+ */
+export function isDelegatedAgent(agent) {
+  try {
+    const header = agent && agent.session ? agent.session.header : undefined
+    if (header === null || typeof header !== 'object') return false
+    if (header.origin === 'subagent') return true
+    return typeof header.delegationDepth === 'number' && header.delegationDepth > 0
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Does the Git Bash dialect apply to THIS agent (v0.27.0)? The row switch
+ * `subagentDialect` (default ON) decides whether delegated agents — subagents,
+ * team members, nested children — participate in the dialect at all; the main
+ * agent always does. A closed function so every consumer (prompt assembly,
+ * dispatch translation, result echo, failure text, the shell-env fact) answers
+ * the same way.
+ *
+ * Note the honest bound: dsh has exactly ONE shell provider per process, so
+ * the executor binary stays Git Bash for every agent; this gate governs the
+ * dialect/translation layers that this plugin owns.
+ * @param {object} dialect - the live dialect switches.
+ * @param {object|undefined} agent - the agent that owns this assembly/execution.
+ * @returns {boolean} true when the dialect applies to this agent.
+ */
+export function dialectApplies(dialect, agent) {
+  if (!dialect || dialect.subagentDialect !== false) return true
+  return !isDelegatedAgent(agent)
+}
+
 /**
  * The roster this plugin serves: the configured list, minus the variant a peer
  * already covers. Two independent facts must BOTH hold before anything is
@@ -776,6 +868,15 @@ export const Config = Schema === null ? undefined : Schema.object({
   globSplit: live(Schema.boolean().default(true)),
   errorDialect: live(Schema.boolean().default(true)),
   codePaths: live(Schema.boolean().default(true)),
+  /**
+   * Whether DELEGATED agents (subagents, team members, nested children) also
+   * use the Git Bash dialect (v0.27.0). Default ON — the historical behavior;
+   * OFF keeps the dialect to the main agent, so a delegated request carries the
+   * official shell semantics (no prompt rewrite, no path-argument translation,
+   * no echo rewrite, no DSH_PATH_DIALECT fact). The executor itself is one
+   * per-process provider, so Git Bash stays the binary either way.
+   */
+  subagentDialect: live(Schema.boolean().default(true)),
   gitAutocrlf: live(Schema.boolean().default(true)),
   bashPath: live(Schema.string().default('')),
   adoptSidebar: live(Schema.boolean().default(true)),
@@ -822,6 +923,8 @@ function makeLiveReader(ctx, config) {
       errorDialect: valueOf(config.errorDialect) === true,
       codePaths: valueOf(config.codePaths) === true,
       gitAutocrlf: valueOf(config.gitAutocrlf) === true,
+      // Default ON: delegated agents keep the dialect unless the user opts out.
+      subagentDialect: valueOf(config.subagentDialect) !== false,
       bashPath: typeof bash === 'string' ? bash : '',
       adoptSidebar: valueOf(config.adoptSidebar) !== false,
     }
@@ -896,7 +999,7 @@ export function readPosixPaths(ctxLike) {
  * first. All default ON (schema defaults); never throws.
  */
 export function readDialectSettings(ctxLike) {
-  const fallback = { posixPaths: false, virtualMounts: false, globSplit: false, errorDialect: false, codePaths: false, gitAutocrlf: false, bashPath: '' }
+  const fallback = { posixPaths: false, virtualMounts: false, globSplit: false, errorDialect: false, codePaths: false, gitAutocrlf: false, bashPath: '', subagentDialect: true }
   try {
     const settings = ctxLike && typeof ctxLike.get === 'function' ? ctxLike.get('settings') : undefined
     const value = settings && typeof settings.get === 'function' ? settings.get(SETTINGS_NAMESPACE) : undefined
@@ -907,6 +1010,8 @@ export function readDialectSettings(ctxLike) {
       globSplit: v.globSplit === true,
       errorDialect: v.errorDialect === true,
       codePaths: v.codePaths === true,
+      // An old host without the key keeps the default (delegated agents covered).
+      subagentDialect: v.subagentDialect !== false,
       gitAutocrlf: v.gitAutocrlf === true,
       bashPath: typeof v.bashPath === 'string' ? v.bashPath : '',
     }
@@ -2057,12 +2162,12 @@ function cleanupLegacyTrees(presetIds) {
  * failures stay visible through the roster's broken diagnostic instead of
  * failing the boot.
  */
-async function registerVariant(ctx, presetId, { gitBashActive, skillsDir, pythonRuntime }) {
+async function registerVariant(ctx, presetId, { gitBashActive, skillsDir, pythonActive }) {
   const meta = PRESET_META[presetId]
   if (!meta) return undefined
   const plugins = meta.kind === 'minimal'
     ? minimalPluginsFor()
-    : pluginsFor({ kind: meta.kind, gitBash: gitBashActive, skillsDir, pythonRuntime })
+    : pluginsFor({ kind: meta.kind, gitBash: gitBashActive, skillsDir, pythonActive })
   return ctx.agentPresets.register({
     id: presetId,
     name: meta.name,
@@ -2077,10 +2182,11 @@ async function registerVariant(ctx, presetId, { gitBashActive, skillsDir, python
  * SHOULD SERVE for the plugin's lifetime, and re-reconcile whenever that set
  * changes. Three inputs drive it — the live `suppressPeerCordis` switch, the
  * peer capability appearing (or leaving) via `ctx.inject`, which fires
- * independent of row activation order, and the peer's experimental-CPython
- * fact (`pythonRuntime`), which changes the ROWS of every variant — and the
- * peer's own coverage only counts while it reports a Git Bash-materialized
- * preset.
+ * independent of row activation order, and the peer's EFFECTIVE CPython
+ * backend (`pythonBackend`, falling back to the `pythonRuntime` intent on a
+ * peer that does not report one), which changes the ROWS of every variant —
+ * and the peer's own coverage only counts while it reports a Git Bash-
+ * materialized preset.
  *
  * The roster picks entries up immediately; sessions already pinned to a
  * variant keep their revision until recomposed, so suppressing a variant never
@@ -2107,17 +2213,19 @@ async function runDeclarativeEra(ctx, presetIds, readSuppress) {
   const reconcile = () => {
     serial = serial.then(async () => {
       const want = desired()
-      // The peer's CPython switch rewrites the workflow rows of EVERY variant
-      // (the official Python composition disables them, and workflow-ptc
-      // refuses a non-TypeScript backend), so a flip re-registers the live
-      // variants instead of leaving stale rows mounted. Same cadence as the
-      // backend swap itself: the peer's patch is evaluated at boot.
+      // The peer's EFFECTIVE CPython backend rewrites the workflow rows of
+      // EVERY variant (the official Python composition disables them, and
+      // workflow-ptc refuses a non-TypeScript backend), so a flip re-registers
+      // the live variants instead of leaving stale rows mounted. Same cadence
+      // as the backend swap itself: the peer's patch is evaluated at boot. A
+      // bare INTENT without the effective backend changes nothing here — the
+      // composition still runs Node, so the workflow rows must stay live.
       if (live.size > 0 && registeredPython !== peerPython) {
         for (const [presetId, off] of [...live]) {
           live.delete(presetId)
           try {
             await off()
-            console.log(TAG + " preset '" + presetId + "' retired (peer CPython switch changed; rows are rebuilt)")
+            console.log(TAG + " preset '" + presetId + "' retired (peer CPython backend changed; rows are rebuilt)")
           } catch (error) {
             console.log(TAG + " preset '" + presetId + "' retirement failed: " + (error && error.message ? error.message : error))
           }
@@ -2136,7 +2244,7 @@ async function runDeclarativeEra(ctx, presetIds, readSuppress) {
       for (const presetId of want) {
         if (live.has(presetId)) continue
         try {
-          const unregister = await registerVariant(ctx, presetId, { gitBashActive, skillsDir, pythonRuntime: peerPython })
+          const unregister = await registerVariant(ctx, presetId, { gitBashActive, skillsDir, pythonActive: peerPython })
           if (unregister) {
             live.set(presetId, unregister)
             console.log(TAG + " preset '" + presetId + "' registered declaratively")
@@ -2163,11 +2271,21 @@ async function runDeclarativeEra(ctx, presetIds, readSuppress) {
       try {
         const coverage = peerCtx[PEER_CAPABILITY] ?? peerCtx.get(PEER_CAPABILITY)
         const nextGitBash = peerFact(coverage, 'gitBashActive')
-        const nextPython = peerFact(coverage, PEER_PYTHON_FIELD)
+        // INTENT (what the user asked for) vs EFFECTIVE (what run_code will
+        // actually use). Only the effective fact may cost the user a variant's
+        // workflow rows; the intent alone is reported, never acted on.
+        const intentPython = peerFact(coverage, PEER_PYTHON_FIELD)
+        const reportedBackend = peerBackend(coverage)
+        const nextPython = pythonBackendActive(coverage)
         if (nextGitBash !== peerGitBash || nextPython !== peerPython) {
           peerGitBash = nextGitBash
           peerPython = nextPython
           if (nextPython) console.log(TAG + ' peer reports the experimental CPython run_code backend: workflow rows go off in every variant')
+          else if (intentPython) {
+            console.log(TAG + ' peer has the CPython switch on but the effective backend is '
+              + (reportedBackend === undefined ? 'unreported (older peer: the intent stands in)' : reportedBackend)
+              + ': workflow rows stay on (reason in the host log)')
+          }
           void reconcile()
         }
       } catch (error) {
@@ -2276,6 +2394,7 @@ export async function apply(ctx, config = {}) {
             globSplit: Schema.boolean().default(true),
             errorDialect: Schema.boolean().default(true),
             codePaths: Schema.boolean().default(true),
+            subagentDialect: Schema.boolean().default(true),
             gitAutocrlf: Schema.boolean().default(true),
             bashPath: Schema.string().default(''),
             adoptSidebar: Schema.boolean().default(true),
@@ -2331,8 +2450,17 @@ export async function apply(ctx, config = {}) {
             // git line endings and anything else non-DSH_* ride the executor's
             // own env layer (src/shell.js), not this registry.
             variables: { [PATH_DIALECT_KEY]: { description: PATH_DIALECT_DESCRIPTION } },
-            resolve() {
-              return liveSettings.posix() ? { [PATH_DIALECT_KEY]: PATH_DIALECT_VALUE } : {}
+            resolve(execution) {
+              try {
+                const dialect = liveSettings.dialect()
+                if (dialect.posixPaths !== true) return {}
+                // The environment fact is per execution, so a delegated agent
+                // the user excluded sees no DSH_PATH_DIALECT at all.
+                if (!dialectApplies(dialect, execution && execution.agent)) return {}
+                return { [PATH_DIALECT_KEY]: PATH_DIALECT_VALUE }
+              } catch {
+                return {}
+              }
             },
           })
           envCtx.effect(() => unregister, 'dsh-gitbash-shell: shellEnv path-dialect fact')
@@ -2358,9 +2486,16 @@ export async function apply(ctx, config = {}) {
   // could corrupt pattern/default fields).
   if (process.platform === 'win32') {
     try {
-      ctx.on('system-prompt/assemble', (assembly, _assembleContext, next) => {
+      ctx.on('system-prompt/assemble', (assembly, assembleContext, next) => {
         try {
-          if (liveSettings.posix() && assembly && typeof assembly === 'object') {
+          /* v0.27.0: the main agent always participates; a DELEGATED agent
+             (subagent / team member / nested child) only while the
+             `subagentDialect` switch is on. Turning it off leaves the official
+             prompt text untouched for those agents — no source replacement and
+             no run_code hint — so they meet the shell they were composed for. */
+          const dialect = liveSettings.dialect()
+          const applies = dialectApplies(dialect, assembleContext && assembleContext.agent)
+          if (applies && dialect.posixPaths === true && assembly && typeof assembly === 'object') {
             for (const section of Array.isArray(assembly.sections) ? assembly.sections : []) {
               if (section && typeof section.text === 'string') section.text = windowsToMsys(section.text)
             }
@@ -2431,7 +2566,10 @@ export async function apply(ctx, config = {}) {
           // `bash.workdir` went through raw, and an in-workspace `/c/...` write
           // fell outside the sandbox. One missed call site, five symptoms.
           const dialect = liveSettings.dialect()
-          if (dialect.posixPaths) {
+          // v0.27.0: a delegated agent the user excluded keeps the official
+          // semantics for BOTH faces of its calls — arguments go through
+          // untouched and the result metadata is not echoed back in MSYS form.
+          if (dialect.posixPaths && dialectApplies(dialect, exec && exec.agent)) {
             echo = true
             const env = dialect.virtualMounts ? buildTranslateEnv(dialect.bashPath) : null
             echoEnv = env
@@ -2482,6 +2620,10 @@ export async function apply(ctx, config = {}) {
         let contentPatch
         try {
           const dialect = liveSettings.dialect()
+          // Same agent gate as the dispatch wrapper: one call, one dialect.
+          // RETURN the downstream promise: a waterfall listener that swallows
+          // it would hand the caller `undefined` instead of the decision.
+          if (!dialectApplies(dialect, exec && exec.agent)) return next()
           if (dialect.posixPaths && dialect.errorDialect && exec && result && typeof result === 'object'
             && result.isError === true && Array.isArray(result.content)) {
             const env = dialect.virtualMounts ? buildTranslateEnv(dialect.bashPath) : null
@@ -2528,10 +2670,14 @@ export async function apply(ctx, config = {}) {
           pctx.effect(() => pctx.systemPrompt.context({
             name: 'gitbash-shell:posix-paths',
             order: 126,
-            text: () => {
+            text: (assembleContext) => {
               try {
                 const dialect = liveSettings.dialect()
                 if (dialect.posixPaths !== true) return ''
+                // A delegated agent whose dialect the user turned off meets the
+                // official shell semantics: no directive, the same way no
+                // translation happens for its calls.
+                if (!dialectApplies(dialect, assembleContext && assembleContext.agent)) return ''
                 return dialect.virtualMounts === false ? POSIX_DIRECTIVE_TEXT_STRICT : POSIX_DIRECTIVE_TEXT
               } catch {
                 return ''
@@ -2657,4 +2803,4 @@ export async function apply(ctx, config = {}) {
 }
 
 // Test surface: pure helpers, no Cordis context required.
-export const _internal = { PRESET_IDS, PEER_COVERED_PRESET_ID, PEER_CAPABILITY, PEER_PYTHON_FIELD, peerFact, effectivePresetIds, detectPeerCoverage, readSuppressPeerCordis, translateDispatch, translateMsysPath, translatePathArguments, rewriteCodePaths, scanCodeLiterals, programPrelude, translateGlobArguments, buildTranslateEnv, rewriteErrorContent, rewriteErrorMessage, rewriteFailureMessage, msysEcho, driveToMsys, pathEcho, ERROR_CONTENT_TOOLS, readPosixPaths, readAdoptSidebar, readDialectSettings, windowsToMsys, rewriteResultPaths, adoptSidebarShell, MARKER_FILE, classify, materialize, cleanupOnDispose, firstUserRoot, hashTree, skillsHashes, syncDecision, installRegisterShim, baseForRoster, detectBase, pickComposition, personaEraForText, detectPersonaEra, injectPresentRow, hostHasToolPresent, detectPresentSupport, injectPluginManagerRow, hostHasPluginManagerTools, rowFormOf, rowFormsOf, alignEngineRow, alignRalphRow, ROW_SOURCE }
+export const _internal = { PRESET_IDS, PEER_COVERED_PRESET_ID, PEER_CAPABILITY, isDelegatedAgent, dialectApplies, PEER_PYTHON_FIELD, PEER_PYTHON_BACKEND_FIELD, peerFact, peerBackend, pythonBackendActive, effectivePresetIds, detectPeerCoverage, readSuppressPeerCordis, translateDispatch, translateMsysPath, translatePathArguments, rewriteCodePaths, scanCodeLiterals, programPrelude, translateGlobArguments, buildTranslateEnv, rewriteErrorContent, rewriteErrorMessage, rewriteFailureMessage, msysEcho, driveToMsys, pathEcho, ERROR_CONTENT_TOOLS, readPosixPaths, readAdoptSidebar, readDialectSettings, windowsToMsys, rewriteResultPaths, adoptSidebarShell, MARKER_FILE, classify, materialize, cleanupOnDispose, firstUserRoot, hashTree, skillsHashes, syncDecision, installRegisterShim, baseForRoster, detectBase, pickComposition, personaEraForText, detectPersonaEra, injectPresentRow, hostHasToolPresent, detectPresentSupport, injectPluginManagerRow, hostHasPluginManagerTools, rowFormOf, rowFormsOf, alignEngineRow, alignRalphRow, ROW_SOURCE }