@jam-mcp/server 1.4.1 → 1.4.3

package/README.md

@@ -74,10 +74,10 @@ auth login   Store Jira credentials in this user's OS secret store
 runtime      Show or change which JAM build this machine runs
 ```
 
-Written out, that is `npx --yes @jam-mcp/launcher@1.4.1 doctor`, or just `jam
+Written out, that is `npx --yes @jam-mcp/launcher@1.4.3 doctor`, or just `jam
 doctor` if you took the launcher's optional global install. Starting from
 nothing — no install, no runtime chosen yet — use
-`npx --yes @jam-mcp/bootstrap@1.4.1 init` instead.
+`npx --yes @jam-mcp/bootstrap@1.4.3 init` instead.
 
 Credentials come from the process environment or this user's OS secret store —
 never from a repository file — and never appear in logs, telemetry, or tool

package/dist/bootstrap/host-mcp.d.ts

@@ -30,6 +30,8 @@ export type HostState = {
     entryVersion?: string;
     /** The entry is present but does not run the launcher this release registers. */
     entryStale?: boolean;
+    /** The entry runs the global `jam` executable rather than an npx pin. */
+    entryBare?: boolean;
 };
 export type HostRunResult = {
     status: number | null;
@@ -40,7 +42,19 @@ export type HostRunResult = {
 /** Injected by tests. Nothing in this module may reach a real CLI unasked. */
 export type HostRunner = (command: HostCommand) => HostRunResult;
 export declare const defaultHostRunner: HostRunner;
-export declare function hostRegistration(id: HostId): HostCommand | undefined;
+/**
+ * A runner that only sees what is persistently installed on this machine.
+ *
+ * Under `npx --yes @jam-mcp/bootstrap@X`, PATH carries npx's cache
+ * `node_modules/.bin` - which contains a `jam` shim that vanishes when npx
+ * exits. Any measurement of "does a global jam exist" through the normal PATH
+ * therefore lies during bootstrap, which is exactly when the answer matters
+ * most. This runner strips those entries first.
+ */
+export declare const persistentHostRunner: HostRunner;
+export declare function hostRegistration(id: HostId, options?: {
+    bare?: boolean;
+}): HostCommand | undefined;
 /** The removal that has to precede re-registering an entry this host already has. */
 export declare function hostUnregistration(id: HostId): HostCommand | undefined;
 /**
@@ -60,15 +74,42 @@ export declare function listsJamEntry(stdout: string): boolean;
 export declare function jamEntryLine(stdout: string): string | null;
 /** The launcher version a listing line runs, when the line names one. */
 export declare function entryLauncherVersion(line: string): string | undefined;
+/**
+ * Does this entry run the persistent `jam` executable rather than an npx pin?
+ *
+ * `jam: jam serve`, `jam: /usr/local/bin/jam serve`, `jam: C:\...\jam.cmd serve`
+ * all count; an npx line never does - its command token is `npx`. A bare entry
+ * carries no version in the listing, so its staleness has to be measured from
+ * the executable it would actually run (bareJamVersion), not from the line.
+ */
+export declare function isBareJamEntry(line: string): boolean;
+/**
+ * The version a bare `jam` registration actually runs, measured by asking the
+ * executable itself. `runtime status --json` answers from ~/.jam/config.yaml
+ * and the resolved build - the same resolution the registered entry performs.
+ *
+ * undefined when `jam` is not on PATH or does not answer: a registration that
+ * cannot be measured counts as stale, same as an unreadable pin.
+ *
+ * Measured through persistentHostRunner by default: under an npx bootstrap
+ * the ordinary PATH resolves `jam` to npx's own ephemeral cache shim, and a
+ * bare registration decided on that evidence dies as soon as npx exits.
+ */
+export declare function bareJamVersion(run?: HostRunner): string | undefined;
+/** Is this measured launcher version the one this release registers? */
+export declare function preferBareRegistration(version: string | undefined): boolean;
 /**
  * Does this entry run the launcher this release registers?
  *
- * Anything else - an older pin, an unpinned spec, a line whose command JAM
- * cannot read - counts as stale. That direction is deliberate: `mcp add`
- * rewrites the same entry, so a needless repair costs one command, while a
- * missed one leaves the agent talking to a server nobody tested it against.
+ * An npx pin answers from the line itself. A bare `jam` line names no version,
+ * so the caller passes what the executable measured (`bareVersion`) - without
+ * it, bare stays stale. Anything else - an older pin, an unpinned spec, a line
+ * whose command JAM cannot read - counts as stale. That direction is
+ * deliberate: `mcp add` rewrites the same entry, so a needless repair costs
+ * one command, while a missed one leaves the agent talking to a server nobody
+ * tested it against.
  */
-export declare function isEntryStale(line: string): boolean;
+export declare function isEntryStale(line: string, bareVersion?: string): boolean;
 /**
  * Ask each host what it has, and whether it is there at all.
  *

package/dist/bootstrap/host-mcp.js

@@ -1,18 +1,43 @@
 import { spawnSync } from "node:child_process";
 import { JAM_MCP_ENTRY } from "./mcp-config-merger.js";
+import { shellInvocation, stripPackageRunnerPath } from "./shell-command.js";
 /**
  * These boot a whole Node CLI, and Claude Code health-checks every configured
  * server while listing, which is seconds rather than milliseconds.
  */
 const HOST_TIMEOUT_MS = 20_000;
 export const defaultHostRunner = ({ command, args }) => {
-    const result = spawnSync(command, args, {
+    // Both CLIs are npm shims on Windows, and Node refuses to spawn a .cmd
+    // without a shell. Every argument JAM passes is a bare token - no JSON, no
+    // spaces - and shellInvocation validates exactly that before joining the
+    // argv into one line (an args array plus shell:true is DEP0190).
+    const invocation = shellInvocation(command, args);
+    const result = spawnSync(invocation.command, invocation.args, {
         encoding: "utf8",
         timeout: HOST_TIMEOUT_MS,
-        // Both CLIs are npm shims on Windows, and Node refuses to spawn a .cmd
-        // without a shell. Every argument JAM passes is a bare token - no JSON, no
-        // spaces - precisely so this cannot become a quoting hazard.
-        shell: process.platform === "win32",
+        shell: invocation.shell,
+    });
+    if (result.error)
+        return { status: null, failed: true, stdout: "" };
+    return { status: result.status, failed: false, stdout: result.stdout ?? "" };
+};
+/**
+ * A runner that only sees what is persistently installed on this machine.
+ *
+ * Under `npx --yes @jam-mcp/bootstrap@X`, PATH carries npx's cache
+ * `node_modules/.bin` - which contains a `jam` shim that vanishes when npx
+ * exits. Any measurement of "does a global jam exist" through the normal PATH
+ * therefore lies during bootstrap, which is exactly when the answer matters
+ * most. This runner strips those entries first.
+ */
+export const persistentHostRunner = ({ command, args }) => {
+    const invocation = shellInvocation(command, args);
+    const pathValue = process.env.PATH ?? process.env.Path ?? "";
+    const result = spawnSync(invocation.command, invocation.args, {
+        encoding: "utf8",
+        timeout: HOST_TIMEOUT_MS,
+        shell: invocation.shell,
+        env: { ...process.env, PATH: stripPackageRunnerPath(pathValue) },
     });
     if (result.error)
         return { status: null, failed: true, stdout: "" };
@@ -23,6 +48,13 @@ export const defaultHostRunner = ({ command, args }) => {
  * Windows shell, and every argument here is a bare token instead.
  */
 const LAUNCH = ["--", JAM_MCP_ENTRY.command, ...JAM_MCP_ENTRY.args];
+/**
+ * What a persistent install registers: the global `jam` executable, no
+ * package runner, no cache. Only offered when the measured global launcher
+ * is exactly this release (preferBareRegistration) - registering bare over
+ * an older global would silently downgrade the served toolset.
+ */
+const LAUNCH_BARE = ["--", "jam", "serve"];
 const ADAPTERS = [
     {
         id: "claude-code",
@@ -39,8 +71,14 @@ const ADAPTERS = [
         unregister: { command: "codex", args: ["mcp", "remove", "jam"] },
     },
 ];
-export function hostRegistration(id) {
-    return ADAPTERS.find((a) => a.id === id)?.register;
+export function hostRegistration(id, options = {}) {
+    const adapter = ADAPTERS.find((a) => a.id === id);
+    if (!adapter)
+        return undefined;
+    if (!options.bare)
+        return adapter.register;
+    const at = adapter.register.args.indexOf("--");
+    return { command: adapter.register.command, args: [...adapter.register.args.slice(0, at), ...LAUNCH_BARE] };
 }
 /** The removal that has to precede re-registering an entry this host already has. */
 export function hostUnregistration(id) {
@@ -74,16 +112,64 @@ export function jamEntryLine(stdout) {
 export function entryLauncherVersion(line) {
     return /@jam-mcp\/launcher@([^\s"']+)/.exec(line)?.[1];
 }
+/**
+ * Does this entry run the persistent `jam` executable rather than an npx pin?
+ *
+ * `jam: jam serve`, `jam: /usr/local/bin/jam serve`, `jam: C:\...\jam.cmd serve`
+ * all count; an npx line never does - its command token is `npx`. A bare entry
+ * carries no version in the listing, so its staleness has to be measured from
+ * the executable it would actually run (bareJamVersion), not from the line.
+ */
+export function isBareJamEntry(line) {
+    const command = line.replace(/^\s*jam\s*:?\s*/, "");
+    return /^(?:\S*[\\/])?jam(?:\.cmd|\.exe)?["']?\s+serve\b/i.test(command);
+}
+/**
+ * The version a bare `jam` registration actually runs, measured by asking the
+ * executable itself. `runtime status --json` answers from ~/.jam/config.yaml
+ * and the resolved build - the same resolution the registered entry performs.
+ *
+ * undefined when `jam` is not on PATH or does not answer: a registration that
+ * cannot be measured counts as stale, same as an unreadable pin.
+ *
+ * Measured through persistentHostRunner by default: under an npx bootstrap
+ * the ordinary PATH resolves `jam` to npx's own ephemeral cache shim, and a
+ * bare registration decided on that evidence dies as soon as npx exits.
+ */
+export function bareJamVersion(run = persistentHostRunner) {
+    const result = run({ command: "jam", args: ["runtime", "status", "--json"] });
+    if (result.failed || result.status !== 0)
+        return undefined;
+    try {
+        const version = JSON.parse(result.stdout).version;
+        return typeof version === "string" ? version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Is this measured launcher version the one this release registers? */
+export function preferBareRegistration(version) {
+    return version !== undefined && version === EXPECTED_LAUNCHER_VERSION;
+}
 /**
  * Does this entry run the launcher this release registers?
  *
- * Anything else - an older pin, an unpinned spec, a line whose command JAM
- * cannot read - counts as stale. That direction is deliberate: `mcp add`
- * rewrites the same entry, so a needless repair costs one command, while a
- * missed one leaves the agent talking to a server nobody tested it against.
+ * An npx pin answers from the line itself. A bare `jam` line names no version,
+ * so the caller passes what the executable measured (`bareVersion`) - without
+ * it, bare stays stale. Anything else - an older pin, an unpinned spec, a line
+ * whose command JAM cannot read - counts as stale. That direction is
+ * deliberate: `mcp add` rewrites the same entry, so a needless repair costs
+ * one command, while a missed one leaves the agent talking to a server nobody
+ * tested it against.
  */
-export function isEntryStale(line) {
-    return entryLauncherVersion(line) !== EXPECTED_LAUNCHER_VERSION;
+export function isEntryStale(line, bareVersion) {
+    const pinned = entryLauncherVersion(line);
+    if (pinned !== undefined)
+        return pinned !== EXPECTED_LAUNCHER_VERSION;
+    if (isBareJamEntry(line))
+        return bareVersion !== EXPECTED_LAUNCHER_VERSION;
+    return true;
 }
 const EXPECTED_LAUNCHER_VERSION = entryLauncherVersion(JAM_MCP_ENTRY.args.join(" "));
 /**
@@ -107,6 +193,7 @@ export function detectHosts(run = defaultHostRunner) {
 }
 let cachedHosts;
 function probeHosts(run) {
+    let bareCache;
     return ADAPTERS.map((adapter) => {
         const result = run(adapter.probe);
         if (result.failed || result.status !== 0) {
@@ -115,15 +202,26 @@ function probeHosts(run) {
         const line = jamEntryLine(result.stdout);
         if (!line)
             return { id: adapter.id, cliAvailable: true, hasJamEntry: false };
-        const version = entryLauncherVersion(line);
+        // A bare entry's version lives in the executable, not the line - measure
+        // it once, only when a bare entry actually shows up.
+        const bare = isBareJamEntry(line);
+        const version = entryLauncherVersion(line) ?? (bare ? measuredBare() : undefined);
         return {
             id: adapter.id,
             cliAvailable: true,
             hasJamEntry: true,
             ...(version ? { entryVersion: version } : {}),
-            entryStale: isEntryStale(line),
+            ...(bare ? { entryBare: true } : {}),
+            entryStale: isEntryStale(line, version),
         };
     });
+    function measuredBare() {
+        // The real probe runner sees npx's contaminated PATH; the persistent
+        // runner is the honest one for this question. An injected runner is a
+        // test, and stays in charge of its own answers.
+        bareCache ??= { version: bareJamVersion(run === defaultHostRunner ? persistentHostRunner : run) };
+        return bareCache.version;
+    }
 }
 /** How a person would do it by hand, for the hosts JAM could not reach. */
 export function describeHostCommand({ command, args }) {

package/dist/bootstrap/live-toolset.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { shellInvocation } from "./shell-command.js";
 import { SERVER_VERSION } from "@jam-mcp/launcher";
 import { TOOL_NAMES } from "../mcp/create-server.js";
 const HANDSHAKE_TIMEOUT_MS = 30_000;
@@ -9,9 +10,12 @@ export const expectedTools = () => [...TOOL_NAMES].sort();
  * one question that is three lines of JSON.
  */
 export const defaultToolsetProbe = ({ command, args }) => new Promise((resolve) => {
-    const child = spawn(command, args, {
+    // npm shims need a shell on Windows; the argv is joined by shellInvocation
+    // (validated bare tokens) because an args array plus shell:true is DEP0190.
+    const invocation = shellInvocation(command, args);
+    const child = spawn(invocation.command, invocation.args, {
         stdio: ["pipe", "pipe", "ignore"],
-        shell: process.platform === "win32",
+        shell: invocation.shell,
     });
     let buffer = "";
     let settled = false;

package/dist/bootstrap/mcp-config-merger.d.ts

@@ -13,7 +13,7 @@ import { LAUNCHER_PACKAGE_SPEC } from "@jam-mcp/launcher";
 export { LAUNCHER_PACKAGE_SPEC };
 export declare const JAM_MCP_ENTRY: {
     readonly command: "npx";
-    readonly args: readonly ["--yes", "@jam-mcp/launcher@1.4.1", "serve"];
+    readonly args: readonly ["--yes", "@jam-mcp/launcher@1.4.3", "serve"];
 };
 /**
  * Recognise wiring from before the launcher existed: a hard-coded `node` path

package/dist/bootstrap/migration-target.js

@@ -1,13 +1,16 @@
 import { spawnSync } from "node:child_process";
+import { shellInvocation } from "./shell-command.js";
 import { LAUNCHER_PACKAGE_SPEC } from "./mcp-config-merger.js";
 import { computeSetupPlan } from "./setup-plan.js";
 const PROBE_TIMEOUT_MS = 10_000;
 function runNpm(command, args) {
-    const result = spawnSync(command, args, {
+    // npm on Windows is a shell script, not an executable; shellInvocation
+    // joins the validated argv because an args array plus shell:true is DEP0190.
+    const invocation = shellInvocation(command, args);
+    const result = spawnSync(invocation.command, invocation.args, {
         encoding: "utf8",
         timeout: PROBE_TIMEOUT_MS,
-        // npm on Windows is a shell script, not an executable.
-        shell: process.platform === "win32",
+        shell: invocation.shell,
     });
     return {
         status: result.status,

package/dist/bootstrap/setup-plan.js

@@ -1,6 +1,6 @@
 import { join } from "node:path";
 import { CONFIG_RELATIVE_PATH } from "../config/load-config.js";
-import { hostRegistration, hostUnregistration } from "./host-mcp.js";
+import { hostRegistration, preferBareRegistration, hostUnregistration } from "./host-mcp.js";
 import { projectBindingsPath } from "./project-bindings.js";
 import { decideProjectKey } from "./project-config-bootstrapper.js";
 import { portableBootstrapCommand } from "@jam-mcp/launcher";
@@ -161,7 +161,11 @@ function planHostChanges(state) {
         // that pin decides which server, and so which tools, the agent actually gets.
         if (host.hasJamEntry && host.entryStale !== true)
             continue;
-        const registration = hostRegistration(host.id);
+        // A machine whose global `jam` already runs this release gets the
+        // persistent registration; anything else keeps the npx pin fallback.
+        const registration = hostRegistration(host.id, {
+            bare: preferBareRegistration(state.bareLauncher),
+        });
         if (!registration)
             continue;
         const removal = hostUnregistration(host.id);

package/dist/bootstrap/setup-state.d.ts

@@ -50,6 +50,12 @@ export type SetupState = {
      * host, which `jam doctor` has no reason to pay.
      */
     hosts: HostState[];
+    /**
+     * The version the global `jam` executable actually runs, when one answers.
+     * Measured with the hosts (same probe budget); undefined otherwise. This is
+     * what decides whether a repair registers bare `jam` or an npx pin.
+     */
+    bareLauncher?: string;
 };
 export type DetectOptions = {
     cwd?: string;

package/dist/bootstrap/setup-state.js

@@ -1,7 +1,7 @@
 import { readRuntimeConfig, resolveRuntime, } from "@jam-mcp/launcher";
 import { CompositeCredentialProvider } from "../adapters/credentials/composite.js";
 import { loadConfig } from "../config/load-config.js";
-import { detectHosts } from "./host-mcp.js";
+import { bareJamVersion, detectHosts } from "./host-mcp.js";
 import { inspectMcpConfig, isLegacyJamEntry } from "./mcp-config-merger.js";
 import { inspectProjectBindings } from "./project-bindings.js";
 import { resolveProjectRoot } from "./project-root-resolver.js";
@@ -31,6 +31,12 @@ export function detectSetupState(options = {}) {
         project: { ...detectProject(located), ...(binding ? { binding } : {}) },
         mcp: detectMcp(located.root),
         hosts: options.probeHosts ? detectHosts(options.runHost) : [],
+        ...(options.probeHosts
+            ? (() => {
+                const measured = bareJamVersion(options.runHost);
+                return measured !== undefined ? { bareLauncher: measured } : {};
+            })()
+            : {}),
     };
 }
 function detectRuntime(home) {

package/dist/bootstrap/shell-command.d.ts

@@ -0,0 +1,36 @@
+/**
+ * How to hand an npm-shim CLI to spawnSync without tripping DEP0190.
+ *
+ * npm-installed CLIs (`claude`, `codex`, `npm`, `npx`, `jam`) are `.cmd`
+ * shims on Windows, and Node only runs those through a shell. But passing an
+ * args ARRAY together with `shell: true` is deprecated (DEP0190): Node
+ * concatenates the arguments without escaping, so the array form is an
+ * illusion of safety. On Windows the argv is therefore joined into a single
+ * command line HERE, deliberately - and every token is validated bare first,
+ * so the join cannot become a quoting hazard. A token that would need cmd.exe
+ * quoting is refused outright rather than escaped: nothing JAM runs ever
+ * carries one, so meeting one means the input is not ours to guess about.
+ *
+ * On every other platform the array form without a shell is correct and
+ * unchanged.
+ */
+export type ShellInvocation = {
+    command: string;
+    args: string[];
+    shell: boolean;
+};
+export declare function shellInvocation(command: string, args: readonly string[], platform?: NodeJS.Platform): ShellInvocation;
+/**
+ * PATH with package-runner injections removed.
+ *
+ * `npx --yes @jam-mcp/bootstrap@X` prepends its cache's `node_modules/.bin`
+ * to PATH, and that directory contains a `jam` shim - so inside a bootstrap
+ * run, `jam` resolves even on a machine where nothing is installed. Measuring
+ * "does this machine have a persistent jam" through that PATH answered yes on
+ * every fresh machine, and setup then registered a bare `jam serve` that died
+ * the moment npx's directory evaporated (the v1.4.2 fresh-install field
+ * failure). A persistent install lives in npm's global bin, never under a
+ * `node_modules` or `_npx` directory, so those entries are dropped before the
+ * measurement.
+ */
+export declare function stripPackageRunnerPath(pathValue: string, separator?: string): string;

package/dist/bootstrap/shell-command.js

@@ -0,0 +1,31 @@
+import { delimiter } from "node:path";
+/** Anything cmd.exe would re-interpret, plus whitespace and quotes. */
+const CMD_UNSAFE = /[\s&|<>^"'`;()]/;
+export function shellInvocation(command, args, platform = process.platform) {
+    if (platform !== "win32")
+        return { command, args: [...args], shell: false };
+    const unsafe = [command, ...args].find((token) => token === "" || CMD_UNSAFE.test(token));
+    if (unsafe !== undefined) {
+        throw new Error(`refusing to pass a token through cmd.exe unquoted: ${JSON.stringify(unsafe)}`);
+    }
+    return { command: [command, ...args].join(" "), args: [], shell: true };
+}
+/**
+ * PATH with package-runner injections removed.
+ *
+ * `npx --yes @jam-mcp/bootstrap@X` prepends its cache's `node_modules/.bin`
+ * to PATH, and that directory contains a `jam` shim - so inside a bootstrap
+ * run, `jam` resolves even on a machine where nothing is installed. Measuring
+ * "does this machine have a persistent jam" through that PATH answered yes on
+ * every fresh machine, and setup then registered a bare `jam serve` that died
+ * the moment npx's directory evaporated (the v1.4.2 fresh-install field
+ * failure). A persistent install lives in npm's global bin, never under a
+ * `node_modules` or `_npx` directory, so those entries are dropped before the
+ * measurement.
+ */
+export function stripPackageRunnerPath(pathValue, separator = delimiter) {
+    return pathValue
+        .split(separator)
+        .filter((entry) => !/[\\/]node_modules[\\/]|[\\/]_npx[\\/]/.test(`${entry}/`.replace(/[\\/]+$/, "/")))
+        .join(separator);
+}

package/dist/cli/agent-api.js

@@ -69,11 +69,23 @@ export async function setupApplyCommand(options = {}) {
         ...(options.home ? { home: options.home } : {}),
         ...(options.runHost ? { runHost: options.runHost } : {}),
     });
-    emitJson({ ...plan, status: applyStatus(plan), changesApplied: result.changesApplied });
+    emitJson({
+        ...plan,
+        status: applyStatus(plan, result.changesApplied),
+        changesApplied: result.changesApplied,
+    });
     return plan.requiresUserAction ? 1 : 0;
 }
-function applyStatus(plan) {
-    return plan.requiresUserAction ? "user_action_required" : "already_configured";
+/**
+ * The status of an apply, after it ran. "already_configured" means nothing
+ * was executed; when changes did run the answer is "applied" - reporting
+ * "already_configured" alongside changesApplied:true made the two fields
+ * contradict each other, and an agent could believe either one.
+ */
+function applyStatus(plan, changesApplied) {
+    if (plan.requiresUserAction)
+        return "user_action_required";
+    return changesApplied ? "applied" : "already_configured";
 }
 /**
  * `jam setup --agent` - one shot: detect, plan, apply what is safe, verify.
@@ -161,7 +173,10 @@ async function inspectAxes(state, options) {
     // and asking it means launching that older release. Repair first.
     if (registered.entryStale)
         return axes;
-    const registration = hostRegistration(registered.id);
+    // Launch what is actually registered: a bare entry runs the global `jam`,
+    // an npx pin runs the pinned launcher. Testing the other one would prove
+    // nothing about the entry the agent uses.
+    const registration = hostRegistration(registered.id, { bare: registered.entryBare === true });
     const launch = registration ? launcherArgv(registration.args) : null;
     if (!launch)
         return { ...axes, live: "UNCHECKED", detail: "could not read the registered command" };

package/dist/cli/setup.js

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+import { shellInvocation } from "../bootstrap/shell-command.js";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { runHealthGate } from "../bootstrap/boot-health-gate.js";
@@ -178,10 +179,13 @@ async function installAndBuild(root) {
         { name: "Build", args: ["run", "build"] },
     ]) {
         line(`\n> npm ${step.args.join(" ")}`);
-        const res = spawnSync("npm", step.args, {
+        // npm is a .cmd shim on Windows; shellInvocation joins the validated argv
+        // because an args array plus shell:true is DEP0190.
+        const invocation = shellInvocation("npm", step.args);
+        const res = spawnSync(invocation.command, invocation.args, {
             cwd: root,
             stdio: "inherit",
-            shell: process.platform === "win32",
+            shell: invocation.shell,
         });
         if (res.status !== 0) {
             line(`[FAIL] ${step.name}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jam-mcp/server",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "description": "JAM (Jira Agent MCP) - agent-facing Jira access layer: MCP server, setup core, and CLI",
   "keywords": [
     "jira",
@@ -41,7 +41,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@jam-mcp/launcher": "1.4.1",
+    "@jam-mcp/launcher": "1.4.3",
     "@modelcontextprotocol/sdk": "^1.30.0",
     "yaml": "^2.9.0",
     "zod": "^4.4.3"