jaitus 0.3.14 → 0.3.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaitus",
-  "version": "0.3.14",
+  "version": "0.3.16",
   "description": "Jaitus — a coding agent in your terminal.",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "test": "node tests/source-sanity.js && node tests/react-build.js && node tests/stalls.js && node tests/clipboard-write.js && node tests/rewind-images.js && node tests/rules.js && node tests/run.js && node tests/commands.js && node tests/login.js && node tests/session.js && node tests/openUrl.js && node tests/ink-tui.js && node tests/tui-render.js && node tests/mouse-e2e.js && node tests/environment.js && node tests/update.js && node tests/service-notices.js && node tests/continuation.js && node tests/steps.js && node tests/files.js && node tests/processes.js && node tests/security.js && node tests/context-budget.js && node tests/context-trim.js",
+    "test": "node tests/source-sanity.js && node tests/react-build.js && node tests/stalls.js && node tests/clipboard-write.js && node tests/rewind-images.js && node tests/rules.js && node tests/run.js && node tests/commands.js && node tests/login.js && node tests/session.js && node tests/openUrl.js && node tests/ink-tui.js && node tests/tui-render.js && node tests/mouse-e2e.js && node tests/environment.js && node tests/update.js && node tests/service-notices.js && node tests/continuation.js && node tests/steps.js && node tests/files.js && node tests/processes.js && node tests/security.js && node tests/context-budget.js && node tests/context-trim.js && node tests/compaction.js && node tests/copy-clean.js && node tests/parallel-tools.js",
     "preview": "node scripts/tui-preview.js",
     "prepublishOnly": "npm test"
   },

package/src/agent/loop.js

