@bash0816/claude-code 2.1.220 → 2.1.223-1

package/lib/termux-run-claude-native.test.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const test = require('node:test');
+const { mock } = require('node:test');
 const assert = require('node:assert/strict');
 const crypto = require('crypto');
 const child_process = require('child_process');
@@ -191,12 +192,32 @@ test('print path does not defer cleanup to exit', () => {
 test('bootstrap path defers cleanup to exit', () => {
   const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
 
-  assert.equal(bootstrapBlock.includes('CLAUDE_TERMUX_PRINT_WAIT_MS'), false);
-  assert.equal(bootstrapBlock.includes('setTimeout(resolve, printWaitMs)'), false);
   assert.equal(bootstrapBlock.includes('process.once(\'exit\''), true);
   assert.equal(bootstrapBlock.includes('process.removeListener(\'uncaughtException\''), true);
 });
 
+test('bootstrap branch exports CLAUDE_TERMUX_PRINT_MODE before invoking node', () => {
+  const bootstrapShellRegion = extractFunction(
+    script,
+    'export CLAUDE_TERMUX_TUI="${_tui}"',
+    'cat <<\'NODE\' > "$_bootstrap"',
+  );
+  assert.equal(bootstrapShellRegion.includes('export CLAUDE_TERMUX_PRINT_MODE="${_pf}"'), true);
+});
+
+test('helper and bootstrap wait for print flush, including the RequestedExit path', () => {
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+  const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+
+  assert.equal(helperBlock.includes('async function waitForPrintFlush()'), true);
+  assert.equal(helperBlock.includes('await waitForPrintFlush();\n    if (asyncErrors.length > 0) throw asyncErrors[0];'), true);
+  assert.equal(helperBlock.includes('process.exitCode = error.code;\n      await waitForPrintFlush();\n      return;'), true);
+
+  assert.equal(bootstrapBlock.includes('async function waitForPrintFlushIfNeeded()'), true);
+  assert.equal(bootstrapBlock.includes('await waitForPrintFlushIfNeeded();\n    if (asyncErrors.length > 0) throw asyncErrors[0];'), true);
+  assert.equal(bootstrapBlock.includes('process.exitCode = error.code;\n      await waitForPrintFlushIfNeeded();\n      return;'), true);
+});
+
 test('entry extraction uses a process-unique filename', () => {
   const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
   const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
@@ -280,9 +301,36 @@ test('cleanupStaleEntryFiles removes only stale extracted files for the same off
 function buildSyntheticBundleSource() {
   const typeofBun = Array.from({ length: 6 }, () => 'typeof Bun').join('; ');
   const bunProps = Array.from({ length: 37 }, (_, index) => `Bun.p${index}`).join('; ');
-  return `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0 }`;
+  return `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; function dYs(){return(e,t,r)=>{let{cmd:n,prefixArgs:o}=ox({pinToCurrentBinary:!0}),i=[n,...o,"--bg-pty-host",r.ptySock];return i}} }`;
 }
 
+test('rewriteNativeChunkSource disables the bg-pty-host factory', () => {
+  process.env.CURRENT_CLAUDE_VERSION = '2.1.198';
+  try {
+    const { rewriteNativeChunkSource } = loadHelperApi();
+    const patched = rewriteNativeChunkSource(buildSyntheticBundleSource());
+    const start = patched.indexOf('function dYs(){');
+    assert.notEqual(start, -1);
+    let depth = 0;
+    let end = -1;
+    for (let index = start; index < patched.length; index += 1) {
+      if (patched[index] === '{') depth += 1;
+      if (patched[index] === '}') {
+        depth -= 1;
+        if (depth === 0) {
+          end = index + 1;
+          break;
+        }
+      }
+    }
+    assert.notEqual(end, -1);
+    const rewrittenFactory = eval('(' + patched.slice(start, end) + ')');
+    assert.equal(rewrittenFactory(), undefined);
+  } finally {
+    delete process.env.CURRENT_CLAUDE_VERSION;
+  }
+});
+
 test('rewriteNativeChunkSource rewrites the synthetic bundle slice (version 2.1.198)', () => {
   process.env.CURRENT_CLAUDE_VERSION = '2.1.198';
   try {
@@ -308,7 +356,7 @@ test('rewriteNativeChunkSource rewrites the synthetic bundle slice (version 2.1.
     const { rewriteNativeChunkSource } = loadHelperApi();
     const typeofBun = Array.from({ length: 7 }, () => 'typeof Bun').join('; ');
     const bunProps = Array.from({ length: 40 }, (_, index) => `Bun.p${index}`).join('; ');
-    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0 }`;
+    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; function dYs(){return(e,t,r)=>{let{cmd:n,prefixArgs:o}=ox({pinToCurrentBinary:!0}),i=[n,...o,"--bg-pty-host",r.ptySock];return i}} }`;
     const patched = rewriteNativeChunkSource(source);
 
     assert.match(patched, /var __claudeBun = globalThis\.__claudeBunShim;/);
@@ -329,7 +377,7 @@ test('rewriteNativeChunkSource rewrites the synthetic bundle slice (version 2.1.
     const { rewriteNativeChunkSource } = loadHelperApi();
     const typeofBun = Array.from({ length: 7 }, () => 'typeof Bun').join('; ');
     const bunProps = Array.from({ length: 41 }, (_, index) => `Bun.p${index}`).join('; ');
-    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0 }`;
+    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; function dYs(){return(e,t,r)=>{let{cmd:n,prefixArgs:o}=ox({pinToCurrentBinary:!0}),i=[n,...o,"--bg-pty-host",r.ptySock];return i}} }`;
     const patched = rewriteNativeChunkSource(source);
 
     assert.match(patched, /var __claudeBun = globalThis\.__claudeBunShim;/);
@@ -350,7 +398,7 @@ test('rewriteNativeChunkSource rewrites the synthetic bundle slice (version 2.1.
     const { rewriteNativeChunkSource } = loadHelperApi();
     const typeofBun = Array.from({ length: 7 }, () => 'typeof Bun').join('; ');
     const bunProps = Array.from({ length: 41 }, (_, index) => `Bun.p${index}`).join('; ');
-    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0 }`;
+    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0; function dYs(){return(e,t,r)=>{let{cmd:n,prefixArgs:o}=ox({pinToCurrentBinary:!0}),i=[n,...o,"--bg-pty-host",r.ptySock];return i}} }`;
     const patched = rewriteNativeChunkSource(source);
 
     assert.match(patched, /var __claudeBun = globalThis\.__claudeBunShim;/);
@@ -371,7 +419,7 @@ test('rewriteNativeChunkSource rewrites the synthetic bundle slice (version 2.1.
     const { rewriteNativeChunkSource } = loadHelperApi();
     const typeofBun = Array.from({ length: 7 }, () => 'typeof Bun').join('; ');
     const bunProps = Array.from({ length: 38 }, (_, index) => `Bun.p${index}`).join('; ');
-    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0 }`;
+    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0; function dYs(){return(e,t,r)=>{let{cmd:n,prefixArgs:o}=ox({pinToCurrentBinary:!0}),i=[n,...o,"--bg-pty-host",r.ptySock];return i}} }`;
     const patched = rewriteNativeChunkSource(source);
 
     assert.match(patched, /var __claudeBun = globalThis\.__claudeBunShim;/);
@@ -392,7 +440,7 @@ test('rewriteNativeChunkSource rejects stale Bun property access count for versi
     const { rewriteNativeChunkSource } = loadHelperApi();
     const typeofBun = Array.from({ length: 7 }, () => 'typeof Bun').join('; ');
     const bunProps = Array.from({ length: 41 }, (_, index) => `Bun.p${index}`).join('; ');
-    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0 }`;
+    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0; function dYs(){return(e,t,r)=>{let{cmd:n,prefixArgs:o}=ox({pinToCurrentBinary:!0}),i=[n,...o,"--bg-pty-host",r.ptySock];return i}} }`;
 
     assert.throws(
       () => rewriteNativeChunkSource(source),
@@ -409,7 +457,7 @@ test('rewriteNativeChunkSource rewrites the synthetic bundle slice (version 2.1.
     const { rewriteNativeChunkSource } = loadHelperApi();
     const typeofBun = Array.from({ length: 7 }, () => 'typeof Bun').join('; ');
     const bunProps = Array.from({ length: 39 }, (_, index) => `Bun.p${index}`).join('; ');
-    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0 }`;
+    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0; function dYs(){return(e,t,r)=>{let{cmd:n,prefixArgs:o}=ox({pinToCurrentBinary:!0}),i=[n,...o,"--bg-pty-host",r.ptySock];return i}} }`;
     const patched = rewriteNativeChunkSource(source);
 
     assert.match(patched, /var __claudeBun = globalThis\.__claudeBunShim;/);
@@ -430,7 +478,7 @@ test('rewriteNativeChunkSource rejects stale Bun property access count for versi
     const { rewriteNativeChunkSource } = loadHelperApi();
     const typeofBun = Array.from({ length: 7 }, () => 'typeof Bun').join('; ');
     const bunProps = Array.from({ length: 38 }, (_, index) => `Bun.p${index}`).join('; ');
-    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0 }`;
+    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0; function dYs(){return(e,t,r)=>{let{cmd:n,prefixArgs:o}=ox({pinToCurrentBinary:!0}),i=[n,...o,"--bg-pty-host",r.ptySock];return i}} }`;
 
     assert.throws(
       () => rewriteNativeChunkSource(source),
@@ -447,7 +495,7 @@ test('rewriteNativeChunkSource rewrites the synthetic bundle slice (version 2.1.
     const { rewriteNativeChunkSource } = loadHelperApi();
     const typeofBun = Array.from({ length: 7 }, () => 'typeof Bun').join('; ');
     const bunProps = Array.from({ length: 40 }, (_, index) => `Bun.p${index}`).join('; ');
-    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0 }`;
+    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0; function dYs(){return(e,t,r)=>{let{cmd:n,prefixArgs:o}=ox({pinToCurrentBinary:!0}),i=[n,...o,"--bg-pty-host",r.ptySock];return i}} }`;
     const patched = rewriteNativeChunkSource(source);
 
     assert.match(patched, /var __claudeBun = globalThis\.__claudeBunShim;/);
@@ -467,7 +515,7 @@ test('rewriteNativeChunkSource rejects stale Bun property access count for versi
     const { rewriteNativeChunkSource } = loadHelperApi();
     const typeofBun = Array.from({ length: 7 }, () => 'typeof Bun').join('; ');
     const bunProps = Array.from({ length: 39 }, (_, index) => `Bun.p${index}`).join('; ');
-    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0 }`;
+    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0; function dYs(){return(e,t,r)=>{let{cmd:n,prefixArgs:o}=ox({pinToCurrentBinary:!0}),i=[n,...o,"--bg-pty-host",r.ptySock];return i}} }`;
 
     assert.throws(
       () => rewriteNativeChunkSource(source),
@@ -484,7 +532,7 @@ test('rewriteNativeChunkSource rewrites the synthetic bundle slice (version 2.1.
     const { rewriteNativeChunkSource } = loadHelperApi();
     const typeofBun = Array.from({ length: 7 }, () => 'typeof Bun').join('; ');
     const bunProps = Array.from({ length: 42 }, (_, index) => `Bun.p${index}`).join('; ');
-    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0 }`;
+    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0; function dYs(){return(e,t,r)=>{let{cmd:n,prefixArgs:o}=ox({pinToCurrentBinary:!0}),i=[n,...o,"--bg-pty-host",r.ptySock];return i}} }`;
     const patched = rewriteNativeChunkSource(source);
 
     assert.match(patched, /var __claudeBun = globalThis\.__claudeBunShim;/);
@@ -504,7 +552,7 @@ test('rewriteNativeChunkSource rejects stale Bun property access count for versi
     const { rewriteNativeChunkSource } = loadHelperApi();
     const typeofBun = Array.from({ length: 7 }, () => 'typeof Bun').join('; ');
     const bunProps = Array.from({ length: 41 }, (_, index) => `Bun.p${index}`).join('; ');
-    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0 }`;
+    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0; function dYs(){return(e,t,r)=>{let{cmd:n,prefixArgs:o}=ox({pinToCurrentBinary:!0}),i=[n,...o,"--bg-pty-host",r.ptySock];return i}} }`;
 
     assert.throws(
       () => rewriteNativeChunkSource(source),
@@ -515,6 +563,43 @@ test('rewriteNativeChunkSource rejects stale Bun property access count for versi
   }
 });
 
+test('rewriteNativeChunkSource rewrites the synthetic bundle slice (version 2.1.223)', () => {
+  process.env.CURRENT_CLAUDE_VERSION = '2.1.223';
+  try {
+    const { rewriteNativeChunkSource } = loadHelperApi();
+    const typeofBun = Array.from({ length: 7 }, () => 'typeof Bun').join('; ');
+    const bunProps = Array.from({ length: 43 }, (_, index) => `Bun.p${index}`).join('; ');
+    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0; function dYs(){return(e,t,r)=>{let{cmd:n,prefixArgs:o}=ox({pinToCurrentBinary:!0}),i=[n,...o,"--bg-pty-host",r.ptySock];return i}} }`;
+    const patched = rewriteNativeChunkSource(source);
+
+    assert.match(patched, /var __claudeBun = globalThis\.__claudeBunShim;/);
+    assert.match(patched, /typeof __claudeBun/);
+    assert.match(patched, /typeof globalThis\.__claudeBun/);
+    assert.match(patched, /globalThis\.__claudeBun/);
+    assert.match(patched, /__claudeBun\./);
+    assert.equal((patched.match(/__claudeBun\./g) || []).length, 43);
+  } finally {
+    delete process.env.CURRENT_CLAUDE_VERSION;
+  }
+});
+
+test('rewriteNativeChunkSource rejects stale Bun property access count for version 2.1.223', () => {
+  process.env.CURRENT_CLAUDE_VERSION = '2.1.223';
+  try {
+    const { rewriteNativeChunkSource } = loadHelperApi();
+    const typeofBun = Array.from({ length: 7 }, () => 'typeof Bun').join('; ');
+    const bunProps = Array.from({ length: 42 }, (_, index) => `Bun.p${index}`).join('; ');
+    const source = `function(exports, require, module, __filename, __dirname) { ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps}; npmInstallDeprecated:!0; npmInstallDeprecated:!0; function dYs(){return(e,t,r)=>{let{cmd:n,prefixArgs:o}=ox({pinToCurrentBinary:!0}),i=[n,...o,"--bg-pty-host",r.ptySock];return i}} }`;
+
+    assert.throws(
+      () => rewriteNativeChunkSource(source),
+      /unexpected Bun property access count 42/,
+    );
+  } finally {
+    delete process.env.CURRENT_CLAUDE_VERSION;
+  }
+});
+
 test('rewriteNativeChunkSource rejects unexpected replacement counts', () => {
   const { rewriteNativeChunkSource } = loadHelperApi();
   const source = buildSyntheticBundleSource().replace('Bun.p30;', '');
@@ -544,3 +629,920 @@ test('tarball contents match the workspace runner and test file', { skip: !fs.ex
 test('CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC is never forced (regression guard)', () => {
   assert.equal(script.includes('CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC'), false);
 });
+
+function buildScenarioFixtureSource() {
+  const typeofBun = Array.from({ length: 7 }, () => 'typeof Bun').join('; ');
+  const bunProps = Array.from({ length: 42 }, (_, i) => `Bun.p${i}`).join('; ');
+  return `function(exports, require, module, __filename, __dirname) {
+    ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps};
+    npmInstallDeprecated:!0; npmInstallDeprecated:!0;
+    function dYs(){return(e,t,r)=>{let{cmd:n,prefixArgs:o}=ox({pinToCurrentBinary:!0}),i=[n,...o,"--bg-pty-host",r.ptySock];return i}}
+    const scenario = process.env.TEST_SCENARIO;
+    if (scenario === 'sync-exit') { process.stdout.write('ok'); process.exit(0); return; }
+    if (scenario === 'async-exit') {
+      setTimeout(() => { process.stdout.write('ok'); }, 100).unref();
+      return;
+    }
+    if (scenario === 'self-sigkill-fallback-string') {
+      try {
+        process.exit(17);
+      } catch (e) {
+        process.kill(process.pid, 'SIGKILL');
+      }
+      return;
+    }
+    if (scenario === 'self-sigkill-fallback-numeric') {
+      try {
+        process.exit(17);
+      } catch (e) {
+        process.kill(process.pid, 9);
+      }
+      return;
+    }
+    if (scenario === 'self-sigkill-fallback-no-code') {
+      try {
+        process.exit();
+      } catch (e) {
+        process.kill(process.pid, 'SIGKILL');
+      }
+      return;
+    }
+    if (scenario === 'other-process-kill') {
+      const cp = require('child_process');
+      const child = cp.spawn('node', ['-e', 'setTimeout(() => {}, 5000)']);
+      const childPid = child.pid;
+      process.kill(childPid, 0);
+      child.kill();
+      process.stdout.write('ok');
+      return;
+    }
+    if (scenario === 'stream-json-result') {
+      process.stdout.write('{"type":"init"}\\n');
+      const msg = '{"type":"result","data":"test"}\\n';
+      process.stdout.write(msg, undefined, () => {});
+      return;
+    }
+    if (scenario === 'stream-json-multibyte-split') {
+      // Split a UTF-8 multi-byte character across write calls
+      // 'あ' is 3 bytes in UTF-8: e3 81 82
+      const buf = Buffer.from('あ', 'utf8');
+      // Split the 3-byte character: first byte in one write, remaining in another
+      const jsonLine = '{"type":"result"}\\n';
+      const part1 = Buffer.concat([Buffer.from(jsonLine), buf.slice(0, 1)]);
+      const part2 = Buffer.concat([buf.slice(1)]);
+      process.stdout.write(part1);
+      process.stdout.write(part2, undefined, () => {});
+      return;
+    }
+    if (scenario === 'stream-json-timeout') {
+      process.stdout.write('{"type":"init"}\\n');
+      setTimeout(() => {}, 5000);
+      return;
+    }
+    if (scenario === 'stream-json-requested-exit-then-result') {
+      process.stdout.write('{"type":"result"}\\n');
+      process.exit(0);
+      return;
+    }
+    process.stdout.write('ok');
+  }`;
+}
+
+function runScenario({ printMode, stdinInherit, scenario, extraArgs }) {
+  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-stdin-test-'));
+  const sourceBin = path.join(tmpBase, 'fake-source.js');
+  const fixtureSource = buildScenarioFixtureSource();
+  fs.writeFileSync(sourceBin, fixtureSource, 'utf8');
+  const entryJsOffset = 0;
+  const entryEndOffset = Buffer.byteLength(fixtureSource, 'utf8');
+  const workdir = path.join(tmpBase, 'workdir');
+  fs.mkdirSync(workdir, { recursive: true });
+
+  const env = {
+    ...process.env,
+    SOURCE_BIN: sourceBin,
+    WORKDIR: workdir,
+    ENTRY_JS_OFFSET: String(entryJsOffset),
+    ENTRY_END_OFFSET: String(entryEndOffset),
+    CURRENT_CLAUDE_VERSION: '2.1.220',
+    CLAUDE_TERMUX_PACKAGE_DIR: path.join(__dirname, '..'),
+    MAGI_ENV: '1',
+    CLAUDE_TERMUX_PRINT_WAIT_MS: '300',
+    TMPDIR: tmpBase,
+    TEST_SCENARIO: scenario,
+  };
+  if (stdinInherit) env.CLAUDE_TERMUX_STDIN = 'inherit';
+  else delete env.CLAUDE_TERMUX_STDIN;
+
+  const args = printMode ? ['-p', 'x', ...(extraArgs || [])] : [];
+  const start = Date.now();
+  const result = child_process.spawnSync('sh', [scriptPath, ...args], {
+    env,
+    input: 'test input\n',
+    encoding: 'utf8',
+    timeout: 10000,
+  });
+  const elapsedMs = Date.now() - start;
+  return { ...result, elapsedMs, tmpBase };
+}
+
+test('helper and bootstrap intercept process.kill(self, SIGKILL) statically', () => {
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+  const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+
+  // Check helper branch
+  const helperOriginalKillIdx = helperBlock.indexOf('const originalKill = process.kill;');
+  assert.ok(helperOriginalKillIdx > -1, 'helper: missing originalKill declaration');
+
+  const helperProcessKillIdx = helperBlock.indexOf('process.kill = (pid, signal) => {', helperOriginalKillIdx);
+  assert.ok(helperProcessKillIdx > helperOriginalKillIdx, 'helper: process.kill override must come after originalKill declaration');
+
+  const helperRestoreIdx = helperBlock.indexOf('process.kill = originalKill;', helperProcessKillIdx);
+  assert.ok(helperRestoreIdx > helperProcessKillIdx, 'helper: process.kill restoration must come after override');
+
+  // Verify SIGKILL check within the override
+  const helperKillOverrideEnd = helperBlock.indexOf('};', helperProcessKillIdx);
+  const helperKillOverride = helperBlock.slice(helperProcessKillIdx, helperKillOverrideEnd);
+  assert.ok(helperKillOverride.includes('signal === \'SIGKILL\''), 'helper: process.kill must check for SIGKILL string');
+  assert.ok(helperKillOverride.includes('signal === 9'), 'helper: process.kill must check for SIGKILL numeric value');
+  assert.ok(helperKillOverride.includes('throw new RequestedExit'), 'helper: process.kill must throw RequestedExit for self SIGKILL');
+
+  // Check bootstrap branch
+  const bootstrapOriginalKillIdx = bootstrapBlock.indexOf('const originalKill = process.kill;');
+  assert.ok(bootstrapOriginalKillIdx > -1, 'bootstrap: missing originalKill declaration');
+
+  const bootstrapProcessKillIdx = bootstrapBlock.indexOf('process.kill = (pid, signal) => {', bootstrapOriginalKillIdx);
+  assert.ok(bootstrapProcessKillIdx > bootstrapOriginalKillIdx, 'bootstrap: process.kill override must come after originalKill declaration');
+
+  const bootstrapRestoreIdx = bootstrapBlock.indexOf('process.kill = originalKill;', bootstrapProcessKillIdx);
+  assert.ok(bootstrapRestoreIdx > bootstrapProcessKillIdx, 'bootstrap: process.kill restoration must come after override');
+
+  // Verify SIGKILL check within the override
+  const bootstrapKillOverrideEnd = bootstrapBlock.indexOf('};', bootstrapProcessKillIdx);
+  const bootstrapKillOverride = bootstrapBlock.slice(bootstrapProcessKillIdx, bootstrapKillOverrideEnd);
+  assert.ok(bootstrapKillOverride.includes('signal === \'SIGKILL\''), 'bootstrap: process.kill must check for SIGKILL string');
+  assert.ok(bootstrapKillOverride.includes('signal === 9'), 'bootstrap: process.kill must check for SIGKILL numeric value');
+  assert.ok(bootstrapKillOverride.includes('throw new RequestedExit'), 'bootstrap: process.kill must throw RequestedExit for self SIGKILL');
+});
+
+test('helper branch (CLI -p, no stdin inherit): normal/sync-exit/async-exit all produce output', () => {
+  for (const scenario of ['normal', 'sync-exit', 'async-exit']) {
+    const r = runScenario({ printMode: true, stdinInherit: false, scenario });
+    try {
+      assert.ok((r.stdout || '').includes('ok'), `scenario=${scenario} stdout=${r.stdout} stderr=${r.stderr}`);
+      assert.equal(r.status, 0, `scenario=${scenario} status=${r.status} stderr=${r.stderr}`);
+    } finally {
+      fs.rmSync(r.tmpBase, { recursive: true, force: true });
+    }
+  }
+});
+
+test('bootstrap branch (-p + CLAUDE_TERMUX_STDIN=inherit): normal/sync-exit/async-exit all produce output', () => {
+  for (const scenario of ['normal', 'sync-exit', 'async-exit']) {
+    const r = runScenario({ printMode: true, stdinInherit: true, scenario });
+    try {
+      assert.ok((r.stdout || '').includes('ok'), `scenario=${scenario} stdout=${r.stdout} stderr=${r.stderr}`);
+      assert.equal(r.status, 0, `scenario=${scenario} status=${r.status} stderr=${r.stderr}`);
+      if (scenario === 'async-exit') {
+        assert.ok(r.elapsedMs >= 250, `expected wait >= 250ms, got ${r.elapsedMs}ms`);
+      }
+    } finally {
+      fs.rmSync(r.tmpBase, { recursive: true, force: true });
+    }
+  }
+});
+
+test('helper branch intercepts self-directed SIGKILL (string signal) and exits with proper code', () => {
+  const r = runScenario({ printMode: true, stdinInherit: false, scenario: 'self-sigkill-fallback-string' });
+  try {
+    assert.equal(r.status, 17, `expected status 17, got ${r.status}; stderr=${r.stderr}`);
+    assert.ok(!r.signal, `expected clean exit (no signal), but got signal: ${r.signal}`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('helper branch intercepts self-directed SIGKILL (numeric signal 9) and exits with proper code', () => {
+  const r = runScenario({ printMode: true, stdinInherit: false, scenario: 'self-sigkill-fallback-numeric' });
+  try {
+    assert.equal(r.status, 17, `expected status 17, got ${r.status}; stderr=${r.stderr}`);
+    assert.ok(!r.signal, `expected clean exit (no signal), but got signal: ${r.signal}`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('helper branch intercepts self-directed SIGKILL with process.exit() (no code) and defaults to 0', () => {
+  const r = runScenario({ printMode: true, stdinInherit: false, scenario: 'self-sigkill-fallback-no-code' });
+  try {
+    assert.equal(r.status, 0, `expected status 0, got ${r.status}; stderr=${r.stderr}`);
+    assert.ok(!r.signal, `expected clean exit (no signal), but got signal: ${r.signal}`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('helper branch allows process.kill to other processes (signal 0, passthrough)', () => {
+  const r = runScenario({ printMode: true, stdinInherit: false, scenario: 'other-process-kill' });
+  try {
+    assert.ok((r.stdout || '').includes('ok'), `expected ok output, got stdout=${r.stdout} stderr=${r.stderr}`);
+    assert.equal(r.status, 0, `expected status 0, got ${r.status}; stderr=${r.stderr}`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('isStreamJsonPrintMode detects print flag and stream-json format (case 1: -p + format + value)', () => {
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+  const fnSource = extractFunction(helperBlock, 'function isStreamJsonPrintMode(argv) {', '\n\nclass RequestedExit');
+  const context = vm.createContext({ module: { exports: {} } });
+  vm.runInContext(`${fnSource}\nmodule.exports = isStreamJsonPrintMode;`, context);
+  const isStreamJsonPrintMode = context.module.exports;
+
+  assert.equal(isStreamJsonPrintMode(['-p', 'hello', '--output-format', 'stream-json']), true, 'case 1');
+  assert.equal(isStreamJsonPrintMode(['-p', 'hello', '--output-format=stream-json']), true, 'case 2');
+  assert.equal(isStreamJsonPrintMode(['--print', '--output-format=stream-json']), true, 'case 3');
+  assert.equal(isStreamJsonPrintMode(['-p', 'hello', '--output-format', 'json']), false, 'case 4');
+  assert.equal(isStreamJsonPrintMode(['-p']), false, 'case 5');
+  assert.equal(isStreamJsonPrintMode(['--output-format=stream-json']), false, 'case 6');
+  assert.equal(isStreamJsonPrintMode(['-p', '--', '--output-format=stream-json']), false, 'case 7');
+  assert.equal(isStreamJsonPrintMode(['-p', '--output-format=stream-json', '--', 'extra']), true, 'case 8');
+  assert.equal(isStreamJsonPrintMode(['-p', '--output-format', '--', 'stream-json']), false, 'case 9');
+  assert.equal(isStreamJsonPrintMode(['-p', '--output-format']), false, 'case 10');
+  assert.equal(isStreamJsonPrintMode([]), false, 'case 11');
+});
+
+test('isStreamJsonPrintMode is identical in helper and bootstrap', () => {
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+  const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+
+  const helperFn = extractFunction(helperBlock, 'function isStreamJsonPrintMode(argv) {', '\n\nclass RequestedExit');
+  const bootstrapFn = extractFunction(bootstrapBlock, 'function isStreamJsonPrintMode(argv) {', '\n\nclass RequestedExit');
+
+  assert.equal(helperFn, bootstrapFn, 'isStreamJsonPrintMode must be identical in both heredocs');
+});
+
+test('CLAUDE_TERMUX_PRINT_RESULT_TIMEOUT_MS fallback to 300000 on NaN', () => {
+  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-timeout-test-'));
+  try {
+    const sourceBin = path.join(tmpBase, 'fake-source.js');
+    const fixtureSource = buildScenarioFixtureSource();
+    fs.writeFileSync(sourceBin, fixtureSource, 'utf8');
+    const entryJsOffset = 0;
+    const entryEndOffset = Buffer.byteLength(fixtureSource, 'utf8');
+    const workdir = path.join(tmpBase, 'workdir');
+    fs.mkdirSync(workdir, { recursive: true });
+
+    const env = {
+      ...process.env,
+      SOURCE_BIN: sourceBin,
+      WORKDIR: workdir,
+      ENTRY_JS_OFFSET: String(entryJsOffset),
+      ENTRY_END_OFFSET: String(entryEndOffset),
+      CURRENT_CLAUDE_VERSION: '2.1.220',
+      CLAUDE_TERMUX_PACKAGE_DIR: path.join(__dirname, '..'),
+      MAGI_ENV: '1',
+      CLAUDE_TERMUX_PRINT_WAIT_MS: '300',
+      CLAUDE_TERMUX_PRINT_RESULT_TIMEOUT_MS: 'invalid',
+      TMPDIR: tmpBase,
+      TEST_SCENARIO: 'stream-json-result',
+    };
+    delete env.CLAUDE_TERMUX_STDIN;
+
+    const result = child_process.spawnSync('sh', [scriptPath, '-p', 'x', '--output-format=stream-json'], {
+      env,
+      input: 'test input\n',
+      encoding: 'utf8',
+      timeout: 10000,
+    });
+    assert.equal(result.status, 0, `expected successful exit with invalid timeout fallback, got status=${result.status} stderr=${result.stderr}`);
+  } finally {
+    fs.rmSync(tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('CLAUDE_TERMUX_PRINT_RESULT_TIMEOUT_MS fallback to 300000 on zero', () => {
+  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-timeout-test-'));
+  try {
+    const sourceBin = path.join(tmpBase, 'fake-source.js');
+    const fixtureSource = buildScenarioFixtureSource();
+    fs.writeFileSync(sourceBin, fixtureSource, 'utf8');
+    const entryJsOffset = 0;
+    const entryEndOffset = Buffer.byteLength(fixtureSource, 'utf8');
+    const workdir = path.join(tmpBase, 'workdir');
+    fs.mkdirSync(workdir, { recursive: true });
+
+    const env = {
+      ...process.env,
+      SOURCE_BIN: sourceBin,
+      WORKDIR: workdir,
+      ENTRY_JS_OFFSET: String(entryJsOffset),
+      ENTRY_END_OFFSET: String(entryEndOffset),
+      CURRENT_CLAUDE_VERSION: '2.1.220',
+      CLAUDE_TERMUX_PACKAGE_DIR: path.join(__dirname, '..'),
+      MAGI_ENV: '1',
+      CLAUDE_TERMUX_PRINT_WAIT_MS: '300',
+      CLAUDE_TERMUX_PRINT_RESULT_TIMEOUT_MS: '0',
+      TMPDIR: tmpBase,
+      TEST_SCENARIO: 'stream-json-result',
+    };
+    delete env.CLAUDE_TERMUX_STDIN;
+
+    const result = child_process.spawnSync('sh', [scriptPath, '-p', 'x', '--output-format=stream-json'], {
+      env,
+      input: 'test input\n',
+      encoding: 'utf8',
+      timeout: 10000,
+    });
+    assert.equal(result.status, 0, `expected successful exit with zero timeout fallback, got status=${result.status} stderr=${result.stderr}`);
+  } finally {
+    fs.rmSync(tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('helper branch (CLI -p, no stdin inherit) stream-json: result detected -> exits immediately without waiting for timeout', () => {
+  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-stream-json-clear-timeout-'));
+  try {
+    const sourceBin = path.join(tmpBase, 'fake-source.js');
+    const fixtureSource = buildScenarioFixtureSource();
+    fs.writeFileSync(sourceBin, fixtureSource, 'utf8');
+    const entryJsOffset = 0;
+    const entryEndOffset = Buffer.byteLength(fixtureSource, 'utf8');
+    const workdir = path.join(tmpBase, 'workdir');
+    fs.mkdirSync(workdir, { recursive: true });
+
+    const env = {
+      ...process.env,
+      SOURCE_BIN: sourceBin,
+      WORKDIR: workdir,
+      ENTRY_JS_OFFSET: String(entryJsOffset),
+      ENTRY_END_OFFSET: String(entryEndOffset),
+      CURRENT_CLAUDE_VERSION: '2.1.220',
+      CLAUDE_TERMUX_PACKAGE_DIR: path.join(__dirname, '..'),
+      MAGI_ENV: '1',
+      CLAUDE_TERMUX_PRINT_WAIT_MS: '300',
+      CLAUDE_TERMUX_PRINT_RESULT_TIMEOUT_MS: '10000',
+      TMPDIR: tmpBase,
+      TEST_SCENARIO: 'stream-json-result',
+    };
+    delete env.CLAUDE_TERMUX_STDIN;
+
+    const start = Date.now();
+    const result = child_process.spawnSync('sh', [scriptPath, '-p', 'x', '--output-format=stream-json'], {
+      env,
+      input: 'test input\n',
+      encoding: 'utf8',
+      timeout: 20000,
+    });
+    const elapsedMs = Date.now() - start;
+
+    assert.equal(result.status, 0, `expected successful exit, got status=${result.status} stderr=${result.stderr}`);
+    assert.ok(
+      elapsedMs < 3000,
+      `expected process to exit quickly after result detected, but elapsed=${elapsedMs}ms (should be < 3000ms with 10000ms timeout). This indicates the timeout timer was not cleared.`
+    );
+  } finally {
+    fs.rmSync(tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('bootstrap branch (-p + CLAUDE_TERMUX_STDIN=inherit) stream-json: result detected -> exits immediately without waiting for timeout', () => {
+  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-stream-json-clear-timeout-bootstrap-'));
+  try {
+    const sourceBin = path.join(tmpBase, 'fake-source.js');
+    const fixtureSource = buildScenarioFixtureSource();
+    fs.writeFileSync(sourceBin, fixtureSource, 'utf8');
+    const entryJsOffset = 0;
+    const entryEndOffset = Buffer.byteLength(fixtureSource, 'utf8');
+    const workdir = path.join(tmpBase, 'workdir');
+    fs.mkdirSync(workdir, { recursive: true });
+
+    const env = {
+      ...process.env,
+      SOURCE_BIN: sourceBin,
+      WORKDIR: workdir,
+      ENTRY_JS_OFFSET: String(entryJsOffset),
+      ENTRY_END_OFFSET: String(entryEndOffset),
+      CURRENT_CLAUDE_VERSION: '2.1.220',
+      CLAUDE_TERMUX_PACKAGE_DIR: path.join(__dirname, '..'),
+      MAGI_ENV: '1',
+      CLAUDE_TERMUX_STDIN: 'inherit',
+      CLAUDE_TERMUX_PRINT_WAIT_MS: '300',
+      CLAUDE_TERMUX_PRINT_RESULT_TIMEOUT_MS: '10000',
+      TMPDIR: tmpBase,
+      TEST_SCENARIO: 'stream-json-result',
+    };
+
+    const start = Date.now();
+    const result = child_process.spawnSync('sh', [scriptPath, '-p', 'x', '--output-format=stream-json'], {
+      env,
+      input: 'test input\n',
+      encoding: 'utf8',
+      timeout: 20000,
+    });
+    const elapsedMs = Date.now() - start;
+
+    assert.equal(result.status, 0, `expected successful exit, got status=${result.status} stderr=${result.stderr}`);
+    assert.ok(
+      elapsedMs < 3000,
+      `expected process to exit quickly after result detected, but elapsed=${elapsedMs}ms (should be < 3000ms with 10000ms timeout). This indicates the timeout timer was not cleared.`
+    );
+  } finally {
+    fs.rmSync(tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('helper and bootstrap installStreamJsonTerminalWatcher helpers stay identical', () => {
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+  const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+
+  const helperWatcher = extractFunction(
+    helperBlock,
+    'function installStreamJsonTerminalWatcher() {',
+    '\n  function forceTimeoutExit',
+  );
+  const bootstrapWatcher = extractFunction(
+    bootstrapBlock,
+    'function installStreamJsonTerminalWatcher() {',
+    '\n  function forceTimeoutExit',
+  );
+
+  assert.equal(helperWatcher, bootstrapWatcher, 'installStreamJsonTerminalWatcher must be identical in both heredocs');
+});
+
+test('helper and bootstrap forceTimeoutExit helpers stay identical', () => {
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+  const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+
+  const helperForceExit = extractFunction(
+    helperBlock,
+    'function forceTimeoutExit(exitCode) {',
+    '\n  async function waitForPrintFlush',
+  );
+  const bootstrapForceExit = extractFunction(
+    bootstrapBlock,
+    'function forceTimeoutExit(exitCode) {',
+    '\n  async function waitForPrintFlushIfNeeded',
+  );
+
+  assert.equal(helperForceExit, bootstrapForceExit, 'forceTimeoutExit must be identical in both heredocs');
+});
+
+test('installStreamJsonTerminalWatcher restores process.stdout.write own property state', () => {
+  // Test with the real process.stdout to verify own property handling
+  const hadOwnPropertyBefore = Object.prototype.hasOwnProperty.call(process.stdout, 'write');
+  const descriptorBefore = hadOwnPropertyBefore ? Object.getOwnPropertyDescriptor(process.stdout, 'write') : undefined;
+
+  // Get the watcher function from helper
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+  const watcherSource = extractFunction(helperBlock, 'function installStreamJsonTerminalWatcher() {', '\n  function forceTimeoutExit');
+
+  const context = vm.createContext({
+    module: { exports: {} },
+    process,
+    Object,
+    Buffer,
+    require: (id) => {
+      if (id === 'string_decoder') return require('string_decoder');
+      throw new Error('require not available');
+    },
+  });
+
+  vm.runInContext(`
+    ${watcherSource}
+    module.exports = installStreamJsonTerminalWatcher;
+  `, context);
+
+  const installStreamJsonTerminalWatcher = context.module.exports;
+
+  try {
+    // Test case 1: Normal case where write is not an own property
+    {
+      const watcher = installStreamJsonTerminalWatcher();
+      const hadOwnPropertyAfterInstall = Object.prototype.hasOwnProperty.call(process.stdout, 'write');
+      assert.equal(hadOwnPropertyAfterInstall, true, 'after install: process.stdout.write should be own property');
+
+      // Restore watcher
+      watcher.restore();
+      const hadOwnPropertyAfterRestore = Object.prototype.hasOwnProperty.call(process.stdout, 'write');
+      assert.equal(hadOwnPropertyAfterRestore, hadOwnPropertyBefore, 'after restore: own property state should match initial');
+
+      // Verify restore is idempotent
+      watcher.restore();
+      const hadOwnPropertyAfterSecondRestore = Object.prototype.hasOwnProperty.call(process.stdout, 'write');
+      assert.equal(hadOwnPropertyAfterSecondRestore, hadOwnPropertyBefore, 'second restore should also maintain initial state');
+    }
+
+    // Test case 2: When write is an own property before installation
+    {
+      const testDescriptor = {
+        value: function testWrite() { return true; },
+        writable: true,
+        configurable: true,
+        enumerable: false,
+      };
+      Object.defineProperty(process.stdout, 'write', testDescriptor);
+
+      const watcher = installStreamJsonTerminalWatcher();
+      const hadOwnAfterInstall = Object.prototype.hasOwnProperty.call(process.stdout, 'write');
+      assert.equal(hadOwnAfterInstall, true, 'test case 2: after install should have own property');
+
+      watcher.restore();
+      const hadOwnAfterRestore = Object.prototype.hasOwnProperty.call(process.stdout, 'write');
+      assert.equal(hadOwnAfterRestore, true, 'test case 2: after restore should still have own property');
+
+      const restoredDescriptor = Object.getOwnPropertyDescriptor(process.stdout, 'write');
+      assert.equal(typeof restoredDescriptor.value, 'function', 'test case 2: restored value should be a function');
+      assert.equal(restoredDescriptor.configurable, true, 'test case 2: restored configurable should match');
+    }
+  } finally {
+    // Ensure stdout.write is fully restored to original state
+    if (hadOwnPropertyBefore && descriptorBefore) {
+      Object.defineProperty(process.stdout, 'write', descriptorBefore);
+    } else if (Object.prototype.hasOwnProperty.call(process.stdout, 'write')) {
+      delete process.stdout.write;
+    }
+  }
+});
+
+test('helper branch stream-json result detection (single write)', () => {
+  const r = runScenario({
+    printMode: true,
+    stdinInherit: false,
+    scenario: 'stream-json-result',
+    extraArgs: ['--output-format=stream-json'],
+  });
+  try {
+    assert.equal(r.status, 0, `expected status 0, got ${r.status}; stderr=${r.stderr}`);
+    // Result detection should be significantly faster than traditional PRINT_WAIT_MS (300ms in tests)
+    assert.ok(r.elapsedMs < 1500, `expected completion < 1500ms (much faster than 300ms PRINT_WAIT_MS), got ${r.elapsedMs}ms`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('bootstrap branch stream-json result detection (single write)', () => {
+  const r = runScenario({
+    printMode: true,
+    stdinInherit: true,
+    scenario: 'stream-json-result',
+    extraArgs: ['--output-format=stream-json'],
+  });
+  try {
+    assert.equal(r.status, 0, `expected status 0, got ${r.status}; stderr=${r.stderr}`);
+    // Result detection should be significantly faster than traditional PRINT_WAIT_MS (300ms in tests)
+    assert.ok(r.elapsedMs < 1500, `expected completion < 1500ms (much faster than 300ms PRINT_WAIT_MS), got ${r.elapsedMs}ms`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('helper branch stream-json multibyte character split handling', () => {
+  const r = runScenario({
+    printMode: true,
+    stdinInherit: false,
+    scenario: 'stream-json-multibyte-split',
+    extraArgs: ['--output-format=stream-json'],
+  });
+  try {
+    assert.equal(r.status, 0, `expected status 0, got ${r.status}; stderr=${r.stderr}`);
+    assert.ok(r.elapsedMs < 6000, `expected completion < 6000ms, got ${r.elapsedMs}ms`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('bootstrap branch stream-json multibyte character split handling', () => {
+  const r = runScenario({
+    printMode: true,
+    stdinInherit: true,
+    scenario: 'stream-json-multibyte-split',
+    extraArgs: ['--output-format=stream-json'],
+  });
+  try {
+    assert.equal(r.status, 0, `expected status 0, got ${r.status}; stderr=${r.stderr}`);
+    assert.ok(r.elapsedMs < 6000, `expected completion < 6000ms, got ${r.elapsedMs}ms`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('helper branch stream-json timeout triggers exit with status 1', () => {
+  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-stream-timeout-'));
+  try {
+    const sourceBin = path.join(tmpBase, 'fake-source.js');
+    const fixtureSource = buildScenarioFixtureSource();
+    fs.writeFileSync(sourceBin, fixtureSource, 'utf8');
+    const entryJsOffset = 0;
+    const entryEndOffset = Buffer.byteLength(fixtureSource, 'utf8');
+    const workdir = path.join(tmpBase, 'workdir');
+    fs.mkdirSync(workdir, { recursive: true });
+
+    const env = {
+      ...process.env,
+      SOURCE_BIN: sourceBin,
+      WORKDIR: workdir,
+      ENTRY_JS_OFFSET: String(entryJsOffset),
+      ENTRY_END_OFFSET: String(entryEndOffset),
+      CURRENT_CLAUDE_VERSION: '2.1.220',
+      CLAUDE_TERMUX_PACKAGE_DIR: path.join(__dirname, '..'),
+      MAGI_ENV: '1',
+      CLAUDE_TERMUX_PRINT_WAIT_MS: '300',
+      CLAUDE_TERMUX_PRINT_RESULT_TIMEOUT_MS: '300',
+      TMPDIR: tmpBase,
+      TEST_SCENARIO: 'stream-json-timeout',
+    };
+    delete env.CLAUDE_TERMUX_STDIN;
+
+    const result = child_process.spawnSync('sh', [scriptPath, '-p', 'x', '--output-format=stream-json'], {
+      env,
+      input: 'test input\n',
+      encoding: 'utf8',
+      timeout: 5000,
+    });
+
+    assert.equal(result.status, 1, `expected status 1 on timeout, got ${result.status}; stderr=${result.stderr}`);
+    const entries = fs.readdirSync(workdir, { withFileTypes: true });
+    const entryFiles = entries.filter(e => e.name.includes('cli.') && e.name.endsWith('.bare-path.js'));
+    assert.equal(entryFiles.length, 0, `expected no extracted entry files after timeout, found ${entryFiles.length}`);
+  } finally {
+    fs.rmSync(tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('bootstrap branch stream-json timeout triggers exit with status 1', () => {
+  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-stream-timeout-'));
+  try {
+    const sourceBin = path.join(tmpBase, 'fake-source.js');
+    const fixtureSource = buildScenarioFixtureSource();
+    fs.writeFileSync(sourceBin, fixtureSource, 'utf8');
+    const entryJsOffset = 0;
+    const entryEndOffset = Buffer.byteLength(fixtureSource, 'utf8');
+    const workdir = path.join(tmpBase, 'workdir');
+    fs.mkdirSync(workdir, { recursive: true });
+
+    const env = {
+      ...process.env,
+      SOURCE_BIN: sourceBin,
+      WORKDIR: workdir,
+      ENTRY_JS_OFFSET: String(entryJsOffset),
+      ENTRY_END_OFFSET: String(entryEndOffset),
+      CURRENT_CLAUDE_VERSION: '2.1.220',
+      CLAUDE_TERMUX_PACKAGE_DIR: path.join(__dirname, '..'),
+      MAGI_ENV: '1',
+      CLAUDE_TERMUX_PRINT_WAIT_MS: '300',
+      CLAUDE_TERMUX_PRINT_RESULT_TIMEOUT_MS: '300',
+      CLAUDE_TERMUX_STDIN: 'inherit',
+      TMPDIR: tmpBase,
+      TEST_SCENARIO: 'stream-json-timeout',
+    };
+
+    const result = child_process.spawnSync('sh', [scriptPath, '-p', 'x', '--output-format=stream-json'], {
+      env,
+      input: 'test input\n',
+      encoding: 'utf8',
+      timeout: 5000,
+    });
+
+    assert.equal(result.status, 1, `expected status 1 on timeout, got ${result.status}; stderr=${result.stderr}`);
+    const entries = fs.readdirSync(workdir, { withFileTypes: true });
+    const entryFiles = entries.filter(e => e.name.includes('cli.') && e.name.endsWith('.bare-path.js'));
+    assert.equal(entryFiles.length, 0, `expected no extracted entry files after timeout, found ${entryFiles.length}`);
+  } finally {
+    fs.rmSync(tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('helper branch stream-json requested exit after result', () => {
+  const r = runScenario({
+    printMode: true,
+    stdinInherit: false,
+    scenario: 'stream-json-requested-exit-then-result',
+    extraArgs: ['--output-format=stream-json'],
+  });
+  try {
+    assert.equal(r.status, 0, `expected status 0, got ${r.status}; stderr=${r.stderr}`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('bootstrap branch stream-json requested exit after result', () => {
+  const r = runScenario({
+    printMode: true,
+    stdinInherit: true,
+    scenario: 'stream-json-requested-exit-then-result',
+    extraArgs: ['--output-format=stream-json'],
+  });
+  try {
+    assert.equal(r.status, 0, `expected status 0, got ${r.status}; stderr=${r.stderr}`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('installStreamJsonTerminalWatcher waits for write callback before completing result', async () => {
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+  const watcherSource = extractFunction(helperBlock, 'function installStreamJsonTerminalWatcher() {', '\n  function forceTimeoutExit');
+
+  // Create a dedicated mock stdout object instead of modifying the real one
+  let callbackFired = false;
+  const mockStdout = Object.create(Object.getPrototypeOf(process.stdout));
+
+  // Copy necessary properties
+  Object.defineProperty(mockStdout, 'write', {
+    value: function(chunk, encoding, callback) {
+      if (typeof encoding === 'function') {
+        callback = encoding;
+        encoding = undefined;
+      }
+      if (callback) {
+        // Defer callback to next microtask
+        setImmediate(() => {
+          callbackFired = true;
+          callback();
+        });
+      }
+      return true;
+    },
+    writable: true,
+    configurable: true,
+  });
+
+  const context = vm.createContext({
+    module: { exports: {} },
+    process: { stdout: mockStdout },
+    Object,
+    Buffer,
+    require: (id) => {
+      if (id === 'string_decoder') return require('string_decoder');
+      throw new Error('require not available');
+    },
+  });
+
+  vm.runInContext(`
+    ${watcherSource}
+    module.exports = installStreamJsonTerminalWatcher;
+  `, context);
+
+  const installStreamJsonTerminalWatcher = context.module.exports;
+  const watcher = installStreamJsonTerminalWatcher();
+
+  // Simulate a write with result JSON
+  const resultJson = '{"type":"result","data":"test"}\n';
+  mockStdout.write(resultJson, 'utf8');
+
+  // Get the promise before callback fires
+  const resultPromise = watcher.waitForResult();
+
+  // Give time for callback to fire
+  await new Promise(resolve => setTimeout(resolve, 50));
+
+  // Promise should now be resolved
+  await resultPromise;
+  assert.ok(callbackFired, 'callback should have been fired');
+
+  watcher.restore();
+});
+
+function extractShimSource(block) {
+  const startMarker = 'const _realChild = require(\'child_process\');';
+  const endMarker = 'Object.assign(globalThis.__claudeBunShim, globalThis.Bun);';
+  const start = block.indexOf(startMarker);
+  assert.notEqual(start, -1, 'missing Bun shim start');
+  const end = block.indexOf(endMarker, start);
+  assert.notEqual(end, -1, 'missing Bun shim end');
+  return block.slice(start, end + endMarker.length);
+}
+
+function loadBunShim(source) {
+  const context = vm.createContext({
+    stringWidth: () => 0,
+    wrapAnsi: value => value,
+    stripANSI: value => value,
+    stableHash: () => 0,
+    __claudeYaml: {},
+    Buffer,
+    require,
+  });
+  context.__claudeBunShim = {};
+  context.__claudeYaml = {};
+  context.Bun = {};
+  context.module = { exports: {} };
+  vm.runInContext(`${source}\nmodule.exports = globalThis.__claudeBunShim;`, context);
+  return context.module.exports;
+}
+
+test('helper and bootstrap Bun shim source is identical', () => {
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+  const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+  assert.equal(extractShimSource(helperBlock), extractShimSource(bootstrapBlock));
+});
+
+test('Bun.file always throws ENOENT', () => {
+  for (const blockMarker of ['cat <<\'NODE\' > "$_helper"', 'cat <<\'NODE\' > "$_bootstrap"']) {
+    const block = extractBlock(blockMarker, '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+    const Bun = loadBunShim(extractShimSource(block));
+    assert.throws(() => Bun.file('/some/path'), error =>
+      error.code === 'ENOENT' && error.errno === -2);
+  }
+});
+
+test('Bun.spawn supports top-level and array stdio forms', async () => {
+  const block = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+  const Bun = loadBunShim(extractShimSource(block));
+  const topLevel = Bun.spawn(['echo', 'hello'], { stdout: 'pipe', stderr: 'ignore' });
+  assert.equal(await topLevel.stdout.text(), 'hello\n');
+  assert.equal(await topLevel.exited, 0);
+  const arrayForm = Bun.spawn(['echo', 'hello'], { stdio: ['ignore', 'pipe', 'ignore'] });
+  assert.equal(await arrayForm.stdout.text(), 'hello\n');
+  assert.equal(await arrayForm.exited, 0);
+});
+
+test('Bun.spawn forwards options, preserves numeric fds, and delegates child controls', () => {
+  const block = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+  const calls = [];
+  const handlers = {};
+  const child = {
+    pid: 123,
+    stdout: null,
+    on(event, handler) { handlers[event] = handler; return this; },
+    unref() { calls.push(['unref']); },
+    kill(signal) { calls.push(['kill', signal]); },
+  };
+  mock.method(child_process, 'spawn', (...args) => {
+    calls.push(args);
+    return child;
+  });
+  try {
+    const Bun = loadBunShim(extractShimSource(block));
+    const result = Bun.spawn(['cmd', 'arg'], {
+      detached: true,
+      argv0: 'argv0-value',
+      cwd: '/tmp/work',
+      env: { TEST: 'yes' },
+      stdio: [0, 1, 2],
+    });
+    assert.deepEqual(JSON.parse(JSON.stringify(calls[0])), [
+      'cmd',
+      ['arg'],
+      {
+        stdio: [0, 1, 2],
+        cwd: '/tmp/work',
+        env: { TEST: 'yes' },
+        detached: true,
+        argv0: 'argv0-value',
+      },
+    ]);
+    result.unref();
+    result.kill('SIGTERM');
+    assert.deepEqual(JSON.parse(JSON.stringify(calls.slice(1))), [['unref'], ['kill', 'SIGTERM']]);
+  } finally {
+    mock.restoreAll();
+  }
+});
+
+test('Bun.spawn prefers stdio array over top-level stdio options', () => {
+  for (const blockMarker of ['cat <<\'NODE\' > "$_helper"', 'cat <<\'NODE\' > "$_bootstrap"']) {
+    const block = extractBlock(blockMarker, '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+    const calls = [];
+    mock.method(child_process, 'spawn', (...args) => {
+      calls.push(args);
+      return { pid: 123, stdout: null, on() { return this; } };
+    });
+    try {
+      const Bun = loadBunShim(extractShimSource(block));
+      Bun.spawn(['cmd'], {
+        stdio: [0, 1, 2],
+        stdin: 'pipe',
+        stdout: 'pipe',
+        stderr: 'pipe',
+      });
+      assert.deepEqual(JSON.parse(JSON.stringify(calls[0][2])), {
+        stdio: [0, 1, 2],
+        detached: false,
+      });
+    } finally {
+      mock.restoreAll();
+    }
+  }
+});
+
+test('Bun.spawn forwards top-level stdin in the first stdio position', () => {
+  for (const blockMarker of ['cat <<\'NODE\' > "$_helper"', 'cat <<\'NODE\' > "$_bootstrap"']) {
+    const block = extractBlock(blockMarker, '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+    const calls = [];
+    mock.method(child_process, 'spawn', (...args) => {
+      calls.push(args);
+      return { pid: 123, stdout: null, on() { return this; } };
+    });
+    try {
+      const Bun = loadBunShim(extractShimSource(block));
+      Bun.spawn(['cmd'], { stdin: 'inherit', stdout: 'pipe', stderr: 'ignore' });
+      assert.equal(calls[0][2].stdio[0], 'inherit');
+      assert.deepEqual(JSON.parse(JSON.stringify(calls[0][2].stdio)), ['inherit', 'pipe', 'ignore']);
+    } finally {
+      mock.restoreAll();
+    }
+  }
+});