Activity

1. github-actions

   added

   bugSomething isn't workingSomething isn't working

   appIssues related to the Codex desktop appIssues related to the Codex desktop app

   browser

   performance

   on Aug 14, 2026
2. perhapseb commented on Aug 14, 2026

   

   perhapseb

   on Aug 14, 2026 – with ChatGPT Codex Connector

   Author

   More actions

   Private in-app diagnostics have now been submitted from the affected task with both current session logs and browser tabs/browser logs included.

   Feedback ID: 019fdd30-fe5e-75d0-b47e-2d6178bde306

   This identifier also corresponds to the affected Codex task referenced in the report, which should help correlate the uploaded diagnostics with the oversized rollout and Chrome-helper reproduction.
3. karan-jani commented on Sep 3, 2026

   

   karan-jani

   on Sep 3, 2026

   More actions

   Additional observation on 2026-09-02, still present in ChatGPT/Codex desktop 26.901.20858 (build 7658).

   Environment:

   • macOS 26.5 (25F71), Apple Silicon / ARM64
   • Bundled Codex: 0.153.0-alpha.5
   • Bundled CUA Node: v24.19.0
   • Unified Computer Use plugin: 26.901.20858

   The Mac became unusually hot at the time the CUA trusted worker started. The worker sustained approximately 60–85% of one CPU core across repeated samples and had accumulated more than an hour of CPU time over roughly two hours. Its sampled physical footprint was 833.9 MB, later rose to about 1.6 GB, and the recorded peak was 5.3 GB.

   The process was cua_node/bin/node .../trusted-worker.js. It held a large Codex rollout JSONL open, including two descriptors in one observation. A native sample captured asynchronous filesystem reads (node::fs::Read, pread), UTF-8 string conversion (StringSlice, StringBytes::Encode, simdutf), and V8 allocation/garbage collection.

   Measured file/runtime limits:

   • Rollout size at the later inspection: 705,941,507 bytes.
   • A bounded-memory incremental UTF-8 scan counted 705,810,151 Unicode code points, a lower bound on the required JavaScript UTF-16 string length.
   • The installed Node runtime reports buffer.constants.MAX_STRING_LENGTH = 536870888 (a string-length limit, not generally a UTF-8 byte limit).

   Inspection of the installed @oai/browser-desktop/scripts/browser-service.mjs shows the same mechanism described here: new sessions start at fileOffset: 0; JY reads all unread data into 64 KiB buffers and calls Buffer.concat(...).toString("utf8"); Xm.processSessionRollout only updates the offset after success; other processing errors are caught while polling remains active, with a 250 ms polling delay. That file cannot fit into a single string in this runtime.

   The exact runtime exception was not captured before termination, so the string-limit retry mechanism is a strongly supported diagnosis, not a fresh controlled reproduction. The stack sample and installed code match this issue closely.

   Terminating only the affected trusted worker removed its persistent CPU load, and the user then confirmed that the Mac was cooling. GPU utilization remained around 30%, so we are not attributing all system activity to this helper. pmset -g therm reported no recorded thermal or performance warning.

   Please prioritize bounded/streaming rollout parsing and handling for unrecoverable conversion errors so the watcher cannot repeatedly reread the same oversized history. No private conversation contents, browser data, or raw session logs are included in this report.
