replicas-engine 0.1.648 → 0.1.650

package/dist/src/{chunk-UOZJPW3V.js → chunk-2TB75JBR.js}

@@ -5922,7 +5922,7 @@ var DEFAULT_CODEX_ARGS = [
 var MIN_CODEX_CLI_VERSION = "0.144.6";
 var CODEX_UPGRADE_TIMEOUT_MS = 12e4;
 var codexCliVersionEnsured = null;
-var ENGINE_PACKAGE_VERSION = "0.1.648";
+var ENGINE_PACKAGE_VERSION = "0.1.650";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";

package/dist/src/headless-agent.js

@@ -7,7 +7,7 @@ import {
   isUnsafeMemoryOutput,
   putPresignedFile,
   recoverCompletedTurn
-} from "./chunk-UOZJPW3V.js";
+} from "./chunk-2TB75JBR.js";
 
 // src/headless-agent.ts
 import { createHash } from "crypto";

package/dist/src/index.js

@@ -172,7 +172,7 @@ import {
   serializeCanvasContentResponse,
   shellQuotePosix,
   stripAgentDiagnosticErrors
-} from "./chunk-UOZJPW3V.js";
+} from "./chunk-2TB75JBR.js";
 
 // src/index.ts
 import { serve } from "@hono/node-server";
@@ -3518,7 +3518,11 @@ var CodingAgentManager = class {
     this.initialized = this.initialize();
   }
   async interrupt() {
-    const { queue, isProcessing } = this.drainQueueForInterrupt();
+    const queue = this.messageQueue.drainQueue({
+      maxItems: MAX_INTERRUPT_QUEUE_ITEMS,
+      maxChars: MAX_INTERRUPT_QUEUE_CHARS
+    });
+    const isProcessing = this.isProcessing();
     if (isProcessing) {
       await this.interruptActiveTurn();
       const event = {
@@ -3638,16 +3642,6 @@ var CodingAgentManager = class {
     }
     return parts.length > 0 ? parts.join("\n\n") : void 0;
   }
-  drainQueueForInterrupt() {
-    const queue = this.messageQueue.drainQueue({
-      maxItems: MAX_INTERRUPT_QUEUE_ITEMS,
-      maxChars: MAX_INTERRUPT_QUEUE_CHARS
-    });
-    return {
-      queue,
-      isProcessing: this.messageQueue.isProcessing()
-    };
-  }
   emitInterruptedQueueEvent(queue) {
     const linearSessionId = ENGINE_ENV.REPLICAS_LINEAR_SESSION_ID;
     if (!linearSessionId || queue.length === 0) {
@@ -3744,6 +3738,7 @@ function buildClaudeAgentEnv(overrides) {
   env.GH_CONFIG_DIR = void 0;
   env.CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD = "1";
   env.CLAUDE_CODE_DISABLE_AUTO_MEMORY = "1";
+  env.CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS = "1";
   return env;
 }
 function shouldStripAnthropicApiKey(isBedrock) {
@@ -4513,6 +4508,9 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   backgroundContinuationTimer = null;
   pendingInterrupt = false;
   activeBackgroundTasks = /* @__PURE__ */ new Set();
+  // Set when background tasks outlive a turn; cleared once their completion
+  // has been reported through onTurnComplete.
+  pendingBackgroundCompletion = false;
   partialMessageStreams = /* @__PURE__ */ new Map();
   partialMessageFlushTimers = /* @__PURE__ */ new Map();
   systemPromptOverride;
@@ -4581,7 +4579,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     return super.isProcessing() || isClaudeSessionActive(this.sessionActivity) || this.activeBackgroundTasks.size > 0;
   }
   hasActiveBackgroundTasks() {
-    return this.activeBackgroundTasks.size > 0;
+    return this.activeBackgroundTasks.size > 0 || this.pendingBackgroundCompletion && isClaudeSessionActive(this.sessionActivity) && !this.messageQueue.isProcessing();
   }
   async listSlashCommands() {
     await this.initialized;
@@ -5189,6 +5187,9 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
         if (hadActiveBackgroundTasks && this.activeBackgroundTasks.size === 0) {
           this.startBackgroundContinuationGrace();
         }
+        if (!this.pendingTurn && this.activeBackgroundTasks.size > 0) {
+          this.pendingBackgroundCompletion = true;
+        }
         await this.handleMessage(msg);
         if (linearSessionId && this.sessionLinearForwarder) {
           this.sessionLinearForwarder.processClaudeEventForPlan(msg);
@@ -5199,6 +5200,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
           this.sessionLinearForwarder?.flushThoughtAsResponse();
           this.resolvePendingTurn();
         }
+        this.maybeCompleteBackgroundTurn();
       }
     } catch (error) {
       loopError = error;
@@ -5219,7 +5221,11 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       }
       this.failPendingTurn(pendingError);
       if (this.activeQuery === response) {
+        const orphanedBackgroundCompletion = this.pendingBackgroundCompletion && !this.messageQueue.isProcessing();
         this.clearSessionState();
+        if (orphanedBackgroundCompletion) {
+          this.notifyBackgroundTurnComplete();
+        }
       }
     }
   }
@@ -5234,6 +5240,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     this.clearBackgroundContinuationTimer();
     resetClaudeSessionActivity(this.sessionActivity);
     this.activeBackgroundTasks.clear();
+    this.pendingBackgroundCompletion = false;
     for (const timer of this.partialMessageFlushTimers.values()) {
       clearTimeout(timer);
     }
@@ -5245,8 +5252,19 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     if (!pending) return;
     this.pendingTurn = null;
     this.pendingInterrupt = false;
+    this.pendingBackgroundCompletion = this.activeBackgroundTasks.size > 0;
     pending.resolve();
   }
