@moxt-ai/mobius 0.0.408 → 0.0.410

package/dist/{chunk-EEGF33EL.js → chunk-2S33N4G2.js}

@@ -3,7 +3,7 @@ import {
   __export,
   __using,
   package_default
-} from "./chunk-ZPDX3V6A.js";
+} from "./chunk-M4L66DBW.js";
 
 // src/engine/runtime/relay/runtime-revocation.ts
 var runtimeRevocationCloseCode = 1008;
@@ -63747,7 +63747,11 @@ var ClaudeAcpAgent = class {
           return;
         }
         this.logger.error(`Session ${params.sessionId}: SDK emitted a terminal assistant message (stop_reason=${capturedReason}) but never followed with result or idle; settling the turn via watchdog after ${RESULT_WATCHDOG_TIMEOUT_MS}ms`);
+        const wasHeld = isHeldOpen(turn);
         settleOrDefer(turnOutcome(session, capturedReason));
+        if (turn.settled && !wasHeld) {
+          this.trackResultOwedBySettledTurn(session, turn);
+        }
       }, RESULT_WATCHDOG_TIMEOUT_MS);
     };
     const sendUpdate = async (notification) => {
@@ -63801,18 +63805,36 @@ var ClaudeAcpAgent = class {
       resetTurnScratch();
     };
     const ensureActiveTurn = (resultUserMessageUuid) => {
+      if (resultUserMessageUuid !== void 0) {
+        const named = findUnsettledTurn(resultUserMessageUuid);
+        if (named !== void 0) {
+          if (named !== session.activeTurn) {
+            handOffActive();
+            activateTurn(named);
+          }
+          return "active";
+        }
+        if (session.orphanCommands?.has(resultUserMessageUuid)) {
+          for (const [uuid3, state] of session.orphanCommands) {
+            if (state === "started" || state === "zombie") {
+              session.orphanCommands.delete(uuid3);
+            }
+          }
+          session.orphanCommands.delete(resultUserMessageUuid);
+          return "owed";
+        }
+      }
       if (session.activeTurn) {
         if (!isHeldOpen(session.activeTurn)) {
-          return;
+          return "active";
         }
-        settleActive(session.activeTurn.deferredSettle);
+        handOffActive();
       }
       if ((session.pendingOrphanResults ?? 0) > 0) {
         session.pendingOrphanResults = (session.pendingOrphanResults ?? 1) - 1;
-        return;
+        return "owed";
       }
       if (session.orphanCommands?.size) {
-        const stampedOrphan = resultUserMessageUuid !== void 0 && session.orphanCommands.has(resultUserMessageUuid);
         let consumedOrphanResult = false;
         let oldestPending;
         for (const [uuid3, state] of session.orphanCommands) {
@@ -63823,26 +63845,22 @@ var ClaudeAcpAgent = class {
             oldestPending ??= uuid3;
           }
         }
-        if (stampedOrphan && resultUserMessageUuid !== void 0) {
-          session.orphanCommands.delete(resultUserMessageUuid);
-          return;
-        }
         if (resultUserMessageUuid !== void 0) {
         } else {
           if (consumedOrphanResult) {
-            return;
+            return "owed";
           }
           if (oldestPending !== void 0) {
             session.orphanCommands.delete(oldestPending);
-            return;
+            return "owed";
           }
         }
       }
       const head = firstUnsettledQueuedTurn();
-      if (!head) {
-        return;
+      if (head) {
+        activateTurn(head);
       }
-      activateTurn(head);
+      return "active";
     };
     const recordResultForOrphanCommands = () => {
       for (const turn of session.turnQueue ?? []) {
@@ -63920,6 +63938,35 @@ var ClaudeAcpAgent = class {
       session.emittedAssistantText = false;
       turn.reject(error62);
     };
+    const failActiveBeforeResult = (error62) => {
+      const turn = session.activeTurn;
+      if (turn && !turn.settled && !isHeldOpen(turn)) {
+        this.trackResultOwedBySettledTurn(session, turn);
+      }
+      failActive(error62);
+    };
+    const handOffActive = () => {
+      if (!session.activeTurn) {
+        return;
+      }
+      if (session.cancelled) {
+        session.idleBoundary = {
+          kind: "accounted",
+          turn: session.activeTurn ?? null
+        };
+        settleActive(turnOutcome(session, "cancelled"));
+      } else if (isHeldOpen(session.activeTurn)) {
+        settleActive(session.activeTurn.deferredSettle);
+      } else if (isSteering(session.activeTurn) && session.activeTurn.steeredSettle !== void 0) {
+        session.idleBoundary = {
+          kind: "accounted",
+          turn: session.activeTurn ?? null
+        };
+        settleActive(session.activeTurn.steeredSettle);
+      } else {
+        settleActive(turnOutcome(session, "end_turn"));
+      }
+    };
     const failAllTurns = (error62) => {
       disarmForceCancel(session);
       const turns = session.activeTurn ? [session.activeTurn, ...(session.turnQueue ?? []).filter((t) => t !== session.activeTurn)] : [...session.turnQueue ?? []];
@@ -63956,16 +64003,7 @@ var ClaudeAcpAgent = class {
         cancelController.signal.removeEventListener("abort", onAbort);
         if (raced === "abort") {
           if (session.activeTurn && !session.activeTurn.settled) {
-            const active = session.activeTurn;
-            if (active.commandFinished === "completed" || active.commandFinished === "discarded" || active.commandFinished === "refused") {
-            } else if (active.commandFinished === "cancelled") {
-              if (!active.commandResultSeen) {
-                this.trackOrphanCommand(session, active.promptUuid, "zombie");
-              }
-            } else if (active.commandResultSeen) {
-            } else {
-              this.trackOrphanCommand(session, active.promptUuid, "started");
-            }
+            this.trackResultOwedBySettledTurn(session, session.activeTurn);
           }
           settleActive(turnOutcome(session, "cancelled"));
           session.emittedAssistantText = false;
@@ -64419,9 +64457,10 @@ ${message.api_refusal_explanation}` : "";
               if (!isAutonomousResult) {
                 await this.syncFastModeState(params.sessionId, session, message.fast_mode_state, message.fast_mode_disabled_reason);
               }
+              let isOwedResult = false;
               if (!isAutonomousResult) {
+                isOwedResult = ensureActiveTurn(message.user_message_uuid) === "owed";
                 recordResultForOrphanCommands();
-                ensureActiveTurn(message.user_message_uuid);
                 if (session.pendingGoalUpdate?.started) {
                   const pendingGoalUpdate = session.pendingGoalUpdate;
                   session.pendingGoalUpdate = void 0;
@@ -64435,7 +64474,7 @@ ${message.api_refusal_explanation}` : "";
               if (isAutonomousResult || !session.cancelled || !session.activeTurn) {
                 session.idleBoundary = { kind: "accounted", turn: session.activeTurn ?? null };
               }
-              if (!isAutonomousResult) {
+              if (!isAutonomousResult && !isOwedResult) {
                 session.accumulatedUsage.inputTokens += message.usage.input_tokens;
                 session.accumulatedUsage.outputTokens += message.usage.output_tokens;
                 session.accumulatedUsage.cachedReadTokens += message.usage.cache_read_input_tokens;
@@ -64444,7 +64483,7 @@ ${message.api_refusal_explanation}` : "";
               const modelUsageReading = normalizeModelUsage(message.modelUsage);
               const resultModelUsage = modelUsageIncrement(modelUsageReading, session.lastModelUsageReading ?? {});
               session.lastModelUsageReading = modelUsageReading;
-              if (!isAutonomousResult) {
+              if (!isAutonomousResult && !isOwedResult) {
                 session.accumulatedModelUsage = addModelUsage(session.accumulatedModelUsage ?? {}, resultModelUsage);
               }
               const matchingModelUsage = lastAssistantModel ? getMatchingModelUsage(message.modelUsage, lastAssistantModel) : null;
@@ -64488,6 +64527,11 @@ ${message.api_refusal_explanation}` : "";
                 }
                 break;
               }
+              if (isOwedResult) {
+                session.pendingExitPlanModeInterruption = void 0;
+                session.pendingExitPlanContextReset = void 0;
+                break;
+              }
               const diagnostic = executionDiagnostic(message);
               if (pendingExitPlanModeInterruption?.toolResultSeen && message.is_error && diagnostic && /(?:^|\s)result_type=user(?:\s|$)/.test(diagnostic) && /(?:^|\s)stop_reason=tool_use(?:\s|$)/.test(diagnostic)) {
                 session.pendingExitPlanModeInterruption = void 0;
@@ -64714,25 +64758,7 @@ ${message.api_refusal_explanation}` : "";
                   }));
                 }
                 if (session.activeTurn !== queued) {
-                  if (session.activeTurn) {
-                    if (session.cancelled) {
-                      session.idleBoundary = {
-                        kind: "accounted",
-                        turn: session.activeTurn ?? null
-                      };
-                      settleActive(turnOutcome(session, "cancelled"));
-                    } else if (isHeldOpen(session.activeTurn)) {
-                      settleActive(session.activeTurn.deferredSettle);
-                    } else if (isSteering(session.activeTurn) && session.activeTurn.steeredSettle !== void 0) {
-                      session.idleBoundary = {
-                        kind: "accounted",
-                        turn: session.activeTurn ?? null
-                      };
-                      settleActive(session.activeTurn.steeredSettle);
-                    } else {
-                      settleActive(turnOutcome(session, "end_turn"));
-                    }
-                  }
+                  handOffActive();
                   activateTurn(queued);
                 }
                 break;
@@ -64793,11 +64819,11 @@ ${message.api_refusal_explanation}` : "";
               break;
             }
             if (message.type === "assistant" && message.error === "authentication_failed") {
-              failActive(RequestError5.authRequired(errorKindData(message.error)));
+              failActiveBeforeResult(RequestError5.authRequired(errorKindData(message.error)));
               break;
             }
             if (message.type === "assistant" && message.parent_tool_use_id === null && message.error === "model_not_found") {
-              failActive(RequestError5.internalError(errorKindData(message.error), "The selected model is unavailable"));
+              failActiveBeforeResult(RequestError5.internalError(errorKindData(message.error), "The selected model is unavailable"));
               break;
             }
             let content;
@@ -64955,6 +64981,30 @@ ${message.api_refusal_explanation}` : "";
       session.pendingOrphanResults = (session.pendingOrphanResults ?? 0) + 1;
     }
   }
+  /** Record that a dispatched turn the adapter is settling BEFORE its result
+   *  (force-cancel backstop, result watchdog, an assistant-level failure)
+   *  still owes that result. Its late result is then consumed as this turn's
+   *  trailer — by its `user_message_uuid` when stamped, positionally otherwise
+   *  — instead of settling the next prompt (see ensureActiveTurn). Every
+   *  settle-before-result lane must record through here so the debt has one
+   *  representation: the orphan-accounting lanes.
+   *
+   *  Seeded by what the frames already told us, mirroring cancel()'s
+   *  queued-turn sweep — the consumer may have drained the turn's result
+   *  and/or terminal frame already, and an entry seeded for a result or frame
+   *  that is already spent would never drain (it would swallow an unrelated
+   *  later echo-less result instead). */
+  trackResultOwedBySettledTurn(session, turn) {
+    if (turn.commandFinished === "completed" || turn.commandFinished === "discarded" || turn.commandFinished === "refused") {
+    } else if (turn.commandFinished === "cancelled") {
+      if (!turn.commandResultSeen) {
+        this.trackOrphanCommand(session, turn.promptUuid, "zombie");
+      }
+    } else if (turn.commandResultSeen) {
+    } else {
+      this.trackOrphanCommand(session, turn.promptUuid, "started");
+    }
+  }
   async cancel(params) {
     for (const submission of this.pendingSubmissions.get(params.sessionId) ?? []) {
       submission.abort();
@@ -88903,7 +88953,10 @@ var ExecutionReceipts = class {
   /**
    * How the Session's most recently admitted turn ended. Admission order survives updates and
    * restarts. Commands that never started (queued, or reserved for cancellation) are not turns,
-   * unless they failed before starting. Undefined while the latest turn runs or none is retained.
+   * unless they failed before starting. A steering command that completed as `steered` joined the
+   * turn it steered, which reports for both; a steer not known to have joined (it failed, or a
+   * restart interrupted it) keeps its own outcome. Undefined while the latest turn runs or none is
+   * retained.
    */
   lastTurn = (sessionId) => {
     let last;
@@ -88913,8 +88966,10 @@ var ExecutionReceipts = class {
         continue;
       }
       const outcome2 = this.outcome(commandId);
-      const failedBeforeStart = outcome2?.type === "lifecycle-metadata" && outcome2.payload.kind === "prompt.failed-before-start";
-      if ((executionStarted(receipt.state) || failedBeforeStart) && receipt.admissionOrder > latestOrder) {
+      const payload = outcome2?.type === "lifecycle-metadata" ? outcome2.payload : void 0;
+      const failedBeforeStart = payload?.kind === "prompt.failed-before-start";
+      const steered = payload?.kind === "prompt.completed" && promptCompletion(payload).kind === "steered";
+      if ((executionStarted(receipt.state) || failedBeforeStart) && !steered && receipt.admissionOrder > latestOrder) {
         last = commandId;
         latestOrder = receipt.admissionOrder;
       }
@@ -93945,4 +94000,4 @@ export {
   * MIT Licensed
   *)
 */
-//# sourceMappingURL=chunk-EEGF33EL.js.map
+//# sourceMappingURL=chunk-2S33N4G2.js.map