dsh-gitbash-shell 0.7.2 → 0.9.0

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-external/dsh-gitbash-shell",
-  "version": "0.7.2",
+  "version": "0.9.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.7.2",
+  "version": "0.9.0",
   "description": "DSH plugin: run every agent shell command through Git for Windows bash on Windows instead of PowerShell. Replaces the pwsh executor with a Git Bash ctx.shell provider and materializes Git Bash variants of the standard/minimal/code/cordis agent presets into your user preset root at startup. On Windows it also adopts dsh-better-sidebar's terminal shell (UI tabs and the model-facing terminal_* tools) through the sidebar's official settings seam, and pairs with dsh-ptc-cordis-preset so the PTC Creation-mode preset materializes as its Git Bash variant. Ships both composition eras for dsh <= 0.1.1 (built-in preset id 'code') and dsh >= 0.1.2 (renamed id 'ptc') — the era is probed per boot and re-materialized automatically after a dsh upgrade, in either upgrade order; preset ids never change so pinned sessions stay valid.",
   "type": "module",
   "repository": {
@@ -10,7 +10,8 @@
   "main": "src/index.js",
   "exports": {
     ".": "./src/index.js",
-    "./shell": "./src/shell.js"
+    "./shell": "./src/shell.js",
+    "./client": "./src/client.js"
   },
   "engines": {
     "node": ">=18"
@@ -18,6 +19,15 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-slots",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ],
+      "platform": "web"
     }
   },
   "files": [
@@ -42,7 +52,8 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1"
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/schemastery": "^3.18.1"
   },
   "publishConfig": {
     "access": "public"

package/src/client.js

@@ -0,0 +1,280 @@
+/**
+ * dsh-gitbash-shell — browser half (hand-written ModuleLoader bundle).
+ *
+ * ONE job: the Settings → Plugins card that gates the unified POSIX path
+ * dialect. The Plugins tab dispatches the intersection of Host-served
+ * namespaces and registered cards, so the card appears only when the host
+ * half (src/index.js) has registered the 'gitbash-shell' settings namespace.
+ *
+ * The card flips one boolean — posixPaths — through a bound settingsScope:
+ *   on  → the host injects the order-126 directive (every tool takes MSYS
+ *         drive roots /c/...) and the tools/execute wrapper translates
+ *         path-argument fields (/x/ → X:/) for the Node-backed file tools;
+ *   off → directive text is empty (dropped at assembly, zero prompt noise)
+ *         and the wrapper passes calls through untouched (dsh-native).
+ * Bash itself is always Git Bash while the plugin is installed; the switch
+ * only governs the cross-tool path dialect.
+ *
+ * Hand-written bundle rules (no build step in this repo):
+ *   - ONE window.__ModuleLoader__.load({...}) call, id = package name;
+ *   - require restricted to the client-module BASELINE whitelist
+ *     (react and @deepseek-ai/dsh-client-ui-primitives only, smoke-enforced);
+ *   - plain React.createElement, no JSX/TS; components at module level;
+ *   - dsh.client.inject in package.json lists the packages that must load
+ *     first so locale / settingsScope / slots exist when this applies.
+ */
+window.__ModuleLoader__.load({
+	id: "dsh-gitbash-shell",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+
+		var React = require("react");
+		var ui = require("@deepseek-ai/dsh-client-ui-primitives");
+
+		var E = React.createElement;
+		var useState = React.useState;
+
+		var TAG = "[gitbash-shell/client]";
+		/** Dictionary namespace (the plugin's own t seat). */
+		var NS = "gitbashShell";
+		/** The settings namespace the HOST half serves. */
+		var SETTINGS_NAMESPACE = "gitbash-shell";
+
+		// ── dictionaries (zh/en MUST stay key-aligned; smoke-enforced) ─────────
+
+		var zh = {
+			"title": "Git Bash 路径方言",
+			"cardDesc": "所有工具统一 /c/ POSIX 路径形式(默认关闭)",
+			"state.label": "当前状态",
+			"state.on": "已启用",
+			"state.off": "已关闭",
+			"switch.on": "启用",
+			"switch.off": "停用",
+			"error": "写入失败",
+			"hint": "启用后:所有工具(bash 命令与 workdir、read/write/edit/read_image/glob/grep 的路径参数)统一使用 MSYS 盘根 POSIX 路径(/c/Users/...);文件工具的路径参数由宿主自动翻译,模型无感。停用后恢复 dsh 原生行为(文件工具用 Windows 路径)。bash 始终是 Git Bash,不受此开关影响。",
+		};
+
+		var en = {
+			"title": "Git Bash path dialect",
+			"cardDesc": "One /c/ POSIX path style for every tool (off by default)",
+			"state.label": "Current state",
+			"state.on": "Enabled",
+			"state.off": "Disabled",
+			"switch.on": "Enable",
+			"switch.off": "Disable",
+			"error": "write failed",
+			"hint": "Enabled: every tool (bash commands and workdir, read/write/edit/read_image/glob/grep path arguments) uses MSYS drive-root POSIX paths (/c/Users/...); the host translates path fields for the file tools automatically. Disabled restores dsh-native behavior (Windows paths for file tools). Bash is always Git Bash while the plugin is installed; this switch only governs the cross-tool path dialect.",
+		};
+
+		// ── styles (gb- prefixed; tokens mirror PluginCard.module.css) ─────────
+
+		var STYLE_ID = "dsh-gitbash-shell-style";
+
+		var CSS = [
+			".gb-card{list-style:none;border:1px solid var(--dsw-alias-border-l2);border-radius:12px;background:var(--dsw-alias-bg-layer-3);transition:border-color .16s,background .16s}",
+			".gb-card:hover{border-color:var(--dsw-alias-label-dimmed)}",
+			".gb-card.gb-open{background:var(--dsw-alias-bg-layer-2);border-color:var(--dsw-alias-label-dimmed)}",
+			".gb-header{width:100%;appearance:none;border:0;background:none;font:inherit;color:inherit;text-align:left;cursor:pointer;display:flex;align-items:center;gap:12px;padding:14px 16px;border-radius:12px}",
+			".gb-header:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:-2px}",
+			".gb-headText{flex:1;min-width:0;display:flex;flex-direction:column;gap:4px}",
+			".gb-name{font-size:15px;font-weight:600;line-height:1.4;color:var(--dsw-alias-label-primary)}",
+			".gb-desc{font-size:13px;line-height:1.5;color:var(--dsw-alias-label-tertiary)}",
+			".gb-chevron{flex:none;color:var(--dsw-alias-label-tertiary);transition:transform .16s}",
+			".gb-chevron.gb-chevronOpen{transform:rotate(180deg)}",
+			".gb-body{display:flex;flex-direction:column;gap:12px;padding:4px 16px 16px;max-width:640px}",
+			".gb-row{display:flex;align-items:baseline;gap:8px;font-size:13px;line-height:1.5;color:var(--dsw-alias-label-secondary)}",
+			".gb-rowLabel{flex:none;color:var(--dsw-alias-label-tertiary)}",
+			".gb-rowValue{min-width:0;overflow-wrap:anywhere;color:var(--dsw-alias-label-primary)}",
+			".gb-seg{display:flex;gap:8px;flex-wrap:wrap}",
+			".gb-segBtn{appearance:none;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-secondary);font:inherit;font-size:13px;padding:6px 12px;cursor:pointer;transition:border-color .16s,color .16s}",
+			".gb-segBtn:hover{border-color:var(--dsw-alias-label-dimmed)}",
+			".gb-segBtn:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}",
+			".gb-segBtn.gb-segActive{border-color:var(--dsw-alias-brand-primary);color:var(--dsw-alias-label-primary)}",
+			".gb-hint{margin:0;font-size:12px;line-height:1.6;color:var(--dsw-alias-label-tertiary)}",
+			".gb-error{margin:0;font-size:12px;color:var(--dsw-alias-status-danger, #e5484d)}",
+		].join("\n");
+
+		function ensureStyles() {
+			try {
+				if (typeof document === "undefined" || typeof document.getElementById !== "function") return function () {};
+				if (document.getElementById(STYLE_ID)) return function () {};
+				var style = document.createElement("style");
+				style.id = STYLE_ID;
+				style.textContent = CSS;
+				document.head.appendChild(style);
+				return function () {
+					try {
+						if (style.parentNode) style.parentNode.removeChild(style);
+					} catch (error) { /* best effort */ }
+				};
+			} catch (error) {
+				return function () {};
+			}
+		}
+
+		/** Defensive primitives lookup: an unknown icon name degrades to a text chevron. */
+		function icon(name) {
+			try {
+				var component = ui && ui[name];
+				return typeof component === "function" ? component : null;
+			} catch (error) {
+				return null;
+			}
+		}
+
+		// ── error boundary (the dsh-better-workspace QuietBoundary pattern) ──────
+
+		/** A render failure degrades THIS card, never the settings page. */
+		function QuietBoundary(props) {}
+		QuietBoundary.prototype = Object.create(React.Component.prototype);
+		QuietBoundary.prototype.constructor = QuietBoundary;
+		QuietBoundary.state = { failed: false };
+		QuietBoundary.getDerivedStateFromError = function () { return { failed: true }; };
+		QuietBoundary.prototype.componentDidCatch = function (error) {
+			console.warn(TAG + " settings card render failed:", error && error.message ? error.message : error);
+		};
+		QuietBoundary.prototype.render = function () {
+			if (this.state && this.state.failed) return null;
+			return this.props.children;
+		};
+
+		// ── settings card (module-level component) ───────────────────────────────
+
+		/**
+		 * The Settings → Plugins card. t arrives through the registration's
+		 * locale field; scope arrives as a PLAIN prop from the inject factory.
+		 * Snapshots are read per render; each write bumps a local tick so the
+		 * card re-reads without an external-store hook adapter.
+		 */
+		function GitBashCard(props) {
+			var t = typeof props.t === "function" ? props.t : function (key) { return key; };
+
+			var openState = useState(false);
+			var open = openState[0];
+			var setOpen = openState[1];
+
+			var errorState = useState("");
+			var error = errorState[0];
+			var setError = errorState[1];
+
+			var tickState = useState(0);
+			var tick = tickState[0];
+			var bumpTick = tickState[1];
+			void tick;
+
+			var scope = props.scope;
+
+			var snap = { status: "unavailable" };
+			try {
+				if (scope && typeof scope.getSnapshot === "function") snap = scope.getSnapshot();
+			} catch (error_) { /* keep unavailable */ }
+
+			if (snap.status !== "ready") return null;
+
+			var value = snap.value || {};
+			var enabled = value.posixPaths === true;
+
+			function write(next) {
+				setError("");
+				scope.set("posixPaths", next)
+					.then(function () { bumpTick(function (n) { return n + 1; }); })
+					.catch(function (err) {
+						bumpTick(function (n) { return n + 1; });
+						setError(t("error") + ": " + (err && err.message ? err.message : String(err)));
+					});
+			}
+
+			var Chevron = icon("IconChevronDownOutline14");
+
+			return E("li", { className: "gb-card" + (open ? " gb-open" : "") },
+				E("button", {
+					type: "button",
+					className: "gb-header",
+					"aria-expanded": open,
+					onClick: function () { setOpen(!open); },
+				},
+					E("span", { className: "gb-headText" },
+						E("span", { className: "gb-name" }, t("title")),
+						E("span", { className: "gb-desc" }, t("cardDesc")),
+					),
+					Chevron
+						? E(Chevron, { className: "gb-chevron" + (open ? " gb-chevronOpen" : "") })
+						: E("span", { className: "gb-chevron" + (open ? " gb-chevronOpen" : "") }, "▾"),
+				),
+				open ? E("div", { className: "gb-body" },
+					E("div", { className: "gb-row" },
+						E("span", { className: "gb-rowLabel" }, t("state.label") + ":"),
+						E("span", { className: "gb-rowValue" }, enabled ? t("state.on") : t("state.off")),
+					),
+					E("div", { className: "gb-seg" },
+						E("button", {
+							type: "button",
+							className: "gb-segBtn" + (enabled ? " gb-segActive" : ""),
+							onClick: function () { if (!enabled) write(true); },
+						}, t("switch.on")),
+						E("button", {
+							type: "button",
+							className: "gb-segBtn" + (!enabled ? " gb-segActive" : ""),
+							onClick: function () { if (enabled) write(false); },
+						}, t("switch.off")),
+					),
+					error ? E("p", { className: "gb-error" }, error) : null,
+					E("p", { className: "gb-hint" }, t("hint")),
+				) : null,
+			);
+		}
+
+		// ── plugin ────────────────────────────────────────────────────────────
+
+		exports.name = "dsh-gitbash-shell/client";
+
+		/** Required client services: locale runtime, settings scopes, slots. */
+		exports.inject = ["locale", "settingsScope", "slots"];
+
+		exports.apply = function (ctx) {
+			var scope = ctx.settingsScope.bind({ namespace: SETTINGS_NAMESPACE });
+
+			ctx.effect(function () {
+				var disposers = [ensureStyles()];
+				try {
+					var disposeDict = ctx.locale.register(NS, { zh: zh, en: en });
+					if (typeof disposeDict === "function") disposers.push(disposeDict);
+				} catch (error) {
+					console.warn(TAG + " dictionary registration failed:", error && error.message ? error.message : error);
+				}
+				return function () {
+					for (var i = 0; i < disposers.length; i++) {
+						try {
+							if (typeof disposers[i] === "function") disposers[i]();
+						} catch (error) { /* best effort */ }
+					}
+				};
+			}, "dsh-gitbash-shell: styles, dictionaries");
+
+			// Guarded registration (the dsh-better-workspace pattern): a thrown
+			// register degrades this one seat, never the plugin fiber.
+			try {
+				var slots = ctx.slots;
+				if (!slots || typeof slots.inject !== "function") {
+					console.warn(TAG + " slots service unavailable; settings card idle");
+					return;
+				}
+				slots.inject("settings.plugin.item",
+					{
+						name: "settings.plugin.item",
+						key: SETTINGS_NAMESPACE,
+						locale: NS,
+						inject: function () { return { scope: scope }; },
+					},
+					function (props) {
+						return E(QuietBoundary, null, E(GitBashCard, props));
+				},
+				);
+			} catch (error) {
+				console.warn(TAG + " settings card registration failed:", error && error.message ? error.message : error);
+			}
+		};
+	},
+});

