fauxnix-cli 0.9.2 → 0.11.0

package/dist/executor.js

@@ -26,7 +26,35 @@ function isNulPath(p) {
     const base = p.split(/[/\\]/).pop() ?? p;
     return /^NUL$/i.test(base);
 }
-function emitToPrepDest(dest, msg, fds, fallback) {
+function applyRedirectDest(op, target, stdout, stderr) {
+    if (op === '2>&1')
+        return { stdout, stderr: stdout };
+    if (op === '1>&2')
+        return { stdout: stderr, stderr };
+    if (op === '<' || target === undefined)
+        return { stdout, stderr };
+    const dest = isNulPath(target) ? { kind: 'nul' } : { kind: 'file', path: target };
+    if (op === '>' || op === '>>')
+        return { stdout: dest, stderr };
+    if (op === '2>' || op === '2>>')
+        return { stdout, stderr: dest };
+    if (op === '&>' || op === '&>>')
+        return { stdout: dest, stderr: dest };
+    return { stdout, stderr };
+}
+/** Last-stage output fds only — captured stdout/stderr apply. */
+function lastStageOutputDests(redirects, resolveTarget) {
+    let stdout = { kind: 'caller', fd: 1 };
+    let stderr = { kind: 'caller', fd: 2 };
+    for (const r of redirects) {
+        const target = r.op === '2>&1' || r.op === '1>&2' || r.op === '<'
+            ? undefined
+            : resolveTarget(winTarget(r.target));
+        ({ stdout, stderr } = applyRedirectDest(r.op, target, stdout, stderr));
+    }
+    return { stdout, stderr };
+}
+function emitToPrepDest(dest, msg, fds, caller) {
     if (dest.kind === 'nul')
         return;
     if (dest.kind === 'file') {
@@ -35,10 +63,14 @@ function emitToPrepDest(dest, msg, fds, fallback) {
             return;
         }
         catch {
-            /* fall through to caller */
+            caller.stderr(msg);
+            return;
         }
     }
-    fallback(msg);
+    if (dest.fd === 1)
+        caller.stdout(msg);
+    else
+        caller.stderr(msg);
 }
 function writeAllSync(fd, data) {
     let off = 0;
@@ -94,9 +126,6 @@ function planRedirects(redirects) {
         appendStdout: false,
         stderrFile: null,
         appendStderr: false,
-        mergeStderr: false,
-        devNull: false,
-        swallowStderr: false,
     };
     for (const red of redirects) {
         const target = winTarget(red.target);
@@ -107,41 +136,30 @@ function planRedirects(redirects) {
             case '>':
             case '&>':
                 if (isNulPath(target)) {
-                    r.devNull = true;
                     r.stdoutFile = null;
-                    if (red.op === '&>') {
-                        r.swallowStderr = true;
+                    if (red.op === '&>')
                         r.stderrFile = null;
-                    }
                 }
                 else {
-                    r.devNull = false;
                     r.stdoutFile = target;
                     r.appendStdout = false;
-                    if (red.op === '&>') {
+                    if (red.op === '&>')
                         r.stderrFile = target;
-                        r.swallowStderr = false;
-                    }
                 }
                 break;
             case '>>':
             case '&>>':
                 if (isNulPath(target)) {
-                    r.devNull = true;
                     r.stdoutFile = null;
-                    if (red.op === '&>>') {
-                        r.swallowStderr = true;
+                    if (red.op === '&>>')
                         r.stderrFile = null;
-                    }
                 }
                 else {
-                    r.devNull = false;
                     r.stdoutFile = target;
                     r.appendStdout = true;
                     if (red.op === '&>>') {
                         r.stderrFile = target;
                         r.appendStderr = true;
-                        r.swallowStderr = false;
                     }
                 }
                 break;
@@ -149,31 +167,22 @@ function planRedirects(redirects) {
                 if (isNulPath(target)) {
                     // stderr only — must not undo a prior >/dev/null
                     r.stderrFile = null;
-                    r.swallowStderr = true;
                 }
                 else {
                     r.stderrFile = target;
                     r.appendStderr = false;
-                    r.swallowStderr = false;
                 }
                 break;
             case '2>>':
                 if (isNulPath(target)) {
                     r.stderrFile = null;
-                    r.swallowStderr = true;
                 }
                 else {
                     r.stderrFile = target;
                     r.appendStderr = true;
-                    r.swallowStderr = false;
                 }
                 break;
-            case '2>&1':
-                r.mergeStderr = true;
-                break;
-            case '1>&2':
-                r.mergeStderr = false;
-                r.stdoutToStderr = true;
+            default:
                 break;
         }
     }
@@ -364,18 +373,19 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
             let redirectPrepFailed = false;
             // Snapshot fd destinations as we walk. `2>&1` copies stdout *at that
             // moment*; a later `>file` must not drag stderr along (bash fd dup).
-            let prepStdout = { kind: 'caller' };
-            let prepStderr = { kind: 'caller' };
-            const emitPrepError = (msg) => emitToPrepDest(prepStderr, msg, prepFds, (s) => {
-                stderr += s;
+            let prepStdout = { kind: 'caller', fd: 1 };
+            let prepStderr = { kind: 'caller', fd: 2 };
+            const emitPrepError = (msg) => emitToPrepDest(prepStderr, msg, prepFds, {
+                stdout: (s) => {
+                    stdout += s;
+                },
+                stderr: (s) => {
+                    stderr += s;
+                },
             });
             for (const r of plan.redirects) {
-                if (r.op === '2>&1') {
-                    prepStderr = prepStdout;
-                    continue;
-                }
-                if (r.op === '1>&2') {
-                    prepStdout = prepStderr;
+                if (r.op === '2>&1' || r.op === '1>&2') {
+                    ({ stdout: prepStdout, stderr: prepStderr } = applyRedirectDest(r.op, undefined, prepStdout, prepStderr));
                     continue;
                 }
                 const target = resolveTarget(winTarget(r.target));
@@ -389,33 +399,16 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
                     }
                     continue;
                 }
-                if (isNulPath(target)) {
-                    if (r.op === '>' || r.op === '>>')
-                        prepStdout = { kind: 'nul' };
-                    else if (r.op === '2>' || r.op === '2>>')
-                        prepStderr = { kind: 'nul' };
-                    else if (r.op === '&>' || r.op === '&>>') {
-                        prepStdout = { kind: 'nul' };
-                        prepStderr = { kind: 'nul' };
+                if (!isNulPath(target)) {
+                    const append = r.op === '>>' || r.op === '2>>' || r.op === '&>>';
+                    const fail = prepareRedirectFile(target, append, prepFds);
+                    if (fail) {
+                        emitPrepError('bash: ' + fail + '\n');
+                        redirectPrepFailed = true;
+                        break;
                     }
-                    continue;
-                }
-                const append = r.op === '>>' || r.op === '2>>' || r.op === '&>>';
-                const fail = prepareRedirectFile(target, append, prepFds);
-                if (fail) {
-                    emitPrepError('bash: ' + fail + '\n');
-                    redirectPrepFailed = true;
-                    break;
-                }
-                const fileDest = { kind: 'file', path: target };
-                if (r.op === '>' || r.op === '>>')
-                    prepStdout = fileDest;
-                else if (r.op === '2>' || r.op === '2>>')
-                    prepStderr = fileDest;
-                else if (r.op === '&>' || r.op === '&>>') {
-                    prepStdout = fileDest;
-                    prepStderr = fileDest;
                 }
+                ({ stdout: prepStdout, stderr: prepStderr } = applyRedirectDest(r.op, target, prepStdout, prepStderr));
             }
             if (redirectPrepFailed) {
                 exitCode = 1;
@@ -438,11 +431,15 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
                 break;
             }
             const encoded = wrapScript(plan.body, { mode: 'host' });
+            // Last-stage fds last-win independently. `2>&1 >/dev/null` snapshots
+            // stderr onto the caller's stdout before stdout is pointed at NUL, so
+            // captured stderr is still returned; `>/dev/null 2>&1` points both at NUL.
+            const applyDests = lastStageOutputDests(plan.outputRedirects, resolveTarget);
             // Response budgets cap what the CALLER receives — streams redirected to
             // files must never be truncated by them (Codex-review P1: `printf … > f`
             // with a small stdoutLimit was writing a clipped file). The final
             // clipUtf8 below still enforces the returned-data budget.
-            const fileRedirected = !!(red.stdoutFile || red.stderrFile);
+            const fileRedirected = applyDests.stdout.kind === 'file' || applyDests.stderr.kind === 'file';
             const inv = await ensureHost().invoke(encoded, {
                 FAUXNIX_CWD: currentDir,
                 FAUXNIX_PREV_EXIT: session.prevExit === null ? '' : String(session.prevExit),
@@ -470,52 +467,45 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
             // GNU line discipline: the PS host terminates Write-Output lines with
             // CRLF. Exact writers (fx-write / printf / echo -n) must keep embedded
             // CR so `printf 'a\r\nb' > out` stays 4 bytes.
-            let segOut = normalizeHostNewlines(decodeOutput(inv.stdout, decodePref));
+            const segOut = normalizeHostNewlines(decodeOutput(inv.stdout, decodePref));
             let segErr = normalizeHostNewlines(normalizeStderr(decodeOutput(inv.stderr, decodePref)));
             if (inv.timedOut) {
                 segErr += timeoutMessage;
             }
-            if (red.mergeStderr) {
-                segOut += (segOut && !segOut.endsWith('\n') && segErr ? '\n' : '') + segErr;
-                segErr = '';
-            }
-            const stdoutToStderr = red.stdoutToStderr;
-            if (stdoutToStderr) {
-                segErr += segOut;
-                segOut = '';
-            }
-            if (red.swallowStderr)
-                segErr = '';
-            if (red.devNull)
-                segOut = '';
             // Write captured streams through the fds opened during preflight
             // (bash: the redirect refers to the open file, not the path). Reopening
             // the path would recreate a file the command just unlinked
             // (`rm out.txt > out.txt`).
             let redirectOk = true;
-            if (red.stdoutFile) {
-                try {
-                    writeToPrepFd(prepFds, red.stdoutFile, segOut);
-                    segOut = '';
-                }
-                catch (e) {
-                    segErr += 'bash: ' + red.stdoutFile + ': cannot create: ' + e.message + '\n';
-                    exitCode = 1;
-                    redirectOk = false;
-                }
-            }
-            if (red.stderrFile) {
-                try {
-                    const body = red.stderrFile === red.stdoutFile ? segOut + segErr : segErr;
-                    writeToPrepFd(prepFds, red.stderrFile, body);
-                    segErr = '';
-                }
-                catch {
-                    /* best effort */
+            const deliverCaptured = (dest, data, fromStdout) => {
+                if (!data)
+                    return;
+                if (dest.kind === 'nul')
+                    return;
+                if (dest.kind === 'file') {
+                    try {
+                        writeToPrepFd(prepFds, dest.path, data);
+                    }
+                    catch (e) {
+                        if (fromStdout) {
+                            stderr += 'bash: ' + dest.path + ': cannot create: ' + e.message + '\n';
+                            exitCode = 1;
+                            redirectOk = false;
+                            stdout += data;
+                        }
+                        else {
+                            stderr += data;
+                        }
+                    }
+                    return;
                 }
-            }
-            stdout += segOut;
-            stderr += segErr;
+                if (dest.fd === 1)
+                    stdout += data;
+                else
+                    stderr += data;
+            };
+            deliverCaptured(applyDests.stdout, segOut, true);
+            deliverCaptured(applyDests.stderr, segErr, false);
             if (inv.truncated)
                 truncated = true;
             exitCode = inv.timedOut ? 124 : inv.cancelled ? 130 : inv.exitCode;

package/dist/install.d.ts

@@ -0,0 +1,15 @@
+export type InstallOptions = {
+    home?: string;
+    /** Accepted for parity with collectDoctorReport; install writes user-level configs only. */
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+};
+export type InstallReport = {
+    lines: string[];
+    ok: boolean;
+};
+export declare const INSTALL_FLAGS: readonly ["claude", "codex", "opencode", "kimi", "qwen"];
+export type HarnessName = (typeof INSTALL_FLAGS)[number];
+export declare function kimiConfigPath(home: string, env: NodeJS.ProcessEnv): string;
+export declare function qwenConfigPath(home: string, env: NodeJS.ProcessEnv): string;
+export declare function runInstall(argv: string[], opts?: InstallOptions): InstallReport;

package/dist/install.js

@@ -0,0 +1,206 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { claudeUserConfigPath, codexConfigPath, hasCodexFauxnix, hasOpenCodeFauxnix, isServerMap, openCodeConfigPath, serverMapHasFauxnix, } from './doctor.js';
+export const INSTALL_FLAGS = ['claude', 'codex', 'opencode', 'kimi', 'qwen'];
+const STDIO = { command: 'fauxnix', args: ['mcp'] };
+const OPENCODE_STDIO = { type: 'local', command: ['fauxnix', 'mcp'] };
+export function kimiConfigPath(home, env) {
+    const root = env.KIMI_CODE_HOME?.trim() || join(home, '.kimi-code');
+    return join(root, 'mcp.json');
+}
+export function qwenConfigPath(home, env) {
+    return join(home, '.qwen', 'settings.json');
+}
+export function runInstall(argv, opts = {}) {
+    const parsed = parseHarnessFlags(argv);
+    if (parsed.help)
+        return { lines: installUsageLines(), ok: true };
+    if (parsed.error)
+        return { lines: [parsed.error, ...installUsageLines()], ok: false };
+    const ctx = {
+        home: opts.home ?? homedir(),
+        env: opts.env ?? process.env,
+    };
+    const lines = [];
+    let ok = true;
+    for (const name of parsed.harnesses) {
+        const one = installHarness(name, ctx);
+        lines.push(one.line);
+        if (!one.ok)
+            ok = false;
+    }
+    return { lines, ok };
+}
+function parseHarnessFlags(argv) {
+    if (argv.some((a) => a === '--help' || a === '-h'))
+        return { help: true, harnesses: [] };
+    if (argv.length === 0) {
+        return { error: 'select a harness: --claude --codex --opencode --kimi --qwen', harnesses: [] };
+    }
+    const harnesses = [];
+    const seen = new Set();
+    for (const a of argv) {
+        if (!a.startsWith('--') || a === '--') {
+            return { error: `unknown argument: ${a}`, harnesses: [] };
+        }
+        const name = a.slice(2);
+        if (!isHarness(name))
+            return { error: `unknown harness: ${a}`, harnesses: [] };
+        if (!seen.has(name)) {
+            seen.add(name);
+            harnesses.push(name);
+        }
+    }
+    return { harnesses };
+}
+function isHarness(s) {
+    return INSTALL_FLAGS.includes(s);
+}
+function installUsageLines() {
+    return ['Usage:', '  fauxnix install --claude|--codex|--opencode|--kimi|--qwen'];
+}
+function installHarness(name, ctx) {
+    switch (name) {
+        case 'claude':
+            return patchMcpServers(claudeUserConfigPath(ctx.home, ctx.env), 'claude');
+        case 'codex':
+            return patchCodex(codexConfigPath(ctx.home, ctx.env));
+        case 'opencode':
+            return patchOpenCode(openCodeConfigPath(ctx.home, ctx.env));
+        case 'kimi':
+            return patchMcpServers(kimiConfigPath(ctx.home, ctx.env), 'kimi');
+        case 'qwen':
+            return patchMcpServers(qwenConfigPath(ctx.home, ctx.env), 'qwen');
+    }
+}
+function patchMcpServers(path, harness) {
+    const read = readJsonObject(path);
+    if (read.state === 'invalid') {
+        return { ok: false, line: `${harness}: ${path} is ${read.reason} — not modified` };
+    }
+    const existed = read.state !== 'missing';
+    const data = read.state === 'ok' ? read.data : {};
+    if (serverMapHasFauxnix(data.mcpServers)) {
+        return { ok: true, line: `${harness}: already configured (${path})` };
+    }
+    if (data.mcpServers != null && !isServerMap(data.mcpServers)) {
+        return { ok: false, line: `${harness}: ${path} mcpServers is not an object — not modified` };
+    }
+    if (!isServerMap(data.mcpServers))
+        data.mcpServers = {};
+    data.mcpServers.fauxnix = {
+        command: STDIO.command,
+        args: [...STDIO.args],
+    };
+    return writeJson(path, data, harness, existed, 'added mcpServers.fauxnix');
+}
+function patchOpenCode(path) {
+    const read = readJsonObject(path);
+    if (read.state === 'invalid') {
+        return { ok: false, line: `opencode: ${path} is ${read.reason} — not modified` };
+    }
+    const existed = read.state !== 'missing';
+    const data = read.state === 'ok' ? read.data : {};
+    if (hasOpenCodeFauxnix(data)) {
+        return { ok: true, line: `opencode: already configured (${path})` };
+    }
+    if (data.mcp != null && !isServerMap(data.mcp)) {
+        return { ok: false, line: `opencode: ${path} mcp is not an object — not modified` };
+    }
+    if (!isServerMap(data.mcp))
+        data.mcp = {};
+    const mcp = data.mcp;
+    const payload = { type: OPENCODE_STDIO.type, command: [...OPENCODE_STDIO.command] };
+    if (isServerMap(mcp.servers)) {
+        mcp.servers.fauxnix = payload;
+        return writeJson(path, data, 'opencode', existed, 'added mcp.servers.fauxnix');
+    }
+    mcp.fauxnix = payload;
+    return writeJson(path, data, 'opencode', existed, 'added mcp.fauxnix');
+}
+function patchCodex(path) {
+    const existed = existsSync(path);
+    if (!existed) {
+        const written = writeText(path, tomlTable('\n'));
+        if (!written.ok)
+            return { ok: false, line: `codex: failed to write ${path}: ${written.error}` };
+        return { ok: true, line: `codex: created ${path}` };
+    }
+    const text = readText(path);
+    if (text === undefined) {
+        return { ok: false, line: `codex: ${path} is unreadable — not modified` };
+    }
+    if (hasCodexFauxnix(stripBom(text))) {
+        return { ok: true, line: `codex: already configured (${path})` };
+    }
+    const nl = text.includes('\r\n') ? '\r\n' : '\n';
+    if (stripBom(text).trim() === '') {
+        const written = writeText(path, tomlTable(nl));
+        if (!written.ok)
+            return { ok: false, line: `codex: failed to write ${path}: ${written.error}` };
+        return { ok: true, line: `codex: patched ${path} (appended [mcp_servers.fauxnix])` };
+    }
+    let body = text;
+    if (!body.endsWith('\n'))
+        body += nl;
+    if (!body.endsWith(nl + nl))
+        body += nl;
+    const written = writeText(path, body + tomlTable(nl));
+    if (!written.ok)
+        return { ok: false, line: `codex: failed to write ${path}: ${written.error}` };
+    return { ok: true, line: `codex: patched ${path} (appended [mcp_servers.fauxnix])` };
+}
+function tomlTable(nl) {
+    return `[mcp_servers.fauxnix]${nl}command = "fauxnix"${nl}args = ["mcp"]${nl}`;
+}
+function writeJson(path, data, harness, existed, change) {
+    const written = writeText(path, JSON.stringify(data, null, 2) + '\n');
+    if (!written.ok) {
+        return { ok: false, line: `${harness}: failed to write ${path}: ${written.error}` };
+    }
+    if (existed)
+        return { ok: true, line: `${harness}: patched ${path} (${change})` };
+    return { ok: true, line: `${harness}: created ${path}` };
+}
+function writeText(path, contents) {
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, contents, 'utf8');
+        return { ok: true };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+function readJsonObject(path) {
+    if (!existsSync(path))
+        return { state: 'missing' };
+    const text = readText(path);
+    if (text === undefined)
+        return { state: 'invalid', reason: 'unreadable' };
+    const stripped = stripBom(text).trim();
+    if (stripped === '')
+        return { state: 'empty' };
+    try {
+        const data = JSON.parse(stripped);
+        if (!data || typeof data !== 'object' || Array.isArray(data)) {
+            return { state: 'invalid', reason: 'not a JSON object' };
+        }
+        return { state: 'ok', data: data };
+    }
+    catch {
+        return { state: 'invalid', reason: 'not valid JSON' };
+    }
+}
+function stripBom(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+function readText(path) {
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/mcp.d.ts

@@ -19,5 +19,11 @@ export declare function bashToolResult(r: ExecResult, sessionId: string, infra:
         sessionId: string;
     };
 };
+export declare function positionalCountFromEnv(env: Record<string, string>): number;
+export declare function formatSessionStatus(session: {
+    cwd: string | null;
+    env: Record<string, string>;
+    id: string;
+}): string;
 export declare function startMcpServer(): Promise<void>;
 export { translatePipelineBody };

package/dist/mcp.js

@@ -31,11 +31,10 @@ const TOOL_DESCRIPTION = `Execute a Linux/bash-style command on this Windows mac
 Commands are deterministically translated to PowerShell and executed natively — no WSL or VM.
 Output is formatted to look like GNU/Linux tooling (ls -l, ps aux, df -h ...), errors look like bash errors, and text encoding (UTF-8/GBK) is handled automatically.
 
-Supported: pipes (|), && / || / ;, redirections (> >> 2> 2>&1 < /dev/null), variables ($VAR $HOME ~), command substitution $(...), and ${registeredNames().length}+ coreutils-style commands (${registeredNames().slice(0, 18).join(', ')}...).
+Supported: pipes (|), && / || / ;, redirections (> >> 2> 2>&1 < /dev/null), variables ($VAR $HOME $1 $# "$@" ~), set -- / shift, array assignment A=(x y z), \${name[n]} \${#name[@]} \${name//pat/str} \${name:off:len}, command substitution $(...), and ${registeredNames().length}+ coreutils-style commands (${registeredNames().slice(0, 18).join(', ')}...).
 Unknown commands (git, node, npm, python, cargo...) are passed through and executed natively with argv-style quoting.
-Not supported: heredocs, while/until/case, env -i/--ignore-environment, background jobs. if/then/elif/else/fi, for-in loops, and word-level \$((...)) arithmetic expansion are supported.
-
-CWD, environment variables, export/unset and cd persist across calls within this session — a resident PowerShell 5.1 host is started when the MCP session begins (and after reset), so the first bash tool call is already warm.
+Not supported: heredocs, env -i/--ignore-environment, background jobs. if/then/elif/else/fi, for-in loops, while/until, case ... esac, and word-level \$((...)) arithmetic expansion are supported.
+CWD, environment variables, export/unset, cd, and positional parameters (set -- / $1 / "$@") persist across calls within this session — a resident PowerShell 5.1 host is started when the MCP session begins (and after reset), so the first bash tool call is already warm.
 Exit codes follow bash conventions (0 ok, 1 fail, 2 usage/serious, 127 command not found, 124 timeout, 130 cancelled). The tool also returns structuredContent (schemaVersion 1) with stdout/stderr/exitCode/timedOut/cancelled/truncated/sessionId.
 
 Platform requirement: the execution backend is native Windows PowerShell 5.1+. On hosts without PowerShell on PATH (e.g. Linux containers/sandboxes), the bash tool returns exit code 127 with an actionable error instead of running the command.`;
@@ -70,7 +69,35 @@ export function bashToolResult(r, sessionId, infra) {
         ...(infra ? { isError: true } : {}),
     };
 }
+/** Packed FAUXNIX_POS uses char-30 separators (same as array sidecar). */
+const POS_SEP = '\x1e';
+export function positionalCountFromEnv(env) {
+    let packed;
+    for (const [k, v] of Object.entries(env)) {
+        if (k.toUpperCase() === 'FAUXNIX_POS') {
+            packed = v;
+            break;
+        }
+    }
+    if (packed == null || packed === '')
+        return 0;
+    return packed.split(POS_SEP).length;
+}
+export function formatSessionStatus(session) {
+    const envKeys = Object.keys(session.env).sort();
+    return ('cwd: ' +
+        (session.cwd ?? '(inherit from server start)') +
+        '\nenv keys: ' +
+        (envKeys.length ? envKeys.join(', ') : '(none tracked)') +
+        '\npositionals: ' +
+        positionalCountFromEnv(session.env) +
+        '\nsession: ' +
+        session.id +
+        '\ncommands registered: ' +
+        registeredNames().length);
+}
 export async function startMcpServer() {
+    process.env.FAUXNIX_ARG0 = TOOL_NAME;
     const server = new McpServer({ name: 'fauxnix', version: packageVersion }, { capabilities: { tools: {} } });
     const session = new FauxnixSession();
     await session.prewarm();
@@ -117,22 +144,17 @@ export async function startMcpServer() {
             return { content: [{ type: 'text', text: msg }], isError: true };
         }
     });
-    server.tool('fauxnix_session', 'Inspect or reset the persistent fauxnix shell session (current directory, environment, session id). Actions: "status" (default) or "reset".', {
+    server.tool('fauxnix_session', 'Inspect or reset the persistent fauxnix shell session (current directory, environment, positional count, session id). Actions: "status" (default) or "reset".', {
         action: z
             .enum(['status', 'reset'])
             .default('status')
-            .describe('"status" shows the session state (cwd, tracked env keys); "reset" clears it back to a fresh shell'),
+            .describe('"status" shows the session state (cwd, tracked env keys, positional count); "reset" clears it back to a fresh shell'),
     }, SESSION_ANNOTATIONS, async ({ action }) => {
         if (action === 'reset') {
             await session.reset();
             return { content: [{ type: 'text', text: 'fauxnix: session reset' }] };
         }
-        const envKeys = Object.keys(session.env).sort();
-        const text = 'cwd: ' + (session.cwd ?? '(inherit from server start)') +
-            '\nenv keys: ' + (envKeys.length ? envKeys.join(', ') : '(none tracked)') +
-            '\nsession: ' + session.id +
-            '\ncommands registered: ' + registeredNames().length;
-        return { content: [{ type: 'text', text }] };
+        return { content: [{ type: 'text', text: formatSessionStatus(session) }] };
     });
     const transport = new StdioServerTransport();
     let shuttingDown = false;