@moxt-ai/mobius 0.0.410 → 0.0.412

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

@@ -3,7 +3,7 @@ import {
   __export,
   __using,
   package_default
-} from "./chunk-M4L66DBW.js";
+} from "./chunk-PMJDO7PC.js";
 
 // src/engine/runtime/relay/runtime-revocation.ts
 var runtimeRevocationCloseCode = 1008;
@@ -20159,6 +20159,9 @@ var agentModelEffortSchema = external_exports.object({
 }).readonly();
 var agentSettingsDiscoverCommandSchema = external_exports.object({
   agentId: identifierStringSchema,
+  // The directory a Session would start in, whose project settings the Agent reads. Omitted, the Runtime's
+  // default directory. A Runtime that predates this field ignores it; see the discovered event's `directoryId`.
+  directoryId: DIRECTORY_IDENTIFIER.optional(),
   kind: external_exports.literal(AGENT_SETTINGS_DISCOVER_KIND),
   model: external_exports.string().min(1).max(500).optional(),
   requestId: identifierStringSchema
@@ -20167,6 +20170,9 @@ var agentSettingsDiscoveredEventSchema = external_exports.object({
   agentId: identifierStringSchema,
   agentName: external_exports.string().max(255),
   agentVersion: external_exports.string().max(128),
+  // The directory the settings were discovered in. Absent from older Runtimes, which always discover in the
+  // Runtime's default directory whatever the command named.
+  directoryId: DIRECTORY_IDENTIFIER.optional(),
   kind: external_exports.literal(AGENT_SETTINGS_DISCOVERED_KIND),
   modelEffort: agentModelEffortSchema,
   requestId: identifierStringSchema,
@@ -20798,9 +20804,10 @@ var sessionEventPayloadSchema = external_exports.discriminatedUnion("type", [
   external_exports.object({ payload: lifecycleMetadataSchema, type: external_exports.literal("lifecycle-metadata") }).readonly()
 ]);
 var positionSchema = external_exports.string().regex(/^(0|[1-9][0-9]*)$/);
+var mobiusMetadataFields = { omitted: external_exports.literal(true).optional(), restated: external_exports.literal(true).optional() };
 var sharedSessionEventFields = {
   eventId: identifierStringSchema,
-  mobiusMetadata: external_exports.object({ omitted: external_exports.literal(true).optional() }).readonly().optional(),
+  mobiusMetadata: external_exports.object(mobiusMetadataFields).readonly().optional(),
   recordedAt: external_exports.iso.datetime({ offset: true }),
   sessionGenerationId: identifierStringSchema,
   sessionId: identifierStringSchema
@@ -20823,7 +20830,7 @@ var wireLifecyclePayloadSchema = external_exports.object({
 }).passthrough().readonly();
 var wireEventFields = {
   ...sessionLiveEventFields,
-  mobiusMetadata: external_exports.object({ omitted: external_exports.literal(true).optional() }).passthrough().readonly().optional()
+  mobiusMetadata: external_exports.object(mobiusMetadataFields).passthrough().readonly().optional()
 };
 var sessionWireEventSchema = external_exports.union([
   external_exports.object({
@@ -88600,8 +88607,10 @@ var PromptLifecycle = class {
   #recordActiveTurn;
   #executions;
   #recordLifecycle;
-  constructor(sink, recordLifecycle, recordActiveTurn, executions) {
+  #append;
+  constructor(sink, recordLifecycle, append, recordActiveTurn, executions) {
     this.#recordLifecycle = recordLifecycle;
+    this.#append = append;
     this.#recordActiveTurn = recordActiveTurn;
     this.#executions = executions;
     this.#sink = sink;
@@ -88640,16 +88649,20 @@ var PromptLifecycle = class {
     const sessionId = recorded.sessionId;
     if (recorded.type === "lifecycle-metadata" && isPromptTerminal(recorded.payload)) {
       this.#terminal.set(recorded.payload.commandId, recorded);
-      const pending2 = this.#publications.get(sessionId) ?? [];
-      pending2.push(recorded);
-      this.#publications.set(sessionId, pending2);
+      const pending = this.#publications.get(sessionId) ?? [];
+      pending.push(recorded);
+      this.#publications.set(sessionId, pending);
       return;
     }
-    const pending = this.#publications.get(sessionId);
+    this.#publishInOrder(recorded);
+  };
+  /** Publishes after the Session's held terminal events, so clients receive its events in order. */
+  #publishInOrder = (event) => {
+    const pending = this.#publications.get(event.sessionId);
     if (pending !== void 0) {
-      pending.push(recorded);
+      pending.push(event);
     } else {
-      this.#sink.publish(recorded);
+      this.#sink.publish(event);
     }
   };
   publishTerminal = (sessionId, commandId) => {
@@ -88674,13 +88687,24 @@ var PromptLifecycle = class {
     }
     this.#queued.delete(commandId);
   };
-  replayOutcome = async (sessionId, event) => {
+  recordOutcome = async (sessionId, event) => {
     if (event.type !== "lifecycle-metadata" || !("commandId" in event.payload)) {
       return;
     }
     await this.#recordLifecycle(sessionId, event);
     this.publishTerminal(sessionId, event.payload.commandId);
   };
+  /**
+   * Answers a retried request about a command with the outcome its receipt already holds. The restatement is marked,
+   * so Recording and status notifications do not take it for a new outcome, and it does not settle the receipt again.
+   */
+  restateOutcome = (sessionId, event) => {
+    if (event.type !== "lifecycle-metadata" || !("commandId" in event.payload)) {
+      return;
+    }
+    const restated = this.#append(sessionId, event);
+    this.#publishInOrder({ ...restated, mobiusMetadata: { ...restated.mobiusMetadata, restated: true } });
+  };
   queueChanged = async (sessionId, commandId) => {
     await this.#recordLifecycle(sessionId, {
       type: "lifecycle-metadata",
@@ -88739,10 +88763,16 @@ var PromptLifecycle = class {
   });
 };
 async function settleAbandonedTurn(projection, operations, cancellation) {
-  const outcome = operations.recordCancellationBeforeAdmission(cancellation.commandId, cancellation.sessionId);
-  if (outcome !== void 0) {
-    await projection.replayOutcome(cancellation.sessionId, outcome);
-    return;
+  const cancelled = operations.recordCancellationBeforeAdmission(cancellation.commandId, cancellation.sessionId);
+  switch (cancelled.kind) {
+    case "recorded":
+      await projection.recordOutcome(cancellation.sessionId, cancelled.outcome);
+      return;
+    case "restated":
+      projection.restateOutcome(cancellation.sessionId, cancelled.outcome);
+      return;
+    case "unavailable":
+      break;
   }
   const attemptId = operations.findUnsettledAttemptId(cancellation.commandId, cancellation.sessionId);
   if (attemptId === null) {
@@ -88834,7 +88864,6 @@ var unexpectedStanding = (standing) => {
 };
 var ExecutionReceipts = class {
   #executions = /* @__PURE__ */ new Map();
-  #recoveredCommands = /* @__PURE__ */ new Set();
   #table;
   #cancellations;
   #closing = false;
@@ -88854,7 +88883,6 @@ var ExecutionReceipts = class {
       if (cancelledBeforeStart(state)) {
         retained.push({ commandId, sessionId: identity2.sessionId });
       }
-      this.#recoveredCommands.add(commandId);
     }
     cancellations.retain(retained);
   }
@@ -88875,7 +88903,6 @@ var ExecutionReceipts = class {
     this.#executions.set(commandId, receipt);
     for (const evictedCommandId of evicted) {
       this.#executions.delete(evictedCommandId);
-      this.#recoveredCommands.delete(evictedCommandId);
     }
     let activeCount = 0;
     for (const entry of this.#executions.values()) {
@@ -89008,22 +89035,30 @@ var ExecutionReceipts = class {
         return unexpectedStanding(standing);
     }
   };
-  /** Reserves an unseen command for cancellation before a delayed prompt can claim its identity. */
+  /**
+   * Reserves an unseen command for cancellation before a delayed prompt can claim its identity. A command that
+   * already has an outcome keeps it, and the outcome is restated rather than recorded again.
+   */
   recordCancellationBeforeAdmission = (commandId, sessionId) => {
     const standing = this.#standing(commandId, sessionId);
     switch (standing.kind) {
       case "foreign":
-        return void 0;
+        return { kind: "unavailable" };
       case "retryable":
-      case "retained":
-        return this.outcome(commandId);
+      case "retained": {
+        const outcome2 = this.outcome(commandId);
+        return outcome2 === void 0 ? { kind: "unavailable" } : { kind: "restated", outcome: outcome2 };
+      }
       case "expired":
         return {
-          type: "lifecycle-metadata",
-          payload: { kind: "prompt.completed", commandId, stopReason: "cancelled" }
+          kind: "restated",
+          outcome: {
+            type: "lifecycle-metadata",
+            payload: { kind: "prompt.completed", commandId, stopReason: "cancelled" }
+          }
         };
       case "cancelled":
-        return cancelledBeforeStartOutcome(commandId);
+        return { kind: "restated", outcome: cancelledBeforeStartOutcome(commandId) };
       case "unseen":
         break;
       default:
@@ -89047,7 +89082,7 @@ var ExecutionReceipts = class {
         outcome: JSON.stringify({ ...outcome, recordedAt: (/* @__PURE__ */ new Date()).toISOString() })
       }
     });
-    return outcome;
+    return { kind: "recorded", outcome };
   };
   /**
    * Receipts follow their command's recorded lifecycle. `prompt.started` is recorded where the command is handed
@@ -89130,14 +89165,13 @@ var ExecutionReceipts = class {
           attemptId: standing.receipt.attemptId,
           commandId,
           kind: "duplicate",
-          outcome: this.#recoveredCommands.has(commandId) ? this.outcome(commandId) : void 0
+          state: executionOutcome(standing.receipt.state) === null ? "unsettled" : "settled"
         };
       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;
@@ -89165,7 +89199,6 @@ var ExecutionReceipts = class {
   };
   close = () => {
     this.#executions.clear();
-    this.#recoveredCommands.clear();
     this.#cancellations.close();
   };
 };
@@ -89827,6 +89860,7 @@ function buildSessionLayer(options) {
       eventProjection.record(recorded);
       return true;
     },
+    (sessionId, event) => events.append(sessionId, event),
     activeSessions.recordSessionEvent,
     operations
   );
@@ -90805,7 +90839,8 @@ function unsupportedModelIds(unsupportedModels) {
 }
 async function discoverAgentSettings(command, resolveAgent, bindingId, directories, sessions, signal) {
   const { agent, adapter: harnessAdapter } = await resolveAgent(command.agentId, signal);
-  const cwd = await directories.resolve(bindingId, "default", signal);
+  const directoryId = command.directoryId ?? "default";
+  const cwd = await directories.resolve(bindingId, directoryId, signal);
   const inspectedBaseSnapshot = await sessions.inspectAgentSettings({
     adapter: harnessAdapter,
     additionalDirectories: [],
@@ -90879,6 +90914,7 @@ async function discoverAgentSettings(command, resolveAgent, bindingId, directori
       agentId: command.agentId,
       agentName: selectedSnapshot.agentName,
       agentVersion: selectedSnapshot.agentVersion,
+      directoryId,
       kind: AGENT_SETTINGS_DISCOVERED_KIND,
       modelEffort,
       requestId: command.requestId,
@@ -91068,8 +91104,9 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
   const { config: config2, directories, sessions, diagnostics, socket, signal, timer } = dependencies;
   const agentSettingsDiscoveries = /* @__PURE__ */ new Map();
   const handle = (command) => {
+    const directoryId = command.directoryId ?? "default";
     const existing = [...agentSettingsDiscoveries.values()].find(
-      (request) => request.agentId === command.agentId && !request.controller.signal.aborted
+      (request) => request.agentId === command.agentId && request.directoryId === directoryId && !request.controller.signal.aborted
     );
     if ([...agentSettingsDiscoveries.values()].some((request) => request.requestIds.has(command.requestId))) {
       if (socket.readyState === WebSocket4.OPEN) {
@@ -91167,6 +91204,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
     })();
     agentSettingsDiscoveries.set(command.requestId, {
       agentId: command.agentId,
+      directoryId,
       model: command.model,
       requestIds,
       completion,
@@ -91703,9 +91741,14 @@ var sessionCancelBeforeStartCommand = {
     }
     const turn = sessionTurns.get(message.commandId, message.sessionId);
     if (turn === void 0) {
-      const outcome = operations.recordCancellationBeforeAdmission(message.commandId, message.sessionId);
+      const cancelled = operations.recordCancellationBeforeAdmission(message.commandId, message.sessionId);
+      const outcome = cancelled.kind === "unavailable" ? void 0 : cancelled.outcome;
       if (outcome?.type === "lifecycle-metadata" && outcome.payload.kind === "prompt.completed" && promptCompletion(outcome.payload).kind === "cancelled") {
-        void eventProjection.replayOutcome(message.sessionId, outcome).catch((error62) => {
+        if (cancelled.kind === "restated") {
+          eventProjection.restateOutcome(message.sessionId, outcome);
+          return;
+        }
+        void eventProjection.recordOutcome(message.sessionId, outcome).catch((error62) => {
           reportOperationFailure(socket, message.commandId, message.sessionId, error62);
         });
         return;
@@ -92268,18 +92311,15 @@ var sessionPromptCommand = {
       return;
     }
     if (receipt.kind === "duplicate") {
-      const outcome = receipt.outcome;
-      const original = context.sessionTurns.get(message.commandId, message.sessionId);
       send(context.socket, {
         kind: "session.prompt.accepted",
         requestId: message.commandId,
         sessionId: message.sessionId,
-        state: outcome !== void 0 ? "settled" : original?.isQueued() === true ? "queued" : "running"
+        state: receipt.state === "settled" ? "settled" : context.sessionTurns.get(message.commandId, message.sessionId)?.isQueued() === true ? "queued" : "running"
       });
+      const outcome = receipt.state === "settled" ? context.operations.outcome(message.commandId) : void 0;
       if (outcome !== void 0) {
-        void context.eventProjection.replayOutcome(message.sessionId, outcome).catch((cause) => {
-          console.error("Could not replay the persisted execution outcome", cause);
-        });
+        context.eventProjection.restateOutcome(message.sessionId, outcome);
       }
       return;
     }
@@ -94000,4 +94040,4 @@ export {
   * MIT Licensed
   *)
 */
-//# sourceMappingURL=chunk-2S33N4G2.js.map
+//# sourceMappingURL=chunk-7ER5P6H5.js.map