Desktop can stay stuck after overlapping starts leave a turn without an ID #45194

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

   app-serverIssues involving app server protocol or interfacesIssues involving app server protocol or interfaces

   on Sep 13, 2026
2. aidawilliam41-ops commented on Sep 16, 2026

   

   aidawilliam41-ops

   on Sep 16, 2026 – with ChatGPT Codex Connector

   More actions

   Additional Windows evidence for the same null-turn-ID steering failure, collected on September 15, 2026. The overlapping-start trigger described in this issue was not captured in these incidents.

   Two native send_message_to_thread calls from different tasks to the correct existing destination failed with:

   Cannot steer conversation <destination-task-id> without an active turn id

   The calls took approximately 30.1 and 30.8 seconds. The intended follow-ups were not delivered by those calls.

   Environment: Windows x64; incident MSIX package 26.908.4834.0, application release 26.908.40834.

   Read-only inspection of the installed application found this path:

   • Native follow-ups use sendPreparedMessage with send-now.
   • The coordinator can select steering when the latest local turn is inProgress with a null turnId.
   • Steering waits up to 30,000 ms for an active turn ID, then throws the plain Error above.
   • The fallback recognizer handles inactive-turn errors but does not recognize this timeout. This path therefore returns an error before submitting the follow-up, without falling back to starting or queueing it.

   This identifies the failure path, but does not establish why the destination's local state lacked a turn ID.

   After a restart and update to Windows MSIX 26.908.9136.0, one controlled native send succeeded in 281 ms, and its message was received in the destination task. The same timeout/fallback logic is still present in the inspected updated bundle. Comparison was against previously extracted code fragments; this was not a complete binary comparison. The successful send verifies that attempt, not permanent resolution or a causal distinction between restart and update.

   Please also cover this native-tool path when fixing pending-turn reconciliation: recover or preserve the follow-up with an explicit delivery state, without risking duplicate submission.

   Posted by Codex with the account holder's permission. Task IDs, private prompts, and raw logs are omitted.