@@ -262,6 +262,12 @@ export function repairToolPairs(messages) {
 export const TRIM_AT = 40_000;          // estimated tokens of conversation
 export const KEEP_RECENT = 6;           // latest tool results always kept whole
 export const TRIM_AT_LEAST = 12_000;    // estimated tokens a clearing must free
+// Past DEEP_AT only the newest KEEP_RECENT_DEEP results stay whole. Production, 7 days to
+// 2 Oct: requests carrying 150k+ tokens were a quarter of all requests and 62% of all
+// credits — every step of a long task re-sent the outputs of its last six tools whole,
+// up to 60,000 characters each.
+export const DEEP_AT = 100_000;
+export const KEEP_RECENT_DEEP = 3;
 const TRIM_MIN_CHARS = 1_500;           // results shorter than this are never cleared
 const CLEARED = '[Output cleared';
 
@@ -281,8 +287,10 @@ export function conversationTokens(messages) {
  * Clear old tool outputs in place when the conversation is large. Returns how many
  * estimated tokens were freed (0 when nothing was worth clearing).
  */
-export function clearOldToolResults(messages, { at = TRIM_AT, keep = KEEP_RECENT, atLeast = TRIM_AT_LEAST } = {}) {
-  if (conversationTokens(messages) < at) return 0;
+export function clearOldToolResults(messages, { at = TRIM_AT, keep, atLeast = TRIM_AT_LEAST } = {}) {
+  const size = conversationTokens(messages);
+  if (size < at) return 0;
+  if (keep === undefined) keep = size >= DEEP_AT ? KEEP_RECENT_DEEP : KEEP_RECENT;
   const names = new Map();
   for (const m of messages) {
     if (m?.role === 'assistant' && Array.isArray(m.content)) for (const b of m.content) if (b?.type === 'tool_use') names.set(b.id, b.name);
@@ -306,6 +314,9 @@ export function clearOldToolResults(messages, { at = TRIM_AT, keep = KEEP_RECENT
   return freed;
 }
 
+// Tools that change nothing and ask nothing: several in one batch run at the same time.
+const PARALLEL_SAFE = new Set(['read_file', 'glob', 'list_files', 'search', 'web_search', 'web_fetch', 'background_list', 'background_read', 'load_skill']);
+
 export const IMAGE_BUDGET = 6_000_000;
 export function withinImageBudget(messages, budget = IMAGE_BUDGET) {
   let used = 0;
@@ -495,7 +506,7 @@ export async function runAgent({
   client, messages, model, cwd, permissions, signal, tui = null,
   extraSystem = '', maxIterations = MAX_ITERATIONS, silent = false,
   onText = null, onEvent = null, systemOverride = null, journal = null,
-  subagents = true, onContext = null, trimContext = true,
+  subagents = true, onContext = null, trimContext = true, beforeStep = null,
 }) {
   // Loop detection. A call is identified by its tool, its input, and how many files had
   // been changed when it was made — so edit → test → edit → test is progress (the count
@@ -544,6 +555,11 @@ export async function runAgent({
       const freed = clearOldToolResults(messages);
       if (freed && tui?.notice) tui.notice(`Cleared old tool output (~${Math.round(freed / 1000)}k tokens) to keep each request small.`, 'info');
     }
+    // The caller may compact the history between steps (index.js: when the context is
+    // nearly full). Never before the first step — the caller already checked then.
+    if (beforeStep && iteration > 0 && !signal?.aborted) {
+      try { await beforeStep(messages); } catch { /* a failed compaction is reported by the caller; the step still runs */ }
+    }
     let streamed = false;
     const spin = tui ? { stop: () => {}, update: () => {} } : (silent ? { stop: () => {}, update: () => {} } : spinner(glyph('Working…', 'Working...')));
     if (tui) tui.setStatus(`${c.brand(glyph('•', '*'))} ${c.brand(glyph('Working…', 'Working...'))}`);
@@ -728,6 +744,26 @@ export async function runAgent({
       return { ...totals, stopReason: 'stuck' };
     }
 
+    // Read-only calls in one batch run AT THE SAME TIME. The model is told to batch
+    // independent reads, and then they ran one after another anyway: five file reads or
+    // three searches cost five or three round trips of wall time. Only tools that change
+    // nothing and need no permission start early; their rows, results and order are
+    // exactly as before — the loop below just finds the work already done. Anything
+    // that writes, runs a command or asks the user still runs one by one, in order.
+    const early = new Map();
+    const parallel = calls.filter((call) => {
+      const t = toolMap[call.name];
+      return t && PARALLEL_SAFE.has(call.name) && !t.needsPermission && call.input?.__parse_error === undefined
+        && !planBlocked.has(call.id) && permissions?.verdict?.(call.name, call.input, cwd) !== 'deny';
+    });
+    if (parallel.length > 1 && !signal?.aborted) {
+      for (const call of parallel) {
+        const started = Promise.resolve().then(() => toolMap[call.name].run(call.input, { cwd, signal }));
+        started.catch(() => { /* reported when the loop reaches the call */ });
+        early.set(call.id, started);
+      }
+    }
+
     // Every call gets a result, whatever happened.
     const results = [];
     for (const call of calls) {
@@ -811,7 +847,7 @@ export async function runAgent({
         } else if (journal && call.name === 'run_command') {
           journal.snapshotTracked(cwd);
         }
-        const output = await tool.run(call.input, { cwd, signal });
+        const output = await (early.get(call.id) ?? tool.run(call.input, { cwd, signal }));
         spin2.stop(); stopElapsed();
         const took = ((Date.now() - toolStarted) / 1000).toFixed(1);
         // opencode tool icons: $ shell, ← edits, → reads, ✱ search,

package/src/api.js

@@ -1,174 +1,177 @@
-// ─── Talking to Jaitus ──────────────────────────────────────────────────────────
-//
-// The CLI is the only client of the gateway. Every failure it gets back is turned into
-// a JaitusError here, at the edge, so no caller ever has an HTTP body in its hands to
-// print — see errors.js for why that matters.
-
-import { endpoints, version } from './config.js';
-import { signedIn, withAuth } from './session.js';
-import { fromGatewayBody, fromNetwork, JaitusError } from './errors.js';
-
-export class NotSignedIn extends Error {}
-
-// fetch() has no timeout of its own, so a request the gateway never answered used to
-// pin the CLI on "Working..." forever. Every call below carries a deadline: slow
-// becomes a `timeout` JaitusError (retryable by the agent loop, shown with a request
-// id) instead of eternity. The caller's signal (Esc) still wins: it aborts through the
-// same controller, and only a genuine user abort reads as one.
-//
-// A turn is bounded by SILENCE, not by its length. Until the reply starts, the gateway
-// may be failing over between provider keys (each gets a 20-45 s budget), so the first
-// byte gets a few minutes. Once it starts, the gateway writes a heartbeat at least every
-// 10 s for as long as the provider is working, so 90 s without a single byte means the
-// connection is dead — while a long, healthy answer streams for as long as it needs.
-// (A fixed 10-minute ceiling on the whole request used to cut long answers off and
-// start them again from nothing.)
-// (Overridable only so the tests can drive a stall in under a second.)
-const FIRST_BYTE_TIMEOUT_MS = Number(process.env.JAITUS_FIRST_BYTE_MS) || 3 * 60 * 1000;
-const STREAM_IDLE_TIMEOUT_MS = Number(process.env.JAITUS_STREAM_IDLE_MS) || 90 * 1000;
-const API_TIMEOUT_MS = 30 * 1000;           // dashboard calls are small JSON
-
-// Combine an optional caller signal with a restartable deadline into one signal.
-// Manual combine (not AbortSignal.any): .any needs Node 20.3+, this works everywhere.
-function withTimeout(signal, ms) {
-  const ctrl = new AbortController();
-  let timedOut = false;
-  let timer = null;
-  const arm = (after) => {
-    clearTimeout(timer);
-    timer = setTimeout(() => {
-      timedOut = true;
-      try { ctrl.abort(new DOMException('Request timed out', 'TimeoutError')); }
-      catch { try { ctrl.abort(); } catch { /* already gone */ } }
-    }, after);
-    if (timer.unref) timer.unref();
-  };
-  arm(ms);
-  const onAbort = () => {
-    clearTimeout(timer);
-    try { ctrl.abort(signal.reason); } catch { try { ctrl.abort(); } catch { /* already gone */ } }
-  };
-  if (signal) {
-    if (signal.aborted) onAbort();
-    else signal.addEventListener('abort', onAbort, { once: true });
-  }
-  return {
-    signal: ctrl.signal,
-    // True only when OUR timer fired. A user abort also lands here as an AbortError,
-    // but signal.aborted is set then — never mistake Esc for a timeout.
-    timedOut: () => timedOut && !signal?.aborted,
-    /** Start the deadline again from now (with a new length). */
-    restart: (after) => { if (!ctrl.signal.aborted) arm(after); },
-    cleanup: () => { clearTimeout(timer); signal?.removeEventListener?.('abort', onAbort); },
-  };
-}
-
-/**
- * The response with its body watched for silence: every chunk restarts the idle
- * deadline, and the end of the body (or the reader letting go of it) stops the timer
- * and drops the caller's abort listener, so nothing outlives the request.
- */
-function watchedResponse(res, t, idleMs) {
-  if (!res.body) { t.cleanup(); return res; }
-  t.restart(idleMs);
-  const body = res.body.pipeThrough(new TransformStream({
-    transform(chunk, controller) { t.restart(idleMs); controller.enqueue(chunk); },
-    flush() { t.cleanup(); },
-    cancel() { t.cleanup(); },
-  }));
-  return new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
-}
-
-function timeoutError() {
-  return new JaitusError({ code: 'timeout', status: 504, message: 'Jaitus took too long to respond. Try again.' });
-}
-
-// The context window the gateway last advertised, or null before it has been asked.
-let contextWindowSeen = null;
-export const advertisedContextWindow = () => contextWindowSeen;
-
-export function createClient() {
-  const { baseUrl } = endpoints();
-  if (!signedIn()) throw new NotSignedIn('Not signed in. Run `jaitus login` first.');
-
-  // x-jaitus-features: what this build understands, so the gateway can use newer error
-  // codes (a used-up usage window) without an older CLI reading them as "went wrong".
-  const base = { 'Content-Type': 'application/json', 'user-agent': `jaitus-cli/${version()}`, 'x-jaitus-features': 'usage-window' };
-  const headers = (token) => ({ ...base, authorization: `Bearer ${token}` });
-
-  return {
-    baseUrl,
-
-    /** POST /v1/messages. Returns the raw Response so the caller can stream it. */
-    async messages(body, { signal } = {}) {
-      const t = withTimeout(signal, FIRST_BYTE_TIMEOUT_MS);
-      let res;
-      try {
-        res = await withAuth((token) => fetch(`${baseUrl}/v1/messages`, {
-          method: 'POST',
-          headers: headers(token),
-          body: JSON.stringify(body),
-          signal: t.signal,
-        }));
-      } catch (cause) {
-        t.cleanup();
-        if (cause?.name === 'JaitusError') throw cause;
-        if (t.timedOut()) throw timeoutError();
-        if (cause?.name === 'AbortError') throw cause;
-        throw fromNetwork(cause);
-      }
-      // A mid-body stall (headers fast, then nothing) aborts the body; the reader sees
-      // an AbortError while the caller's signal is NOT aborted, and turns it into a
-      // timeout — keeping whatever already arrived (agent/loop.js).
-      return watchedResponse(res, t, STREAM_IDLE_TIMEOUT_MS);
-    },
-
-    /** A dashboard API call, returning parsed JSON. */
-    async api(pathname, init = {}) {
-      const t = withTimeout(init.signal, API_TIMEOUT_MS);
-      let res;
-      try {
-        res = await withAuth((token) => fetch(`${baseUrl}/api${pathname}`, {
-          ...init,
-          headers: { ...headers(token), ...(init.headers || {}) },
-          signal: t.signal,
-        }));
-        const body = await res.json().catch(() => ({}));
-        return { ok: res.ok, status: res.status, body };
-      } catch (cause) {
-        if (cause?.name === 'JaitusError') throw cause;
-        if (t.timedOut()) throw timeoutError();
-        if (cause?.name === 'AbortError') throw cause;
-        throw fromNetwork(cause);
-      } finally {
-        t.cleanup();
-      }
-    },
-
-    /** Model ids the gateway advertises. */
-    async models() {
-      const t = withTimeout(undefined, API_TIMEOUT_MS);
-      let res;
-      try {
-        res = await withAuth((token) => fetch(`${baseUrl}/v1/models`, { headers: headers(token), signal: t.signal }));
-      } catch (cause) {
-        t.cleanup();
-        if (cause?.name === 'JaitusError') throw cause;
-        if (t.timedOut()) throw timeoutError();
-        if (cause?.name === 'AbortError') throw cause;
-        throw fromNetwork(cause);
-      }
-      const body = await res.json().catch(() => ({}));
-      t.cleanup();
-      if (!res.ok) throw fromGatewayBody(res.status, body, { requestId: res.headers.get('x-request-id') || '' });
-      const models = (body?.data || []).map((m) => m?.id).filter(Boolean);
-      // How much conversation fits, as the gateway computed it for this account.
-      const ctx = (body?.data || []).map((m) => Number(m?.context_window)).find((n) => n > 0);
-      if (ctx) contextWindowSeen = ctx;
-      // An empty list is a service fault, not something the user can fix — and naming
-      // the gateway's model map to them would be naming our internals.
-      if (!models.length) throw new JaitusError({ code: 'unavailable', status: 502 });
-      return models;
-    },
-  };
-}
+// ─── Talking to Jaitus ──────────────────────────────────────────────────────────
+//
+// The CLI is the only client of the gateway. Every failure it gets back is turned into
+// a JaitusError here, at the edge, so no caller ever has an HTTP body in its hands to
+// print — see errors.js for why that matters.
+
+import { endpoints, version } from './config.js';
+import { signedIn, withAuth } from './session.js';
+import { fromGatewayBody, fromNetwork, JaitusError } from './errors.js';
+import { machineHeader } from './machine.js';
+
+export class NotSignedIn extends Error {}
+
+// fetch() has no timeout of its own, so a request the gateway never answered used to
+// pin the CLI on "Working..." forever. Every call below carries a deadline: slow
+// becomes a `timeout` JaitusError (retryable by the agent loop, shown with a request
+// id) instead of eternity. The caller's signal (Esc) still wins: it aborts through the
+// same controller, and only a genuine user abort reads as one.
+//
+// A turn is bounded by SILENCE, not by its length. Until the reply starts, the gateway
+// may be failing over between provider keys (each gets a 20-45 s budget), so the first
+// byte gets a few minutes. Once it starts, the gateway writes a heartbeat at least every
+// 10 s for as long as the provider is working, so 90 s without a single byte means the
+// connection is dead — while a long, healthy answer streams for as long as it needs.
+// (A fixed 10-minute ceiling on the whole request used to cut long answers off and
+// start them again from nothing.)
+// (Overridable only so the tests can drive a stall in under a second.)
+const FIRST_BYTE_TIMEOUT_MS = Number(process.env.JAITUS_FIRST_BYTE_MS) || 3 * 60 * 1000;
+const STREAM_IDLE_TIMEOUT_MS = Number(process.env.JAITUS_STREAM_IDLE_MS) || 90 * 1000;
+const API_TIMEOUT_MS = 30 * 1000;           // dashboard calls are small JSON
+
+// Combine an optional caller signal with a restartable deadline into one signal.
+// Manual combine (not AbortSignal.any): .any needs Node 20.3+, this works everywhere.
+function withTimeout(signal, ms) {
+  const ctrl = new AbortController();
+  let timedOut = false;
+  let timer = null;
+  const arm = (after) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      timedOut = true;
+      try { ctrl.abort(new DOMException('Request timed out', 'TimeoutError')); }
+      catch { try { ctrl.abort(); } catch { /* already gone */ } }
+    }, after);
+    if (timer.unref) timer.unref();
+  };
+  arm(ms);
+  const onAbort = () => {
+    clearTimeout(timer);
+    try { ctrl.abort(signal.reason); } catch { try { ctrl.abort(); } catch { /* already gone */ } }
+  };
+  if (signal) {
+    if (signal.aborted) onAbort();
+    else signal.addEventListener('abort', onAbort, { once: true });
+  }
+  return {
+    signal: ctrl.signal,
+    // True only when OUR timer fired. A user abort also lands here as an AbortError,
+    // but signal.aborted is set then — never mistake Esc for a timeout.
+    timedOut: () => timedOut && !signal?.aborted,
+    /** Start the deadline again from now (with a new length). */
+    restart: (after) => { if (!ctrl.signal.aborted) arm(after); },
+    cleanup: () => { clearTimeout(timer); signal?.removeEventListener?.('abort', onAbort); },
+  };
+}
+
+/**
+ * The response with its body watched for silence: every chunk restarts the idle
+ * deadline, and the end of the body (or the reader letting go of it) stops the timer
+ * and drops the caller's abort listener, so nothing outlives the request.
+ */
+function watchedResponse(res, t, idleMs) {
+  if (!res.body) { t.cleanup(); return res; }
+  t.restart(idleMs);
+  const body = res.body.pipeThrough(new TransformStream({
+    transform(chunk, controller) { t.restart(idleMs); controller.enqueue(chunk); },
+    flush() { t.cleanup(); },
+    cancel() { t.cleanup(); },
+  }));
+  return new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
+}
+
+function timeoutError() {
+  return new JaitusError({ code: 'timeout', status: 504, message: 'Jaitus took too long to respond. Try again.' });
+}
+
+// The context window the gateway last advertised, or null before it has been asked.
+let contextWindowSeen = null;
+export const advertisedContextWindow = () => contextWindowSeen;
+
+export function createClient() {
+  const { baseUrl } = endpoints();
+  if (!signedIn()) throw new NotSignedIn('Not signed in. Run `jaitus login` first.');
+
+  // x-jaitus-features: what this build understands, so the gateway can use newer error
+  // codes (a used-up usage window) without an older CLI reading them as "went wrong".
+  const base = { 'Content-Type': 'application/json', 'user-agent': `jaitus-cli/${version()}`, 'x-jaitus-features': 'usage-window' };
+  // x-jaitus-device: this computer's hashed identifiers (machine.js), which the free
+  // tier is limited by. Built once per process.
+  const headers = (token) => ({ ...base, 'x-jaitus-device': machineHeader(), authorization: `Bearer ${token}` });
+
+  return {
+    baseUrl,
+
+    /** POST /v1/messages. Returns the raw Response so the caller can stream it. */
+    async messages(body, { signal } = {}) {
+      const t = withTimeout(signal, FIRST_BYTE_TIMEOUT_MS);
+      let res;
+      try {
+        res = await withAuth((token) => fetch(`${baseUrl}/v1/messages`, {
+          method: 'POST',
+          headers: headers(token),
+          body: JSON.stringify(body),
+          signal: t.signal,
+        }));
+      } catch (cause) {
+        t.cleanup();
+        if (cause?.name === 'JaitusError') throw cause;
+        if (t.timedOut()) throw timeoutError();
+        if (cause?.name === 'AbortError') throw cause;
+        throw fromNetwork(cause);
+      }
+      // A mid-body stall (headers fast, then nothing) aborts the body; the reader sees
+      // an AbortError while the caller's signal is NOT aborted, and turns it into a
+      // timeout — keeping whatever already arrived (agent/loop.js).
+      return watchedResponse(res, t, STREAM_IDLE_TIMEOUT_MS);
+    },
+
+    /** A dashboard API call, returning parsed JSON. */
+    async api(pathname, init = {}) {
+      const t = withTimeout(init.signal, API_TIMEOUT_MS);
+      let res;
+      try {
+        res = await withAuth((token) => fetch(`${baseUrl}/api${pathname}`, {
+          ...init,
+          headers: { ...headers(token), ...(init.headers || {}) },
+          signal: t.signal,
+        }));
+        const body = await res.json().catch(() => ({}));
+        return { ok: res.ok, status: res.status, body };
+      } catch (cause) {
+        if (cause?.name === 'JaitusError') throw cause;
+        if (t.timedOut()) throw timeoutError();
+        if (cause?.name === 'AbortError') throw cause;
+        throw fromNetwork(cause);
+      } finally {
+        t.cleanup();
+      }
+    },
+
+    /** Model ids the gateway advertises. */
+    async models() {
+      const t = withTimeout(undefined, API_TIMEOUT_MS);
+      let res;
+      try {
+        res = await withAuth((token) => fetch(`${baseUrl}/v1/models`, { headers: headers(token), signal: t.signal }));
+      } catch (cause) {
+        t.cleanup();
+        if (cause?.name === 'JaitusError') throw cause;
+        if (t.timedOut()) throw timeoutError();
+        if (cause?.name === 'AbortError') throw cause;
+        throw fromNetwork(cause);
+      }
+      const body = await res.json().catch(() => ({}));
+      t.cleanup();
+      if (!res.ok) throw fromGatewayBody(res.status, body, { requestId: res.headers.get('x-request-id') || '' });
+      const models = (body?.data || []).map((m) => m?.id).filter(Boolean);
+      // How much conversation fits, as the gateway computed it for this account.
+      const ctx = (body?.data || []).map((m) => Number(m?.context_window)).find((n) => n > 0);
+      if (ctx) contextWindowSeen = ctx;
+      // An empty list is a service fault, not something the user can fix — and naming
+      // the gateway's model map to them would be naming our internals.
+      if (!models.length) throw new JaitusError({ code: 'unavailable', status: 502 });
+      return models;
+    },
+  };
+}

package/src/commands/update.js

@@ -121,10 +121,15 @@ function run(cmd, args, { capture = false } = {}) {
 export function installGlobal(v, { onTick = () => {}, onStart = () => {} } = {}) {
   return new Promise((resolve) => {
     const args = ['install', '-g', `jaitus@${v}`, '--no-audit', '--no-fund', '--loglevel=error'];
-    const opts = { stdio: ['ignore', 'ignore', 'pipe'], detached: true, windowsHide: true };
+    // Windows: `detached` gives the child a console of its OWN — the update opened a
+    // second terminal window. Instead npm runs in this window through `start /b`, which
+    // makes it ignore Ctrl+C (cmd's documented behaviour), so it still cannot be cut off
+    // halfway; delayed expansion hands npm's exit code back through `start /wait`.
+    // Elsewhere a detached process group does the same without any window.
     const child = process.platform === 'win32'
-      ? spawn(['npm', ...args].join(' '), { ...opts, shell: true })
-      : spawn('npm', args, opts);
+      ? spawn('cmd.exe', ['/d', '/v:on', '/s', '/c', `"start "" /b /wait npm ${args.join(' ')} & exit !errorlevel!"`],
+        { stdio: ['ignore', 'ignore', 'pipe'], windowsHide: true, windowsVerbatimArguments: true })
+      : spawn('npm', args, { stdio: ['ignore', 'ignore', 'pipe'], detached: true });
     if (child.pid) onStart(child.pid);
     let stderr = '';
     child.stderr?.on('data', (d) => { stderr = (stderr + d).slice(-4000); });