package/src/index.js

@@ -290,6 +290,75 @@ export function installRegisterShim(reg) {
   }
 }
 
+// ── unified path dialect: settings namespace + gate (v0.9.0) ───────────────
+//
+// The dialect (directive + translation wrapper) is OFF by default and gated
+// by the posixPaths boolean in the 'gitbash-shell' settings namespace,
+// flipped from the Settings → Plugins card (src/client.js). The directive's
+// text closure returns '' while off — empty context contributions are
+// dropped at assembly, so a disabled dialect adds zero prompt noise; the
+// wrapper reads the same value per dispatch and passes calls through.
+
+const SETTINGS_NAMESPACE = 'gitbash-shell'
+
+/** The full directive text, injected only while posixPaths is on. */
+const POSIX_DIRECTIVE_TEXT = 'The host is Windows and the working shell is Git for Windows bash: use POSIX-style paths with MSYS drive roots everywhere — /c/Users/..., /e/project/... Every tool accepts this form: bash commands and the workdir parameter, and the file tools (read, write, edit, read_image, glob, grep) file_path/path arguments — MSYS roots are translated for them automatically, so never switch to a Windows form on their behalf. Never emit Windows drive-letter paths (C:\Users or C:/Users): when instructions, facts, or context show one, rewrite it to the POSIX form before use; when a tool result prints a Windows path, use its POSIX form (/c/...) in later calls.'
+
+/** Read the posixPaths switch from the live settings service; never throws. */
+export function readPosixPaths(ctxLike) {
+  try {
+    const settings = ctxLike && typeof ctxLike.get === 'function' ? ctxLike.get('settings') : undefined
+    const value = settings && typeof settings.get === 'function' ? settings.get(SETTINGS_NAMESPACE) : undefined
+    return !!(value && value.posixPaths === true)
+  } catch {
+    return false
+  }
+}
+
+// ── MSYS drive-root path translation (Windows, EVERY tool dispatch) ────────
+//
+// The directive below tells the model to use POSIX-style MSYS paths (/c/...)
+// for EVERY tool. Bash digests those natively, but the Node-backed file tools
+// resolve an MSYS root against the current drive (/c/Users -> C:/c/Users), so a
+// global tools/execute wrapper rewrites the path-bearing ARGUMENT FIELDS (by
+// field NAME, not by tool name — dynamic tools using the standard field names
+// are covered too) into the drive-letter form the host accepts. The bash
+// command field is deliberately untouched: MSYS roots are Git Bash native
+// there. Defensive by design: the waterfall hands the same mutable exec object
+// to the tool body, but if a future registry freezes it the write throws, is
+// swallowed, and the call proceeds with the model original arguments (the
+// directive still stands).
+
+const MSYS_DRIVE_ROOT = /^\/([a-z])\/(.*)$/i
+const TRANSLATABLE_PATH_FIELDS = new Set(['file_path', 'path', 'workdir'])
+
+/** '/c/Users/x' -> 'C:/Users/x'; any other shape returns the input unchanged. */
+export function translateMsysPath(value) {
+  if (typeof value !== 'string') return value
+  const match = MSYS_DRIVE_ROOT.exec(value)
+  if (!match) return value
+  return match[1].toUpperCase() + ':/' + match[2]
+}
+
+/**
+ * Rewrite MSYS drive roots in an arguments object path fields, in place.
+ * @returns {boolean} whether any field changed (false also when args is not
+ *   an object — the caller treats that as nothing to do).
+ */
+export function translatePathArguments(args) {
+  if (!args || typeof args !== 'object') return false
+  let changed = false
+  for (const key of Object.keys(args)) {
+    if (!TRANSLATABLE_PATH_FIELDS.has(key)) continue
+    const value = args[key]
+    if (typeof value !== 'string') continue
+    const translated = translateMsysPath(value)
+    if (translated === value) continue
+    try { args[key] = translated; changed = true } catch { /* frozen: degrade */ }
+  }
+  return changed
+}
+
 // ── dsh-better-sidebar shell cooperation ───────────────────────────────────
 //
 // dsh-better-sidebar (v0.15.2+) resolves its terminal shell PER OPEN: a
