perf(javascript): reuse the source-analysis worker within a process (#5819)

* perf(javascript): reuse the source-analysis worker within a process

Each analyze-javascript-application call started a new Node worker.
That startup, not fixture IO or the shared CLI session, dominated the
slow loader-review and factory-completion files.

Park one healthy worker on the artifact resource scope and on the CLI
process. Stop it when the scope, session, or one-shot process ends.
Do not reuse after failure, cancellation, or a different heap or timeout.

Co-authored-by: morluto <morluto@users.noreply.github.com>

* fix(cli): close the JavaScript worker when dispatch throws

Minimal dispatcher runtimes now export a no-op closeCliJavaScriptResources,
and CLI dispatch plus output rendering always await that cleanup. A dispatch
failure and a cleanup failure are both reported.

Co-authored-by: morluto <morluto@users.noreply.github.com>

* fix(artifacts): report close-hook failures with retained cleanup

When retained cleanup and the scope close hook both fail, the close error
keeps both causes and both resource labels. The pending owners and the hook
stay registered so the next close retries each path.

Co-authored-by: morluto <morluto@users.noreply.github.com>

* fix(javascript): stop a replaced analysis worker before the next one starts

A heap or timeout change now closes the parked worker before constructing
its replacement. The scope retains that process only when the close fails.

Co-authored-by: morluto <morluto@users.noreply.github.com>

* style: format worker-reuse close and launch helpers

Co-authored-by: morluto <morluto@users.noreply.github.com>

* fix(cli): report a failed JavaScript worker shutdown before exit

Share one in-flight close and drop the CLI scope only after it succeeds,
so a later caller retries a worker that is still owned. The one-shot
exit callback writes that failure and exits non-zero, while a closed
stdout pipe still exits 141.

Co-authored-by: morluto <morluto@users.noreply.github.com>

* fix(javascript): keep a worker parked during an overlapping limit change

Claim the scope slot only when it is still empty after the replaced
worker closes. A concurrent analysis that parked another healthy worker
keeps that process, and the extra worker is closed through its own port.

Co-authored-by: morluto <morluto@users.noreply.github.com>

* fix(artifacts): run later close hooks when an earlier hook fails

Run every registered close hook on each close. One failure is returned
unchanged, and several failures are aggregated so a later hook is not
skipped.

Co-authored-by: morluto <morluto@users.noreply.github.com>

* fix(javascript): fail a limit change when the previous worker stays alive

A failed close used to be retained and then ignored, so MCP could return
a successful analysis while the old process and its replacement were
both owned. The request now fails before the replacement is constructed,
and the still-live worker stays owned for a later close.

Co-authored-by: morluto <morluto@users.noreply.github.com>

---------

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: morluto <morluto@users.noreply.github.com>

scripts/rea.mjs

@@ -80,7 +80,7 @@ if (!(await compiledRuntimeExists(runtimeFiles))) {
   writeStdout(result.output);
   process.exitCode = result.exitCode;
 } else {
-  const { cliConfigurationError, createCli } =
+  const { cliConfigurationError, closeCliJavaScriptResources, createCli } =
     await import("../dist/cli-runtime/cli.js");
   const { createCliResultOutput } =
     await import("../dist/cli-runtime/cliResultOutput.js");
@@ -94,47 +94,97 @@ if (!(await compiledRuntimeExists(runtimeFiles))) {
   const cliArgs = normalizeCliArguments(args);
   const outputArguments = validateCliOutputArguments(cliArgs);
   const configurationError = cliConfigurationError(process.env);
-  // Doctor is the readiness report for this failure. Other commands still stop
-  // here so they do not run with an unusable log level.
-  if (configurationError !== undefined && !isDoctorCommand(cliArgs)) {
-    process.stderr.write(`${configurationError}\n`);
-    process.exitCode = 1;
-  } else if (!outputArguments.ok) {
-    writeStdout(renderCliOutputArgumentError(outputArguments));
-    process.exitCode = 1;
-  } else {
-    let wroteOutput = false;
-    const resultOutput = createCliResultOutput(cliArgs, process.stdout);
-    try {
-      await createCli(process.env, resultOutput).serve(cliArgs, {
-        stdout: (output) => {
-          if (resultOutput?.handled) {
-            if (resultOutput.failed && !stdoutClosed)
-              process.stderr.write(output);
-            return;
-          }
-          if (output.length > 0) wroteOutput = true;
-          writeStdout(output);
-        },
-        // A command failure caused by the closed pipe keeps the pipe's status.
-        exit: (code) => process.exit(stdoutClosed ? SIGPIPE_EXIT_STATUS : code),
-      });
-    } catch (cause) {
-      if (wroteOutput) throw cause;
-      const recovered = await resultOutput
-        ?.recoverFormattingFailure(cause)
-        .catch((writeFailure) => {
-          // Recovery writes outside Incur's command boundary. A reader that
-          // declined this document keeps the same quiet SIGPIPE outcome.
-          if (!stdoutClosed) throw writeFailure;
-          return true;
+  let dispatchFailure;
+  // Incur can exit from the callback below before this function returns.
+  // That callback owns the status, including a closed-pipe exit of 141.
+  let exiting = false;
+  try {
+    // Doctor is the readiness report for this failure. Other commands still stop
+    // here so they do not run with an unusable log level.
+    if (configurationError !== undefined && !isDoctorCommand(cliArgs)) {
+      process.stderr.write(`${configurationError}\n`);
+      process.exitCode = 1;
+    } else if (!outputArguments.ok) {
+      writeStdout(renderCliOutputArgumentError(outputArguments));
+      process.exitCode = 1;
+    } else {
+      let wroteOutput = false;
+      const resultOutput = createCliResultOutput(cliArgs, process.stdout);
+      try {
+        await createCli(process.env, resultOutput).serve(cliArgs, {
+          stdout: (output) => {
+            if (resultOutput?.handled) {
+              if (resultOutput.failed && !stdoutClosed)
+                process.stderr.write(output);
+              return;
+            }
+            if (output.length > 0) wroteOutput = true;
+            writeStdout(output);
+          },
+          // A command failure caused by the closed pipe keeps the pipe's status.
+          // Worker shutdown is shared with the dispatch finally below. A failed
+          // shutdown is reported here because this callback is what exits.
+          exit: (code) => {
+            exiting = true;
+            const status = stdoutClosed ? SIGPIPE_EXIT_STATUS : code;
+            void Promise.resolve()
+              .then(() => closeCliJavaScriptResources())
+              .then(
+                () => {
+                  process.exit(status);
+                },
+                (cleanup) => {
+                  process.stderr.write(
+                    `Failed to close the JavaScript analysis worker: ${cleanupFailureText(cleanup)}\n`,
+                  );
+                  process.exit(
+                    stdoutClosed
+                      ? SIGPIPE_EXIT_STATUS
+                      : status === 0
+                        ? 1
+                        : status,
+                  );
+                },
+              );
+          },
         });
-      if (!recovered) throw cause;
-      process.exitCode = stdoutClosed ? SIGPIPE_EXIT_STATUS : 1;
+      } catch (cause) {
+        if (wroteOutput) throw cause;
+        const recovered = await resultOutput
+          ?.recoverFormattingFailure(cause)
+          .catch((writeFailure) => {
+            // Recovery writes outside Incur's command boundary. A reader that
+            // declined this document keeps the same quiet SIGPIPE outcome.
+            if (!stdoutClosed) throw writeFailure;
+            return true;
+          });
+        if (!recovered) throw cause;
+        process.exitCode = stdoutClosed ? SIGPIPE_EXIT_STATUS : 1;
+      }
+      if (!wroteOutput && !resultOutput?.handled)
+        writeStdout(renderEmptyFilteredCliOutput(cliArgs) ?? "");
+    }
+  } catch (cause) {
+    dispatchFailure = cause;
+  } finally {
+    // Serve and output rendering can throw after a worker is parked. Stop it
+    // on that path too, and keep the dispatch failure when both fail.
+    try {
+      await closeCliJavaScriptResources();
+    } catch (cleanup) {
+      // The exit callback reports this same shared failure and then exits.
+      if (!exiting) {
+        dispatchFailure =
+          dispatchFailure === undefined
+            ? cleanup
+            : new AggregateError(
+                [dispatchFailure, cleanup],
+                "CLI dispatch failed and the JavaScript analysis worker remained owned",
+              );
+      }
     }
-    if (!wroteOutput && !resultOutput?.handled)
-      writeStdout(renderEmptyFilteredCliOutput(cliArgs) ?? "");
   }
+  if (!exiting && dispatchFailure !== undefined) throw dispatchFailure;
 }
 
 /** True when the first positional command is `doctor`, after global output flags. */
@@ -164,6 +214,11 @@ function isDoctorCommand(arguments_) {
  * with the status a SIGPIPE-terminated writer reports. MCP stdio keeps its own
  * client lifecycle.
  */
+function cleanupFailureText(cleanup) {
+  if (cleanup instanceof Error) return cleanup.stack ?? cleanup.message;
+  return String(cleanup);
+}
+
 function guardClosedStdout() {
   process.stdout.on("error", (cause) => {
     if (cause?.code === "EPIPE") {