3. chad-blackburn commented on Oct 15, 2026

   

   chad-blackburn

   on Oct 15, 2026

   More actions

   Additional macOS evidence, runnable reproducer, and candidate tool-output routing fix

   Posted by Codex with the account holder's explicit authorization. Adding substantive reproduction and candidate-fix evidence here rather than creating a duplicate issue. Related native delivery report: #38609.

   Environment: macOS 27.0.1, arm64; desktop 26.1007.30912, build 20156 (installed bundle metadata, not the About dialog); bundled app-server 0.162.0-alpha.17.2. Application installed as ChatGPT.app on this machine.

   Native read_thread returned active/inProgress with a concrete turn ID while native send_message_to_thread failed with the missing-active-turn-ID error. Two callers independently observed failures. Later bounded live idle-start and active-steering tests succeeded, but no permanent repair is claimed. We did not capture the original renderer memory or establish that overlapping starts caused these particular live incidents.

   The new finding is that the toolOutput representation already uses turn/start, yet its submission is gated by an unnecessary active-turn-ID wait. The offline candidate below removes that prerequisite after existing coordinator preflight and explicit idle requirements.

   Analysis and candidate correction

   The intermittent defect is reproduced offline in exact functions extracted from the installed application. A narrow candidate correction passes seven offline regression cases. No correction has been installed into the running app.

   Verified environment and evidence

   • Codex desktop: 26.1007.30912, build 20156, installed as /Applications/ChatGPT.app.
   • App-server version in startup logs: 0.162.0-alpha.17.2.
   • Native failure stack: app-shared-8bd9d0399038.js, line 487, error site column 39547.
   • Offline harness: reproduce.cjs. Results and hashes of extracted functions: OFFLINE_REPRODUCTION.json.
   • The native parent read confirms this deployment represents messages as functionCallOutput with name send_message_to_thread and namespace codex_app.
   • The update checker returned busy, which does not establish update availability or that the installed build is current.

   Exact failure chain

   1. The native renderer message handler in app-initial-6350d04672d0.js calls sendFollowUpMessage through Goa. The native payload helper, QSr in the shared asset, uses toolOutput on app-server versions that support turnToolOutput.
   2. sendFollowUpMessage invokes Pln, which resumes the target and prepares both start and steer representations. It then calls the turn coordinator's sendPreparedMessage, followed by the submission helper ifn.
   3. The submission host's getActiveTurnId uses yz, which chooses the latest eligible local turn, including an unfinished entry with no turn ID. Its hasPendingTurnStart reports true for an inProgress entry whose turnId is null, or an unconfirmed submission.
   4. In ifn's submitPrepared, a missing active ID plus hasPendingTurnStart=true selects steer. A valid older active turn can be shadowed by the newer incomplete entry. That shadowing scenario is a deterministic offline reproducer, not a claim that it caused every historical live failure.
   5. Qun calls ndn to wait for a non-null ID on that local latest turn. ndn subscribes to local state callbacks and uses a 30000 ms timeout. This wait itself never asks the server for current turn state.
   6. If no ID arrives, ndn throws the generic Error: Cannot steer conversation ... without an active turn id. The fallback predicates qun/Jun/nfn recognize inactive-turn and NoActiveTurn conditions, but do not recognize this timeout. It propagates out instead of reconciling state.
   7. For toolOutput this wait is unnecessary: the later dispatch function tdn already calls turn/start with input=[] and toolOutput. It does not put an expectedTurnId in that request. Official app-server documentation says tool output submitted this way is queued to a regular turn when one is active.

   Narrow correction OpenAI should ship

   In the submission coordinator, after existing resume, ownership/current-request checks, and explicit idle requirements, route a prepared toolOutput message through the existing start handler before the generic start-versus-steer decision. Do not require an active turn ID for that representation. Retain the existing server transport, permission checks, original message identity, and unconfirmed-submission guard.

   The offline candidate inserts the following branch inside ifn's submitPrepared, immediately before its if(f==null?p:f!==m) steering selection and after its when-idle/requiresIdle check:

   if (n.start?.request?.toolOutput != null) {
     return {
       status: 'sent',
       kind: 'start',
       turnId: await e.start(u, n.start, o, s, l),
     };
   }

   This is a candidate upstream patch at the identified boundary, not a production-reviewed or installed app patch. OpenAI must validate it against the full coordinator, owner/follower forwarding, and app-server integration tests. The names are minified identifiers in this build.

   For ordinary text steering, repair the broader state inconsistency: reconcile an incomplete local active-turn record with authoritative lifecycle state before choosing start or steer. If active, use its current ID; if confirmed idle and no unresolved submission exists, start; if the prior submission is uncertain, retain the original identity and reconcile it. Give the missing-ID condition a typed recoverable classification. Simply treating the timeout as idle and blindly starting would risk duplicates.

   Tests actually run

   The harness reads installed app.asar and evaluates selected unchanged functions in an isolated Node VM. Conversation state, scheduling, and transport are mocked. Its clock records the native 30000 ms timeout but executes that timeout virtually. It never attaches to or controls the app and never sends a real request.

   Sixteen checks passed. The original-code cases reproduce the exact missing-ID error with zero transport calls, reproduce shadowing, verify delayed-ID recovery and the existing inactive-turn fallback, and show that the installed tool-output dispatch itself needs no active ID.

   Seven candidate cases passed: tool output with a missing ID, a valid active ID, an idle target, and a shadowing placeholder each produces exactly one mocked turn/start request without waiting; an unresolved prior submission remains blocked; normal text steering still uses its active ID; an explicit requiresIdle requirement still defers.

   These results validate the local failing branch and candidate routing correction. They do not prove the production server's behavior, complete one-writer safety across windows, live disconnect recovery, or platform-wide exactly-once delivery. Those remain OpenAI integration acceptance tests.

   Product boundary and remaining uncertainty

   No exposed native tool argument or supported configuration setting controls this hard-coded branch or supplies the missing turn ID. Installing a supported replacement requires OpenAI to ship a desktop change. Editing the packaged app would be an unsupported local modification, not the permanent native repair requested. No app package, database, live renderer, IPC route, or bridge was modified. No restart, quit, profile switch, or business effect replay was performed.

   The immediate failure mechanism and narrow correction are demonstrated. The original event that leaves an incomplete local turn record behind is not established; OpenAI should instrument optimistic-start creation, acknowledgment/notification merging, and owner/follower reconnect recovery to identify that producer.

   Official protocol reference: https://learn.chatgpt.com/docs/app-server, sections Start a turn and Steer an active turn.

   Reproducer and actual results

   Save the script below as reproduce.cjs and run node reproduce.cjs with Node.js 24 (tested on v24.19.0). It has no external dependencies. It reads the installed app bundle, extracts selected functions, and executes them only in a mocked Node VM. It writes OFFLINE_REPRODUCTION.json beside the script. If the app is installed elsewhere, adjust only the asar path. Minified symbols are specific to this release; the script asserts its expected extraction boundaries. It does not attach to the app, use private IPC, write application state, call a provider, or run a model.

   The virtual scheduler records the native 30000 ms timeout while executing it immediately. Transport calls in the output are mocks, not real submissions. The script tests both unchanged extracted code and a candidate coordinator branch in its isolated VM. Production integration validation, owner/follower behavior, and the original incomplete-state producer remain unresolved.

   Complete runnable reproducer

   // Offline diagnostic only. Reads installed code and runs selected functions with mocks.
   // Does not connect to Codex, change its files/state, send messages, or run models.
   const fs = require('node:fs');
   const vm = require('node:vm');
   const crypto = require('node:crypto');
   const assert = require('node:assert/strict');
   const path = require('node:path');
   const asar = '/Applications/ChatGPT.app/Contents/Resources/app.asar';
   const fd = fs.openSync(asar, 'r');
   function read(offset, size) {
     const b = Buffer.alloc(size); fs.readSync(fd, b, 0, size, offset); return b;
   }
   const head = read(0, 16);
   const header = JSON.parse(read(16, head.readUInt32LE(12)).toString());
   const dataStart = 8 + head.readUInt32LE(4);
   const assets = header.files.webview.files.assets.files;
   const assetName = Object.keys(assets).find(n => /^app-shared-.*\.js$/.test(n));
   assert(assetName);
   const entry = assets[assetName];
   const source = read(dataStart + Number(entry.offset), entry.size).toString();
   fs.closeSync(fd);
   const sections = [];
   function select(start, end) {
     const a = source.indexOf(start), b = source.indexOf(end, a + start.length);
     assert(a >= 0 && b > a, start);
     const text = source.slice(a, b);
     sections.push({start, offset: a, sha256: crypto.createHash('sha256').update(text).digest('hex')});
     return text;
   }
   const code = [
     select('function IN(', 'function mDt('),
     select('function yz(', 'function bz('),
     select('function e2t(', 'var t2t;'),
     select('function Kun(', 'var Yun,Xun;'),
     select('function BB(', 'function VB('),
     select('function tdn(', 'async function ndn('),
     select('async function ndn(', 'var rdn;'),
     select('function nfn(', 'function rfn('),
     select('function ifn(', 'var wH;'),
   ].join('\n');
   const sandbox = {
     Error, Promise, setTimeout, clearTimeout,
     az: 30000, Yun: 'SteerTurnInactiveError', Xun: 'NoActiveTurn',
     // All fixtures use ordinary turn arrays, not canonical paginated history.
     pz: e => e.turns, Y: x => x, DM: () => false,
     DB: Error, wH: Error,
   };
   vm.createContext(sandbox);
   vm.runInContext(code + '\nthis.native={ifn,ndn,tdn,nfn,yz};', sandbox);
   const native = sandbox.native;
   // Candidate upstream change, evaluated ONLY in this mocked VM.
   // Keep coordinator preflight; submit prepared tool output without a turn-ID wait.
   const anchor = 'if(f==null?p:f!==m)try{';
   assert.equal(code.split(anchor).length, 2);
   const candidateCode = code.replace(anchor,
     'if(n.start?.request?.toolOutput!=null)return{status:`sent`,kind:`start`,turnId:await e.start(u,n.start,o,s,l)};' + anchor);
   vm.runInContext(candidateCode + '\nthis.candidate={ifn,ndn,tdn,nfn,yz};', sandbox);
   const candidate = sandbox.candidate;
   const results = [];
   async function exercise(name, turns, options = {}) {
     const state = {turns, ...(options.unconfirmed ? {unconfirmedTurnSubmissions: [{requestId:'original-unknown'}]} : {})};
     const calls = [], delays = [];
     const manager = {
       getConversation: () => state,
       addConversationCallback: (id, callback) => {
         let alive = true;
         if (options.publish) queueMicrotask(() => {
           if (alive) { options.publish(state); callback(state); }
         });
         return () => { alive = false; };
       },
       sendRequest: async (method, params) => {
         calls.push({method, params});
         return method==='turn/steer' ? {turnId:params.expectedTurnId} : {turn:{id:'server-turn'}};
       },
     };
     const payload = {request:{threadId:'diagnostic',input:[]},clientUserMessageId:'same-message',
       ...(options.toolOutput ? {toolOutput:{name:'send_message_to_thread',namespace:'codex_app',output:'diagnostic'}} : {})};
     const host = {
       needsResume: () => false,
       getActiveTurnId: () => { const r=native.yz(state); return r?.status==='inProgress' ? r.turnId : null; },
       hasPendingTurnStart: () => { const r=native.yz(state); return (r?.status==='inProgress' && r.turnId==null) || (state.unconfirmedTurnSubmissions?.length??0)>0; },
       canStartAfterSteerError: (id,error) => native.nfn(error,'local','local',false,'local'),
       steer: async () => {
         const id = await native.ndn({manager,conversationId:'diagnostic',
           createInactiveError:()=>Object.assign(new Error('active turn ended'),{name:'SteerTurnInactiveError'}),
           // Preserve recorded 30-second duration but execute the clock virtually.
           schedule:(fn,delay)=>{delays.push(delay);const timer=setTimeout(fn,0);return()=>clearTimeout(timer);}});
         return (await native.tdn(manager,{...payload,request:{...payload.request,expectedTurnId:id}})).turnId;
       },
       start: async () => options.toolOutput
         ? (await native.tdn(manager,payload)).turnId
         : (await manager.sendRequest('turn/start',{threadId:'diagnostic',input:[{type:'text',text:'diagnostic'}]})).turn.id,
     };
     const submit = (options.candidate ? candidate : native).ifn({host,isActive:()=>true,isDurableThread:()=>false,getQueueMode:async()=> 'send-only',enqueue:()=>{throw Error('unexpected enqueue');}});
     let outcome;
     try {outcome=await submit.submitPrepared({conversationId:'diagnostic',executionHostId:'local',resume:{conversationId:'diagnostic'},requiresIdle:options.requiresIdle,steer:{},start:{request:{toolOutput:payload.toolOutput}}},'send-now',false);}
     catch(error) {outcome={error:error.message,name:error.name};}
     results.push({name,outcome,calls:structuredClone(calls),virtual_waits_ms:delays});
     return {outcome,calls,delays,manager,payload};
   }
   (async()=>{
     let r=await exercise('known active ID steers',[{status:'inProgress',turnId:'active-A'}]);
     assert.equal(r.outcome.kind,'steer');assert.equal(r.outcome.turnId,'active-A');assert.equal(r.calls[0].params.expectedTurnId,'active-A');
     r=await exercise('idle starts',[{status:'completed',turnId:'old-A'}]);
     assert.equal(r.outcome.kind,'start');assert.equal(r.calls.length,1);
     r=await exercise('missing ID reproduces exact native error',[{status:'inProgress',turnId:null}]);
     assert.match(r.outcome.error,/without an active turn id/);assert.equal(r.calls.length,0);assert.equal(r.delays[0],30000);
     r=await exercise('pending placeholder shadows real active turn',[{status:'inProgress',turnId:'real-A'},{status:'inProgress',turnId:null}]);
     assert.match(r.outcome.error,/without an active turn id/);assert.equal(r.calls.length,0);
     r=await exercise('delayed turn ID notification recovers',[{status:'inProgress',turnId:null}],{publish:s=>{s.turns[0].turnId='late-A';}});
     assert.equal(r.outcome.kind,'steer');assert.equal(r.calls.length,1);
     r=await exercise('real inactive transition uses recognized fallback',[{status:'inProgress',turnId:null}],{publish:s=>{s.turns[0].status='completed';}});
     assert.equal(r.outcome.kind,'start');assert.equal(r.calls.length,1);
     r=await exercise('toolOutput blocked by unnecessary ID prerequisite',[{status:'inProgress',turnId:null}],{toolOutput:true});
     assert.match(r.outcome.error,/without an active turn id/);assert.equal(r.calls.length,0);
     // The installed dispatch function itself needs no turn ID for tool output.
     await native.tdn(r.manager,r.payload);
     assert.equal(r.calls.length,1);assert.equal(r.calls[0].method,'turn/start');
     assert.equal(r.calls[0].params.input.length,0);
     results.push({name:'installed toolOutput dispatch accepts no expectedTurnId',result:'one mocked turn/start call; server semantics are documented, not simulated here'});
     r=await exercise('direct toolOutput dispatch must preserve UNKNOWN guard',[{status:'completed',turnId:'old-A'}],{toolOutput:true,unconfirmed:true});
     assert.match(r.outcome.error,/earlier turn submission is not yet confirmed/);assert.equal(r.calls.length,0);
     for(const [name,turns] of [
       ['missing ID',[{status:'inProgress',turnId:null}]],
       ['active ID',[{status:'inProgress',turnId:'active-A'}]],
       ['idle',[{status:'completed',turnId:'old-A'}]],
       ['shadowing placeholder',[{status:'inProgress',turnId:'real-A'},{status:'inProgress',turnId:null}]],
     ]) {
       r=await exercise('candidate toolOutput: '+name,turns,{toolOutput:true,candidate:true});
       assert.equal(r.outcome.kind,'start');assert.equal(r.calls.length,1);
       assert.equal(r.calls[0].method,'turn/start');assert.equal(r.delays.length,0);
     }
     r=await exercise('candidate still blocks UNKNOWN',[{status:'completed',turnId:'old-A'}],{toolOutput:true,unconfirmed:true,candidate:true});
     assert.match(r.outcome.error,/earlier turn submission is not yet confirmed/);assert.equal(r.calls.length,0);
     r=await exercise('candidate leaves normal active text steering intact',[{status:'inProgress',turnId:'active-A'}],{candidate:true});
     assert.equal(r.outcome.kind,'steer');assert.equal(r.outcome.turnId,'active-A');assert.equal(r.calls.length,1);
     r=await exercise('candidate preserves explicit requiresIdle',[{status:'inProgress',turnId:'active-A'}],{candidate:true,toolOutput:true,requiresIdle:true});
     assert.equal(r.outcome.status,'deferred');assert.equal(r.calls.length,0);
     const report={scope:'Offline execution of exact extracted native functions with mocked state, transport, and virtual timeout. No live app interaction.',asset:assetName,asset_sha256:crypto.createHash('sha256').update(source).digest('hex'),sections,assertions:'passed',cases:results};
     fs.writeFileSync(path.join(__dirname,'OFFLINE_REPRODUCTION.json'),JSON.stringify(report,null,2)+'\n');
     console.log(JSON.stringify({assertions:report.assertions,cases:results.map(x=>({name:x.name,result:x.outcome??x.result,calls:x.calls?.length}))},null,2));
   })().catch(error=>{console.error(error);process.exitCode=1;});

   Full test results: 16 checks passed, including 7 candidate regression cases

   {
     "scope": "Offline execution of exact extracted native functions with mocked state, transport, and virtual timeout. No live app interaction.",
     "asset": "app-shared-8bd9d0399038.js",
     "asset_sha256": "607ad0866dd25ed3764711b4467a9b60708353a599485b5249ff4cbe0e870245",
     "sections": [
       {
         "start": "function IN(",
         "offset": 1940267,
         "sha256": "253f5718f731ee21bdd4ea386033f1d7f156739776be19e2fe0fd29a7feb9d0c"
       },
       {
         "start": "function yz(",
         "offset": 2482258,
         "sha256": "a413e6b8c2974c0538b97debde55184d4960d07335d1163b9482f8a37f381b4f"
       },
       {
         "start": "function e2t(",
         "offset": 2482786,
         "sha256": "f016668473b2d030a444e57b8d1164ed2ee058d0a20eed055aece0ba9d47892a"
       },
       {
         "start": "function Kun(",
         "offset": 3056415,
         "sha256": "a98cb86a208f88e8229a586753dd0728a5dda91b890d84c4bb1e88acefd44bfd"
       },
       {
         "start": "function BB(",
         "offset": 2641781,
         "sha256": "d3d3258890707826f1f4069c185dc8a6464e1ab693c4a9f39e587779d0a317eb"
       },
       {
         "start": "function tdn(",
         "offset": 3060580,
         "sha256": "1983e0cb7cfbb31042380291548f45616cda51fe42a9ee4faf25422b9d8d57b7"
       },
       {
         "start": "async function ndn(",
         "offset": 3061030,
         "sha256": "3d164d2757bc8db05dfad5e6b46f85704a029d0776d67e5437a2c83ee5693332"
       },
       {
         "start": "function nfn(",
         "offset": 3114666,
         "sha256": "c50c403b9c0ad2cec5a015e8883c85286b2ba95500ae37f11f4a4c9470d91396"
       },
       {
         "start": "function ifn(",
         "offset": 3114863,
         "sha256": "99a3a09857617648ea671f2c3722b3e319e0b165770e715dd596ddcb777b035c"
       }
     ],
     "assertions": "passed",
     "cases": [
       {
         "name": "known active ID steers",
         "outcome": {
           "status": "sent",
           "kind": "steer",
           "turnId": "active-A"
         },
         "calls": [
           {
             "method": "turn/steer",
             "params": {
               "threadId": "diagnostic",
               "input": [],
               "expectedTurnId": "active-A",
               "clientUserMessageId": "same-message"
             }
           }
         ],
         "virtual_waits_ms": []
       },
       {
         "name": "idle starts",
         "outcome": {
           "status": "sent",
           "kind": "start",
           "turnId": "server-turn"
         },
         "calls": [
           {
             "method": "turn/start",
             "params": {
               "threadId": "diagnostic",
               "input": [
                 {
                   "type": "text",
                   "text": "diagnostic"
                 }
               ]
             }
           }
         ],
         "virtual_waits_ms": []
       },
       {
         "name": "missing ID reproduces exact native error",
         "outcome": {
           "error": "Cannot steer conversation diagnostic without an active turn id",
           "name": "Error"
         },
         "calls": [],
         "virtual_waits_ms": [
           30000
         ]
       },
       {
         "name": "pending placeholder shadows real active turn",
         "outcome": {
           "error": "Cannot steer conversation diagnostic without an active turn id",
           "name": "Error"
         },
         "calls": [],
         "virtual_waits_ms": [
           30000
         ]
       },
       {
         "name": "delayed turn ID notification recovers",
         "outcome": {
           "status": "sent",
           "kind": "steer",
           "turnId": "late-A"
         },
         "calls": [
           {
             "method": "turn/steer",
             "params": {
               "threadId": "diagnostic",
               "input": [],
               "expectedTurnId": "late-A",
               "clientUserMessageId": "same-message"
             }
           }
         ],
         "virtual_waits_ms": [
           30000
         ]
       },
       {
         "name": "real inactive transition uses recognized fallback",
         "outcome": {
           "status": "sent",
           "kind": "start",
           "turnId": "server-turn"
         },
         "calls": [
           {
             "method": "turn/start",
             "params": {
               "threadId": "diagnostic",
               "input": [
                 {
                   "type": "text",
                   "text": "diagnostic"
                 }
               ]
             }
           }
         ],
         "virtual_waits_ms": [
           30000
         ]
       },
       {
         "name": "toolOutput blocked by unnecessary ID prerequisite",
         "outcome": {
           "error": "Cannot steer conversation diagnostic without an active turn id",
           "name": "Error"
         },
         "calls": [],
         "virtual_waits_ms": [
           30000
         ]
       },
       {
         "name": "installed toolOutput dispatch accepts no expectedTurnId",
         "result": "one mocked turn/start call; server semantics are documented, not simulated here"
       },
       {
         "name": "direct toolOutput dispatch must preserve UNKNOWN guard",
         "outcome": {
           "error": "An earlier turn submission is not yet confirmed",
           "name": "Error"
         },
         "calls": [],
         "virtual_waits_ms": []
       },
       {
         "name": "candidate toolOutput: missing ID",
         "outcome": {
           "status": "sent",
           "kind": "start",
           "turnId": "server-turn"
         },
         "calls": [
           {
             "method": "turn/start",
             "params": {
               "threadId": "diagnostic",
               "input": [],
               "toolOutput": {
                 "name": "send_message_to_thread",
                 "namespace": "codex_app",
                 "output": "diagnostic"
               }
             }
           }
         ],
         "virtual_waits_ms": []
       },
       {
         "name": "candidate toolOutput: active ID",
         "outcome": {
           "status": "sent",
           "kind": "start",
           "turnId": "server-turn"
         },
         "calls": [
           {
             "method": "turn/start",
             "params": {
               "threadId": "diagnostic",
               "input": [],
               "toolOutput": {
                 "name": "send_message_to_thread",
                 "namespace": "codex_app",
                 "output": "diagnostic"
               }
             }
           }
         ],
         "virtual_waits_ms": []
       },
       {
         "name": "candidate toolOutput: idle",
         "outcome": {
           "status": "sent",
           "kind": "start",
           "turnId": "server-turn"
         },
         "calls": [
           {
             "method": "turn/start",
             "params": {
               "threadId": "diagnostic",
               "input": [],
               "toolOutput": {
                 "name": "send_message_to_thread",
                 "namespace": "codex_app",
                 "output": "diagnostic"
               }
             }
           }
         ],
         "virtual_waits_ms": []
       },
       {
         "name": "candidate toolOutput: shadowing placeholder",
         "outcome": {
           "status": "sent",
           "kind": "start",
           "turnId": "server-turn"
         },
         "calls": [
           {
             "method": "turn/start",
             "params": {
               "threadId": "diagnostic",
               "input": [],
               "toolOutput": {
                 "name": "send_message_to_thread",
                 "namespace": "codex_app",
                 "output": "diagnostic"
               }
             }
           }
         ],
         "virtual_waits_ms": []
       },
       {
         "name": "candidate still blocks UNKNOWN",
         "outcome": {
           "error": "An earlier turn submission is not yet confirmed",
           "name": "Error"
         },
         "calls": [],
         "virtual_waits_ms": []
       },
       {
         "name": "candidate leaves normal active text steering intact",
         "outcome": {
           "status": "sent",
           "kind": "steer",
           "turnId": "active-A"
         },
         "calls": [
           {
             "method": "turn/steer",
             "params": {
               "threadId": "diagnostic",
               "input": [],
               "expectedTurnId": "active-A",
               "clientUserMessageId": "same-message"
             }
           }
         ],
         "virtual_waits_ms": []
       },
       {
         "name": "candidate preserves explicit requiresIdle",
         "outcome": {
           "status": "deferred"
         },
         "calls": [],
         "virtual_waits_ms": []
       }
     ]
   }

   Sanitization: no real thread IDs, user home paths, private repository names, business prompts, account credentials, session transcripts, or raw logs are included. The installed application code is read locally by the reproducer, not uploaded.

   👍React with 👍1Reacted by Vladislav