4. AdamArroyo92 commented on Sep 6, 2026

   

   AdamArroyo92

   on Sep 6, 2026 – with ChatGPT Codex Connector

   More actions

   Additional Windows reproduction on September 5, 2026, with a much larger rollout and the same unbounded reader still present in a newer installed runtime.

   Environment

   • Windows x64; 31.15 GiB visible physical RAM.
   • Installed Codex desktop package: OpenAI.Codex_26.901.5280.0_x64.
   • unified-computer-use plugin: 26.901.41600.
   • Bundled cua_node runtime directory: 440c4f095d41ea30; Node v24.19.0.
   • Measured buffer.constants.MAX_STRING_LENGTH: 536,870,888.
   • Installed @oai/browser-desktop/scripts/browser-service.mjs SHA256: 3032666DE451E423DB76B5F9B0456E370D4F57416BBF53D0C746BE636359BA02.

   Observed impact

   A long-lived task's rollout JSONL is 18,575,189,258 bytes (file metadata measured without loading the transcript).

   During an earlier explicitly authorized read-only browser test in that task, opening a hosted game-server control panel and navigating to File Manager coincided with:

   • A new Node worker reaching 35,806 MiB private committed memory.
   • Available physical RAM falling from 15.95 GiB to 1.12 GiB.
   • codex.exe private memory rising from 2,846 MiB to 10,504 MiB and then 15,803 MiB.
   • Severe user-visible system lag. User reported disk/RAM saturation; no reliable disk counter was retained for that earlier incident.
   • Resetting the JavaScript session did not terminate/release the runaway worker. Terminating the specifically identified worker recovered resources.

   Fresh-task comparison

   A new task on the same machine, with a ~1.6 MB rollout at inspection, performed read-only browser discovery and navigation through the same control panel: Console, File Manager, oxide/plugins directory, Server Metrics, Players, then Console.
   A bounded watchdog recorded 112 samples over ~104 seconds including setup/cleanup:

   • Peak system RAM utilization: 51.44%.
   • Peak physical disk active time: 23%.
   • Peak private allocation of any monitored task-specific Node worker: 167 MiB.
     The test tab was closed and the identified test workers terminated. No hosted files, settings, commands, or server state were changed by the test.

   Static code evidence in this build

   In browser-service.mjs, around line 4205, the minified Xm tracker and JY reader still:

   1. Initialize/reset fileOffset to 0 for a newly discovered rollout.
   2. Allocate/read 64 KiB chunks until EOF and retain every chunk in an array.
   3. Call Buffer.concat(chunks).toString("utf8"), then split the whole result into lines.
   4. Update the stored fileOffset only after the reader successfully returns.
   5. Catch errors and retain polling, configured at 250 ms between processing cycles.

   For this transcript, the retained chunks plus a concatenated buffer alone total approximately 35,429 MiB, close to the observed 35,806 MiB private allocation, before text decoding/parsing and other overhead. This is strong evidence for the mechanism described in this issue; we did not take a heap dump or rerun the dangerous large-task case.

   Trigger nuance: Gm.getInfo enables tracking for extension/cdp backends, not directly for iab. The CUA discovery used in these tests lists an available Chrome extension as well as the in-app browser; getUserTabs routes through sendSessionRequest and its tracker. Therefore do not attribute the full read exclusively to the hosted page or iab navigation. Please investigate discovery/extension inventory as a trigger even when the intended working tab is iab.

   Suggested fix remains bounded streaming/tailing and controlled handling of unrecoverable size errors; also ensure reset/disposal cancels an in-progress read. No runtime patch or hidden environment-variable workaround was applied.

   Private transcript contents, server address/identifiers, credentials, and screenshots are deliberately omitted. Posted by Codex at the affected user's explicit request.
