@moxt-ai/mobius 0.0.394 → 0.0.399

package/dist/{chunk-CHYQFODX.js → chunk-3GLSEDI2.js}

@@ -3,7 +3,7 @@ import {
   __export,
   __using,
   package_default
-} from "./chunk-X4NQKPXV.js";
+} from "./chunk-L3C522E4.js";
 
 // src/engine/runtime/relay/runtime-revocation.ts
 var runtimeRevocationCloseCode = 1008;
@@ -85920,6 +85920,26 @@ var SessionInteractions = class {
   };
 };
 
+// src/engine/session/settings/configuration-dependencies.ts
+function isModelOption(option) {
+  return option.id === "model" || option.category === "model";
+}
+function dependencyRank(configId, options) {
+  const category = options.find((option) => option.id === configId)?.category ?? "";
+  if (isModelOption({ category, id: configId })) {
+    return 0;
+  }
+  if (configId === "reasoning_effort" || category === "thought_level") {
+    return 1;
+  }
+  return category === "model_config" ? 2 : 3;
+}
+function inDependencyOrder(selections, options) {
+  return selections.toSorted(
+    (left, right) => dependencyRank(left.configId, options) - dependencyRank(right.configId, options) || left.configId.localeCompare(right.configId)
+  );
+}
+
 // src/engine/session/live/session-configurations.ts
 var storedSessionConfigurationSchema = external_exports.discriminatedUnion("type", [
   external_exports.object({ booleanValue: external_exports.boolean(), configId: external_exports.string().max(128), type: external_exports.literal("boolean") }),
@@ -85929,43 +85949,43 @@ var decodeStoredSessionConfigurations = (value) => external_exports.array(extern
   const decoded = storedSessionConfigurationSchema.safeParse(configuration);
   return decoded.success ? [decoded.data] : [];
 });
+var storedSessionConfiguration = (option) => option.type === "boolean" ? { booleanValue: option.booleanValue, configId: option.id, type: "boolean" } : { configId: option.id, type: "select", value: option.currentValue };
+async function replaySessionConfigurations(selections, options, apply, signal) {
+  for (const selection of inDependencyOrder(selections, options())) {
+    const current = options().find((option) => option.id === selection.configId && option.type === selection.type);
+    if (current === void 0) {
+      continue;
+    }
+    if (selection.type === "boolean") {
+      if (current.booleanValue !== selection.booleanValue) {
+        await apply(selection, signal);
+      }
+      continue;
+    }
+    if (current.currentValue !== selection.value && current.values.some((value) => value.value === selection.value)) {
+      await apply(selection, signal);
+    }
+  }
+}
 var SessionConfigurations = class {
   #selected = [];
   stored = () => this.#selected;
+  /** Follows the Agent's own changes, such as leaving Plan mode, to the settings a user chose. */
   capture = (options) => {
     this.#selected = this.#selected.map((selection) => {
       const current = options.find(
         (option) => option.id === selection.configId && option.type === selection.type
       );
-      if (current === void 0) {
-        return selection;
-      }
-      return current.type === "boolean" ? { booleanValue: current.booleanValue, configId: current.id, type: "boolean" } : { configId: current.id, type: "select", value: current.currentValue };
+      return current === void 0 ? selection : storedSessionConfiguration(current);
     });
   };
   select = (option) => {
-    const selected = option.type === "boolean" ? { booleanValue: option.booleanValue, configId: option.id, type: "boolean" } : { configId: option.id, type: "select", value: option.currentValue };
+    const selected = storedSessionConfiguration(option);
     this.#selected = [...this.#selected.filter((selection) => selection.configId !== selected.configId), selected];
   };
   restore = async (stored, options, apply, signal) => {
     this.#selected = stored;
-    for (const selection of this.#selected) {
-      const current = options().find(
-        (option) => option.id === selection.configId && option.type === selection.type
-      );
-      if (current === void 0) {
-        continue;
-      }
-      if (selection.type === "boolean") {
-        if (current.booleanValue !== selection.booleanValue) {
-          await apply(selection, signal);
-        }
-        continue;
-      }
-      if (current.currentValue !== selection.value && current.values.some((value) => value.value === selection.value)) {
-        await apply(selection, signal);
-      }
-    }
+    await replaySessionConfigurations(stored, options, apply, signal);
   };
 };
 