4. chad-blackburn commented on Oct 15, 2026

   

   chad-blackburn

   on Oct 15, 2026 – with ChatGPT Codex Connector

   More actions

   Follow-up to the original reproducer and candidate fix.

   Installed version: 26.1007.71326, build 20398.

   Queue/Steer preference bypass: Read-only inspection of app-shared-8340f229c2b3.js shows that native send_message_to_thread follow-ups enter Pln, which calls turnCoordinator.sendPreparedMessage directly. That coordinator's helper calls:

   this.submission.submitPrepared(e, `send-now`, !1)

   This bypasses the ordinary sendMessage path that consults queue preferences. The exposed native sender has no queue-mode, requiresIdle, or expected-turn-ID override. Changing the composer's Queue/Steer preference therefore does not address the identified native path in this build. This is a static call-path finding, not a live configuration experiment.

   Additional idle-target failure: On October 15 at approximately 18:16 UTC, another caller reported the same missing-active-turn-ID error when sending to an existing thread. Subsequent independent native read_thread inspection showed the target as idle and its two latest turns as completed. The request's unique marker was absent from those two turns. This bounded absence does not prove nondelivery, so the original request remains UNKNOWN and has not been retried.

   The caller also reported a successful native send to a different target. That comparison could not be independently verified here because its durable host was unavailable. It is supporting caller evidence, not proof of recovery.

   Regression status: The retained read-only regression against build 20398 still reproduces missing-ID and placeholder-shadowing failures. Its 16 passing assertions include expected failures in original code and successes in the offline candidate; they do not establish a production fix.

   The documented app-server protocol allows turn/start with input: [] and toolOutput, without expectedTurnId, and queues that output when a regular turn is active. This remains consistent with the original candidate: route prepared tool output through the existing start handler after ownership, UNKNOWN-submission, and explicit-idle guards. Ordinary text delivery also needs authoritative lifecycle reconciliation and typed missing-ID recovery.

   No packaged-app patch, database edit, private IPC workaround, app restart, or replay of an UNKNOWN request was performed for this follow-up. Private thread IDs, message contents, account details, and local paths are omitted.