5. jsegeren commented on Sep 7, 2026

   

   jsegeren

   on Sep 7, 2026 – with ChatGPT Codex Connector

   More actions

   Additional macOS measurements and proposed bounded reader fix (September 6, 2026)

   Posted by Codex on behalf of the affected user, with explicit authorization. This adds a larger scale case and a tested reference implementation to this existing issue. Current desktop version: 26.901.51231 (build 8109).

   Summary

   The Codex unified browser helper can allocate tens of gigabytes while detecting turn-completion events in a large JSONL rollout. The installed tracker starts with fileOffset=0 and pendingFragment="". Its reader collects every available 64 KiB chunk, Buffer.concat() copies them, toString("utf8") creates a large string, and split("\n") materializes records. Incomplete giant records also grow pendingFragment without a bound. Failed reads/parses can leave the committed offset unchanged, allowing repeat scans. File-change notifications additionally queue a separate processing promise for every notification.

   Observed impact

   On an Apple M5 Max MacBook Pro with 128 GB RAM and macOS 26.5, a trusted browser worker held two read handles on a 23,330,114,904-byte rollout. A process sample recorded peak physical footprint 48.8 GiB, file reads and garbage collection. System disk traffic sampled around 282–358 MB/s, with approximately 21 GiB swap occupied. The worker later restarted and grew again. No user transcript is included in this report.

   The user also experienced system stutters and AirPods audio becoming silent while shown as connected; reconnecting restored playback. Bluetooth retry counters rose during one incident. A causal relationship between this reader and Bluetooth failure has NOT been established. The reader's excessive memory use is independently reproducible from its implementation.

   Affected code

   Observed in @oai/browser-desktop/scripts/browser-service.mjs used by unified-computer-use 26.901.41123 and still present with 26.901.51231. Installed application-bundle SHA-256: 3032666de451e423db76b5f9b0456e370d4f57416bbf53d0c746be636359ba02. Relevant minified reader: JY; tracker: Xm. Function names may change by build.

   Proposed fix

   Retain both native turn-ended events and transcript fallback. Replace whole-file accumulation with a resumable streaming JSONL reader that selects only lifecycle fields and active turn IDs. Bound bytes per scan, preserve parser/cursor state across partial records, and coalesce pending scan requests. Handle truncation, inode replacement, malformed lines and excessive record nesting explicitly.

   The reference implementation below uses 64 KiB buffers, an 8 MiB scan budget, stream-json with value packing disabled, and a 128-container record-depth limit. It does not cap agent concurrency or change CPU priorities. Huge strings and keys are consumed without retaining their contents. No completion ID is emitted until the containing line validates and ends with a newline. Historical IDs not currently tracked are not retained.

   Reproduction and validation

   Use synthetic data only. benchmark.cjs streams a configurable large single JSONL record to a temporary file, places a lifecycle turn ID after the large string, runs the reader and reports peak RSS. It deletes the fixture afterward. A 256 MiB single-record run completed in 33 bounded scans, 483 ms, peak RSS 71 MiB, under --max-old-space-size=128. Seven tests passed covering record semantics, giant strings and keys, byte boundaries/Unicode, malformed input, partial append, truncation/replacement, native/fallback cleanup, and notification coalescing. The tests that extract the installed tracker need build.py to prepare the runtime first.

   This is a proposed local implementation, not an official patch. Review the 8 MiB scheduling budget, 128-level depth policy, full-history disk cost, and lifecycle/cleanup integration upstream. A maintained streaming parser already used within the product may be preferable to adding the dependency chosen for this local demonstration.

   Local installation scope

   A private local copy of the service is loaded through the unsigned plugin launcher, guarded against an upstream hash change. The signed application remains unchanged. Existing running helpers were not interrupted. End-to-end browser use with a freshly loaded helper and long-term audio stability remain to be observed.

   Reference implementation and synthetic tests

   These expandable sections contain the proposed reader, tests, benchmark, and a build-specific local integration script. No private conversation contents, account identifiers, credentials, device serials, or full proprietary service bundle are included. The integration script is provided to make the seven tests reproducible against the stated installed build; it creates a local copy and does not install the launcher override. This is a review candidate, not an upstream-reviewed production fix.

   Save these five files in one new directory, run npm install --ignore-scripts, then python3 build.py on the stated macOS build. Run node --test test.cjs and node --max-old-space-size=128 benchmark.cjs 256 using the bundled Node runtime or a compatible Node version. The first five reader tests and benchmark use only synthetic fixtures; the last two tests extract the tracker from the locally installed service.

   package.json

   {
     "dependencies": {
       "stream-json": "1.9.1"
     }
   }
   

   reader.cjs

   'use strict';
   // Incremental JSONL lifecycle reader. No transcript content is returned or logged.
   const {open} = require('node:fs/promises');
   const Parser = require('stream-json/Parser');
   const cursors = new WeakMap();
   const CHUNK_BYTES = 64 * 1024;
   const PASS_BYTES = 8 * 1024 * 1024;
   const MAX_DEPTH = 128;
   const shape = {method: 'method', type: 'type', payload: {type: 'event', turn_id: 'id'}, params: {turn: {id: 'id'}}};
   const isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);
   
   function completion(value) {
     if (!isObject(value)) return;
     if (value.method === 'turn/completed') return isObject(value.params) && isObject(value.params.turn) ? value.params.turn.id : undefined;
     if (value.type === 'event_msg' && isObject(value.payload) && ['task_complete', 'turn_aborted'].includes(value.payload.type)) return value.payload.turn_id;
   }
   
   function record(activeTurnIds) {
     const parser = new Parser({packValues: false, streamValues: true});
     const frames = [];
     let projected, key = null, string = null, invalid = false;
     function target() {
       if (!frames.length) return {node: shape, put(value) { projected = value; }};
       const frame = frames[frames.length - 1];
       const name = frame.key;
       return {node: frame.node && Object.hasOwn(frame.node, name) ? frame.node[name] : undefined,
         put(value) { if (frame.value && frame.node && Object.hasOwn(frame.node, name)) frame.value[name] = value; }};
     }
     parser.on('error', () => { invalid = true; });
     parser.on('data', token => {
       if (invalid) return;
       const {name, value} = token;
       if (name === 'startKey') { key = ''; return; }
       if (name === 'endKey') { frames[frames.length - 1].key = key; key = null; return; }
       if (name === 'stringChunk') {
         if (key !== null) { key = key.length + value.length <= 16 ? key + value : '\0'.repeat(17); return; }
         if (string) {
           string.candidates = string.candidates.filter(candidate => candidate.startsWith(value, string.offset));
           string.offset += value.length;
         }
         return;
       }
       if (name === 'startObject' || name === 'startArray') {
         if (frames.length >= MAX_DEPTH) { invalid = true; return; }
         const location = target();
         const node = name === 'startObject' && isObject(location.node) ? location.node : undefined;
         const object = node ? Object.create(null) : null;
         location.put(object);
         frames.push({node, value: object, key: undefined});
         return;
       }
       if (name === 'endObject' || name === 'endArray') { frames.pop(); return; }
       if (name === 'startString') {
         const location = target();
         const candidates = location.node === 'id' ? [...activeTurnIds.values()] :
           location.node === 'method' ? ['turn/completed'] : location.node === 'type' ? ['event_msg'] :
           location.node === 'event' ? ['task_complete', 'turn_aborted'] : [];
         location.put(null);
         string = {candidates, offset: 0, put: location.put};
         return;
       }
       if (name === 'endString') {
         string.put(string.candidates.find(candidate => candidate.length === string.offset) ?? null);
         string = null;
         return;
       }
       if (['startNumber', 'nullValue', 'trueValue', 'falseValue'].includes(name)) target().put(null);
     });
     return {
       async write(bytes) {
         if (invalid || !bytes.length) return;
         await new Promise(resolve => parser.write(bytes, () => resolve()));
         // The parser's own nesting stack is bounded by stopping after our depth check.
         if (invalid) parser.destroy();
       },
       async finish() {
         if (invalid) { parser.destroy(); return; }
         await new Promise(resolve => {
           parser.once('finish', resolve);
           parser.once('error', resolve);
           parser.end();
         });
         const id = invalid ? undefined : completion(projected);
         parser.destroy();
         return id;
       },
       destroy() { parser.destroy(); }
     };
   }
   
   async function readRollout(path, state, options = {}) {
     const handle = await open(path, 'r');
     let cursor;
     try {
       const stat = await handle.stat();
       cursor = cursors.get(state);
       if (!cursor || cursor.path !== path || cursor.ino !== stat.ino || cursor.dev !== stat.dev || stat.size < cursor.offset) {
         cursor?.record?.destroy();
         cursor = {path, ino: stat.ino, dev: stat.dev, offset: 0, record: null, completed: new Set()};
         cursors.set(state, cursor);
       }
       const end = Math.min(stat.size, cursor.offset + (options.passBytes ?? PASS_BYTES));
       const buffer = Buffer.allocUnsafe(options.chunkBytes ?? CHUNK_BYTES);
       while (cursor.offset < end) {
         const {bytesRead} = await handle.read(buffer, 0, Math.min(buffer.length, end - cursor.offset), cursor.offset);
         if (!bytesRead) break;
         let position = 0;
         while (position < bytesRead) {
           let newline = buffer.indexOf(10, position);
           if (newline >= bytesRead) newline = -1;
           const stop = newline < 0 ? bytesRead : newline;
           cursor.record ??= record(state.activeTurnIds);
           await cursor.record.write(buffer.subarray(position, stop));
           cursor.offset += stop - position;
           if (newline < 0) break;
           const id = await cursor.record.finish();
           if (typeof id === 'string' && id.length && [...state.activeTurnIds.values()].includes(id)) cursor.completed.add(id);
           cursor.record = null;
           cursor.offset++;
           position = newline + 1;
         }
       }
       const completedTurnIds = cursor.completed;
       cursor.completed = new Set();
       return {completedTurnIds, fileOffset: cursor.offset, pendingFragment: ''};
     } finally {
       await handle.close();
     }
   }
   module.exports = {readRollout, CHUNK_BYTES, PASS_BYTES};

   test.cjs

   'use strict';
   const assert = require('node:assert/strict');
   const {test} = require('node:test');
   const fs = require('node:fs/promises');
   const os = require('node:os');
   const path = require('node:path');
   const {readRollout} = require('./reader.cjs');
   const ids = ['turn-a', 'turn-b', 't😀é', 'escaped"\\id'];
   const state = () => ({fileOffset: 0, pendingFragment: '', activeTurnIds: new Map(ids.map(id => [()=>{}, id]))});
   async function fixture(run) { const dir=await fs.mkdtemp(path.join(os.tmpdir(),'bounded-rollout-')); try {await run(path.join(dir,'log'));}finally{await fs.rm(dir,{recursive:true,force:true});} }
   async function drain(file,s,options={}) { const result=new Set();const size=(await fs.stat(file)).size;let calls=0;do{const r=await readRollout(file,s,options);Object.assign(s,r);for(const id of r.completedTurnIds)result.add(id);assert.ok(++calls<100000);}while(s.fileOffset<size);return [...result].sort(); }
   const event=id=>JSON.stringify({type:'event_msg',payload:{type:'task_complete',turn_id:id}});
   function reference(line) {let e;try{e=JSON.parse(line)}catch{return}const obj=x=>x&&typeof x==='object'&&!Array.isArray(x);if(!obj(e))return;let id;if(e.method==='turn/completed'){if(obj(e.params)&&obj(e.params.turn))id=e.params.turn.id;}else if(e.type==='event_msg'&&obj(e.payload)&&['task_complete','turn_aborted'].includes(e.payload.type))id=e.payload.turn_id;return ids.includes(id)?id:undefined;}
   test('matches lifecycle semantics across byte boundaries, Unicode, duplicate keys, irrelevant and malformed records',()=>fixture(async file=>{
    const lines=[...ids.map(event),JSON.stringify({method:'turn/completed',params:{turn:{id:'turn-b'}}}),
    '{"type":"event_msg","payload":{"type":"turn_aborted","turn_id":"turn-a"}}',
    '{"type":"event_msg","payload":{"type":"task_complete","turn_id":"turn-a"},"payload":null}',
    '{"method":"turn/completed","params":null,"type":"event_msg","payload":{"type":"task_complete","turn_id":"turn-a"}}',
    '{"type":"event_msg","payload":{"type":"task_complete","turn_id":"turn-a","turn_id":[]}}',
    '{"type":"event_msg","payload":{"type":"task_complete","turn_id":"turn-a"}}garbage',
    'invalid', '', 'null', '[]', '{"nested":'+event('turn-a')+'}',
    event('historical-id'), '{"type":"event_msg","payload":{"type":"task_complete","turn_id":"turn-a"},"type":"other"}'];
    for(let i=0;i<80;i++)lines.push(JSON.stringify({type:i%2?'event_msg':'other',payload:{type:i%3?'task_complete':null,turn_id:ids[i%4],other:['x',null,{a:i}]}}));
    for(const line of lines){await fs.writeFile(file,line+'\n');const actual=await drain(file,state(),{chunkBytes:7,passBytes:19});assert.deepEqual(actual,reference(line)?[reference(line)]:[],line);}
   }));
   test('does not dispatch partial lines; resumes append without rereading; completion requires newline',()=>fixture(async file=>{
    const s=state(),text=event('turn-a');await fs.writeFile(file,text.slice(0,-2));assert.deepEqual(await drain(file,s),[]);
    await fs.appendFile(file,text.slice(-2));assert.deepEqual(await drain(file,s),[]);
    await fs.appendFile(file,'\n'+event('turn-b')+'\n');assert.deepEqual(await drain(file,s),['turn-a','turn-b']);
    assert.deepEqual((await readRollout(file,s)).completedTurnIds,new Set());
   }));
   test('resets on truncation and replacement, including a partial record',()=>fixture(async file=>{
    const s=state();await fs.writeFile(file,'{"ignored":"'+'x'.repeat(1000));await drain(file,s);
    await fs.writeFile(file,event('turn-a')+'\n');assert.deepEqual(await drain(file,s),['turn-a']);
    await fs.rename(file,file+'.old');await fs.writeFile(file,event('turn-b')+'\n');assert.deepEqual(await drain(file,s),['turn-b']);
   }));
   test('bounds each pass and handles large strings and keys without discarding lifecycle fields',()=>fixture(async file=>{
    const handle=await fs.open(file,'w');const chunk=Buffer.alloc(65536,120);
    await handle.write('{"type":"event_msg","payload":{"type":"task_complete","large":"');
    for(let i=0;i<512;i++)await handle.write(chunk);
    await handle.write('","turn_id":"turn-a"},"');
    for(let i=0;i<32;i++)await handle.write(chunk);
    await handle.write('":false}\n'+event('turn-b')+'\n');await handle.close();
    const s=state();const first=await readRollout(file,s,{passBytes:131072});assert.equal(first.fileOffset,131072);Object.assign(s,first);
    assert.deepEqual(await drain(file,s),['turn-a','turn-b']);
   }));
   test('recovers at the next line after invalid JSON or excessive nesting',()=>fixture(async file=>{
    await fs.writeFile(file,'[invalid\n'+'['.repeat(200)+']'.repeat(200)+'\n'+event('turn-a')+'\n');
    assert.deepEqual(await drain(file,state()),['turn-a']);
   }));
   function trackerClass() {
    const source=require('node:fs').readFileSync(path.join(__dirname,'runtime/scripts/browser-service.mjs'),'utf8');
    const start=source.indexOf('var zY="BROWSER_USE_DISABLE_ROLLOUT_TRACKING"'),end=source.indexOf('l();function XB',start);
    assert.ok(start>=0&&end>start);
    return new Function('ju','$Y','WY','HY','LY','rt','UY','qY','jY','localRolloutReader',source.slice(start,end)+';return Xm;')(
     path,os.homedir,clearTimeout,setTimeout,require('node:fs').watch,e=>{throw e},fs.open,fs.stat,fs.readdir,require('./reader.cjs'));
   }
   test('actual patched tracker preserves transcript fallback and native completion callbacks',()=>fixture(async file=>{
    const Tracker=trackerClass(),rollout=path.join(path.dirname(file),'rollout-test-session.jsonl');
    await fs.writeFile(rollout,event('turn-a')+'\n');let native;const received=[];
    const tracker=new Tracker({env:{BROWSER_USE_ROLLOUT_SESSIONS_ROOT:path.dirname(file)},addTurnEndedHandler(h){native=h;return()=>{};}});
    try {
     await tracker.track({session_id:'session',turn_id:'turn-a'},async event=>received.push(event));
     assert.deepEqual(received,[{session_id:'session',turn_id:'turn-a'}]);
     await tracker.track({session_id:'session',turn_id:'turn-b'},async event=>received.push(event));
     await native.run({session_id:'session',turn_id:'turn-b'});
     assert.equal(received.length,2);assert.equal(tracker.sessions.size,0);assert.equal(tracker.watchers.size,0);
    }finally{tracker.dispose();}
   }));
   test('actual patched tracker coalesces concurrent notifications and permits subsequent scans',async()=>{
    const Tracker=trackerClass(),tracker=new Tracker({env:{BROWSER_USE_DISABLE_ROLLOUT_TRACKING:'1'}});
    let runs=0,release;tracker.processRollouts=async()=>{runs++;await new Promise(r=>{release=r;});};
    const first=tracker.queueProcessing();await Promise.resolve();for(let i=0;i<100;i++)assert.equal(tracker.queueProcessing(),first);
    release();await first;assert.equal(runs,1);const second=tracker.queueProcessing();await Promise.resolve();release();await second;assert.equal(runs,2);tracker.dispose();
   });

   benchmark.cjs

   const fs=require('node:fs/promises'),os=require('node:os'),path=require('node:path');
   const {readRollout}=require('./reader.cjs');
   (async()=>{const dir=await fs.mkdtemp(path.join(os.tmpdir(),'rollout-memory-'));try{
    const file=path.join(dir,'synthetic.jsonl'),handle=await fs.open(file,'w');const b=Buffer.alloc(65536,120);
    await handle.write('{"type":"event_msg","payload":{"type":"task_complete","text":"');
    const mib=Number(process.argv[2]||256);for(let i=0;i<mib*16;i++)await handle.write(b);
    await handle.write('","turn_id":"test-turn"}}\n');await handle.close();
    const state={activeTurnIds:new Map([[()=>{},'test-turn']]),fileOffset:0,pendingFragment:''};
    const start=performance.now();let calls=0,found=false;const size=(await fs.stat(file)).size;
    while(state.fileOffset<size){const result=await readRollout(file,state);Object.assign(state,result);calls++;found ||=result.completedTurnIds.has('test-turn');}
    if(!found)throw Error('Lifecycle event missing');
    console.log(JSON.stringify({fixtureMiB:mib,calls,elapsedMs:Math.round(performance.now()-start),maxRssMiB:Math.round(process.resourceUsage().maxRSS/1024),heapMiB:Math.round(process.memoryUsage().heapUsed/1048576),externalMiB:Math.round(process.memoryUsage().external/1048576)}));
    }finally{await fs.rm(dir,{recursive:true,force:true});}})().catch(e=>{console.error(e);process.exitCode=1});

   build.py

   from pathlib import Path
   import shutil,hashlib,json
   root=Path(__file__).resolve().parent
   original=Path('/Applications/ChatGPT.app/Contents/Resources/cua_node/lib/node_modules/@oai/browser-desktop')
   s=(original/'scripts/browser-service.mjs').read_text()
   start=s.index('async function JY(');end=s.index('async function GB(',start)
   expected='s.push(m.subarray(0,h))'
   assert expected in s[start:end] and 'VB.concat(s).toString("utf8")' in s[start:end]
   old_queue='queueProcessing(){return this.processing=this.processing.then(async()=>this.processRollouts()).catch(()=>Uo()),this.processing}'
   assert s.count(old_queue)==1
   queue='queueProcessing(){if(this.localRolloutQueued)return this.processing;this.localRolloutQueued=true;return this.processing=this.processing.then(async()=>{try{await this.processRollouts()}finally{this.localRolloutQueued=false}}).catch(()=>{this.localRolloutQueued=false;Uo()}),this.processing}'
   patched='import localRolloutReader from "../../reader.cjs";\n'+s[:start]+'async function JY(t,e){return localRolloutReader.readRollout(t,e)}'+s[end:]
   patched=patched.replace(old_queue,queue)
   runtime=root/'runtime'
   assert not runtime.exists(),'Existing build; inspect before replacing'
   shutil.copytree(original,runtime)
   (runtime/'scripts/browser-service.mjs').write_text(patched)
   (root/'node_modules/classic-level').symlink_to(original.parent.parent/'classic-level',target_is_directory=True)
   metadata={'originalPath':str(original/'scripts/browser-service.mjs'),'originalSha256':hashlib.sha256(s.encode()).hexdigest(),'patchedSha256':hashlib.sha256(patched.encode()).hexdigest(),'pluginVersion':'26.901.51231'}
   (root/'build.json').write_text(json.dumps(metadata,indent=2)+'\n')
   (root/'original-reader.js').write_text(s[start:end]+'\n')
   print(json.dumps(metadata))
