@nomix-ai/nomix-harness 0.2.5 → 0.2.6

package/dist/kernel/subprocess-local/lib/types/windows-inspector.js

@@ -0,0 +1,259 @@
+/**
+ * Windows process-table operations for terminal readiness, signalling, and
+ * teardown: Toolhelp32 snapshot enumeration with GetProcessTimes creation-time
+ * identity and process-handle wait-state liveness, the shell pid as a pseudo
+ * process group (Windows has no POSIX groups), and taskkill tree signalling.
+ * The koffi bindings load lazily so
+ * non-Windows processes never touch Win32 libraries; all decision logic takes
+ * an injectable internals boundary so suites can pin it on any host.
+ * @module nomix-subprocess-local/windows-inspector
+ */
+import { spawnSync } from 'node:child_process';
+import koffi from 'koffi';
+/**
+ * Walk a process table from one root in children-first order, retaining only
+ * members whose start identity is readable (unreadable members are detector
+ * misses, exactly like an unreadable `/proc` entry on Linux).
+ * @param entries - the process table snapshot.
+ * @param rootPid - the tree root to descend from.
+ * @param started - creation-time identity resolver for one member.
+ * @returns the root and its current transitive descendants, children first.
+ */
+/* jscpd:ignore-start -- the Windows inspector deliberately mirrors process-inspector.ts:
+   the decision logic (tree walk, identity fencing, group signalling) is the same contract over
+   Win32 primitives, per the persistent-pty note 2026-08-11-pwsh-persistent-pty. */
+export function windowsProcessTree(entries, rootPid, started) {
+    const byPid = new Map(entries.map(entry => [entry.pid, entry]));
+    const root = byPid.get(rootPid);
+    if (root === undefined)
+        return [];
+    const byParent = new Map();
+    for (const entry of entries) {
+        const children = byParent.get(entry.parentPid) ?? [];
+        children.push(entry);
+        byParent.set(entry.parentPid, children);
+    }
+    const visited = new Set();
+    const result = [];
+    const visit = (entry) => {
+        if (visited.has(entry.pid))
+            return;
+        visited.add(entry.pid);
+        for (const child of byParent.get(entry.pid) ?? [])
+            visit(child);
+        const identity = started(entry.pid);
+        if (identity !== undefined)
+            result.push({ pid: entry.pid, started: identity });
+    };
+    visit(root);
+    return result;
+}
+/**
+ * Windows {@link ProcessInspector}. The shell pid stands in for a foreground
+ * process group: it is a stable pseudo-group that lets the prompt-marker
+ * readiness path compare foreground identities, while every actual signal
+ * targets the console-wide tree through taskkill (SIGINT is delivered by the
+ * terminal handle as a `\x03` input write and never reaches this layer).
+ */
+export class WindowsProcessInspector {
+    internals;
+    constructor(internals = defaultWindowsProcessInternals()) {
+        this.internals = internals;
+    }
+    foregroundPgid(shellPid) {
+        return shellPid;
+    }
+    isStdinWaiting(_pgid) {
+        return false;
+    }
+    processTree(rootPid) {
+        return windowsProcessTree(this.internals.snapshot(), rootPid, pid => this.internals.processState(pid)?.started);
+    }
+    processSession(_sessionId) {
+        return [];
+    }
+    isAlive(identity) {
+        const state = this.internals.processState(identity.pid);
+        return state?.active === true && state.started === identity.started;
+    }
+    signalGroup(pgid, signal) {
+        this.internals.taskkill(pgid, signal === 'SIGKILL');
+    }
+    signalProcess(identity, signal) {
+        if (this.isAlive(identity))
+            this.internals.taskkill(identity.pid, signal === 'SIGKILL');
+    }
+}
+/* jscpd:ignore-end */
+/**
+ * Create the Windows process inspector.
+ * @param internals - injectable process operations; defaults to the koffi-backed table.
+ * @returns the Windows inspector.
+ */
+export function createWindowsProcessInspector(internals = defaultWindowsProcessInternals()) {
+    return new WindowsProcessInspector(internals);
+}
+/** Terminate one Windows process tree with taskkill, contained like POSIX group signalling. */
+function taskkillTree(pid, force) {
+    if (pid <= 0)
+        return;
+    // Outcome deliberately unchecked: an already-absent tree, exit races, and a
+    // missing taskkill binary are as tolerable here as ESRCH is for POSIX.
+    spawnSync('taskkill', ['/PID', String(pid), '/T', ...(force ? ['/F'] : [])], { stdio: 'ignore' });
+}
+/**
+ * True for NULL and INVALID_HANDLE_VALUE returns from Win32 handle APIs.
+ * @param value - a handle as koffi may hand it back (pointer, null, or 0n).
+ * @returns whether the value signals an invalid handle.
+ */
+export function isInvalidHandle(value) {
+    if (value === null || value === undefined)
+        return true;
+    const asBigInt = value;
+    return asBigInt === 0n || asBigInt === 0xffffffffffffffffn || asBigInt === -1n;
+}
+const PVOID = koffi.pointer('void');
+/**
+ * Resolve the koffi Win32 struct types once. Registration is lazy and cached
+ * because koffi's type registry is global per process: test runners that
+ * re-evaluate this module (a hoisted `vi.mock` re-imports the graph) must not
+ * re-register the names.
+ */
+function win32Structs() {
+    if (cachedStructs !== undefined)
+        return cachedStructs;
+    // koffi PROCESSENTRY32W layout (tlhelp32.h); the size assert pins the x64 layout.
+    const PROCESSENTRY32W = koffi.struct('PROCESSENTRY32W', {
+        dwSize: 'uint32',
+        cntUsage: 'uint32',
+        th32ProcessID: 'uint32',
+        th32DefaultHeapID: PVOID,
+        th32ModuleID: 'uint32',
+        cCntThreads: 'uint32',
+        th32ParentProcessID: 'uint32',
+        pcPriClassBase: 'int32',
+        dwFlags: 'uint32',
+        szExeFile: koffi.array('char16', 260),
+    });
+    // koffi FILETIME layout (minwinbase.h): two 32-bit halves of the 64-bit timestamp.
+    const FILETIME = koffi.struct('FILETIME', {
+        dwLowDateTime: 'uint32',
+        dwHighDateTime: 'uint32',
+    });
+    /* v8 ignore start -- a layout-mismatch guard fires only on ABI breakage; the windows-native suites exercise the real struct. */
+    if (PROCESSENTRY32W.size !== 568) {
+        throw new Error(`PROCESSENTRY32W layout mismatch: koffi computed ${PROCESSENTRY32W.size}, Windows headers say 568`);
+    }
+    /* v8 ignore stop */
+    cachedStructs = { PROCESSENTRY32W, FILETIME };
+    return cachedStructs;
+}
+let cachedStructs;
+const TH32CS_SNAPPROCESS = 0x2;
+const PROCESS_QUERY_LIMITED_INFORMATION = 0x1000;
+const SYNCHRONIZE = 0x00100000;
+const WAIT_OBJECT_0 = 0;
+const WAIT_TIMEOUT = 0x102;
+let cachedBindings;
+/**
+ * Resolve the lazy Win32 bindings (throws the first binding failure, fail-closed).
+ * @returns the cached binding table.
+ */
+function win32Bindings() {
+    if (cachedBindings !== undefined)
+        return cachedBindings;
+    const { PROCESSENTRY32W, FILETIME } = win32Structs();
+    const kernel32 = koffi.load('kernel32.dll');
+    const bind = (name, result, args) => kernel32.func('__stdcall', name, result, args);
+    cachedBindings = {
+        createToolhelp32Snapshot: bind('CreateToolhelp32Snapshot', PVOID, ['uint32', 'uint32']),
+        process32FirstW: bind('Process32FirstW', 'int', [PVOID, koffi.pointer(PROCESSENTRY32W)]),
+        process32NextW: bind('Process32NextW', 'int', [PVOID, koffi.pointer(PROCESSENTRY32W)]),
+        openProcess: bind('OpenProcess', PVOID, ['uint32', 'int', 'uint32']),
+        getProcessTimes: bind('GetProcessTimes', 'int', [
+            PVOID,
+            koffi.pointer(FILETIME),
+            koffi.pointer(FILETIME),
+            koffi.pointer(FILETIME),
+            koffi.pointer(FILETIME),
+        ]),
+        waitForSingleObject: bind('WaitForSingleObject', 'uint32', [PVOID, 'uint32']),
+        closeHandle: bind('CloseHandle', 'int', [PVOID]),
+    };
+    return cachedBindings;
+}
+/**
+ * Allocate koffi memory as a branded {@link NativePtr}; koffi's TS types are
+ * `any`, so the cast goes through `unknown` to keep the unsafe surface here.
+ * @param type - the koffi type to allocate.
+ * @param count - element count.
+ * @returns the branded allocation pointer.
+ */
+function allocNative(type, count) {
+    const value = koffi.alloc(type, count);
+    return value;
+}
+/** Enumerate the current process table through Toolhelp32. */
+function snapshotWindowsProcesses(bindings) {
+    const { PROCESSENTRY32W } = win32Structs();
+    const snapshot = bindings.createToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+    /* v8 ignore next -- an invalid snapshot for the process flag is not producible through the public API;
+       the guard mirrors POSIX's unreadable-proc tolerance and isInvalidHandle is unit-tested. */
+    if (isInvalidHandle(snapshot))
+        return [];
+    const entries = [];
+    try {
+        const entry = allocNative(PROCESSENTRY32W, 1);
+        koffi.encode(entry, 'uint32', PROCESSENTRY32W.size);
+        let ok = bindings.process32FirstW(snapshot, entry);
+        while (ok !== 0) {
+            const record = koffi.decode(entry, PROCESSENTRY32W);
+            entries.push({ pid: record.th32ProcessID, parentPid: record.th32ParentProcessID });
+            ok = bindings.process32NextW(snapshot, entry);
+        }
+    }
+    finally {
+        bindings.closeHandle(snapshot);
+    }
+    return entries;
+}
+/** Read one process's creation identity and current wait state. */
+function windowsProcessState(bindings, pid) {
+    const { FILETIME } = win32Structs();
+    const handle = bindings.openProcess(PROCESS_QUERY_LIMITED_INFORMATION | SYNCHRONIZE, 0, pid);
+    if (isInvalidHandle(handle))
+        return undefined;
+    try {
+        const creation = allocNative(FILETIME, 1);
+        const exit = allocNative(FILETIME, 1);
+        const kernel = allocNative(FILETIME, 1);
+        const user = allocNative(FILETIME, 1);
+        /* v8 ignore next -- a GetProcessTimes failure after a successful open races process exit and
+           cannot be staged deterministically; the absent-process path is covered and the caller
+           treats undefined as a detector miss. */
+        if (bindings.getProcessTimes(handle, creation, exit, kernel, user) === 0)
+            return undefined;
+        const record = koffi.decode(creation, FILETIME);
+        const wait = bindings.waitForSingleObject(handle, 0);
+        /* v8 ignore next -- an opened process handle has exactly one of these two
+           zero-time wait states; an unexpected Win32 failure is an unreadable process. */
+        if (wait !== WAIT_OBJECT_0 && wait !== WAIT_TIMEOUT)
+            return undefined;
+        return {
+            started: `${record.dwHighDateTime}:${record.dwLowDateTime}`,
+            active: wait === WAIT_TIMEOUT,
+        };
+    }
+    finally {
+        bindings.closeHandle(handle);
+    }
+}
+/** The koffi-backed default internals; bindings resolve lazily on first use. */
+function defaultWindowsProcessInternals() {
+    return {
+        snapshot: () => snapshotWindowsProcesses(win32Bindings()),
+        processState: pid => windowsProcessState(win32Bindings(), pid),
+        taskkill: taskkillTree,
+    };
+}
+//# sourceMappingURL=windows-inspector.js.map

