@linzumi/cli 0.0.78-beta → 0.0.79-beta

package/dist/index.js

@@ -3831,6 +3831,15 @@ async function attachChannelSession(args) {
               if (turnTerminalNotificationIsStale(args, state, turnId)) {
                 break;
               }
+              if (rememberPendingStartingTerminalFailure(
+                args,
+                state,
+                threadId,
+                turnId,
+                abortReason(params)
+              )) {
+                break;
+              }
               void failActiveCodexTurn(
                 args,
                 state,
@@ -3856,10 +3865,28 @@ async function attachChannelSession(args) {
             if (turnId !== void 0 && turnTerminalNotificationIsStale(args, state, turnId)) {
               break;
             }
+            if (turnId !== void 0 && rememberPendingStartingTerminalCompletion(
+              args,
+              state,
+              threadId,
+              turnId
+            )) {
+              break;
+            }
             const completedTurnId = turnId ?? inferThreadOnlyCompletedTurnId(args, state, threadId);
             if (completedTurnId !== void 0) {
-              enqueueWebSearchProgressCompletion(args, state, completedTurnId);
-              enqueueFileChangeCompletion(args, state, completedTurnId);
+              enqueueWebSearchProgressCompletion(
+                args,
+                state,
+                completedTurnId,
+                payloadContext
+              );
+              enqueueFileChangeCompletion(
+                args,
+                state,
+                completedTurnId,
+                payloadContext
+              );
               void forwardCompletedCodexTurn(
                 args,
                 state,
@@ -4040,11 +4067,14 @@ function initialChannelSessionState(cursor, rootSeq, kandanThreadId, codexThread
     closed: false,
     minSeq: cursor,
     queue: createPendingKandanMessageQueue(),
+    queueDrainRunning: false,
+    queueDrainRequested: false,
     forwardedTurnIds: /* @__PURE__ */ new Set(),
     forwardingTurnIds: /* @__PURE__ */ new Set(),
     completionForwardingTurnIds: /* @__PURE__ */ new Set(),
     recoveredCompletingTurnIds: /* @__PURE__ */ new Set(),
     pendingInterruptedThreadOnlyCompletions: [],
+    pendingStartingTerminalNotifications: [],
     retryableTurnIds: /* @__PURE__ */ new Set(),
     completedAssistantItemKeys: /* @__PURE__ */ new Set(),
     completedAssistantItemTurns: createBoundedCache(maxForwardedTurnIds),
@@ -5515,6 +5545,21 @@ async function processKandanChatEvent(args, state, runnerIdentity, event, payloa
   }
 }
 async function drainKandanMessageQueue(args, state, payloadContext) {
+  if (state.queueDrainRunning) {
+    state.queueDrainRequested = true;
+    return;
+  }
+  state.queueDrainRunning = true;
+  try {
+    do {
+      state.queueDrainRequested = false;
+      await drainKandanMessageQueueOnce(args, state, payloadContext);
+    } while (state.queueDrainRequested);
+  } finally {
+    state.queueDrainRunning = false;
+  }
+}
+async function drainKandanMessageQueueOnce(args, state, payloadContext) {
   if (state.closed) {
     logQueuedDrainBlocked(args, state, "session_closed");
     return;
@@ -5587,6 +5632,22 @@ async function drainKandanMessageQueue(args, state, payloadContext) {
     state.turn = { status: "active", turnId, queuedSeq: next.seq };
     rememberTurnReplyTarget(state, turnId, next.seq);
     args.log("codex.turn_started", { turn_id: turnId });
+    const pendingStartingTerminal = consumePendingStartingTerminalNotification(
+      state,
+      codexThreadId,
+      turnId,
+      next.seq
+    );
+    if (pendingStartingTerminal !== void 0) {
+      await handlePendingStartingTerminalNotification(
+        args,
+        state,
+        pendingStartingTerminal,
+        turnId,
+        payloadContext
+      );
+      return;
+    }
     if (interruptAfterStart) {
       await recoverInterruptedCodexTurn(
         args,
@@ -5932,7 +5993,12 @@ async function forwardCompletedCodexTurn(args, state, turnId, payloadContext) {
     ).length;
     const completedForwardedAssistantSnapshotCount = forwardedAssistantSnapshotOutputCount(state, messages);
     const completedSourceSeqAssistantItemCount = sourceMessageSeq === void 0 ? 0 : completedAssistantItemForwardedForSourceSeq(state, sourceMessageSeq);
-    const completedStreamingAssistantOutputCount = completedAssistantOutputCount === 0 ? await completeStreamingAssistantOutputsForTurn(args, state, turnId) : 0;
+    const completedStreamingAssistantOutputCount = completedAssistantOutputCount === 0 ? await completeStreamingAssistantOutputsForTurn(
+      args,
+      state,
+      turnId,
+      payloadContext
+    ) : 0;
     const completedAssistantResponseSeen = completedAssistantOutputCount > 0 || completedForwardedAssistantSnapshotCount > 0 || completedSourceSeqAssistantItemCount > 0 || completedStreamingAssistantOutputCount > 0 || completedAssistantItemForwardedForTurn(state, turnId);
     for (const output of completedOutputs) {
       if (completingTurnWasRecovered(state, turnId)) {
@@ -6277,7 +6343,9 @@ function completedMessageSemanticKey(message) {
 function completedSnapshotOutputProjection(state, turnId, message, snapshotIndex) {
   const streamedStructured = resolveStreamingStructuredOutputForCompletedMessage(
     state,
+    turnId,
     message.itemKey,
+    message.body,
     message.structured
   );
   if (streamedStructured !== void 0) {
@@ -6291,6 +6359,8 @@ function completedSnapshotOutputProjection(state, turnId, message, snapshotIndex
         match: {
           kind: "structured",
           itemKey: message.itemKey,
+          streamKey: streamedStructured.streamKey,
+          streamState: streamedStructured.streamState,
           structured: message.structured,
           matchKey: structuredOutputMatchKey(structuredKind, message.itemKey)
         }
@@ -6325,7 +6395,11 @@ function completedSnapshotOutputProjection(state, turnId, message, snapshotIndex
           sortOrder: streamed.output.seq,
           snapshotIndex,
           message,
-          match: { kind: "assistant", itemKey: streamed.output.itemKey }
+          match: {
+            kind: "assistant",
+            itemKey: streamed.output.itemKey,
+            streamKey: streamed.output.streamKey
+          }
         }
       ];
     case "ambiguous":
@@ -6339,7 +6413,7 @@ async function postCompletedOutputProjection(args, state, payloadContext, params
     case "snapshot": {
       switch (params.output.match.kind) {
         case "none":
-          await streamCompletedCodexOutput(args, state, payloadContext, {
+          await (stringValue(params.output.message.structured.kind) === "codex_assistant_message" ? postCompletedCodexOutput : streamCompletedCodexOutput)(args, state, payloadContext, {
             turnId: params.turnId,
             sourceMessageSeq: params.sourceMessageSeq,
             rootSeq: params.rootSeq,
@@ -6347,24 +6421,37 @@ async function postCompletedOutputProjection(args, state, payloadContext, params
           });
           break;
         case "assistant":
-          await editStreamedCodexOutput(
-            args,
-            state,
-            params.output.sortOrder,
-            params.output.message.itemKey,
-            params.output.message.body,
-            "completed"
-          );
+          await postCompletedCodexOutput(args, state, payloadContext, {
+            turnId: params.turnId,
+            sourceMessageSeq: params.sourceMessageSeq,
+            rootSeq: params.rootSeq,
+            message: params.output.message
+          });
+          await streamCodexStructuredOutput(args, state, payloadContext, {
+            turnId: params.turnId,
+            sourceMessageSeq: params.sourceMessageSeq,
+            rootSeq: params.rootSeq,
+            streamKey: params.output.match.streamKey,
+            body: params.output.message.body,
+            structured: codexAssistantStructuredMessage(
+              params.output.match.itemKey,
+              params.output.message.body,
+              "completed"
+            )
+          });
           forgetStreamingAssistantOutput(state, params.output.match.itemKey);
           break;
         case "structured":
-          await editCodexStructuredOutput(
-            args,
-            state,
-            params.output.sortOrder,
-            params.output.message.body,
-            params.output.message.structured
-          );
+          if (params.output.match.streamState === "streaming") {
+            await streamCodexStructuredOutput(args, state, payloadContext, {
+              turnId: params.turnId,
+              sourceMessageSeq: params.sourceMessageSeq,
+              rootSeq: params.rootSeq,
+              streamKey: params.output.match.streamKey,
+              body: params.output.message.body,
+              structured: params.output.message.structured
+            });
+          }
           forgetStreamingStructuredOutput(
             state,
             params.output.match.itemKey,
@@ -6391,13 +6478,14 @@ async function postCompletedOutputProjection(args, state, payloadContext, params
           "completed"
         )
       };
-      await editCodexStructuredOutput(
-        args,
-        state,
-        output.seq,
-        message.body,
-        message.structured
-      );
+      await streamCodexStructuredOutput(args, state, payloadContext, {
+        turnId: params.turnId,
+        sourceMessageSeq: params.sourceMessageSeq,
+        rootSeq: params.rootSeq,
+        streamKey: output.streamKey,
+        body: message.body,
+        structured: message.structured
+      });
       forgetStreamingReasoningOutput(state, output.itemKey);
       logCompletedCodexOutput(args, state, params.turnId, message);
       break;
@@ -6418,13 +6506,14 @@ async function postCompletedOutputProjection(args, state, payloadContext, params
           "completed"
         )
       };
-      await editCodexStructuredOutput(
-        args,
-        state,
-        output.seq,
-        message.body,
-        message.structured
-      );
+      await streamCodexStructuredOutput(args, state, payloadContext, {
+        turnId: params.turnId,
+        sourceMessageSeq: params.sourceMessageSeq,
+        rootSeq: params.rootSeq,
+        streamKey: output.streamKey,
+        body: message.body,
+        structured: message.structured
+      });
       forgetStreamingCommandOutput(state, output.itemKey);
       logCompletedCodexOutput(args, state, params.turnId, message);
       break;
@@ -6441,13 +6530,16 @@ async function postCompletedOutputProjection(args, state, payloadContext, params
           "completed"
         )
       };
-      await editCodexStructuredOutput(
-        args,
-        state,
-        output.seq,
-        message.body,
-        message.structured
-      );
+      if (output.streamState === "streaming") {
+        await streamCodexStructuredOutput(args, state, payloadContext, {
+          turnId: params.turnId,
+          sourceMessageSeq: params.sourceMessageSeq,
+          rootSeq: params.rootSeq,
+          streamKey: output.streamKey,
+          body: message.body,
+          structured: message.structured
+        });
+      }
       forgetStreamingFileChangeOutput(state, output.itemKey);
       logCompletedCodexOutput(args, state, params.turnId, message);
       break;
@@ -6526,11 +6618,12 @@ async function forwardCompletedAssistantItem(args, state, params, payloadContext
     message.body,
     structured
   );
+  const completedSourceMessageSeq = streamed.status === "matched" ? sourceMessageSeq ?? streamed.output.sourceMessageSeq : sourceMessageSeq;
   switch (streamed.status) {
     case "none":
-      await streamCompletedCodexOutput(args, state, payloadContext, {
+      await postCompletedCodexOutput(args, state, payloadContext, {
         turnId: turnId ?? `item:${message.itemKey}`,
-        sourceMessageSeq,
+        sourceMessageSeq: completedSourceMessageSeq,
         rootSeq: state.rootSeq,
         message: {
           ...message,
@@ -6539,14 +6632,23 @@ async function forwardCompletedAssistantItem(args, state, params, payloadContext
       });
       break;
     case "matched":
-      await editStreamedCodexOutput(
-        args,
-        state,
-        streamed.output.seq,
-        message.itemKey,
-        message.body,
-        "completed"
-      );
+      await postCompletedCodexOutput(args, state, payloadContext, {
+        turnId: turnId ?? `item:${message.itemKey}`,
+        sourceMessageSeq: completedSourceMessageSeq,
+        rootSeq: state.rootSeq,
+        message: {
+          ...message,
+          structured
+        }
+      });
+      await streamCodexStructuredOutput(args, state, payloadContext, {
+        turnId: messageTurnId ?? `item:${message.itemKey}`,
+        sourceMessageSeq: completedSourceMessageSeq,
+        rootSeq: state.rootSeq,
+        streamKey: streamed.output.streamKey,
+        body: message.body,
+        structured
+      });
       forgetStreamingAssistantOutput(state, streamed.output.itemKey);
       break;
     case "ambiguous":
@@ -6558,7 +6660,7 @@ async function forwardCompletedAssistantItem(args, state, params, payloadContext
     state,
     message.itemKey,
     messageTurnId,
-    sourceMessageSeq
+    completedSourceMessageSeq
   );
   logCompletedCodexOutput(
     args,
@@ -6652,58 +6754,26 @@ async function forwardAssistantDeltaPayload(args, state, delta, payloadContext)
   if (existing === void 0 && nextContent.trim() === "") {
     return;
   }
-  if (existing === void 0) {
-    const session = args.options.channelSession;
-    const reply = await pushOk2(
-      args.kandan,
-      args.topic,
-      "session:post_thread_message",
-      {
-        workspace: session.workspaceSlug,
-        channel: session.channelSlug,
-        thread_id: state.kandanThreadId,
-        body: nextContent,
-        payload: {
-          ...localRunnerPayload(
-            args.options,
-            args.instanceId,
-            "codex_output",
-            state.codexThreadId,
-            payloadContext,
-            sourceMessageSeq
-          ),
-          ...rootSeq === void 0 ? {} : { reply_to_seq: rootSeq },
-          structured: codexAssistantStructuredMessage(
-            delta.itemKey,
-            nextContent,
-            "streaming"
-          )
-        },
-        client_message_id: streamingClientMessageId(args.instanceId, delta)
-      }
-    );
-    const seq = integerValue(reply.seq);
-    if (seq !== void 0) {
-      rememberStreamingAssistantOutput(state, {
-        itemKey: delta.itemKey,
-        turnId: delta.turnId,
-        sourceMessageSeq,
-        seq,
-        content: nextContent
-      });
-    }
-  } else {
-    await editStreamedCodexOutput(
-      args,
-      state,
-      existing.seq,
+  const streamKey = existing?.streamKey ?? streamingClientMessageId(args.instanceId, delta);
+  const seq = await streamCodexStructuredOutput(args, state, payloadContext, {
+    turnId: delta.turnId,
+    sourceMessageSeq,
+    rootSeq,
+    streamKey,
+    body: nextContent,
+    structured: codexAssistantStructuredMessage(
       delta.itemKey,
       nextContent,
       "streaming"
-    );
+    )
+  }) ?? existing?.seq;
+  if (seq !== void 0) {
     rememberStreamingAssistantOutput(state, {
-      ...existing,
-      sourceMessageSeq: existing.sourceMessageSeq ?? sourceMessageSeq,
+      itemKey: delta.itemKey,
+      turnId: existing?.turnId ?? delta.turnId,
+      sourceMessageSeq: existing?.sourceMessageSeq ?? sourceMessageSeq,
+      seq,
+      streamKey,
       content: nextContent
     });
   }
@@ -6839,9 +6909,9 @@ function enqueueWebSearchProgress(args, state, params, payloadContext) {
     });
   });
 }
-function enqueueWebSearchProgressCompletion(args, state, turnId) {
+function enqueueWebSearchProgressCompletion(args, state, turnId, payloadContext) {
   const previous = state.webSearchProgressForwardChain;
-  const next = previous.catch(() => void 0).then(() => completeWebSearchProgress(args, state, turnId));
+  const next = previous.catch(() => void 0).then(() => completeWebSearchProgress(args, state, turnId, payloadContext));
   state.webSearchProgressForwardChain = next.catch((error) => {
     args.log("codex.web_search_progress_completion_failed", {
       turn_id: turnId,
@@ -6849,9 +6919,9 @@ function enqueueWebSearchProgressCompletion(args, state, turnId) {
     });
   });
 }
-function enqueueFileChangeCompletion(args, state, turnId) {
+function enqueueFileChangeCompletion(args, state, turnId, payloadContext) {
   const previous = state.fileChangeQueue.chain;
-  const next = previous.catch(() => void 0).then(() => completeFileChangeOutputs(args, state, turnId));
+  const next = previous.catch(() => void 0).then(() => completeFileChangeOutputs(args, state, turnId, payloadContext));
   state.fileChangeQueue.chain = next.catch((error) => {
     args.log("codex.file_change_completion_failed", {
       turn_id: turnId,
@@ -6901,58 +6971,28 @@ async function forwardReasoningDeltaPayload(args, state, delta, payloadContext)
   if (existing === void 0 && nextContent.trim() === "") {
     return;
   }
-  if (existing === void 0) {
-    const session = args.options.channelSession;
-    const reply = await pushOk2(
-      args.kandan,
-      args.topic,
-      "session:post_thread_message",
-      {
-        workspace: session.workspaceSlug,
-        channel: session.channelSlug,
-        thread_id: state.kandanThreadId,
-        body: nextContent,
-        payload: {
-          ...localRunnerPayload(
-            args.options,
-            args.instanceId,
-            "codex_output",
-            state.codexThreadId,
-            payloadContext,
-            sourceMessageSeq
-          ),
-          ...state.rootSeq === void 0 ? {} : { reply_to_seq: state.rootSeq },
-          structured: codexReasoningStructuredMessage(
-            delta.itemKey,
-            nextContent,
-            "streaming"
-          )
-        },
-        client_message_id: streamingClientMessageId(args.instanceId, {
-          itemKey: `reasoning:${delta.itemKey}`,
-          turnId
-        })
-      }
-    );
-    const seq = integerValue(reply.seq);
-    if (seq !== void 0) {
-      rememberStreamingReasoningOutput(state, {
-        itemKey: delta.itemKey,
-        turnId,
-        seq,
-        content: nextContent
-      });
-    }
-  } else {
-    await editCodexStructuredOutput(
-      args,
-      state,
-      existing.seq,
+  const streamKey = existing?.streamKey ?? streamingClientMessageId(args.instanceId, {
+    itemKey: `reasoning:${delta.itemKey}`,
+    turnId
+  });
+  const seq = await streamCodexStructuredOutput(args, state, payloadContext, {
+    turnId,
+    sourceMessageSeq,
+    rootSeq: state.rootSeq,
+    streamKey,
+    body: nextContent,
+    structured: codexReasoningStructuredMessage(
+      delta.itemKey,
       nextContent,
-      codexReasoningStructuredMessage(delta.itemKey, nextContent, "streaming")
-    );
+      "streaming"
+    )
+  }) ?? existing?.seq;
+  if (seq !== void 0) {
     rememberStreamingReasoningOutput(state, {
-      ...existing,
+      itemKey: delta.itemKey,
+      turnId: existing?.turnId ?? turnId,
+      seq,
+      streamKey,
       content: nextContent
     });
   }
@@ -7089,60 +7129,27 @@ async function forwardCommandOutputDeltaPayload(args, state, delta, payloadConte
       persisted_length: persistedOutput.length
     });
   }
-  if (existing === void 0) {
-    const session = args.options.channelSession;
-    const reply = await pushOk2(
-      args.kandan,
-      args.topic,
-      "session:post_thread_message",
-      {
-        workspace: session.workspaceSlug,
-        channel: session.channelSlug,
-        thread_id: state.kandanThreadId,
-        body,
-        payload: {
-          ...localRunnerPayload(
-            args.options,
-            args.instanceId,
-            "codex_output",
-            state.codexThreadId,
-            payloadContext,
-            sourceMessageSeq
-          ),
-          ...state.rootSeq === void 0 ? {} : { reply_to_seq: state.rootSeq },
-          structured
-        },
-        client_message_id: streamingClientMessageId(args.instanceId, {
-          itemKey: `command:${delta.itemKey}`,
-          turnId
-        })
-      }
-    );
-    const seq = integerValue(reply.seq);
-    if (seq !== void 0) {
-      rememberStreamingCommandOutput(state, {
-        itemKey: delta.itemKey,
-        turnId,
-        seq,
-        command,
-        output: persistedOutput,
-        processId: delta.processId ?? pending?.processId,
-        stream: delta.stream
-      });
-    }
-  } else {
-    await editCodexStructuredOutput(
-      args,
-      state,
-      existing.seq,
-      body,
-      structured
-    );
+  const streamKey = existing?.streamKey ?? streamingClientMessageId(args.instanceId, {
+    itemKey: `command:${delta.itemKey}`,
+    turnId
+  });
+  const seq = await streamCodexStructuredOutput(args, state, payloadContext, {
+    turnId,
+    sourceMessageSeq,
+    rootSeq: state.rootSeq,
+    streamKey,
+    body,
+    structured
+  }) ?? existing?.seq;
+  if (seq !== void 0) {
     rememberStreamingCommandOutput(state, {
-      ...existing,
+      itemKey: delta.itemKey,
+      turnId: existing?.turnId ?? turnId,
+      seq,
+      streamKey,
       command,
       output: persistedOutput,
-      processId: delta.processId ?? existing.processId,
+      processId: delta.processId ?? existing?.processId ?? pending?.processId,
       stream: delta.stream
     });
   }
@@ -7180,55 +7187,26 @@ async function forwardFileChangeDeltaPayload(args, state, delta, payloadContext)
     "streaming",
     "started"
   );
-  if (existing === void 0) {
-    const session = args.options.channelSession;
-    const reply = await pushOk2(
-      args.kandan,
-      args.topic,
-      "session:post_thread_message",
-      {
-        workspace: session.workspaceSlug,
-        channel: session.channelSlug,
-        thread_id: state.kandanThreadId,
-        body: patchText,
-        payload: {
-          ...localRunnerPayload(
-            args.options,
-            args.instanceId,
-            "codex_output",
-            state.codexThreadId,
-            payloadContext,
-            sourceMessageSeq
-          ),
-          ...state.rootSeq === void 0 ? {} : { reply_to_seq: state.rootSeq },
-          structured
-        },
-        client_message_id: streamingClientMessageId(args.instanceId, {
-          itemKey: `file-change:${delta.itemKey}`,
-          turnId
-        })
-      }
-    );
-    const seq = integerValue(reply.seq);
-    if (seq !== void 0) {
-      rememberStreamingFileChangeOutput(state, {
-        itemKey: delta.itemKey,
-        turnId,
-        seq,
-        patchText
-      });
-    }
-  } else {
-    await editCodexStructuredOutput(
-      args,
-      state,
-      existing.seq,
-      patchText,
-      structured
-    );
+  const streamKey = existing?.streamKey ?? streamingClientMessageId(args.instanceId, {
+    itemKey: `file-change:${delta.itemKey}`,
+    turnId
+  });
+  const seq = await streamCodexStructuredOutput(args, state, payloadContext, {
+    turnId,
+    sourceMessageSeq,
+    rootSeq: state.rootSeq,
+    streamKey,
+    body: patchText,
+    structured
+  }) ?? existing?.seq;
+  if (seq !== void 0) {
     rememberStreamingFileChangeOutput(state, {
-      ...existing,
-      patchText
+      itemKey: delta.itemKey,
+      turnId: existing?.turnId ?? turnId,
+      seq,
+      streamKey,
+      patchText,
+      streamState: "streaming"
     });
   }
   args.log("kandan.codex_file_change_forwarded", {
@@ -7262,56 +7240,34 @@ async function forwardCompletedFileChangePayload(args, state, delta, payloadCont
     "completed"
   );
   const existing = findStreamingFileChangeOutput(state, delta.itemKey);
-  if (existing === void 0) {
-    const session = args.options.channelSession;
-    const reply = await pushOk2(
-      args.kandan,
-      args.topic,
-      "session:post_thread_message",
-      {
-        workspace: session.workspaceSlug,
-        channel: session.channelSlug,
-        thread_id: state.kandanThreadId,
-        body: delta.patchText,
-        payload: {
-          ...localRunnerPayload(
-            args.options,
-            args.instanceId,
-            "codex_output",
-            state.codexThreadId,
-            payloadContext,
-            sourceMessageSeq
-          ),
-          ...state.rootSeq === void 0 ? {} : { reply_to_seq: state.rootSeq },
-          structured
-        },
-        client_message_id: streamingClientMessageId(args.instanceId, {
-          itemKey: `file-change:${delta.itemKey}`,
-          turnId
-        })
-      }
-    );
-    const seq = integerValue(reply.seq);
-    if (seq !== void 0) {
-      rememberStreamingFileChangeOutput(state, {
-        itemKey: delta.itemKey,
-        turnId,
-        seq,
-        patchText: delta.patchText
-      });
+  if (existing?.streamState === "completed") {
+    if (normalizedTranscriptText(existing.patchText) !== normalizedTranscriptText(delta.patchText)) {
+      throw new LogicalProjectionError(
+        `Cannot complete file-change item ${delta.itemKey} twice with different patch text`
+      );
     }
-  } else {
-    await editCodexStructuredOutput(
-      args,
-      state,
-      existing.seq,
-      delta.patchText,
-      structured
-    );
+    return;
+  }
+  const streamKey = existing?.streamKey ?? streamingClientMessageId(args.instanceId, {
+    itemKey: `file-change:${delta.itemKey}`,
+    turnId
+  });
+  const seq = await streamCodexStructuredOutput(args, state, payloadContext, {
+    turnId,
+    sourceMessageSeq,
+    rootSeq: state.rootSeq,
+    streamKey,
+    body: delta.patchText,
+    structured
+  }) ?? existing?.seq;
+  if (seq !== void 0) {
     rememberStreamingFileChangeOutput(state, {
-      ...existing,
-      turnId: existing.turnId ?? turnId,
-      patchText: delta.patchText
+      itemKey: delta.itemKey,
+      turnId: existing?.turnId ?? turnId,
+      seq,
+      streamKey,
+      patchText: delta.patchText,
+      streamState: "completed"
     });
   }
   args.log("kandan.codex_file_change_forwarded", {
@@ -7409,54 +7365,21 @@ async function forwardWebSearchProgress(args, state, params, payloadContext) {
     queries,
     "streaming"
   );
-  if (existing === void 0) {
-    const session = args.options.channelSession;
-    const reply = await pushOk2(
-      args.kandan,
-      args.topic,
-      "session:post_thread_message",
-      {
-        workspace: session.workspaceSlug,
-        channel: session.channelSlug,
-        thread_id: state.kandanThreadId,
-        body,
-        payload: {
-          ...localRunnerPayload(
-            args.options,
-            args.instanceId,
-            "codex_output",
-            state.codexThreadId,
-            payloadContext,
-            sourceMessageSeq
-          ),
-          ...state.rootSeq === void 0 ? {} : { reply_to_seq: state.rootSeq },
-          structured
-        },
-        client_message_id: webSearchProgressClientMessageId(
-          args.instanceId,
-          progress.turnId
-        )
-      }
-    );
-    const seq = integerValue(reply.seq);
-    if (seq !== void 0) {
-      rememberWebSearchProgressOutput(state, {
-        turnId: progress.turnId,
-        itemKey,
-        seq,
-        queries
-      });
-    }
-  } else if (queries.length !== existing.queries.length) {
-    await editCodexStructuredOutput(
-      args,
-      state,
-      existing.seq,
-      body,
-      structured
-    );
+  const streamKey = existing?.streamKey ?? webSearchProgressClientMessageId(args.instanceId, progress.turnId);
+  const seq = await streamCodexStructuredOutput(args, state, payloadContext, {
+    turnId: progress.turnId,
+    sourceMessageSeq,
+    rootSeq: state.rootSeq,
+    streamKey,
+    body,
+    structured
+  }) ?? existing?.seq;
+  if (seq !== void 0) {
     rememberWebSearchProgressOutput(state, {
-      ...existing,
+      turnId: progress.turnId,
+      itemKey,
+      seq,
+      streamKey,
       queries
     });
   }
@@ -7468,41 +7391,49 @@ async function forwardWebSearchProgress(args, state, params, payloadContext) {
     query_count: queries.length
   });
 }
-async function completeWebSearchProgress(args, state, turnId) {
+async function completeWebSearchProgress(args, state, turnId, payloadContext) {
   const existing = findWebSearchProgressOutput(state, turnId);
   if (existing === void 0) {
     return;
   }
-  await editCodexStructuredOutput(
-    args,
-    state,
-    existing.seq,
-    webSearchProgressBody(existing.queries),
-    codexWebSearchStructuredMessage(
+  await streamCodexStructuredOutput(args, state, payloadContext, {
+    turnId,
+    sourceMessageSeq: sourceMessageSeqForTurn(state, turnId),
+    rootSeq: state.rootSeq,
+    streamKey: existing.streamKey,
+    body: webSearchProgressBody(existing.queries),
+    structured: codexWebSearchStructuredMessage(
       existing.itemKey,
       existing.queries,
       "completed"
     )
-  );
+  });
   forgetWebSearchProgressOutput(state, turnId);
 }
-async function completeFileChangeOutputs(args, state, turnId) {
+async function completeFileChangeOutputs(args, state, turnId, payloadContext) {
   const outputs = boundedCacheValues(state.streamingFileChangeOutputs).filter(
-    (output) => output.turnId === turnId
+    (output) => output.turnId === turnId && output.streamState === "streaming"
   );
+  const sourceMessageSeq = sourceMessageSeqForTurn(state, turnId);
   for (const output of outputs) {
-    await editCodexStructuredOutput(
-      args,
-      state,
-      output.seq,
-      output.patchText,
-      codexFileChangeStructuredMessage(
+    const seq = await streamCodexStructuredOutput(args, state, payloadContext, {
+      turnId,
+      sourceMessageSeq,
+      rootSeq: state.rootSeq,
+      streamKey: output.streamKey,
+      body: output.patchText,
+      structured: codexFileChangeStructuredMessage(
         output.itemKey,
         output.patchText,
         "completed",
         "completed"
       )
-    );
+    }) ?? output.seq;
+    rememberStreamingFileChangeOutput(state, {
+      ...output,
+      seq,
+      streamState: "completed"
+    });
   }
 }
 async function completeInterruptedAssistantOutputs(args, state, turnId, payloadContext) {
@@ -7511,19 +7442,23 @@ async function completeInterruptedAssistantOutputs(args, state, turnId, payloadC
     (output) => output.turnId === turnId && bodyWithoutKandanAttachmentFooter(output.content) !== output.content
   );
   for (const output of outputs) {
-    await editStreamedCodexOutput(
-      args,
-      state,
-      output.seq,
-      output.itemKey,
-      output.content,
-      "completed"
-    );
+    await streamCodexStructuredOutput(args, state, payloadContext, {
+      turnId,
+      sourceMessageSeq: output.sourceMessageSeq ?? sourceMessageSeqForTurn(state, turnId),
+      rootSeq: state.rootSeq,
+      streamKey: output.streamKey,
+      body: output.content,
+      structured: codexAssistantStructuredMessage(
+        output.itemKey,
+        output.content,
+        "completed"
+      )
+    });
     forgetStreamingAssistantOutput(state, output.itemKey);
     rememberCompletedAssistantItemKey(state, output.itemKey, turnId);
   }
 }
-async function completeStreamingAssistantOutputsForTurn(args, state, turnId) {
+async function completeStreamingAssistantOutputsForTurn(args, state, turnId, payloadContext) {
   const sourceMessageSeq = sourceMessageSeqForTurn(state, turnId);
   const outputs = boundedCacheValues(state.streamingAssistantOutputs).filter(
     (output) => output.turnId === turnId || sourceMessageSeq !== void 0 && output.sourceMessageSeq === sourceMessageSeq
@@ -7538,14 +7473,24 @@ async function completeStreamingAssistantOutputsForTurn(args, state, turnId) {
         "completed"
       )
     };
-    await editStreamedCodexOutput(
-      args,
-      state,
-      output.seq,
-      output.itemKey,
-      output.content,
-      "completed"
-    );
+    await postCompletedCodexOutput(args, state, payloadContext, {
+      turnId,
+      sourceMessageSeq: output.sourceMessageSeq ?? sourceMessageSeq,
+      rootSeq: state.rootSeq,
+      message
+    });
+    await streamCodexStructuredOutput(args, state, payloadContext, {
+      turnId,
+      sourceMessageSeq: output.sourceMessageSeq ?? sourceMessageSeq,
+      rootSeq: state.rootSeq,
+      streamKey: output.streamKey,
+      body: output.content,
+      structured: codexAssistantStructuredMessage(
+        output.itemKey,
+        output.content,
+        "completed"
+      )
+    });
     forgetStreamingAssistantOutput(state, output.itemKey);
     rememberCompletedAssistantItemKey(
       state,
@@ -7568,7 +7513,7 @@ function webSearchProgressClientMessageId(instanceId, turnId) {
 function webSearchProgressItemKey(turnId) {
   return `web-search:${turnId}`;
 }
-async function streamCompletedCodexOutput(args, state, payloadContext, params) {
+async function postCompletedCodexOutput(args, state, payloadContext, params) {
   if (state.kandanThreadId === void 0 || state.codexThreadId === void 0) {
     return;
   }
@@ -7607,11 +7552,10 @@ async function streamCompletedCodexOutput(args, state, payloadContext, params) {
     structured,
     displayBody
   );
-  await pushOk2(args.kandan, args.topic, "session:stream_thread_message", {
+  await pushOk2(args.kandan, args.topic, "session:post_thread_message", {
     workspace: session.workspaceSlug,
     channel: session.channelSlug,
     thread_id: state.kandanThreadId,
-    stream_key: streamKey,
     body: displayBody,
     payload: {
       ...localRunnerPayload(
@@ -7632,24 +7576,24 @@ async function streamCompletedCodexOutput(args, state, payloadContext, params) {
     client_message_id: streamKey
   });
 }
-function structuredWithStreamKey(structured, streamKey) {
-  return streamKey === void 0 ? structured : { ...structured, stream_key: streamKey };
-}
-async function editStreamedCodexOutput(args, state, targetSeq, itemKey, content, streamState) {
-  await editCodexStructuredOutput(
-    args,
-    state,
-    targetSeq,
-    content,
-    codexAssistantStructuredMessage(itemKey, content, streamState)
-  );
-}
-async function editCodexStructuredOutput(args, state, targetSeq, content, structured) {
-  if (state.kandanThreadId === void 0) {
+async function streamCompletedCodexOutput(args, state, payloadContext, params) {
+  if (state.kandanThreadId === void 0 || state.codexThreadId === void 0) {
     return;
   }
   const session = args.options.channelSession;
-  const uploadedFileIds = stringValue(structured.stream_state) === "completed" ? await uploadedFileIdsForCommanderOutput(
+  const streamKey = streamingClientMessageId(args.instanceId, {
+    itemKey: params.message.itemKey,
+    turnId: params.turnId
+  });
+  const streamMetadata = {
+    turn_id: params.turnId,
+    stream_key: streamKey
+  };
+  const structured = structuredWithStreamKey(
+    params.message.structured,
+    streamKey
+  );
+  const uploadedFileIds = await uploadedFileIdsForCommanderOutput(
     {
       kandan: args.kandan,
       topic: args.topic,
@@ -7660,27 +7604,111 @@ async function editCodexStructuredOutput(args, state, targetSeq, content, struct
       token: args.options.token,
       fetch: args.options.fetch
     },
-    content,
+    params.message.body,
     structured
-  ) : [];
-  const displayContent = displayBodyForCommanderOutput(
-    content,
+  );
+  const displayBody = displayBodyForCommanderOutput(
+    params.message.body,
     uploadedFileIds
   );
   const displayStructured = structuredWithAssistantContent(
     structured,
-    displayContent
+    displayBody
   );
-  await pushOk2(args.kandan, args.topic, "session:edit_thread_message", {
+  await pushOk2(args.kandan, args.topic, "session:stream_thread_message", {
     workspace: session.workspaceSlug,
     channel: session.channelSlug,
     thread_id: state.kandanThreadId,
-    target_seq: targetSeq,
-    body: displayContent,
-    structured: displayStructured,
-    ...uploadedFileIds.length === 0 ? {} : { uploaded_file_ids: uploadedFileIds }
+    stream_key: streamKey,
+    body: displayBody,
+    payload: {
+      ...localRunnerPayload(
+        args.options,
+        args.instanceId,
+        "codex_output",
+        state.codexThreadId,
+        payloadContext,
+        params.sourceMessageSeq,
+        streamMetadata
+      ),
+      ...params.rootSeq === void 0 ? {} : { reply_to_seq: params.rootSeq },
+      ...params.sourceMessageSeq === void 0 ? {} : { source_message_seq: params.sourceMessageSeq },
+      ...streamMetadata,
+      structured: displayStructured
+    },
+    ...uploadedFileIds.length === 0 ? {} : { uploaded_file_ids: uploadedFileIds },
+    client_message_id: streamKey
   });
 }
+async function streamCodexStructuredOutput(args, state, payloadContext, params) {
+  if (state.kandanThreadId === void 0 || state.codexThreadId === void 0) {
+    return void 0;
+  }
+  const session = args.options.channelSession;
+  const streamMetadata = params.turnId === void 0 ? { stream_key: params.streamKey } : {
+    turn_id: params.turnId,
+    stream_key: params.streamKey
+  };
+  const structured = structuredWithStreamKey(
+    params.structured,
+    params.streamKey
+  );
+  const uploadedFileIds = stringValue(structured.stream_state) === "completed" ? await uploadedFileIdsForCommanderOutput(
+    {
+      kandan: args.kandan,
+      topic: args.topic,
+      workspace: session.workspaceSlug,
+      channel: session.channelSlug,
+      cwd: args.options.cwd,
+      kandanUrl: args.options.kandanUrl,
+      token: args.options.token,
+      fetch: args.options.fetch
+    },
+    params.body,
+    structured
+  ) : [];
+  const displayBody = displayBodyForCommanderOutput(
+    params.body,
+    uploadedFileIds
+  );
+  const displayStructured = structuredWithAssistantContent(
+    structured,
+    displayBody
+  );
+  const reply = await pushOk2(
+    args.kandan,
+    args.topic,
+    "session:stream_thread_message",
+    {
+      workspace: session.workspaceSlug,
+      channel: session.channelSlug,
+      thread_id: state.kandanThreadId,
+      stream_key: params.streamKey,
+      body: displayBody,
+      payload: {
+        ...localRunnerPayload(
+          args.options,
+          args.instanceId,
+          "codex_output",
+          state.codexThreadId,
+          payloadContext,
+          params.sourceMessageSeq,
+          streamMetadata
+        ),
+        ...params.rootSeq === void 0 ? {} : { reply_to_seq: params.rootSeq },
+        ...params.sourceMessageSeq === void 0 ? {} : { source_message_seq: params.sourceMessageSeq },
+        ...streamMetadata,
+        structured: displayStructured
+      },
+      ...uploadedFileIds.length === 0 ? {} : { uploaded_file_ids: uploadedFileIds },
+      client_message_id: params.streamKey
+    }
+  );
+  return integerValue(reply.seq);
+}
+function structuredWithStreamKey(structured, streamKey) {
+  return streamKey === void 0 ? structured : { ...structured, stream_key: streamKey };
+}
 async function mirrorLocalTuiInputFromNotification(args, state, turnId, params, payloadContext) {
   if (!isLocalTuiTurn(state, turnId)) {
     return;
@@ -7796,24 +7824,60 @@ function findPendingCommandOutput(state, itemKey) {
 function findStreamingFileChangeOutput(state, itemKey) {
   return getBoundedCacheValue(state.streamingFileChangeOutputs, itemKey);
 }
-function resolveStreamingStructuredOutputForCompletedMessage(state, itemKey, structured) {
+function resolveStreamingStructuredOutputForCompletedMessage(state, turnId, itemKey, body, structured) {
   switch (stringValue(structured.kind)) {
     case "codex_reasoning": {
-      const output = findStreamingReasoningOutput(state, itemKey);
-      return output === void 0 ? void 0 : { itemKey: output.itemKey, seq: output.seq };
+      const output = findStreamingReasoningOutput(state, itemKey) ?? singleMatchingStreamedStructuredOutput(
+        boundedCacheValues(state.streamingReasoningOutputs),
+        turnId,
+        body,
+        (candidate) => candidate.content
+      );
+      return output === void 0 ? void 0 : {
+        itemKey: output.itemKey,
+        seq: output.seq,
+        streamKey: output.streamKey,
+        streamState: "streaming"
+      };
     }
     case "codex_command_execution": {
-      const output = findStreamingCommandOutput(state, itemKey);
-      return output === void 0 ? void 0 : { itemKey: output.itemKey, seq: output.seq };
+      const output = findStreamingCommandOutput(state, itemKey) ?? singleMatchingStreamedStructuredOutput(
+        boundedCacheValues(state.streamingCommandOutputs),
+        turnId,
+        body,
+        (candidate) => codexCommandOutputBody(candidate.command, candidate.output)
+      );
+      return output === void 0 ? void 0 : {
+        itemKey: output.itemKey,
+        seq: output.seq,
+        streamKey: output.streamKey,
+        streamState: "streaming"
+      };
     }
     case "codex_file_change": {
-      const output = findStreamingFileChangeOutput(state, itemKey);
-      return output === void 0 ? void 0 : { itemKey: output.itemKey, seq: output.seq };
+      const output = findStreamingFileChangeOutput(state, itemKey) ?? singleMatchingStreamedStructuredOutput(
+        boundedCacheValues(state.streamingFileChangeOutputs),
+        turnId,
+        body,
+        (candidate) => candidate.patchText
+      );
+      return output === void 0 ? void 0 : {
+        itemKey: output.itemKey,
+        seq: output.seq,
+        streamKey: output.streamKey,
+        streamState: output.streamState
+      };
     }
     default:
       return void 0;
   }
 }
+function singleMatchingStreamedStructuredOutput(outputs, turnId, body, bodyForOutput) {
+  const matches = outputs.filter(
+    (output) => output.turnId === turnId && normalizedTranscriptText(bodyForOutput(output)) === normalizedTranscriptText(body)
+  );
+  return matches.length === 1 ? matches[0] : void 0;
+}
 function forgetStreamingStructuredOutput(state, itemKey, structured) {
   switch (stringValue(structured.kind)) {
     case "codex_reasoning":
@@ -8145,6 +8209,116 @@ function turnTerminalNotificationIsStale(args, state, turnId) {
   });
   return true;
 }
+function rememberPendingStartingTerminalCompletion(args, state, threadId, turnId) {
+  if (state.turn.status !== "starting") {
+    return false;
+  }
+  if (threadId === void 0 || state.codexThreadId !== threadId) {
+    return false;
+  }
+  if (!terminalNotificationCanBelongToStartingTurn(
+    state,
+    turnId,
+    state.turn.queuedSeq
+  )) {
+    return false;
+  }
+  const pending = {
+    status: "completed",
+    threadId,
+    turnId,
+    queuedSeq: state.turn.queuedSeq
+  };
+  rememberPendingStartingTerminalNotification(state, pending);
+  args.log("codex.starting_turn_terminal_deferred", {
+    status: pending.status,
+    thread_id: threadId,
+    turn_id: turnId,
+    queued_seq: pending.queuedSeq
+  });
+  return true;
+}
+function rememberPendingStartingTerminalFailure(args, state, threadId, turnId, reason) {
+  if (state.turn.status !== "starting") {
+    return false;
+  }
+  if (threadId === void 0 || state.codexThreadId !== threadId) {
+    return false;
+  }
+  if (!terminalNotificationCanBelongToStartingTurn(
+    state,
+    turnId,
+    state.turn.queuedSeq
+  )) {
+    return false;
+  }
+  const pending = {
+    status: "failed",
+    threadId,
+    turnId,
+    queuedSeq: state.turn.queuedSeq,
+    reason
+  };
+  rememberPendingStartingTerminalNotification(state, pending);
+  args.log("codex.starting_turn_terminal_deferred", {
+    status: pending.status,
+    thread_id: threadId,
+    turn_id: turnId,
+    queued_seq: pending.queuedSeq,
+    reason
+  });
+  return true;
+}
+function terminalNotificationCanBelongToStartingTurn(state, turnId, startingQueuedSeq) {
+  const sourceMessageSeq = sourceMessageSeqForTurn(state, turnId);
+  return sourceMessageSeq === void 0 || sourceMessageSeq === startingQueuedSeq;
+}
+function rememberPendingStartingTerminalNotification(state, pending) {
+  const alreadyPending = state.pendingStartingTerminalNotifications.some(
+    (entry) => entry.status === pending.status && entry.threadId === pending.threadId && entry.turnId === pending.turnId && entry.queuedSeq === pending.queuedSeq
+  );
+  if (alreadyPending) {
+    return;
+  }
+  state.pendingStartingTerminalNotifications = [
+    ...state.pendingStartingTerminalNotifications,
+    pending
+  ].slice(-maxForwardedTurnIds);
+}
+function consumePendingStartingTerminalNotification(state, threadId, turnId, queuedSeq) {
+  const index = state.pendingStartingTerminalNotifications.findIndex(
+    (pending2) => pending2.threadId === threadId && pending2.queuedSeq === queuedSeq && pending2.turnId === turnId
+  );
+  if (index < 0) {
+    return void 0;
+  }
+  const [pending] = state.pendingStartingTerminalNotifications.splice(index, 1);
+  return pending;
+}
+async function handlePendingStartingTerminalNotification(args, state, pending, turnId, payloadContext) {
+  args.log("codex.starting_turn_terminal_replayed", {
+    status: pending.status,
+    thread_id: pending.threadId,
+    turn_id: turnId,
+    queued_seq: pending.queuedSeq
+  });
+  switch (pending.status) {
+    case "completed":
+      enqueueWebSearchProgressCompletion(args, state, turnId, payloadContext);
+      enqueueFileChangeCompletion(args, state, turnId, payloadContext);
+      await forwardCompletedCodexTurn(args, state, turnId, payloadContext);
+      break;
+    case "failed":
+      await failActiveCodexTurn(
+        args,
+        state,
+        turnId,
+        pending.reason,
+        payloadContext
+      );
+      break;
+  }
+}
 function codexNotificationActiveTurnFallback(method, state, params, threadId) {
   if (threadId === void 0 || state.codexThreadId !== threadId) {
     return void 0;
@@ -14657,7 +14831,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.78-beta";
+    linzumiCliVersion = "0.0.79-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -18554,6 +18728,26 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const missingAllowedCwds = {
     value: normalizeAllowedCwds(options.missingAllowedCwds ?? [])
   };
+  const applyRunnerConfigSync = (config, syncOptions) => {
+    const persistedAllowedCwds = replaceAllowedCwdsForLinzumiUrl(
+      config.allowedCwds,
+      options.kandanUrl
+    );
+    const updatedAllowedCwds = configuredAllowedCwds(persistedAllowedCwds, {
+      createMissing: true
+    });
+    allowedCwds.value = normalizeAllowedCwds([
+      ...syncOptions.includeStartupAllowedCwds ? startupAllowedCwds : [],
+      ...updatedAllowedCwds.allowedCwds
+    ]);
+    missingAllowedCwds.value = updatedAllowedCwds.missingAllowedCwds;
+    log("runner.config_updated", {
+      source: syncOptions.source,
+      configVersion: config.configVersion,
+      allowedCwdCount: allowedCwds.value.length,
+      missingAllowedCwdCount: missingAllowedCwds.value.length
+    });
+  };
   const localEditorState = {
     value: { status: "disabled" }
   };
@@ -18660,6 +18854,28 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   const joinResponse = await kandan.join(topic, joinPayload(), {
     rejoinPayload: joinPayload
   });
+  const joinedRunnerConfig = parseRunnerConfigSyncPayload(
+    objectValue(joinResponse)?.runner_config
+  );
+  switch (joinedRunnerConfig.type) {
+    case "missing":
+      break;
+    case "invalid":
+      log("runner.config_join_invalid", {
+        runnerId: options.runnerId,
+        kandanUrl: options.kandanUrl,
+        reason: joinedRunnerConfig.reason
+      });
+      throw new Error(
+        `invalid runner_config in Kandan join response: ${joinedRunnerConfig.reason}`
+      );
+    case "ok":
+      applyRunnerConfigSync(joinedRunnerConfig.config, {
+        includeStartupAllowedCwds: false,
+        source: "join"
+      });
+      break;
+  }
   const replacedRunners = replacementRunnerSummaries(
     objectValue(joinResponse)?.replaced_runners
   );
@@ -19971,23 +20187,16 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       return;
     }
     if (isUpdateRunnerConfigControl(control)) {
-      const persistedAllowedCwds = replaceAllowedCwdsForLinzumiUrl(
-        control.allowedCwds,
-        options.kandanUrl
+      applyRunnerConfigSync(
+        {
+          allowedCwds: control.allowedCwds,
+          configVersion: control.configVersion ?? null
+        },
+        {
+          includeStartupAllowedCwds: true,
+          source: "control"
+        }
       );
-      const updatedAllowedCwds = configuredAllowedCwds(persistedAllowedCwds, {
-        createMissing: true
-      });
-      allowedCwds.value = normalizeAllowedCwds([
-        ...startupAllowedCwds,
-        ...updatedAllowedCwds.allowedCwds
-      ]);
-      missingAllowedCwds.value = updatedAllowedCwds.missingAllowedCwds;
-      log("runner.config_updated", {
-        configVersion: control.configVersion ?? null,
-        allowedCwdCount: allowedCwds.value.length,
-        missingAllowedCwdCount: missingAllowedCwds.value.length
-      });
       void pushHeartbeat();
       return;
     }
@@ -20269,6 +20478,42 @@ function replacementRunnerSummaries(value) {
     ];
   });
 }
+function parseRunnerConfigSyncPayload(value) {
+  if (value === void 0) {
+    return { type: "missing" };
+  }
+  const payload = objectValue(value);
+  if (payload === void 0) {
+    return { type: "invalid", reason: "runner_config_not_object" };
+  }
+  const entries = arrayValue(payload.allowedCwds);
+  if (entries === void 0) {
+    return { type: "invalid", reason: "allowed_cwds_not_array" };
+  }
+  const allowedCwds = [];
+  for (const [index, entry] of entries.entries()) {
+    const allowedCwd = stringValue(entry);
+    if (allowedCwd === void 0) {
+      return {
+        type: "invalid",
+        reason: `allowed_cwd_${index}_not_string`
+      };
+    }
+    allowedCwds.push(allowedCwd);
+  }
+  const rawConfigVersion = payload.configVersion;
+  const configVersion = rawConfigVersion === void 0 || rawConfigVersion === null ? null : integerValue(rawConfigVersion);
+  if (configVersion === void 0) {
+    return { type: "invalid", reason: "config_version_not_integer" };
+  }
+  return {
+    type: "ok",
+    config: {
+      allowedCwds,
+      configVersion
+    }
+  };
+}
 function makeRunnerLogger(options) {
   const consoleReporter = options.launchTui && options.consoleReporter === void 0 ? void 0 : (event, payload) => {
     if (!options.launchTui) {