6. kernelpanic888 commented on Sep 14, 2026

   

   kernelpanic888

   on Sep 14, 2026

   More actions

   Issue: #38611.

   This reviews the streaming-reader proposal by jsegeren. It is NOT a claim to have patched or reproduced the currently installed browser helper. The original high-memory retry mechanism and the proposed streaming design were already documented by others.

   New small counterexample for the proposed reader

   The proposal's test oracle uses JSON.parse to reject malformed records. With its pinned stream-json 1.9.1 parser, a non-breaking space before a colon is accepted as whitespace and a completion is emitted:

   const line = '{"type"\u00a0:"event_msg","payload":{"type":"task_complete","turn_id":"turn-a"}}';
   JSON.parse(line); // throws
   // Proposed readRollout emits turn-a when it is active and the line is newline-terminated.

   The stream-json parser uses JavaScript \s in structural-whitespace patterns, which is broader than JSON's space/tab/CR/LF. Of 20 small cases, 15 agree with the strict oracle and five do not: BOM prefix, NBSP before a colon, vertical tab suffix, form-feed suffix and thin space before a comma. BOM tolerance may be a deliberate interoperability policy; the internal NBSP/thin-space cases provide the less ambiguous grammar mismatch. The observation is about compatibility with the stated JSON.parse oracle, not evidence of a security exploit or the original memory bug.

   Local review candidate

   A small incremental byte guard before the parser rejects non-ASCII bytes and non-JSON controls outside quoted strings, retaining only quoted/escaped state across chunks. Inside strings it leaves UTF-8 and escapes to the actual parser. It is not a replacement JSON parser and does not collect the whole line.

   The unchanged reference reader and the local derived candidate were both tested with Node 24.19.0 and --max-old-space-size=64:

   • 20 cases total: UTF-8 split over small chunks, escaped identifiers, duplicate keys, malformed syntax, non-JSON whitespace, allowed whitespace inside strings, partial append, excessive depth and a large ignored string before the lifecycle ID.
   • Original proposal: 15/20 agree; derived candidate: 20/20 agree.
   • The large synthetic record is 2 MiB, not a live or gigabyte-scale transcript. Both implementations recover the ID after the large string in 257 scans, with at most 8192 bytes advanced per pass. Peak RSS was 62 MiB for each in the recorded final run.

   Tests and the independent guard: reader-audit/reader-probe.cjs, reader-audit/strict-json-syntax.cjs. The candidate builder is hash-guarded. Dependencies were fetched from their pinned npm releases with SHA-512 validation; no package lifecycle or posted plugin-integration script was executed.

   Before adopting the upstream streaming proposal, please make the intended malformed-record contract explicit and add this counterexample. The separate product work still needs verification of cancellation/disposal, scheduling/coalescing, file replacement, lifecycle callbacks and bounded memory on representative workloads. These tests do not cover all those properties and do not imply that #38611 is fixed.

   Reference reader authorship remains with jsegeren and its dependencies' authors. Alexey Salkutsan selected this investigation; Lina, an AI assistant, prepared and ran the independent tests and authored the small strict-syntax guard. No runtime patch was installed.

   Reproducer package

   Download the synthetic reproductions and reader audit. The same small packet supports this issue and the related investigations in #43017, #43129 and #38611. It contains no personal histories, databases, raw RPC logs or bundled executable. Original third-party reader code is fetched by the setup with a pinned hash and attribution.

   Verified after extraction into a clean directory on macOS arm64 with Node 24.19.0. Read README_EN.md, then run node bootstrap.mjs and node verify.mjs --portable; setup downloads pinned public dependencies and the official binary. The clean verification used the already downloaded, hash-verified official binary archive with --archive; it fetched the reader and npm dependencies afresh. Linux, Windows and the uncached binary-download branch were not tested. The ZIP contains the earlier preparation drafts, whose NOT SENT headings describe the pre-publication snapshot.

   ZIP SHA-256: 2d60212455f72dddfd52410b3c8cc55e826ba2900e0813e26c070d65566972fb.