@@ -86475,11 +86495,8 @@ var AgentSession = class _AgentSession {
     }
   };
   restoreStoredConfigurations = async (session, signal, intent = "restore") => {
-    const configurations = intent === "fork" ? session.configurations.toSorted(
-      (left, right) => Number(right.configId === "model") - Number(left.configId === "model")
-    ) : session.configurations;
     await this.#sessionConfigurations.restore(
-      configurations,
+      session.configurations,
       () => this.#configOptions,
       this.#applyConfiguration,
       signal
@@ -87372,35 +87389,21 @@ var SessionManager2 = class {
         )
       );
       try {
-        for (const desired of desiredConfigOptions) {
-          const current = runtime.prepared().configOptions.find((option) => option.id === desired.id);
-          if (current === void 0 || current.type !== desired.type) {
-            continue;
-          }
-          if (desired.type === "boolean") {
-            if (current.booleanValue !== desired.booleanValue) {
-              await runtime.applyConfiguration({
-                ...options,
-                booleanValue: desired.booleanValue,
-                configId: desired.id,
-                requestId: `execution-prepare-${desired.id}`,
-                value: "",
-                valueType: "boolean"
-              });
-            }
-            continue;
-          }
-          if (current.currentValue !== desired.currentValue && current.values.some((value) => value.value === desired.currentValue)) {
+        await replaySessionConfigurations(
+          desiredConfigOptions.map(storedSessionConfiguration),
+          () => runtime.prepared().configOptions,
+          async (desired) => {
             await runtime.applyConfiguration({
               ...options,
-              booleanValue: false,
-              configId: desired.id,
-              requestId: `execution-prepare-${desired.id}`,
-              value: desired.currentValue,
-              valueType: "select"
+              booleanValue: desired.type === "boolean" && desired.booleanValue,
+              configId: desired.configId,
+              requestId: `execution-prepare-${desired.configId}`,
+              value: desired.type === "select" ? desired.value : "",
+              valueType: desired.type
             });
-          }
-        }
+          },
+          options.signal
+        );
       } catch (error62) {
         await this.#retireSessionProcess(options.sessionId, runtime, async () => await runtime.close());
         throw error62;
@@ -87534,9 +87537,7 @@ var SessionManager2 = class {
         const prepared = runtime.prepared();
         const discoveredModelEffort = runtime.agentSettingsModelEffort();
         const model = options2.model;
-        const modelOption2 = prepared.configOptions.find(
-          (option) => option.id === "model" || option.category === "model"
-        );
+        const modelOption2 = prepared.configOptions.find(isModelOption);
         const modelIsFixed = modelOption2?.type === "select" && modelOption2.values.length < 2 && modelOption2.currentValue === model;
         const configOptions = model === void 0 || modelIsFixed ? prepared.configOptions : (await runtime.applyConfiguration({
           ...options2,
@@ -88614,10 +88615,13 @@ var PromptLifecycle = class {
       );
     }
   };
-  /** Settles a failed command; whether it failed before or after starting is its receipt's fact. */
+  /**
+   * Settles a failed command; whether it failed before or after starting is its receipt's fact. The unsettled
+   * receipt, not the queue registration, admits the failure: a turn that ended without recording its terminal
+   * event has already left the queue, and its abandonment must still settle it.
+   */
   failed = async (sessionId, commandId, attemptId, code, message) => {
-    const request = this.#queued.get(commandId);
-    if (request?.sessionId !== sessionId || this.#executions.isTerminalExecution(commandId, sessionId)) {
+    if (this.#executions.findUnsettledAttemptId(commandId, sessionId) === null) {
       return;
     }
     const recorded = await this.#recordLifecycle(sessionId, {
@@ -88684,6 +88688,13 @@ function cancelledBeforeStart(state) {
   const outcome = decodeKnownSessionEventPayload(JSON.parse(state.outcome));
   return outcome?.type === "lifecycle-metadata" && outcome.payload.kind === "prompt.completed" && promptCompletion(outcome.payload).kind === "cancelled";
 }
+function restartedBeforeStart(state) {
+  if (state.kind !== "settled-before-start") {
+    return false;
+  }
+  const outcome = decodeKnownSessionEventPayload(JSON.parse(state.outcome));
+  return outcome?.type === "lifecycle-metadata" && outcome.payload.kind === "prompt.failed-before-start" && outcome.payload.code === "runtime_restarted";
+}
 function executionOutcome(state) {
   switch (state.kind) {
     case "pending":
@@ -88701,6 +88712,31 @@ function executionOutcome(state) {
 function settledExecution(state, outcome) {
   return { kind: executionStarted(state) ? "settled-after-start" : "settled-before-start", outcome };
 }
+function commandStanding({ receipt, identity: identity2, cancellation }, sessionId) {
+  if (receipt !== void 0) {
+    if (receipt.sessionId !== sessionId) {
+      return { kind: "foreign" };
+    }
+    if (!executionStarted(receipt.state) && !cancelledBeforeStart(receipt.state) && cancellation?.sessionId === sessionId) {
+      return { kind: "cancelled", receipt };
+    }
+    return restartedBeforeStart(receipt.state) ? { kind: "retryable", receipt } : { kind: "retained", receipt };
+  }
+  if (identity2 !== void 0) {
+    return identity2.sessionId === sessionId ? { kind: "expired", commandHash: identity2.commandHash } : { kind: "foreign" };
+  }
+  if (cancellation !== void 0) {
+    return cancellation.sessionId === sessionId ? { kind: "cancelled", receipt: void 0 } : { kind: "foreign" };
+  }
+  return { kind: "unseen" };
+}
+var cancelledBeforeStartOutcome = (commandId) => ({
+  type: "lifecycle-metadata",
+  payload: { kind: "prompt.completed", commandId, stopReason: "cancelled", execution: "not-started" }
+});
+var unexpectedStanding = (standing) => {
+  throw new Error("Unexpected command standing", { cause: standing });
+};
 var ExecutionReceipts = class {
   #executions = /* @__PURE__ */ new Map();
   #recoveredCommands = /* @__PURE__ */ new Set();
@@ -88727,6 +88763,19 @@ var ExecutionReceipts = class {
     }
     cancellations.retain(retained);
   }
+  /** Reads every ledger that can still change the answer and classifies the identifier for the Session. */
+  #standing = (commandId, sessionId) => {
+    const receipt = this.#executions.get(commandId);
+    const final = receipt !== void 0 && (executionStarted(receipt.state) || cancelledBeforeStart(receipt.state));
+    return commandStanding(
+      {
+        receipt,
+        identity: receipt === void 0 ? this.#table.identity(commandId) : void 0,
+        cancellation: final ? void 0 : this.#cancellations.read(commandId)
+      },
+      sessionId
+    );
+  };
   #remember = (commandId, receipt, evicted) => {
     this.#executions.set(commandId, receipt);
     for (const evictedCommandId of evicted) {
@@ -88776,14 +88825,22 @@ var ExecutionReceipts = class {
   };
   /** The command's delivery as these receipts know it; another Session's command reads as unknown. */
   delivery = (commandId, sessionId) => {
-    const receipt = this.#executions.get(commandId);
-    if (receipt === void 0) {
-      return this.#table.identity(commandId)?.sessionId === sessionId || this.#cancellations.read(commandId)?.sessionId === sessionId ? { state: "expired" } : { state: "unknown" };
-    }
-    if (receipt.sessionId !== sessionId) {
-      return { state: "unknown" };
+    const standing = this.#standing(commandId, sessionId);
+    switch (standing.kind) {
+      case "unseen":
+      case "foreign":
+        return { state: "unknown" };
+      case "expired":
+        return { state: "expired" };
+      case "cancelled":
+        return { state: "completed", stopReason: "cancelled" };
+      case "retryable":
+      case "retained":
+        break;
+      default:
+        return unexpectedStanding(standing);
     }
-    if (executionOutcome(receipt.state) === null) {
+    if (executionOutcome(standing.receipt.state) === null) {
       return { state: "accepted" };
     }
     const outcome = this.outcome(commandId);
@@ -88836,38 +88893,43 @@ var ExecutionReceipts = class {
   };
   /** Started identities remain authoritative after their detailed receipt is evicted. */
   hasStarted = (commandId, sessionId) => {
-    const receipt = this.#executions.get(commandId);
-    return receipt?.sessionId === sessionId && executionStarted(receipt.state) || this.#table.identity(commandId)?.sessionId === sessionId;
+    const standing = this.#standing(commandId, sessionId);
+    switch (standing.kind) {
+      case "unseen":
+      case "foreign":
+      case "cancelled":
+      case "retryable":
+        return false;
+      case "expired":
+        return true;
+      case "retained":
+        return executionStarted(standing.receipt.state);
+      default:
+        return unexpectedStanding(standing);
+    }
   };
   /** Reserves an unseen command for cancellation before a delayed prompt can claim its identity. */
   recordCancellationBeforeAdmission = (commandId, sessionId) => {
-    const existing = this.#executions.get(commandId);
-    if (existing !== void 0) {
-      return existing.sessionId === sessionId ? this.outcome(commandId) : void 0;
-    }
-    const identity2 = this.#table.identity(commandId);
-    if (identity2 !== void 0) {
-      return identity2.sessionId === sessionId ? {
-        type: "lifecycle-metadata",
-        payload: { kind: "prompt.completed", commandId, stopReason: "cancelled" }
-      } : void 0;
-    }
-    const cancellation = this.#cancellations.read(commandId);
-    if (cancellation !== void 0) {
-      return cancellation.sessionId === sessionId ? {
-        type: "lifecycle-metadata",
-        payload: {
-          kind: "prompt.completed",
-          commandId,
-          stopReason: "cancelled",
-          execution: "not-started"
-        }
-      } : void 0;
+    const standing = this.#standing(commandId, sessionId);
+    switch (standing.kind) {
+      case "foreign":
+        return void 0;
+      case "retryable":
+      case "retained":
+        return this.outcome(commandId);
+      case "expired":
+        return {
+          type: "lifecycle-metadata",
+          payload: { kind: "prompt.completed", commandId, stopReason: "cancelled" }
+        };
+      case "cancelled":
+        return cancelledBeforeStartOutcome(commandId);
+      case "unseen":
+        break;
+      default:
+        return unexpectedStanding(standing);
     }
-    const outcome = {
-      type: "lifecycle-metadata",
-      payload: { kind: "prompt.completed", commandId, stopReason: "cancelled", execution: "not-started" }
-    };
+    const outcome = cancelledBeforeStartOutcome(commandId);
     const commandHash = createHash8("sha256").update(
       encodeSessionCancelBeforeStartCommand({
         commandId,
@@ -88923,16 +88985,8 @@ var ExecutionReceipts = class {
     const recovered = [];
     for (const [commandId, receipt] of [...this.#executions]) {
       const outcome = executionOutcome(receipt.state);
-      const restoreCancellation = !this.hasStarted(commandId, receipt.sessionId) && !cancelledBeforeStart(receipt.state) && this.#cancellations.read(commandId)?.sessionId === receipt.sessionId;
-      const event = restoreCancellation ? {
-        type: "lifecycle-metadata",
-        payload: {
-          kind: "prompt.completed",
-          commandId,
-          stopReason: "cancelled",
-          execution: "not-started"
-        }
-      } : outcome === null ? {
+      const restoreCancellation = this.#standing(commandId, receipt.sessionId).kind === "cancelled";
+      const event = restoreCancellation ? cancelledBeforeStartOutcome(commandId) : outcome === null ? {
         type: "lifecycle-metadata",
         payload: executionStarted(receipt.state) ? {
           kind: "prompt.failed",
@@ -88963,31 +89017,32 @@ var ExecutionReceipts = class {
   };
   claimExecution = (commandId, sessionId, commandJson) => {
     const commandHash = createHash8("sha256").update(commandJson).digest("hex");
-    let existing = this.#executions.get(commandId);
-    const previous = this.outcome(commandId);
-    if (existing?.sessionId === sessionId && !executionStarted(existing.state) && previous?.type === "lifecycle-metadata" && previous.payload.kind === "prompt.failed-before-start" && previous.payload.code === "runtime_restarted") {
-      this.#table.remove(commandId);
-      this.#executions.delete(commandId);
-      this.#recoveredCommands.delete(commandId);
-      existing = void 0;
-    }
-    if (existing !== void 0) {
-      if (existing.sessionId !== sessionId || existing.commandHash !== commandHash) {
+    const standing = this.#standing(commandId, sessionId);
+    switch (standing.kind) {
+      case "foreign":
+      case "cancelled":
         return { kind: "conflict" };
-      }
-      return {
-        attemptId: existing.attemptId,
-        commandId,
-        kind: "duplicate",
-        outcome: this.#recoveredCommands.has(commandId) ? this.outcome(commandId) : void 0
-      };
-    }
-    const identity2 = this.#table.identity(commandId);
-    if (identity2 !== void 0) {
-      return identity2.sessionId === sessionId && identity2.commandHash === commandHash ? { kind: "expired" } : { kind: "conflict" };
-    }
-    if (this.#cancellations.read(commandId) !== void 0) {
-      return { kind: "conflict" };
+      case "retained":
+        if (standing.receipt.commandHash !== commandHash) {
+          return { kind: "conflict" };
+        }
+        return {
+          attemptId: standing.receipt.attemptId,
+          commandId,
+          kind: "duplicate",
+          outcome: this.#recoveredCommands.has(commandId) ? this.outcome(commandId) : void 0
+        };
+      case "expired":
+        return standing.commandHash === commandHash ? { kind: "expired" } : { kind: "conflict" };
+      case "retryable":
+        this.#table.remove(commandId);
+        this.#executions.delete(commandId);
+        this.#recoveredCommands.delete(commandId);
+        return this.claimExecution(commandId, sessionId, commandJson);
+      case "unseen":
+        break;
+      default:
+        return unexpectedStanding(standing);
     }
     const attemptId = randomUUID15();
     this.#save(commandId, {
@@ -90771,7 +90826,7 @@ function withoutUnsupportedModels(settings, modelSettingId, unsupportedModelIds2
   });
 }
 function modelOption(options) {
-  return options.find((option) => option.id === "model" || option.category === "model");
+  return options.find(isModelOption);
 }
 function effortOption(options) {
   return options.find((option) => option.id === "reasoning_effort" || option.category === "thought_level");
@@ -91803,19 +91858,6 @@ function sessionConfigurationMatches(option, selection) {
   validateSessionConfigurationSelection(option, selection);
   return option.type === "boolean" ? option.booleanValue === selection.booleanValue : option.currentValue === selection.value;
 }
-function sessionConfigurationPriority(selection, options) {
-  const option = options.find((candidate) => candidate.id === selection.configId);
-  if (selection.configId === "model" || option?.category === "model") {
-    return 0;
-  }
-  if (selection.configId === "reasoning_effort" || option?.category === "thought_level") {
-    return 1;
-  }
-  if (option?.category === "model_config") {
-    return 2;
-  }
-  return 3;
-}
 function assertAppliedSessionConfiguration(options, selections) {
   const selectionsById = new Map(selections.map((selection) => [selection.configId, selection]));
   for (const option of options) {
@@ -91906,11 +91948,7 @@ async function applySessionConfigurationSelection(sessions, options, selection,
 }
 async function applyCompleteSessionConfiguration(sessions, initialOptions, selections, agent, adapter, cwd, additionalDirectories, commandId, sessionId, signal) {
   let options = initialOptions;
-  const orderedSelections = selections.toSorted((left, right) => {
-    const priority = sessionConfigurationPriority(left, initialOptions) - sessionConfigurationPriority(right, initialOptions);
-    return priority === 0 ? left.configId.localeCompare(right.configId) : priority;
-  });
-  for (const selection of orderedSelections) {
+  for (const selection of inDependencyOrder(selections, initialOptions)) {
     options = await applySessionConfigurationSelection(
       sessions,
       options,
@@ -93839,4 +93877,4 @@ export {
   * MIT Licensed
   *)
 */
-//# sourceMappingURL=chunk-CHYQFODX.js.map
+//# sourceMappingURL=chunk-3GLSEDI2.js.map