package/dist/kernel/subprocess-local/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-subprocess-local",
   "description": "Local-subprocess implementation of the Nomix Harness subprocess seam",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },
@@ -42,6 +42,7 @@
     "@nomix-ai/cordis": "workspace:^"
   },
   "dependencies": {
+    "koffi": "^3.1.0",
     "node-pty": "1.2.0-beta.15"
   },
   "devDependencies": {

package/dist/kernel/system-prompt/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-system-prompt",
   "description": "System prompt assembly registry for the Nomix Harness",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/terminal/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-terminal",
   "description": "Persistent PTY session seam for the Nomix Harness — owner-scoped ids, backend registry, interactive sends, reads, signals, and awaited cleanup",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/terminal-bash/lib/index.js

@@ -1,18 +1,44 @@
 import { TerminalBackendCleanupError, TerminalError } from "../../terminal/lib/index.js";
 import { effectiveSandboxMode } from "../../sandbox-policy/lib/index.js";
+import { ENCODING_PREAMBLE, resolvePwshPath } from "../../pwsh-local/lib/index.js";
 import z from "../../schemastery/lib/index.mjs";
 import { Buffer } from "node:buffer";
 //#region lib/types/config.js
 /** Validated configuration for the local PTY backend. */
+/** Bash dialect default executable. */
+const DEFAULT_BASH_SHELL = "/bin/bash";
+/** Bash dialect default arguments (interactive, profile-free). */
+const DEFAULT_BASH_ARGS = [
+	"--noprofile",
+	"--norc",
+	"-i"
+];
+/** Pwsh dialect default arguments (interactive host, profile-free). */
+const DEFAULT_PWSH_ARGS = ["-NoLogo", "-NoProfile"];
+/**
+* Resolve the effective per-dialect shell specification. Defaulting is this
+* explicit step: an unset or empty `shellPath`/`shellArgs` selects the
+* dialect's defaults, while a non-empty explicit value always wins.
+* (Schemastery materializes an absent optional array as `[]`, so emptiness —
+* not just `undefined` — means "dialect default".)
+* @param config - Schemastery-resolved plugin configuration.
+* @returns the fully resolved configuration.
+*/
+function resolveConfig(config) {
+	const shellDialect = config.shellDialect ?? "bash";
+	return {
+		...config,
+		shellDialect,
+		shellPath: config.shellPath !== void 0 && config.shellPath.length > 0 ? config.shellPath : shellDialect === "pwsh" ? resolvePwshPath() : DEFAULT_BASH_SHELL,
+		shellArgs: config.shellArgs !== void 0 && config.shellArgs.length > 0 ? config.shellArgs : shellDialect === "pwsh" ? DEFAULT_PWSH_ARGS : DEFAULT_BASH_ARGS
+	};
+}
 /** Schemastery config exposed by the plugin. */
 const Config = z.object({
 	backendType: z.string().default("shell"),
-	shellPath: z.string().default("/bin/bash"),
-	shellArgs: z.array(z.string()).default([
-		"--noprofile",
-		"--norc",
-		"-i"
-	]),
+	shellDialect: z.union(["bash", "pwsh"]).default("bash"),
+	shellPath: z.string().required(false),
+	shellArgs: z.array(z.string()).required(false),
 	rows: z.number().default(40),
 	cols: z.number().default(160),
 	scrollbackLines: z.number().default(1e4),
@@ -26,7 +52,7 @@ const Config = z.object({
 	disposeGraceMs: z.number().default(3e3)
 });
 /**
-* Assert every numeric config field is a positive safe integer and bounds compose.
+* Assert every effective numeric config field is a positive safe integer and bounds compose.
 * @param config - Schemastery-resolved plugin configuration.
 * @returns Narrows the input to the fully resolved configuration.
 */
@@ -713,19 +739,33 @@ function ensureSandboxModeFence(ctx, owner) {
 		throw new Error(`cannot change sandbox mode from "${currentMode}" to "${event.data.mode}" while persistent terminal sessions are open or being created; wait for creation to settle and close them first`);
 	}, { global: true });
 }
-function childEnvironment(spec) {
-	return {
+function childEnvironment(spec, dialect) {
+	const common = {
 		TERM: "dumb",
 		PAGER: "cat",
 		GIT_PAGER: "cat",
-		PS1: CONTROLLED_PROMPT,
-		PROMPT_COMMAND: `printf "\\033]133;D;%s\\007" "$?"; PS1='${CONTROLLED_PROMPT}'`,
-		BASH_SILENCE_DEPRECATION_WARNING: "1",
 		NOMIX_SHELL: "1",
 		NOMIX_SESSION_ID: spec.owner.id,
 		NOMIX_PTY_SESSION_ID: spec.sessionId
 	};
+	if (dialect === "pwsh") return {
+		...common,
+		NO_COLOR: "1"
+	};
+	return {
+		...common,
+		PS1: CONTROLLED_PROMPT,
+		PROMPT_COMMAND: `printf "\\033]133;D;%s\\007" "$?"; PS1='${CONTROLLED_PROMPT}'`,
+		BASH_SILENCE_DEPRECATION_WARNING: "1"
+	};
 }
+/**
+* The pwsh prompt function that emits the shared OSC `133;D;` + BEL marker
+* before every prompt, mirroring bash's PROMPT_COMMAND. `[char]27`/`[char]7`
+* build the control bytes at runtime because raw ESC characters in submitted
+* input are unreliable under PSReadLine.
+*/
+const PWSH_PROMPT_SETUP = "function prompt { [Console]::Write([char]27 + ']133;D;' + [int]$LASTEXITCODE + [char]7); 'nomix> ' }";
 function spawnArgv(ctx, config, policy) {
 	const argv = [config.shellPath, ...config.shellArgs];
 	if (policy.mode === "danger-full-access") return argv;
@@ -736,9 +776,33 @@ function spawnArgv(ctx, config, policy) {
 		mode: policy.mode
 	}).argv;
 }
-async function initializeSession(session, signal) {
+async function startupSession(session, dialect, signal) {
+	const start = async () => {
+		if (dialect === "bash") {
+			await session.initialize(signal);
+			return;
+		}
+		let viewport = "";
+		for (;;) {
+			const first = viewport.length === 0;
+			const result = await session.startSend({
+				text: first ? ENCODING_PREAMBLE + PWSH_PROMPT_SETUP : "",
+				submit: first,
+				...signal !== void 0 ? { signal } : {}
+			}).done;
+			if (result.waitReason === "session_exit") throw new Error("PTY shell exited during startup");
+			if (result.waitReason === "timeout") throw new Error("PTY shell did not reach readiness before startup timeout");
+			viewport = result.viewport;
+			const scrollback = session.read({
+				offset: 0,
+				count: 20
+			}).text;
+			if (viewport.includes("nomix> ") || scrollback.includes("nomix> ")) break;
+		}
+		session.motd = viewport;
+	};
 	if (signal === void 0) {
-		await session.initialize(signal);
+		await start();
 		return;
 	}
 	const aborted = Promise.withResolvers();
@@ -748,7 +812,7 @@ async function initializeSession(session, signal) {
 	signal.addEventListener("abort", onAbort, { once: true });
 	try {
 		signal.throwIfAborted();
-		await Promise.race([session.initialize(signal), aborted.promise]);
+		await Promise.race([start(), aborted.promise]);
 	} finally {
 		signal.removeEventListener("abort", onAbort);
 	}
@@ -776,7 +840,7 @@ var BashTerminalBackend = class {
 		const terminal = await this.spawnTerminal({
 			argv,
 			cwd: spec.cwd ?? policy.workspaceRoot,
-			env: childEnvironment(spec),
+			env: childEnvironment(spec, this.config.shellDialect),
 			rows: this.config.rows,
 			cols: this.config.cols,
 			graceMs: this.config.disposeGraceMs,
@@ -784,7 +848,7 @@ var BashTerminalBackend = class {
 		});
 		const session = this.createSession(terminal, this.config);
 		try {
-			await initializeSession(session, spec.signal);
+			await startupSession(session, this.config.shellDialect, spec.signal);
 			return session;
 		} catch (error) {
 			try {
@@ -798,8 +862,9 @@ var BashTerminalBackend = class {
 };
 /** Register the local PTY backend. */
 function apply(ctx, config) {
-	validateConfig(config);
-	ctx.terminals.registerBackend(new BashTerminalBackend(ctx, config));
+	const resolved = resolveConfig(config);
+	validateConfig(resolved);
+	ctx.terminals.registerBackend(new BashTerminalBackend(ctx, resolved));
 }
 //#endregion
-export { BashTerminalBackend, Config, apply, inject, name };
+export { BashTerminalBackend, Config, PWSH_PROMPT_SETUP, apply, inject, name };

package/dist/kernel/terminal-bash/lib/types/config.d.ts

@@ -1,12 +1,16 @@
 /** Validated configuration for the local PTY backend. */
 import z from '../../../schemastery/lib/index.mjs';
+/** One supported interactive shell dialect. */
+export type ShellDialect = 'bash' | 'pwsh';
 /** Public plugin configuration. */
 export interface Config {
     /** Backend registry type (default: `shell`). */
     backendType?: string;
-    /** Interactive shell executable (default: `/bin/bash`). */
+    /** Interactive shell dialect (default: `bash`); selects the argv/env/startup defaults. */
+    shellDialect?: ShellDialect;
+    /** Interactive shell executable (default per dialect: `/bin/bash`, or the resolved pwsh). */
     shellPath?: string;
-    /** Shell arguments (default: `--noprofile --norc -i`). */
+    /** Shell arguments (default per dialect: bash `--noprofile --norc -i`, pwsh `-NoLogo -NoProfile`). */
     shellArgs?: string[];
     /** Terminal rows. */
     rows?: number;
@@ -34,12 +38,32 @@ export interface Config {
     /** Grace before teardown escalates to `SIGKILL`. */
     disposeGraceMs?: number;
 }
-/** Configuration after Schemastery defaults. */
-export type ResolvedConfig = Required<Config>;
+/** Configuration after Schemastery defaults and dialect resolution. */
+export type ResolvedConfig = Omit<Required<Config>, 'shellDialect' | 'shellPath' | 'shellArgs'> & {
+    shellDialect: ShellDialect;
+    shellPath: string;
+    shellArgs: string[];
+};
+/** Bash dialect default executable. */
+export declare const DEFAULT_BASH_SHELL = "/bin/bash";
+/** Bash dialect default arguments (interactive, profile-free). */
+export declare const DEFAULT_BASH_ARGS: string[];
+/** Pwsh dialect default arguments (interactive host, profile-free). */
+export declare const DEFAULT_PWSH_ARGS: string[];
+/**
+ * Resolve the effective per-dialect shell specification. Defaulting is this
+ * explicit step: an unset or empty `shellPath`/`shellArgs` selects the
+ * dialect's defaults, while a non-empty explicit value always wins.
+ * (Schemastery materializes an absent optional array as `[]`, so emptiness —
+ * not just `undefined` — means "dialect default".)
+ * @param config - Schemastery-resolved plugin configuration.
+ * @returns the fully resolved configuration.
+ */
+export declare function resolveConfig(config: Config): ResolvedConfig;
 /** Schemastery config exposed by the plugin. */
 export declare const Config: z<Config>;
 /**
- * Assert every numeric config field is a positive safe integer and bounds compose.
+ * Assert every effective numeric config field is a positive safe integer and bounds compose.
  * @param config - Schemastery-resolved plugin configuration.
  * @returns Narrows the input to the fully resolved configuration.
  */

package/dist/kernel/terminal-bash/lib/types/config.js

@@ -1,10 +1,40 @@
 /** Validated configuration for the local PTY backend. */
 import z from '../../../schemastery/lib/index.mjs';
+import { resolvePwshPath } from '../../../pwsh-local/lib/index.js';
+/** Bash dialect default executable. */
+export const DEFAULT_BASH_SHELL = '/bin/bash';
+/** Bash dialect default arguments (interactive, profile-free). */
+export const DEFAULT_BASH_ARGS = ['--noprofile', '--norc', '-i'];
+/** Pwsh dialect default arguments (interactive host, profile-free). */
+export const DEFAULT_PWSH_ARGS = ['-NoLogo', '-NoProfile'];
+/**
+ * Resolve the effective per-dialect shell specification. Defaulting is this
+ * explicit step: an unset or empty `shellPath`/`shellArgs` selects the
+ * dialect's defaults, while a non-empty explicit value always wins.
+ * (Schemastery materializes an absent optional array as `[]`, so emptiness —
+ * not just `undefined` — means "dialect default".)
+ * @param config - Schemastery-resolved plugin configuration.
+ * @returns the fully resolved configuration.
+ */
+export function resolveConfig(config) {
+    const shellDialect = config.shellDialect ?? 'bash';
+    return {
+        ...config,
+        shellDialect,
+        shellPath: config.shellPath !== undefined && config.shellPath.length > 0
+            ? config.shellPath
+            : (shellDialect === 'pwsh' ? resolvePwshPath() : DEFAULT_BASH_SHELL),
+        shellArgs: config.shellArgs !== undefined && config.shellArgs.length > 0
+            ? config.shellArgs
+            : (shellDialect === 'pwsh' ? DEFAULT_PWSH_ARGS : DEFAULT_BASH_ARGS),
+    };
+}
 /** Schemastery config exposed by the plugin. */
 export const Config = z.object({
     backendType: z.string().default('shell'),
-    shellPath: z.string().default('/bin/bash'),
-    shellArgs: z.array(z.string()).default(['--noprofile', '--norc', '-i']),
+    shellDialect: z.union(['bash', 'pwsh']).default('bash'),
+    shellPath: z.string().required(false),
+    shellArgs: z.array(z.string()).required(false),
     rows: z.number().default(40),
     cols: z.number().default(160),
     scrollbackLines: z.number().default(10_000),
@@ -18,7 +48,7 @@ export const Config = z.object({
     disposeGraceMs: z.number().default(3_000),
 });
 /**
- * Assert every numeric config field is a positive safe integer and bounds compose.
+ * Assert every effective numeric config field is a positive safe integer and bounds compose.
  * @param config - Schemastery-resolved plugin configuration.
  * @returns Narrows the input to the fully resolved configuration.
  */

package/dist/kernel/terminal-bash/lib/types/index.d.ts

@@ -14,6 +14,13 @@ export type { Config as TerminalLocalConfig } from './config.ts';
 export declare const name = "terminal-bash";
 /** Required services: PTY registry, shared confinement policy, and process substrate. */
 export declare const inject: string[];
+/**
+ * The pwsh prompt function that emits the shared OSC `133;D;` + BEL marker
+ * before every prompt, mirroring bash's PROMPT_COMMAND. `[char]27`/`[char]7`
+ * build the control bytes at runtime because raw ESC characters in submitted
+ * input are unreliable under PSReadLine.
+ */
+export declare const PWSH_PROMPT_SETUP: string;
 /** Local shell backend registered under the configured type. */
 export declare class BashTerminalBackend implements TerminalBackend {
     private readonly ctx;