@bash0816/claude-code 2.1.220 → 2.1.222

package/README.md

@@ -37,7 +37,7 @@ npm が `claude` bin link を管理する状態になれば、通常の `npm ins
 Latest audited version / 最新監査済み版:
 
 ```sh
-npm install -g @bash0816/claude-code@2.1.219
+npm install -g @bash0816/claude-code@2.1.220-2
 ```
 
 ## Update / 更新

package/config/claude-native-audited-versions.json

@@ -580,6 +580,42 @@
       "entry_end_offset": 265457701,
       "tarball_integrity": "sha512-VHFI8mKruIntKn7eq81sbyS19/KWmQcmJQsS/C+j9M/E+w0s4UytgsL7DADPjBE/GByNiKoRtLYDMntCjRlOdA==",
       "tarball_sha256": "e38454d73576a08a2e707f26539d73fc9ef33e890228ca5c58a2bbe810ac884d",
+      "status": "termux_verified"
+    },
+    "2.1.220-1": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.220",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.220",
+      "entry_js_offset": 243831156,
+      "entry_end_offset": 265457701,
+      "tarball_integrity": "sha512-VHFI8mKruIntKn7eq81sbyS19/KWmQcmJQsS/C+j9M/E+w0s4UytgsL7DADPjBE/GByNiKoRtLYDMntCjRlOdA==",
+      "tarball_sha256": "e38454d73576a08a2e707f26539d73fc9ef33e890228ca5c58a2bbe810ac884d",
+      "status": "offset_discovered"
+    },
+    "2.1.220-2": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.220",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.220",
+      "entry_js_offset": 243831156,
+      "entry_end_offset": 265457701,
+      "tarball_integrity": "sha512-VHFI8mKruIntKn7eq81sbyS19/KWmQcmJQsS/C+j9M/E+w0s4UytgsL7DADPjBE/GByNiKoRtLYDMntCjRlOdA==",
+      "tarball_sha256": "e38454d73576a08a2e707f26539d73fc9ef33e890228ca5c58a2bbe810ac884d",
+      "status": "termux_verified"
+    },
+    "2.1.220-3": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.220",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.220",
+      "entry_js_offset": 243831156,
+      "entry_end_offset": 265457701,
+      "tarball_integrity": "sha512-VHFI8mKruIntKn7eq81sbyS19/KWmQcmJQsS/C+j9M/E+w0s4UytgsL7DADPjBE/GByNiKoRtLYDMntCjRlOdA==",
+      "tarball_sha256": "e38454d73576a08a2e707f26539d73fc9ef33e890228ca5c58a2bbe810ac884d",
+      "status": "offset_discovered"
+    },
+    "2.1.222": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.222",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.222",
+      "entry_js_offset": 256895476,
+      "entry_end_offset": 279849039,
+      "tarball_integrity": "sha512-EXSediF1ujcqQeElbXdCEe+uW3NUQAOjn1xHHAgvwzY08nzJeePjagn9+YS6bmhHxBgDKwlGu7pL8Kv7EpiFtg==",
+      "tarball_sha256": "1bb3c8364d652dd08a15856ee27c6600ecd1e45360243154fa846f240ce7a1df",
       "status": "offset_discovered"
     }
   }

package/config/claude-termux-release-manifest.json

@@ -1,9 +1,9 @@
 {
   "manifest_version": 1,
   "package_name": "@bash0816/claude-code",
-  "latest_audited_version": "2.1.219",
-  "latest_candidate_version": "2.1.220",
-  "previous_stable_version": "2.1.218",
+  "latest_audited_version": "2.1.220-2",
+  "latest_candidate_version": "2.1.222",
+  "previous_stable_version": "2.1.220",
   "stable_pinned_version": "2.1.193",
   "manifest_url": "https://raw.githubusercontent.com/bash0816/ClaudeCode-Termux/main/config/claude-termux-release-manifest.json"
 }

package/lib/termux-run-claude-native.sh

@@ -79,6 +79,22 @@ const entryJsOffset = Number(process.env.ENTRY_JS_OFFSET);
 const entryEndOffset = Number(process.env.ENTRY_END_OFFSET);
 const argv = process.argv.slice(2);
 
+function isStreamJsonPrintMode(argv) {
+  const dashDashIndex = argv.indexOf('--');
+  const ownArgs = dashDashIndex === -1 ? argv : argv.slice(0, dashDashIndex);
+  const hasPrintFlag = ownArgs.includes('-p') || ownArgs.includes('--print');
+  let hasStreamJsonFormat = false;
+  for (let i = 0; i < ownArgs.length; i++) {
+    const tok = ownArgs[i];
+    if (tok === '--output-format=stream-json') { hasStreamJsonFormat = true; break; }
+    if (tok === '--output-format' && ownArgs[i + 1] === 'stream-json') {
+      hasStreamJsonFormat = true;
+      break;
+    }
+  }
+  return hasPrintFlag && hasStreamJsonFormat;
+}
+
 class RequestedExit extends Error {
   constructor(code) {
     super(`process.exit ${code}`);
@@ -623,10 +639,12 @@ async function main() {
 
   const originalArgv = process.argv.slice();
   const originalExit = process.exit;
+  const originalKill = process.kill;
   const originalBun = process.versions.bun;
   const hadGlobalBun = Object.prototype.hasOwnProperty.call(globalThis, 'Bun');
   const originalGlobalBun = globalThis.Bun;
   const asyncErrors = [];
+  let streamJsonWatcher = null;
 
   globalThis.__claudeYaml = createYamlShim();
   if (!globalThis.__claudeBunShim || typeof globalThis.__claudeBunShim !== 'object') {
@@ -636,6 +654,100 @@ async function main() {
   function onAsyncError(error) {
     asyncErrors.push(error);
   }
+  const printWaitMs = Number(process.env.CLAUDE_TERMUX_PRINT_WAIT_MS || 5000);
+
+  function installStreamJsonTerminalWatcher() {
+    const hadOwnWrite = Object.prototype.hasOwnProperty.call(process.stdout, 'write');
+    const originalWriteDescriptor = hadOwnWrite ? Object.getOwnPropertyDescriptor(process.stdout, 'write') : undefined;
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    const { StringDecoder } = require('string_decoder');
+    const decoder = new StringDecoder('utf8');
+    let lineBuffer = '';
+    let resultPromiseResolve = null;
+    let foundResult = false;
+    let restored = false;
+
+    process.stdout.write = function wrappedWrite(chunk, encoding, callback) {
+      let cb = callback;
+      let enc = encoding;
+      if (typeof encoding === 'function') {
+        cb = encoding;
+        enc = undefined;
+      }
+      const combinedCallback = (err) => {
+        if (!err && !foundResult) {
+          const chunkStr = typeof chunk === 'string'
+            ? decoder.write(Buffer.from(chunk, typeof enc === 'string' ? enc : 'utf8'))
+            : decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+          lineBuffer += chunkStr;
+          const lines = lineBuffer.split('\n');
+          lineBuffer = lines[lines.length - 1];
+          for (let i = 0; i < lines.length - 1; i++) {
+            try {
+              const parsed = JSON.parse(lines[i]);
+              if (parsed && parsed.type === 'result') {
+                foundResult = true;
+                if (typeof resultPromiseResolve === 'function') resultPromiseResolve();
+              }
+            } catch {}
+          }
+        }
+        if (typeof cb === 'function') cb(err);
+      };
+      return originalWrite(chunk, enc, combinedCallback);
+    };
+
+    return {
+      waitForResult() {
+        if (foundResult) return Promise.resolve();
+        return new Promise((resolve, reject) => {
+          resultPromiseResolve = resolve;
+        });
+      },
+      restore() {
+        if (restored) return;
+        restored = true;
+        if (hadOwnWrite) {
+          Object.defineProperty(process.stdout, 'write', originalWriteDescriptor);
+        } else {
+          delete process.stdout.write;
+        }
+      },
+    };
+  }
+
+  function forceTimeoutExit(exitCode) {
+    try { if (streamJsonWatcher) streamJsonWatcher.restore(); } catch {}
+    if (extractedFile) {
+      try { fs.rmSync(extractedFile, { force: true }); } catch {}
+    }
+    originalExit(exitCode);
+  }
+
+  async function waitForPrintFlush() {
+    if (isStreamJsonPrintMode(argv) && streamJsonWatcher) {
+      let timedOut = false;
+      const rawResultTimeoutMs = Number(process.env.CLAUDE_TERMUX_PRINT_RESULT_TIMEOUT_MS);
+      const resultTimeoutMs = (Number.isFinite(rawResultTimeoutMs) && rawResultTimeoutMs > 0) ? rawResultTimeoutMs : 300000;
+      let timeoutHandle;
+      const timeoutPromise = new Promise(resolve => {
+        timeoutHandle = setTimeout(() => { timedOut = true; resolve(); }, resultTimeoutMs);
+      });
+      try {
+        await Promise.race([streamJsonWatcher.waitForResult(), timeoutPromise]);
+      } finally {
+        clearTimeout(timeoutHandle);
+      }
+      if (timedOut) {
+        forceTimeoutExit(1);
+        return;
+      }
+      return;
+    }
+    if (Number.isFinite(printWaitMs) && printWaitMs > 0) {
+      await new Promise(resolve => setTimeout(resolve, printWaitMs));
+    }
+  }
 
   try {
     process.once('uncaughtException', onAsyncError);
@@ -694,21 +806,31 @@ async function main() {
     globalThis.__claudeBun = globalThis.__claudeBunShim;
     globalThis.Bun = globalThis.__claudeBunShim;
     process.argv = ['node', extractedFile, ...argv];
+    let lastExitAttemptCode = 0;
     process.exit = code => {
-      throw new RequestedExit(code);
+      lastExitAttemptCode = code ?? 0;
+      throw new RequestedExit(lastExitAttemptCode);
+    };
+    process.kill = (pid, signal) => {
+      if (pid === process.pid && (signal === 'SIGKILL' || signal === 9)) {
+        throw new RequestedExit(lastExitAttemptCode);
+      }
+      return originalKill.call(process, pid, signal);
     };
 
-    const printWaitMs = Number(process.env.CLAUDE_TERMUX_PRINT_WAIT_MS || 5000);
+    if (isStreamJsonPrintMode(argv)) {
+      streamJsonWatcher = installStreamJsonTerminalWatcher();
+    }
+
     const moduleLike = { exports: {} };
     const maybePromise = fn(moduleLike.exports, fakeRequire, moduleLike, extractedFile, workdir);
     if (maybePromise && typeof maybePromise.then === 'function') await maybePromise;
-    if (Number.isFinite(printWaitMs) && printWaitMs > 0) {
-      await new Promise(resolve => setTimeout(resolve, printWaitMs));
-    }
+    await waitForPrintFlush();
     if (asyncErrors.length > 0) throw asyncErrors[0];
   } catch (error) {
     if (error instanceof RequestedExit) {
       process.exitCode = error.code;
+      await waitForPrintFlush();
       return;
     }
     throw error;
@@ -722,6 +844,10 @@ async function main() {
     }
     process.argv = originalArgv;
     process.exit = originalExit;
+    process.kill = originalKill;
+    if (streamJsonWatcher) {
+      try { streamJsonWatcher.restore(); } catch {}
+    }
     try {
       if (originalBun === undefined) {
         delete process.versions.bun;
@@ -758,6 +884,7 @@ else
   _bootstrap=$(mktemp "${TERMUX_TMPDIR}/claude-bootstrap.XXXXXX.js")
   trap 'rm -f "$_bootstrap"' EXIT HUP INT TERM
   export CLAUDE_TERMUX_TUI="${_tui}"
+  export CLAUDE_TERMUX_PRINT_MODE="${_pf}"
   cat <<'NODE' > "$_bootstrap"
 const fs = require('fs');
 const path = require('path');
@@ -772,6 +899,22 @@ const entryJsOffset = Number(process.env.ENTRY_JS_OFFSET);
 const entryEndOffset = Number(process.env.ENTRY_END_OFFSET);
 const argv = process.argv.slice(2);
 
+function isStreamJsonPrintMode(argv) {
+  const dashDashIndex = argv.indexOf('--');
+  const ownArgs = dashDashIndex === -1 ? argv : argv.slice(0, dashDashIndex);
+  const hasPrintFlag = ownArgs.includes('-p') || ownArgs.includes('--print');
+  let hasStreamJsonFormat = false;
+  for (let i = 0; i < ownArgs.length; i++) {
+    const tok = ownArgs[i];
+    if (tok === '--output-format=stream-json') { hasStreamJsonFormat = true; break; }
+    if (tok === '--output-format' && ownArgs[i + 1] === 'stream-json') {
+      hasStreamJsonFormat = true;
+      break;
+    }
+  }
+  return hasPrintFlag && hasStreamJsonFormat;
+}
+
 class RequestedExit extends Error {
   constructor(code) {
     super(`process.exit ${code}`);
@@ -1316,10 +1459,12 @@ async function main() {
 
   const originalArgv = process.argv.slice();
   const originalExit = process.exit;
+  const originalKill = process.kill;
   const originalBun = process.versions.bun;
   const hadGlobalBun = Object.prototype.hasOwnProperty.call(globalThis, 'Bun');
   const originalGlobalBun = globalThis.Bun;
   const asyncErrors = [];
+  let streamJsonWatcher = null;
 
   globalThis.__claudeYaml = createYamlShim();
   if (!globalThis.__claudeBunShim || typeof globalThis.__claudeBunShim !== 'object') {
@@ -1330,6 +1475,101 @@ async function main() {
     asyncErrors.push(error);
   }
 
+  function installStreamJsonTerminalWatcher() {
+    const hadOwnWrite = Object.prototype.hasOwnProperty.call(process.stdout, 'write');
+    const originalWriteDescriptor = hadOwnWrite ? Object.getOwnPropertyDescriptor(process.stdout, 'write') : undefined;
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    const { StringDecoder } = require('string_decoder');
+    const decoder = new StringDecoder('utf8');
+    let lineBuffer = '';
+    let resultPromiseResolve = null;
+    let foundResult = false;
+    let restored = false;
+
+    process.stdout.write = function wrappedWrite(chunk, encoding, callback) {
+      let cb = callback;
+      let enc = encoding;
+      if (typeof encoding === 'function') {
+        cb = encoding;
+        enc = undefined;
+      }
+      const combinedCallback = (err) => {
+        if (!err && !foundResult) {
+          const chunkStr = typeof chunk === 'string'
+            ? decoder.write(Buffer.from(chunk, typeof enc === 'string' ? enc : 'utf8'))
+            : decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+          lineBuffer += chunkStr;
+          const lines = lineBuffer.split('\n');
+          lineBuffer = lines[lines.length - 1];
+          for (let i = 0; i < lines.length - 1; i++) {
+            try {
+              const parsed = JSON.parse(lines[i]);
+              if (parsed && parsed.type === 'result') {
+                foundResult = true;
+                if (typeof resultPromiseResolve === 'function') resultPromiseResolve();
+              }
+            } catch {}
+          }
+        }
+        if (typeof cb === 'function') cb(err);
+      };
+      return originalWrite(chunk, enc, combinedCallback);
+    };
+
+    return {
+      waitForResult() {
+        if (foundResult) return Promise.resolve();
+        return new Promise((resolve, reject) => {
+          resultPromiseResolve = resolve;
+        });
+      },
+      restore() {
+        if (restored) return;
+        restored = true;
+        if (hadOwnWrite) {
+          Object.defineProperty(process.stdout, 'write', originalWriteDescriptor);
+        } else {
+          delete process.stdout.write;
+        }
+      },
+    };
+  }
+
+  function forceTimeoutExit(exitCode) {
+    try { if (streamJsonWatcher) streamJsonWatcher.restore(); } catch {}
+    if (extractedFile) {
+      try { fs.rmSync(extractedFile, { force: true }); } catch {}
+    }
+    originalExit(exitCode);
+  }
+
+  async function waitForPrintFlushIfNeeded() {
+    if (process.env.CLAUDE_TERMUX_PRINT_MODE !== '1') return;
+    if (isStreamJsonPrintMode(argv) && streamJsonWatcher) {
+      let timedOut = false;
+      const rawResultTimeoutMs = Number(process.env.CLAUDE_TERMUX_PRINT_RESULT_TIMEOUT_MS);
+      const resultTimeoutMs = (Number.isFinite(rawResultTimeoutMs) && rawResultTimeoutMs > 0) ? rawResultTimeoutMs : 300000;
+      let timeoutHandle;
+      const timeoutPromise = new Promise(resolve => {
+        timeoutHandle = setTimeout(() => { timedOut = true; resolve(); }, resultTimeoutMs);
+      });
+      try {
+        await Promise.race([streamJsonWatcher.waitForResult(), timeoutPromise]);
+      } finally {
+        clearTimeout(timeoutHandle);
+      }
+      if (timedOut) {
+        forceTimeoutExit(1);
+        return;
+      }
+      return;
+    }
+    const printWaitMs = Number(process.env.CLAUDE_TERMUX_PRINT_WAIT_MS || 5000);
+    if (Number.isFinite(printWaitMs) && printWaitMs > 0) {
+      await new Promise(resolve => setTimeout(resolve, printWaitMs));
+    }
+  }
+
   try {
     process.once('uncaughtException', onAsyncError);
     process.once('unhandledRejection', onAsyncError);
@@ -1387,17 +1627,31 @@ async function main() {
     globalThis.__claudeBun = globalThis.__claudeBunShim;
     globalThis.Bun = globalThis.__claudeBunShim;
     process.argv = ['node', extractedFile, ...argv];
+    let lastExitAttemptCode = 0;
     process.exit = code => {
-      throw new RequestedExit(code);
+      lastExitAttemptCode = code ?? 0;
+      throw new RequestedExit(lastExitAttemptCode);
     };
+    process.kill = (pid, signal) => {
+      if (pid === process.pid && (signal === 'SIGKILL' || signal === 9)) {
+        throw new RequestedExit(lastExitAttemptCode);
+      }
+      return originalKill.call(process, pid, signal);
+    };
+
+    if (isStreamJsonPrintMode(argv)) {
+      streamJsonWatcher = installStreamJsonTerminalWatcher();
+    }
 
     const moduleLike = { exports: {} };
     const maybePromise = fn(moduleLike.exports, fakeRequire, moduleLike, extractedFile, workdir);
     if (maybePromise && typeof maybePromise.then === 'function') await maybePromise;
+    await waitForPrintFlushIfNeeded();
     if (asyncErrors.length > 0) throw asyncErrors[0];
   } catch (error) {
     if (error instanceof RequestedExit) {
       process.exitCode = error.code;
+      await waitForPrintFlushIfNeeded();
       return;
     }
     throw error;
@@ -1406,6 +1660,10 @@ async function main() {
     process.removeListener('unhandledRejection', onAsyncError);
     process.argv = originalArgv;
     process.exit = originalExit;
+    process.kill = originalKill;
+    if (streamJsonWatcher) {
+      try { streamJsonWatcher.restore(); } catch {}
+    }
     process.once('exit', () => {
       if (extractedFile) {
         try {

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

@@ -191,12 +191,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=');
@@ -544,3 +564,777 @@ 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;
+    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();
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bash0816/claude-code",
-  "version": "2.1.220",
+  "version": "2.1.222",
   "description": "Unofficial Termux-native Claude Code wrapper with audited native replay",
   "license": "GPL-3.0-only",
   "bin": {