+  maybeCompleteBackgroundTurn() {
+    if (!this.pendingBackgroundCompletion || this.pendingTurn || this.messageQueue.isProcessing() || this.activeBackgroundTasks.size > 0 || isClaudeSessionActive(this.sessionActivity)) return;
+    this.pendingBackgroundCompletion = false;
+    this.notifyBackgroundTurnComplete();
+  }
+  notifyBackgroundTurnComplete() {
+    void this.historyFile.flush().then(() => this.onTurnComplete()).catch((error) => {
+      console.error("[ClaudeManager] Background turn completion failed:", error);
+    });
+  }
   failPendingTurn(err) {
     const pending = this.pendingTurn;
     if (!pending) return;
@@ -5261,6 +5279,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       this.backgroundContinuationTimer = null;
       if (this.activeBackgroundTasks.size > 0 || !expireClaudeSessionFallbackContinuation(this.sessionActivity)) return;
       this.emitSyntheticEvent(CLAUDE_ACTIVITY_STATUS_EVENT_TYPE, { state: "idle" });
+      this.maybeCompleteBackgroundTurn();
     }, CLAUDE_BACKGROUND_CONTINUATION_GRACE_MS);
   }
   clearBackgroundContinuationTimer() {
@@ -5684,6 +5703,11 @@ var ACCOUNT_RATE_LIMITS_READ_METHOD = "account/rateLimits/read";
 var MODEL_LIST_METHOD = "model/list";
 var SKILLS_LIST_METHOD = "skills/list";
 var MAX_CODEX_ASP_TRANSCRIPT_OUTPUT_CHARS = DEFAULT_HOOK_OUTPUT_PREVIEW_CHARS;
+function getReconciledActiveTurnId(error, expectedTurnId) {
+  const message = error instanceof Error ? error.message : String(error);
+  const match = message.match(/expected active turn id ([0-9a-f-]{36}) but found ([0-9a-f-]{36})/i);
+  return match?.[1]?.toLowerCase() === expectedTurnId.toLowerCase() ? match[2] ?? null : null;
+}
 function codexApprovalPolicyOverrides() {
   return {
     approvalPolicy: "untrusted",
@@ -6433,15 +6457,43 @@ var CodexAspManager = class extends CodingAgentManager {
     if (!this.currentThreadId || !this.activeTurnId) {
       return;
     }
+    const threadId = this.currentThreadId;
+    const expectedTurnId = this.activeTurnId;
+    const result = await this.requestActiveTurnWithReconciliation(
+      "interrupt",
+      expectedTurnId,
+      (host, turnId) => host.client.request(
+        TURN_INTERRUPT_METHOD,
+        { threadId, turnId }
+      )
+    );
+    if (result.ok) return;
+    console.warn(
+      result.error.code === "retry_failed" ? "[CodexAspManager] Failed to interrupt reconciled active turn; leaving shared Codex app-server running:" : "[CodexAspManager] Failed to interrupt active turn:",
+      result.error.details
+    );
+  }
+  async requestActiveTurnWithReconciliation(operation, expectedTurnId, request) {
     try {
-      const host = await getCodexAspHost();
-      const params = {
-        threadId: this.currentThreadId,
-        turnId: this.activeTurnId
-      };
-      await host.client.request(TURN_INTERRUPT_METHOD, params);
+      await request(await getCodexAspHost(), expectedTurnId);
+      return createSuccessResult(expectedTurnId);
     } catch (error) {
-      console.warn("[CodexAspManager] Failed to interrupt active turn:", error);
+      const reconciledTurnId = getReconciledActiveTurnId(error, expectedTurnId);
+      if (!reconciledTurnId) {
+        return createErrorResult({ code: "request_failed", message: `Failed to ${operation} active turn`, details: error });
+      }
+      this.activeTurnId = reconciledTurnId;
+      console.warn(`[CodexAspManager] Active turn changed during ${operation}; retrying with provider turn:`, reconciledTurnId);
+      try {
+        await request(await getCodexAspHost(), reconciledTurnId);
+        return createSuccessResult(reconciledTurnId);
+      } catch (retryError) {
+        return createErrorResult({
+          code: "retry_failed",
+          message: `Failed to ${operation} reconciled active turn`,
+          details: retryError
+        });
+      }
     }
   }
   // Serialize so concurrent steers can't race one `turn/steer` RPC ahead of another.
@@ -6455,18 +6507,23 @@ var CodexAspManager = class extends CodingAgentManager {
     if (this.isCompacting()) return false;
     if (getGoalCommand(request.message, request.goalMode) || isCompactCommand(request.message)) return false;
     const { input, tempImagePaths } = await buildTurnInput(request);
-    try {
-      const host = await getCodexAspHost();
-      await host.client.request(
+    const result = await this.requestActiveTurnWithReconciliation(
+      "steer",
+      expectedTurnId,
+      (host, turnId) => host.client.request(
         TURN_STEER_METHOD,
-        { threadId, expectedTurnId, input }
-      );
-    } catch (error) {
+        { threadId, expectedTurnId: turnId, input }
+      )
+    );
+    if (!result.ok) {
       await removeTempImageFiles(tempImagePaths);
-      console.warn("[CodexAspManager] Failed to steer active turn, keeping message queued:", error);
+      console.warn(
+        result.error.code === "retry_failed" ? "[CodexAspManager] Failed to steer reconciled active turn, keeping message queued:" : "[CodexAspManager] Failed to steer active turn, keeping message queued:",
+        result.error.details
+      );
       return false;
     }
-    if (this.activeTurnId === expectedTurnId) {
+    if (this.activeTurnId === result.data) {
       this.steeredTempImagePaths.push(...tempImagePaths);
     } else {
       await removeTempImageFiles(tempImagePaths);
@@ -6842,7 +6899,7 @@ var CodexAspManager = class extends CodingAgentManager {
     const model = request.model ?? DEFAULT_MODEL;
     let tempImagePaths = [];
     const linearForwarder = new LinearEventForwarder(linearSessionId);
-    const matchesTurn = (notificationThreadId, notificationTurnId) => notificationThreadId === threadId && (!observedTurnId || notificationTurnId === null || notificationTurnId === observedTurnId);
+    const matchesTurn = (notificationThreadId, notificationTurnId) => notificationThreadId === threadId && (!observedTurnId || notificationTurnId === null || notificationTurnId === observedTurnId || notificationTurnId === this.activeTurnId);
     const resolveIfGoalIdle = () => {
       if (!lastCompletedTurn || completedResolved) return;
       if (!options.waitForActiveGoal || this.currentGoal?.status !== "active") {
@@ -6994,7 +7051,8 @@ var CodexAspManager = class extends CodingAgentManager {
       },
       [TURN_COMPLETED_METHOD]: (notification) => {
         if (notification.params.threadId !== threadId) return;
-        if (!observedTurnIds.has(notification.params.turn.id)) return;
+        if (!observedTurnIds.has(notification.params.turn.id) && notification.params.turn.id !== this.activeTurnId) return;
+        observedTurnIds.add(notification.params.turn.id);
         observedTurnId = notification.params.turn.id;
         const completedTurn = recoverCompletedTurn(notification.params.turn, completedItems, agentMessageDeltas);
         this.mergeTranscriptTurn(notification.params.threadId, completedTurn);
@@ -10645,7 +10703,7 @@ function hasActiveAgentWork(chat) {
   return chat.provider.isProcessing() || (chat.provider.hasActiveBackgroundTasks?.() ?? false);
 }
 function hasActiveChatTurn(chat) {
-  return chat.hasActiveTurn || chat.pendingMessageIds.length > 0;
+  return chat.hasActiveTurn || chat.pendingMessageIds.length > 0 || (chat.provider.hasActiveBackgroundTasks?.() ?? false);
 }
 function isPersistedChat(value) {
   if (!isRecord2(value)) {
@@ -11392,17 +11450,13 @@ var ChatService = class {
     if (!chat.hasActiveTurn) {
       const queuedMessageIds = new Set(chat.provider.getQueue().map((message) => message.id));
       const completedMessageId = chat.pendingMessageIds.find((messageId) => !queuedMessageIds.has(messageId));
-      if (!completedMessageId) {
-        await this.publishAgentTurnCompleteWebhook(chat);
-        return;
-      }
       chat.pendingMessageIds = chat.pendingMessageIds.filter((messageId) => messageId !== completedMessageId);
     }
     chat.hasActiveTurn = false;
     chat.activeMessageId = null;
     this.agentChatActivityTrackerService.noteTurnEnded(chatId);
     const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const processing = chat.provider.getQueue().length > 0;
+    const processing = chat.provider.getQueue().length > 0 || (chat.provider.hasActiveBackgroundTasks?.() ?? false);
     this.publish({
       type: "chat.turn.completed",
       payload: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.648",
+  "version": "0.1.650",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",