@@ -458,14 +527,65 @@ export async function apply(ctx, config = {}) {
   const disposeGitBash = ctx.provide('gitBash', gitBashCapability)
   ctx.effect(() => disposeGitBash, 'dsh-gitbash-shell: gitBash capability')
 
-  // ── POSIX path directive (Windows Git Bash, EVERY session) ─────────────
-  // The host shell is Git for Windows bash for every mode/preset on this
-  // machine: drive-letter paths (C:/..., C:\...) are a Windows-shell idiom
-  // that Git Bash only sometimes tolerates, /c/... is the unambiguous form.
-  // One global runtime-context directive (same channel dsh-agent-lang uses;
+  // ── settings namespace: the posixPaths switch (default OFF) ──────────────
+  // Served on the host so the Plugins tab pairs it with the browser card
+  // (the tab dispatches Host-served namespaces ∩ registered cards). Dynamic
+  // imports keep the zero-dependency smoke path importable; the schema MUST
+  // be a callable schemastery object (dsh-settings calls schema(merged)).
+  try {
+    ctx.inject(['settings'], (sctx) => {
+      Promise.all([import('@deepseek-ai/dsh-settings'), import('@deepseek-ai/schemastery')])
+        .then(([ds, sm]) => {
+          const settings = sctx && sctx.settings
+          if (!settings || typeof settings.register !== 'function') return
+          const Schema = sm.default
+          // Era probe: newer dsh register() takes a plain string; the older
+          // one accepted the branded helper — one call satisfies both.
+          const ns = typeof ds.settingsNamespace === 'function'
+            ? ds.settingsNamespace(SETTINGS_NAMESPACE)
+            : SETTINGS_NAMESPACE
+          settings.register(ns, Schema.object({
+            posixPaths: Schema.boolean().default(false),
+          }))
+          console.log(`${TAG} settings namespace registered: ${SETTINGS_NAMESPACE} (posixPaths default off)`)
+        })
+        .catch((error) => {
+          console.log(`${TAG} settings namespace registration FAILED: ${error && error.stack || String(error)}`)
+        })
+    })
+  } catch (error) {
+    console.log(`${TAG} settings inject wiring failed: ${error?.message ?? error}`)
+  }
+
+  // ── MSYS path translation on every tool dispatch (Windows only) ─────────
+  // Covers every preset and mode: the wrapper sits on the global
+  // tools/execute waterfall, through which model-direct calls, PTC run_code
+  // sub-dispatches, and dynamic-tool calls all pass.
+  if (process.platform === 'win32') {
+    try {
+      ctx.on('tools/execute', (exec, next) => {
+        try {
+          if (exec && exec.arguments && typeof exec.arguments === 'object' && readPosixPaths(ctx)) {
+            translatePathArguments(exec.arguments)
+          }
+        } catch { /* never block a call on translation */ }
+        return next()
+      })
+      console.log(TAG + ' MSYS drive-root translation active on tool dispatch')
+    } catch (error) {
+      console.log(TAG + ' tools/execute wiring failed: ' + (error?.message ?? error))
+    }
+  }
+
+  // ── Unified POSIX path directive (Windows Git Bash, EVERY session) ─────
+  // ONE path style for every tool: MSYS drive roots (/c/Users/...). Bash
+  // digests them natively; the file tools receive the drive-letter form
+  // through the translation wrapper above, so the model never has to switch
+  // dialects. The directive also pins the rewrite rules that neutralize the
+  // Windows-form facts the harness injects elsewhere (backslash cwd strings,
+  // tool results printing drive-letter paths). Same channel as dsh-agent-lang;
   // order 126 sits after the official CONTEXT_ORDERS 110/115/120 and beside
-  // the 125 free slot) so no preset/persona has to carry it. Non-Windows
-  // mounts inject nothing.
+  // the 125 free slot. Non-Windows mounts inject nothing.
   if (process.platform === 'win32') {
     try {
       ctx.inject(['systemPrompt'], (pctx) => {
@@ -473,9 +593,17 @@ export async function apply(ctx, config = {}) {
           pctx.effect(() => pctx.systemPrompt.context({
             name: 'gitbash-shell:posix-paths',
             order: 126,
-            text: 'The working shell is Git for Windows bash: use POSIX-style paths only — drive roots are /c/, /d/, ... (/c/Users/..., /c/Program Files/...). Windows drive-letter path forms are not accepted.',
+            text: () => {
+              try {
+                const settings = pctx.get('settings')
+                const value = settings && typeof settings.get === 'function' ? settings.get(SETTINGS_NAMESPACE) : undefined
+                return value && value.posixPaths === true ? POSIX_DIRECTIVE_TEXT : ''
+              } catch {
+                return ''
+              }
+            },
           }), 'dsh-gitbash-shell: posix-path context')
-          console.log(TAG + ' POSIX-path directive context active (win32)')
+          console.log(TAG + ' unified POSIX-path directive context active (win32, gated by the posixPaths setting)')
         } catch (error) {
           console.log(TAG + ' context registration failed: ' + (error?.message ?? error))
         }
@@ -553,4 +681,4 @@ export async function apply(ctx, config = {}) {
 }
 
 // Test surface: pure helpers, no Cordis context required.
-export const _internal = { PRESET_IDS, MARKER_FILE, classify, materialize, cleanupOnDispose, firstUserRoot, hashTree, skillsHashes, syncDecision, installRegisterShim, baseForRoster, detectBase, pickComposition }
+export const _internal = { PRESET_IDS, translateMsysPath, translatePathArguments, readPosixPaths, MARKER_FILE, classify, materialize, cleanupOnDispose, firstUserRoot, hashTree, skillsHashes, syncDecision, installRegisterShim, baseForRoster, detectBase, pickComposition }