replicas-engine 0.1.986 → 0.1.988

package/dist/src/{asp-host-Q474L67V.js → asp-host-64RO3V36.js}

@@ -5,12 +5,12 @@ import {
   getCodexAspHost,
   restartCodexAspHost,
   restartCodexAspHostIfRunning
-} from "./chunk-O2ZKAC2G.js";
-import "./chunk-Z3D5SVUI.js";
-import "./chunk-SAJ6ERGR.js";
-import "./chunk-4WBOMDAN.js";
+} from "./chunk-D246GL25.js";
+import "./chunk-W4UVXL3R.js";
+import "./chunk-4V3WESQO.js";
+import "./chunk-5MEISXIX.js";
 import "./chunk-UZSNFLDQ.js";
-import "./chunk-IIANP4GI.js";
+import "./chunk-FWG6GISJ.js";
 import "./chunk-VEQXQN22.js";
 export {
   getCodexAspHost,

package/dist/src/{chunk-SAJ6ERGR.js → chunk-4V3WESQO.js}

@@ -3,10 +3,10 @@ import { createRequire as __createRequire } from 'node:module';
 const require = __createRequire(import.meta.url);
 import {
   execFileAsync
-} from "./chunk-4WBOMDAN.js";
+} from "./chunk-5MEISXIX.js";
 import {
   isVersionBelow
-} from "./chunk-IIANP4GI.js";
+} from "./chunk-FWG6GISJ.js";
 
 // src/utils/codex-agent-env.ts
 function buildCodexAgentEnv(source = process.env) {
@@ -240,7 +240,7 @@ function getCodexModelProvider(method) {
   if (method === "foundry") return "azure";
   return method === "ollama" || method === "openai-compatible" ? "replicas_openai_compatible" : "openai";
 }
-var ENGINE_PACKAGE_VERSION = "0.1.986";
+var ENGINE_PACKAGE_VERSION = "0.1.988";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";

package/dist/src/{chunk-4WBOMDAN.js → chunk-5MEISXIX.js}

@@ -3,7 +3,7 @@ import { createRequire as __createRequire } from 'node:module';
 const require = __createRequire(import.meta.url);
 import {
   HOOK_EXEC_MAX_BUFFER_BYTES
-} from "./chunk-IIANP4GI.js";
+} from "./chunk-FWG6GISJ.js";
 
 // src/utils/exec.ts
 import { exec, execFile } from "child_process";

package/dist/src/{chunk-YQE57AE6.js → chunk-6LIDXAYC.js}

@@ -5,7 +5,7 @@ import {
   extractCommandProtectionCommandText,
   isRecord,
   parseCodeHostPrUrl
-} from "./chunk-IIANP4GI.js";
+} from "./chunk-FWG6GISJ.js";
 
 // src/services/published-pull-request-urls.ts
 function publishedPullRequestUrls(result) {

package/dist/src/{chunk-O2ZKAC2G.js → chunk-D246GL25.js}

@@ -5,15 +5,15 @@ import {
   ENGINE_ENV,
   monolithRequest,
   setAgentCredentialSnapshot
-} from "./chunk-Z3D5SVUI.js";
+} from "./chunk-W4UVXL3R.js";
 import {
   AppServerProcess,
   buildCodexAgentEnv
-} from "./chunk-SAJ6ERGR.js";
+} from "./chunk-4V3WESQO.js";
 import {
   SUBPROCESS_MAX_BUFFER,
   execFileAsync
-} from "./chunk-4WBOMDAN.js";
+} from "./chunk-5MEISXIX.js";
 import {
   isRecord
 } from "./chunk-UZSNFLDQ.js";
@@ -27,7 +27,7 @@ import {
   listOpenAICompatibleModels,
   readOllamaAuthEnv,
   resolveOpenAICompatibleModelsUrl
-} from "./chunk-IIANP4GI.js";
+} from "./chunk-FWG6GISJ.js";
 
 // src/managers/codex-token-manager.ts
 import { promises as fs } from "fs";
@@ -260,7 +260,7 @@ var CodexTokenManager = class extends BaseRefreshManager {
     await this.applyCredentialUpdate(++this.credentialGeneration, async () => {
       await this.applyCredentialsResponse(data);
       setAgentCredentialSnapshot("codex", data);
-      const { restartCodexAspHostIfRunning: restartCodexAspHostIfRunning2 } = await import("./asp-host-Q474L67V.js");
+      const { restartCodexAspHostIfRunning: restartCodexAspHostIfRunning2 } = await import("./asp-host-64RO3V36.js");
       await restartCodexAspHostIfRunning2();
     });
     await this.start(true);
@@ -280,7 +280,7 @@ var CodexTokenManager = class extends BaseRefreshManager {
     await this.applyCredentialUpdate(generation, async () => {
       await this.applyCredentialsResponse(data);
       if (restartOnChange && CODEX_AUTH_ENV_KEYS.some((key, index) => process.env[key] !== previousEnv[index])) {
-        const { restartCodexAspHostIfRunning: restartCodexAspHostIfRunning2 } = await import("./asp-host-Q474L67V.js");
+        const { restartCodexAspHostIfRunning: restartCodexAspHostIfRunning2 } = await import("./asp-host-64RO3V36.js");
         await restartCodexAspHostIfRunning2();
       }
       setAgentCredentialSnapshot("codex", data);

package/dist/src/{chunk-IIANP4GI.js → chunk-FWG6GISJ.js}

@@ -1194,7 +1194,8 @@ var subagentResponseSchema = z3.object({
   chatId: z3.string().uuid(),
   status: z3.enum(["working", "completed"]),
   response: z3.string().optional(),
-  timedOut: z3.literal(true).optional()
+  timedOut: z3.literal(true).optional(),
+  interruptedByUserMessage: z3.literal(true).optional()
 });
 var integrationErrorNotificationTargetSchema = z3.discriminatedUnion("type", [
   z3.object({
@@ -7179,10 +7180,6 @@ function detectLanguageByPath(filePath) {
 }
 
 // ../shared/src/context-usage.ts
-var CODEX_CATEGORY_COLORS = {
-  input: "#3eeba3",
-  output: "#56b6c2"
-};
 function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
@@ -7213,9 +7210,7 @@ function normalizeAutoCompactThreshold(threshold, maxTokens) {
   return clampPercentage(value);
 }
 function clampTokensToWindow(rawTokens, maxTokens) {
-  if (!maxTokens || maxTokens <= 0) return { totalTokens: rawTokens };
-  if (rawTokens <= maxTokens) return { totalTokens: rawTokens };
-  return { totalTokens: maxTokens, totalProcessedTokens: rawTokens };
+  return maxTokens && maxTokens > 0 ? Math.min(rawTokens, maxTokens) : rawTokens;
 }
 function compactCategories(categories) {
   return categories.filter((category) => Boolean(category && category.tokens > 0)).map((category) => ({
@@ -7227,16 +7222,12 @@ function buildCodexTokenUsageContextUsagePayload(usage) {
   const maxTokens = usage.modelContextWindow;
   const inputTokens = usage.last.inputTokens;
   const outputTokens = usage.last.outputTokens;
-  const lastTurnTokens = usage.last.totalTokens;
-  const { totalTokens } = clampTokensToWindow(lastTurnTokens, maxTokens);
-  const cumulativeTotalTokens = usage.total?.totalTokens ?? null;
-  const totalProcessedTokens = cumulativeTotalTokens !== null && cumulativeTotalTokens > totalTokens ? cumulativeTotalTokens : clampTokensToWindow(lastTurnTokens, maxTokens).totalProcessedTokens;
+  const totalTokens = clampTokensToWindow(usage.last.totalTokens, maxTokens);
   return {
     provider: "codex",
     source: "codex_token_count",
     ...usage.model !== void 0 ? { model: usage.model } : {},
     totalTokens,
-    ...totalProcessedTokens !== void 0 ? { totalProcessedTokens } : {},
     maxTokens,
     rawMaxTokens: maxTokens,
     percentage: percentage(totalTokens, maxTokens),
@@ -7245,23 +7236,14 @@ function buildCodexTokenUsageContextUsagePayload(usage) {
       {
         name: "Input context",
         tokens: inputTokens,
-        percentage: percentage(inputTokens, maxTokens),
-        color: CODEX_CATEGORY_COLORS.input
+        percentage: percentage(inputTokens, maxTokens)
       },
       {
         name: "Generated output",
         tokens: outputTokens,
-        percentage: percentage(outputTokens, maxTokens),
-        color: CODEX_CATEGORY_COLORS.output
+        percentage: percentage(outputTokens, maxTokens)
       }
     ]),
-    apiUsage: {
-      inputTokens,
-      outputTokens,
-      ...usage.last.cachedInputTokens !== null && usage.last.cachedInputTokens !== void 0 ? { cachedInputTokens: usage.last.cachedInputTokens } : {},
-      ...usage.last.reasoningOutputTokens !== null && usage.last.reasoningOutputTokens !== void 0 ? { reasoningOutputTokens: usage.last.reasoningOutputTokens } : {},
-      ...cumulativeTotalTokens !== null ? { totalTokens: cumulativeTotalTokens } : {}
-    },
     updatedAt: usage.updatedAt
   };
 }
@@ -7287,10 +7269,7 @@ function coerceContextUsagePayload(payload, timestamp) {
   const reportedMaxTokens = numberOrNull(payload.maxTokens);
   const { maxTokens, usedKnownWindow } = resolveClaudeContextWindow(provider, model, reportedMaxTokens);
   const rawMaxTokens = usedKnownWindow ? maxTokens : numberOrNull(payload.rawMaxTokens);
-  const clamped = clampTokensToWindow(rawTotalTokens, maxTokens);
-  const totalTokens = clamped.totalTokens;
-  const payloadTotalProcessedTokens = numberOrNull(payload.totalProcessedTokens);
-  const totalProcessedTokens = payloadTotalProcessedTokens !== null ? payloadTotalProcessedTokens : clamped.totalProcessedTokens ?? null;
+  const totalTokens = clampTokensToWindow(rawTotalTokens, maxTokens);
   const source = payload.source === "codex_token_count" || payload.source === "claude_usage" || payload.source === "provider_usage" ? payload.source : "claude_context";
   const categories = Array.isArray(payload.categories) ? compactCategories(payload.categories.map((item) => {
     if (!isRecord2(item)) return null;
@@ -7298,23 +7277,13 @@ function coerceContextUsagePayload(payload, timestamp) {
     const tokens = numberOrNull(item.tokens);
     const categoryPercentage = numberOrNull(item.percentage);
     if (!name || tokens === null || categoryPercentage === null) return null;
+    if (item.isDeferred === true || name === "Free space" || name === "Autocompact buffer") return null;
     return {
       name,
       tokens,
-      percentage: usedKnownWindow ? percentage(tokens, maxTokens) : categoryPercentage,
-      ...typeof item.color === "string" ? { color: item.color } : {},
-      ...typeof item.isDeferred === "boolean" ? { isDeferred: item.isDeferred } : {}
+      percentage: usedKnownWindow ? percentage(tokens, maxTokens) : categoryPercentage
     };
   })) : [];
-  const apiUsage = isRecord2(payload.apiUsage) ? {
-    ...numberOrNull(payload.apiUsage.inputTokens) !== null ? { inputTokens: numberOrNull(payload.apiUsage.inputTokens) } : {},
-    ...numberOrNull(payload.apiUsage.outputTokens) !== null ? { outputTokens: numberOrNull(payload.apiUsage.outputTokens) } : {},
-    ...numberOrNull(payload.apiUsage.cacheCreationInputTokens) !== null ? { cacheCreationInputTokens: numberOrNull(payload.apiUsage.cacheCreationInputTokens) } : {},
-    ...numberOrNull(payload.apiUsage.cacheReadInputTokens) !== null ? { cacheReadInputTokens: numberOrNull(payload.apiUsage.cacheReadInputTokens) } : {},
-    ...numberOrNull(payload.apiUsage.cachedInputTokens) !== null ? { cachedInputTokens: numberOrNull(payload.apiUsage.cachedInputTokens) } : {},
-    ...numberOrNull(payload.apiUsage.reasoningOutputTokens) !== null ? { reasoningOutputTokens: numberOrNull(payload.apiUsage.reasoningOutputTokens) } : {},
-    ...numberOrNull(payload.apiUsage.totalTokens) !== null ? { totalTokens: numberOrNull(payload.apiUsage.totalTokens) } : {}
-  } : null;
   const compactsAutomatically = typeof payload.compactsAutomatically === "boolean" ? payload.compactsAutomatically : void 0;
   const autoCompactThreshold = normalizeAutoCompactThreshold(payload.autoCompactThreshold, maxTokens);
   return {
@@ -7322,14 +7291,12 @@ function coerceContextUsagePayload(payload, timestamp) {
     source,
     ...model ? { model } : {},
     totalTokens,
-    ...totalProcessedTokens !== null ? { totalProcessedTokens } : {},
     maxTokens,
     rawMaxTokens,
     percentage: usedKnownWindow ? percentage(totalTokens, maxTokens) : clampPercentage(percentageValue),
     ...compactsAutomatically !== void 0 ? { compactsAutomatically } : {},
     ...autoCompactThreshold !== null ? { autoCompactThreshold } : {},
     categories,
-    apiUsage,
     updatedAt: typeof payload.updatedAt === "string" ? payload.updatedAt : timestamp
   };
 }
@@ -7340,20 +7307,15 @@ function codexTokenCountToContextUsage(event) {
   if (!info) return null;
   const lastUsage = isRecord2(info.last_token_usage) ? info.last_token_usage : null;
   if (!lastUsage) return null;
-  const totalUsage = isRecord2(info.total_token_usage) ? info.total_token_usage : null;
   const maxTokens = numberOrNull(info.model_context_window);
   const inputTokens = numberOrNull(lastUsage.input_tokens) ?? 0;
   const outputTokens = numberOrNull(lastUsage.output_tokens) ?? 0;
-  const cumulativeTotalTokens = numberOrNull(totalUsage?.total_tokens);
   return buildCodexTokenUsageContextUsagePayload({
     last: {
       inputTokens,
       outputTokens,
-      totalTokens: numberOrNull(lastUsage.total_tokens) ?? inputTokens + outputTokens,
-      cachedInputTokens: numberOrNull(lastUsage.cached_input_tokens),
-      reasoningOutputTokens: numberOrNull(lastUsage.reasoning_output_tokens)
+      totalTokens: numberOrNull(lastUsage.total_tokens) ?? inputTokens + outputTokens
     },
-    total: cumulativeTotalTokens !== null ? { totalTokens: cumulativeTotalTokens } : null,
     modelContextWindow: maxTokens,
     updatedAt: event.timestamp
   });

package/dist/src/{chunk-B2JQRHF4.js → chunk-TZHZU4JB.js}

@@ -3,18 +3,18 @@ import { createRequire as __createRequire } from 'node:module';
 const require = __createRequire(import.meta.url);
 import {
   monolithRequest
-} from "./chunk-Z3D5SVUI.js";
+} from "./chunk-W4UVXL3R.js";
 import {
   SUBPROCESS_MAX_BUFFER,
   execFileAsync
-} from "./chunk-4WBOMDAN.js";
+} from "./chunk-5MEISXIX.js";
 import {
   extractCommandProtectionCommandText,
   findCommandProtectionGitLookups,
   findGitCommitSignals,
   findPrMergeSignals,
   parseCommandProtectionRequest
-} from "./chunk-IIANP4GI.js";
+} from "./chunk-FWG6GISJ.js";
 
 // src/services/command-protection-service.ts
 import { readFile, stat } from "fs/promises";

package/dist/src/{chunk-Z3D5SVUI.js → chunk-W4UVXL3R.js}

@@ -14,7 +14,7 @@ import {
   isValidAgentProvider,
   parsePosixEnvFile,
   readReplicasRuntimeEnv
-} from "./chunk-IIANP4GI.js";
+} from "./chunk-FWG6GISJ.js";
 
 // src/runtime-env-loader.ts
 import { readFileSync } from "fs";

package/dist/src/command-protection-hook.js

@@ -3,13 +3,13 @@ import { createRequire as __createRequire } from 'node:module';
 const require = __createRequire(import.meta.url);
 import {
   evaluateCommandProtection
-} from "./chunk-B2JQRHF4.js";
-import "./chunk-Z3D5SVUI.js";
-import "./chunk-4WBOMDAN.js";
+} from "./chunk-TZHZU4JB.js";
+import "./chunk-W4UVXL3R.js";
+import "./chunk-5MEISXIX.js";
 import {
   isRecord
 } from "./chunk-UZSNFLDQ.js";
-import "./chunk-IIANP4GI.js";
+import "./chunk-FWG6GISJ.js";
 import "./chunk-VEQXQN22.js";
 
 // src/command-protection-hook.ts

package/dist/src/headless-agent.js

@@ -7,12 +7,12 @@ import {
 import {
   AppServerProcess,
   buildCodexAgentEnv
-} from "./chunk-SAJ6ERGR.js";
-import "./chunk-4WBOMDAN.js";
+} from "./chunk-4V3WESQO.js";
+import "./chunk-5MEISXIX.js";
 import {
   AGENT,
   headlessAgentRequestSchema
-} from "./chunk-IIANP4GI.js";
+} from "./chunk-FWG6GISJ.js";
 import "./chunk-VEQXQN22.js";
 
 // src/headless-agent.ts

package/dist/src/index.js

@@ -32,7 +32,7 @@ import {
   reportCommandProtectionBlock,
   resolveDiffBase,
   runGitCommand
-} from "./chunk-B2JQRHF4.js";
+} from "./chunk-TZHZU4JB.js";
 import {
   ACCOUNT_RATE_LIMITS_UPDATED_METHOD,
   AGENT_MESSAGE_DELTA_METHOD,
@@ -57,7 +57,7 @@ import {
 } from "./chunk-P73LGPQO.js";
 import {
   publishedPullRequestUrls
-} from "./chunk-YQE57AE6.js";
+} from "./chunk-6LIDXAYC.js";
 import {
   BaseRefreshManager,
   CodexAspAuthMethodChangedError,
@@ -72,7 +72,7 @@ import {
   refreshDelayMs,
   restartCodexAspHost,
   routineRefreshExclusions
-} from "./chunk-O2ZKAC2G.js";
+} from "./chunk-D246GL25.js";
 import {
   ENGINE_ENV,
   monolithRequest,
@@ -80,16 +80,16 @@ import {
   readRuntimeEnvFile,
   reloadEngineEnv,
   setAgentCredentialSnapshot
-} from "./chunk-Z3D5SVUI.js";
+} from "./chunk-W4UVXL3R.js";
 import {
   AspClient,
   getCodexModelProvider
-} from "./chunk-SAJ6ERGR.js";
+} from "./chunk-4V3WESQO.js";
 import {
   SUBPROCESS_MAX_BUFFER,
   execAsync,
   execFileAsync
-} from "./chunk-4WBOMDAN.js";
+} from "./chunk-5MEISXIX.js";
 import {
   isRecord as isRecord2
 } from "./chunk-UZSNFLDQ.js";
@@ -315,7 +315,7 @@ import {
   workspaceCredentialProviderSchema,
   workspaceTokenRequestSchema,
   workspaceTokenResponseSchema
-} from "./chunk-IIANP4GI.js";
+} from "./chunk-FWG6GISJ.js";
 import {
   cloneMcpConfig,
   ensureCompatibilityImports,
@@ -10166,6 +10166,7 @@ var EnvironmentDetailsService = class {
     details.engineVersion = ENGINE_ENV.REPLICAS_SANDBOX_IMAGE_VERSION;
     details.supportsMidTurnSteering = true;
     details.supportsClaudeMidTurnSteering = true;
+    details.supportsSendNow = true;
     details.supportsClaudeGoals = true;
     details.supportsGoalUpdates = true;
     details.supportsQueuedMessageEditing = true;
@@ -11769,6 +11770,7 @@ var MessageQueueService = class {
   // version below.
   acceptanceWithdrawals = /* @__PURE__ */ new WeakSet();
   queueCancellationVersion = 0;
+  activeTurn = null;
   constructor(processMessage, onProcessingChanged = () => {
   }, onMessageStarted = async () => {
   }) {
@@ -11863,6 +11865,8 @@ var MessageQueueService = class {
     return tail.merge === true && tail.type === request.type;
   }
   async startProcessing(queuedMessage) {
+    const turn = new AbortController();
+    this.activeTurn = turn;
     this.processing = true;
     this.onProcessingChanged(true);
     try {
@@ -11874,11 +11878,14 @@ var MessageQueueService = class {
         this.acceptanceByMessage.delete(queuedMessage);
         break;
       }
-      await this.onMessageStarted(queuedMessage);
-      await this.processMessage(queuedMessage);
+      if (!turn.signal.aborted) {
+        await this.onMessageStarted(queuedMessage);
+        await this.processMessage(queuedMessage, turn.signal);
+      }
     } catch (error) {
       console.error("[MessageQueue] Error processing message:", error);
     } finally {
+      this.activeTurn = null;
       this.processing = false;
       if (this.queue.length === 0) {
         this.onProcessingChanged(false);
@@ -11898,22 +11905,15 @@ var MessageQueueService = class {
   isProcessing() {
     return this.processing;
   }
-  drainQueue(options) {
-    const maxItems = options?.maxItems ?? this.queue.length;
-    const maxChars = options?.maxChars ?? Number.POSITIVE_INFINITY;
-    const drained = [];
-    let totalChars = 0;
-    for (const message of this.queue) {
-      if (drained.length >= maxItems) break;
-      const text = message.message;
-      if (totalChars + text.length > maxChars) break;
-      drained.push(text);
-      totalChars += text.length;
-    }
+  drainQueue() {
+    const drained = this.queue;
     this.queueCancellationVersion++;
     this.queue = [];
     return drained;
   }
+  cancelActiveTurn() {
+    this.activeTurn?.abort();
+  }
   /**
    * Get all queued messages (does not include the currently processing message)
    */
@@ -11973,6 +11973,16 @@ Native subagent tools are disabled in this workspace. To delegate work to a suba
 // src/managers/coding-agent-manager.ts
 var MAX_INTERRUPT_QUEUE_ITEMS = 1e3;
 var MAX_INTERRUPT_QUEUE_CHARS = 2e5;
+function toQueuedMessageInfo(message) {
+  return {
+    id: message.id,
+    message: message.message,
+    queuedAt: message.queuedAt,
+    ...message.senderUserId ? { senderUserId: message.senderUserId } : {},
+    ...message.senderEmail ? { senderEmail: message.senderEmail } : {},
+    ...message.senderDisplayName ? { senderDisplayName: message.senderDisplayName } : {}
+  };
+}
 var subagentMcpConfigRequest = null;
 var CodingAgentManager = class {
   workingDirectory;
@@ -11984,13 +11994,14 @@ var CodingAgentManager = class {
   onUsageUpdate;
   linearSessionId;
   chatId;
-  onTurnComplete;
+  hostOnTurnComplete;
   onProcessingChanged;
   onMessageStarted;
   onModelSwitched;
   authFallback;
   subagentMcpChatId;
   subagentMcpEnabledForTurn = false;
+  unreadSteers = /* @__PURE__ */ new Map();
   constructor(options) {
     this.workingDirectory = options.workingDirectory ?? ENGINE_ENV.WORKSPACE_ROOT;
     this.initialSessionId = options.initialSessionId;
@@ -12001,7 +12012,7 @@ var CodingAgentManager = class {
     this.subagentMcpChatId = options.parentChatId === null && options.provider && SUBAGENT_MCP_HARNESSES.includes(options.provider) ? options.chatId : void 0;
     this.linearSessionId = options.linearSessionId;
     this.chatId = options.chatId;
-    this.onTurnComplete = options.onTurnComplete;
+    this.hostOnTurnComplete = options.onTurnComplete;
     this.onProcessingChanged = options.onProcessingChanged ?? (() => {
     });
     this.onMessageStarted = options.onMessageStarted ?? (async () => {
@@ -12019,6 +12030,10 @@ var CodingAgentManager = class {
     if (result.outcome === "switched" && result.model) await this.onModelSwitched(result.model);
     return result;
   }
+  onTurnComplete = async () => {
+    this.requeueUnreadSteers();
+    await this.hostOnTurnComplete();
+  };
   emitSyntheticEvent(type, payload) {
     this.onEvent({
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -12061,9 +12076,10 @@ var CodingAgentManager = class {
   }
   initializeManager(processMessage) {
     this.messageQueue = new MessageQueueService(
-      async (request) => {
+      async (request, signal) => {
         await this.refreshSubagentMcp();
-        await processMessage(request);
+        if (signal.aborted) return;
+        await processMessage(request, signal);
       },
       this.onProcessingChanged,
       this.onMessageStarted
@@ -12091,46 +12107,55 @@ var CodingAgentManager = class {
     if (!history?.appendDurably) throw new Error("Chat history is unavailable");
     await history.appendDurably(event);
   }
-  async interrupt() {
-    const queuedMessages = this.messageQueue.getQueue();
-    const queue = this.messageQueue.drainQueue({
-      maxItems: MAX_INTERRUPT_QUEUE_ITEMS,
-      maxChars: MAX_INTERRUPT_QUEUE_CHARS
-    });
+  async interrupt(persistRemoval) {
+    const queuedMessages = this.messageQueue.drainQueue();
+    const unreadSteers = [...this.unreadSteers.values()];
+    this.unreadSteers.clear();
+    this.messageQueue.cancelActiveTurn();
     const isProcessing = this.isProcessing();
     if (isProcessing) {
       try {
         await this.interruptActiveTurn();
       } catch (error) {
-        this.restoreQueuedMessages(queuedMessages.slice(0, queue.length).map((message) => ({ message, index: 0 })));
+        for (const steer of unreadSteers) this.unreadSteers.set(steer.message.id, steer);
+        this.restoreQueuedMessages(queuedMessages.map((message, index) => ({ message, index })));
         throw error;
       }
-      const event = {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        type: CHAT_INTERRUPTED_EVENT_TYPE,
-        payload: {}
-      };
-      this.onEvent(event);
-      this.getHistorySink()?.append(event);
+    }
+    const removed = [...unreadSteers.map(({ message }) => message), ...queuedMessages];
+    if (removed.length > 0) await persistRemoval(removed.map(({ id }) => id));
+    if (isProcessing) this.recordInterrupted();
+    const queue = [];
+    let queueChars = 0;
+    for (const { message } of removed) {
+      if (queue.length >= MAX_INTERRUPT_QUEUE_ITEMS || queueChars + message.length > MAX_INTERRUPT_QUEUE_CHARS) break;
+      queue.push(message);
+      queueChars += message.length;
     }
     this.emitInterruptedQueueEvent(queue);
     return {
-      interrupted: isProcessing || queue.length > 0,
-      queue
+      interrupted: isProcessing || removed.length > 0,
+      queue,
+      removedMessageIds: removed.map(({ id }) => id)
+    };
+  }
+  recordInterrupted() {
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: CHAT_INTERRUPTED_EVENT_TYPE,
+      payload: {}
     };
+    this.onEvent(event);
+    this.getHistorySink()?.append(event);
   }
   isProcessing() {
     return this.messageQueue.isProcessing();
   }
   getQueue() {
-    return this.messageQueue.getQueue().map((m) => ({
-      id: m.id,
-      message: m.message,
-      queuedAt: m.queuedAt,
-      ...m.senderUserId ? { senderUserId: m.senderUserId } : {},
-      ...m.senderEmail ? { senderEmail: m.senderEmail } : {},
-      ...m.senderDisplayName ? { senderDisplayName: m.senderDisplayName } : {}
-    }));
+    return [
+      ...[...this.unreadSteers.values()].map(({ message, steeredAt }) => ({ ...toQueuedMessageInfo(message), steeredAt })),
+      ...this.messageQueue.getQueue().map(toQueuedMessageInfo)
+    ];
   }
   async removeFromQueue(messageId, persistRemoval) {
     return this.removeQueuedMessages([messageId], persistRemoval);
@@ -12176,33 +12201,54 @@ var CodingAgentManager = class {
     if (!taken) {
       return { success: false, queue: this.getQueue() };
     }
-    const keepQueued = this.keepSteeredMessageQueued();
-    if (keepQueued) {
-      this.messageQueue.restoreToQueue(taken.message, 0);
-    }
     let steered = false;
     try {
       steered = await this.steerRequest(taken.message);
     } catch (error) {
       console.error("[CodingAgentManager] steerRequest threw, keeping message queued:", error);
     }
-    if (!steered) {
-      if (keepQueued) {
-        const prioritized = this.messageQueue.takeFromQueue(messageId);
-        if (prioritized) this.restoreQueuedMessages([{ message: prioritized.message, index: taken.index }]);
-      } else {
-        this.restoreQueuedMessages([taken]);
+    if (steered) this.unreadSteers.set(messageId, { message: taken.message, steeredAt: (/* @__PURE__ */ new Date()).toISOString() });
+    else this.restoreQueuedMessages([{ message: taken.message, index: 0 }]);
+    return { success: steered, queue: this.getQueue() };
+  }
+  async sendNow(messageId) {
+    await this.initialized;
+    const queued = this.messageQueue.getQueue().some(({ id }) => id === messageId);
+    if (!queued && !this.unreadSteers.has(messageId)) return { success: false, queue: this.getQueue() };
+    const turnRunning = this.messageQueue.isProcessing();
+    if (turnRunning && this.canDeliverSteersNow()) {
+      if (queued) await this.steerFromQueue(messageId);
+      if (this.unreadSteers.has(messageId)) {
+        await this.deliverSteersNow();
+        return { success: true, queue: this.getQueue() };
       }
     }
-    return {
-      success: steered,
-      queue: this.getQueue(),
-      ...steered ? { steeredAt: (/* @__PURE__ */ new Date()).toISOString() } : {}
-    };
+    this.requeueUnreadSteers();
+    const taken = this.messageQueue.takeFromQueue(messageId);
+    if (taken) this.messageQueue.restoreToQueue(taken.message, 0);
+    if (turnRunning) {
+      this.recordInterrupted();
+      this.messageQueue.cancelActiveTurn();
+      await this.interruptActiveTurn();
+    }
+    return { success: true, queue: this.getQueue() };
   }
-  keepSteeredMessageQueued() {
+  requeueUnreadSteers() {
+    const steers = [...this.unreadSteers.values()].map(({ message }) => message);
+    this.unreadSteers.clear();
+    this.restoreQueuedMessages(steers.map((message) => ({ message, index: 0 })));
+  }
+  markSteerRead(messageId) {
+    const steer = this.unreadSteers.get(messageId);
+    this.unreadSteers.delete(messageId);
+    return steer?.message ?? this.messageQueue.takeFromQueue(messageId)?.message;
+  }
+  canDeliverSteersNow() {
     return false;
   }
+  deliverSteersNow() {
+    return Promise.resolve();
+  }
   steerRequest(_request) {
     return Promise.resolve(false);
   }
@@ -13035,11 +13081,19 @@ function isClaudeSessionActive(activity) {
 // src/managers/claude-background-tasks.ts
 var ClaudeBackgroundTasks = class {
   active = /* @__PURE__ */ new Set();
+  foreground = /* @__PURE__ */ new Set();
   reset() {
     this.active.clear();
+    this.foreground.clear();
   }
   update(message) {
-    if (message.type !== "system" || message.subtype !== "background_tasks_changed") return;
+    if (message.type !== "system") return;
+    if (message.subtype === "task_started" && message.is_backgrounded === false) this.foreground.add(message.task_id);
+    if (message.subtype === "task_notification") this.foreground.delete(message.task_id);
+    if (message.subtype === "task_updated" && (message.patch.is_backgrounded || message.patch.status && message.patch.status !== "running")) {
+      this.foreground.delete(message.task_id);
+    }
+    if (message.subtype !== "background_tasks_changed") return;
     this.active.clear();
     for (const task of message.tasks) {
       if (!task.ambient) this.active.add(task.task_id);
@@ -13359,25 +13413,31 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     await this.abortAllPendingToolInputs();
     await this.tearDownSession(true);
   }
+  canDeliverSteersNow() {
+    return this.activeQuery !== null && this.backgroundTasks.foreground.size > 0;
+  }
+  async deliverSteersNow() {
+    await this.activeQuery?.backgroundTasks();
+  }
   // Claude Code folds a `next`-priority prompt into the running turn at its next tool boundary.
   async steerRequest(request) {
     const pendingTurn = this.pendingTurn;
     const promptStream = this.activePromptStream;
     if (!pendingTurn || !promptStream) return false;
-    if (getGoalCommand(request.message, request.goalMode)) {
-      this.messageQueue.restoreToQueue(request, 0);
-      await this.interruptActiveTurn();
-      return true;
-    }
+    if (getGoalCommand(request.message, request.goalMode)) return false;
     const userMessage = await this.buildUserMessage(request);
     if (this.pendingTurn !== pendingTurn || this.activePromptStream !== promptStream) return false;
     pendingTurn.userMessageUuids.add(userMessage.uuid);
-    const steer = { ...userMessage, priority: "next" };
-    pendingTurn.steered.push(steer);
-    await this.recordEvent(userMessage, request.messageId);
-    promptStream.push(steer);
+    pendingTurn.steers.set(userMessage.uuid, { messageId: request.id, userMessage });
+    promptStream.push({ ...userMessage, priority: "next" });
     return true;
   }
+  async recordSteerRead(uuid) {
+    const steer = this.pendingTurn?.steers.get(uuid);
+    if (!steer) return;
+    this.pendingTurn?.steers.delete(uuid);
+    if (this.markSteerRead(steer.messageId)) await this.recordEvent(steer.userMessage, steer.messageId);
+  }
   async abortAllPendingToolInputs() {
     const pending = Array.from(this.pendingToolInputs.values());
     this.pendingToolInputs.clear();
@@ -13633,7 +13693,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       }
     }
   }
-  async processMessageInternal(request) {
+  async processMessageInternal(request, signal) {
     let lastError;
     let authRetryExhausted = false;
     let quotaFallbacks = 0;
@@ -13643,7 +13703,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     let midTurnContinues = 0;
     let missingSessionReset = false;
     let currentRequest = request;
-    let carriedSteers = [];
+    let carriedSteers = /* @__PURE__ */ new Map();
     await this.goalClear?.catch(() => {
     });
     try {
@@ -13651,10 +13711,10 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       await this.turnCredentials?.refresh();
       while (true) {
         const attemptedCredential = this.turnCredentials ? this.turnCredentials.snapshot() : ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS.claude;
-        const steered = carriedSteers;
-        carriedSteers = [];
+        const steers = carriedSteers;
+        carriedSteers = /* @__PURE__ */ new Map();
         try {
-          await this.executeQuery(currentRequest, { skipUserMessageRecord: attempt > 0, steered });
+          await this.executeQuery(currentRequest, { skipUserMessageRecord: attempt > 0, signal, steers });
           return;
         } catch (error) {
           lastError = error;
@@ -13699,7 +13759,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
             missingSessionReset = true;
             console.warn(`[ClaudeManager] Session ${this.sessionId} has no transcript; starting a fresh session:`, error.message);
             this.sessionId = null;
-            carriedSteers = steered;
+            carriedSteers = steers;
             await this.onSaveSessionId(null);
             await this.tearDownSession();
             attempt++;
@@ -13882,21 +13942,21 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     if (!promptStream || !activeQuery) {
       throw new Error("Claude session unavailable after ensureSession");
     }
-    if (this.pendingInterrupt) {
+    if (this.pendingInterrupt || options.signal?.aborted) {
       this.pendingInterrupt = false;
       return;
     }
     await new Promise((resolve7, reject) => {
-      const steered = options.steered ?? [];
+      const steers = options.steers ?? /* @__PURE__ */ new Map();
       this.pendingTurn = {
         resolve: resolve7,
         reject,
         sawActivity: false,
-        steered,
-        userMessageUuids: /* @__PURE__ */ new Set([userMessage.uuid, ...steered.flatMap((steer) => steer.uuid ?? [])])
+        steers,
+        userMessageUuids: /* @__PURE__ */ new Set([userMessage.uuid, ...steers.keys()])
       };
       promptStream.push(goalCommand ? { ...userMessage, message: { role: "user", content: `/goal ${goalObjective ?? "clear"}` } } : userMessage);
-      for (const steer of steered) promptStream.push(steer);
+      for (const { userMessage: steer } of steers.values()) promptStream.push({ ...steer, priority: "next" });
     });
   }
   async buildUserMessage({ message, images }) {
@@ -14119,6 +14179,10 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
         }
         const wasProcessing = this.isProcessing();
         this.setAuthRetrying(false);
+        const lifecycle2 = msg;
+        if (isRecord(lifecycle2) && lifecycle2.type === "command_lifecycle" && lifecycle2.state === "started" && typeof lifecycle2.command_uuid === "string") {
+          await this.recordSteerRead(lifecycle2.command_uuid);
+        }
         if (this.pendingTurn && _ClaudeManager.isTurnActivity(msg)) {
           this.pendingTurn.sawActivity = true;
         }
@@ -14145,6 +14209,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
           if (this.activeQuery !== response) break;
           this.sessionLinearForwarder?.flushThoughtAsResponse();
           const pendingUuids = this.pendingTurn?.userMessageUuids;
+          for (const uuid of msg.user_message_uuids ?? []) await this.recordSteerRead(uuid);
           if (msg.user_message_uuid) {
             for (const uuid of msg.user_message_uuids ?? [msg.user_message_uuid]) pendingUuids?.delete(uuid);
             if (pendingUuids?.size === 0) this.resolvePendingTurn();
@@ -14327,32 +14392,23 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     const reportedMaxTokens = Number.isFinite(usage.maxTokens) ? usage.maxTokens : null;
     const knownMaxTokens = getClaudeModelContextWindow(usage.model);
     const maxTokens = knownMaxTokens ?? reportedMaxTokens;
-    const clamped = clampTokensToWindow(usage.totalTokens, maxTokens);
+    const totalTokens = clampTokensToWindow(usage.totalTokens, maxTokens);
     const autoCompactThreshold = normalizeAutoCompactThreshold(usage.autoCompactThreshold, maxTokens);
     return {
       provider: "claude",
       source: "claude_context",
       model: usage.model,
-      totalTokens: clamped.totalTokens,
-      ...clamped.totalProcessedTokens !== void 0 ? { totalProcessedTokens: clamped.totalProcessedTokens } : {},
+      totalTokens,
       maxTokens,
       rawMaxTokens: knownMaxTokens ?? (Number.isFinite(usage.rawMaxTokens) ? usage.rawMaxTokens : maxTokens),
-      percentage: percentage(clamped.totalTokens, maxTokens),
+      percentage: percentage(totalTokens, maxTokens),
       compactsAutomatically: usage.isAutoCompactEnabled === true,
       ...autoCompactThresholdField(autoCompactThreshold),
-      categories: usage.categories.map((category) => ({
+      categories: usage.categories.filter((category) => category.kind === "used").map((category) => ({
         name: category.name,
         tokens: category.tokens,
-        percentage: percentage(category.tokens, maxTokens),
-        color: category.color,
-        ...category.isDeferred !== void 0 ? { isDeferred: category.isDeferred } : {}
+        percentage: percentage(category.tokens, maxTokens)
       })),
-      apiUsage: usage.apiUsage ? {
-        inputTokens: usage.apiUsage.input_tokens,
-        outputTokens: usage.apiUsage.output_tokens,
-        cacheCreationInputTokens: usage.apiUsage.cache_creation_input_tokens,
-        cacheReadInputTokens: usage.apiUsage.cache_read_input_tokens
-      } : null,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
@@ -15308,10 +15364,13 @@ var CodexAspManager = class extends CodingAgentManager {
   async subagentMcpForTurn(enabled) {
     return this.currentThreadId ? existsSync9(join17(SUBAGENT_MCP_THREADS_DIR, this.currentThreadId)) : enabled;
   }
-  async interruptActiveTurn() {
+  async interrupt(persistRemoval) {
     if (this.currentGoal?.status === "active") {
       await this.updateGoal({ status: "paused" });
     }
+    return super.interrupt(persistRemoval);
+  }
+  async interruptActiveTurn() {
     if (!this.currentThreadId || !this.activeTurnId) {
       return;
     }
@@ -15370,7 +15429,7 @@ var CodexAspManager = class extends CodingAgentManager {
       expectedTurnId,
       (host, turnId) => host.client.request(
         TURN_STEER_METHOD,
-        { threadId, expectedTurnId: turnId, input }
+        { threadId, expectedTurnId: turnId, input, clientUserMessageId: request.id }
       )
     );
     if (!result.ok) {
@@ -15386,7 +15445,6 @@ var CodexAspManager = class extends CodingAgentManager {
     } else {
       await removeTempImageFiles(tempImagePaths);
     }
-    this.recordUserMessageEvent(request);
     return true;
   }
   async getHistory(page2 = {}) {
@@ -15477,7 +15535,7 @@ var CodexAspManager = class extends CodingAgentManager {
       ...extraPayload
     }));
   }
-  async processMessageInternal(request) {
+  async processMessageInternal(request, signal) {
     let userMessageRecorded = false;
     let quotaFallbackAttempted = false;
     const recordUserMessage = (extraPayload = {}) => {
@@ -15488,8 +15546,8 @@ var CodexAspManager = class extends CodingAgentManager {
     const goalCommand = getGoalCommand(request.message, request.goalMode);
     const dispatch = async () => {
       if (isCompactCommand(request.message)) {
-        await this.executeAspTurn(request, recordUserMessage, {
-          runTurn: (host, threadId) => this.observeTurn(host, threadId, request, async () => {
+        await this.executeAspTurn(request, recordUserMessage, signal, {
+          runTurn: (host, threadId) => this.observeTurn(host, threadId, request, signal, async () => {
             await host.client.request(
               THREAD_COMPACT_START_METHOD,
               { threadId }
@@ -15513,13 +15571,13 @@ var CodexAspManager = class extends CodingAgentManager {
         return;
       }
       if (goalCommand?.type === "set") {
-        await this.executeAspTurn(request, recordUserMessage, {
-          runTurn: (host, threadId) => this.runGoalTurn(host, threadId, request, goalCommand.objective),
+        await this.executeAspTurn(request, recordUserMessage, signal, {
+          runTurn: (host, threadId) => this.runGoalTurn(host, threadId, request, goalCommand.objective, signal),
           userMessagePayload: { command: "goal" }
         });
         return;
       }
-      await this.executeAspTurn(request, recordUserMessage);
+      await this.executeAspTurn(request, recordUserMessage, signal);
     };
     let attemptedCredential = ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS.codex;
     try {
@@ -15611,14 +15669,15 @@ var CodexAspManager = class extends CodingAgentManager {
     const threadId = await this.ensureThread(host, request, developerInstructions);
     return { host, threadId };
   }
-  async executeAspTurn(request, recordUserMessage, options = {}) {
+  async executeAspTurn(request, recordUserMessage, signal, options = {}) {
     const host = await getCodexAspHost();
     const developerInstructions = this.buildCombinedInstructions(request.customInstructions, true);
     recordUserMessage(options.userMessagePayload);
     const threadId = await this.ensureThread(host, request, developerInstructions);
     const serviceTier = await this.resolveRequestedServiceTier(host, request);
     await this.applyThreadServiceTier(host, threadId, serviceTier);
-    const runTurn = options.runTurn ?? ((aspHost, aspThreadId) => this.runTurn(aspHost, aspThreadId, request, serviceTier));
+    if (signal.aborted) return;
+    const runTurn = options.runTurn ?? ((aspHost, aspThreadId) => this.runTurn(aspHost, aspThreadId, request, serviceTier, signal));
     let completedTurn;
     try {
       completedTurn = await runTurn(host, threadId);
@@ -15758,9 +15817,9 @@ ${text.slice(-24e3)}`
       console.warn("[CodexAspManager] Failed to apply skill registries:", error);
     }
   }
-  async runTurn(host, threadId, request, serviceTier) {
+  async runTurn(host, threadId, request, serviceTier, signal) {
     const { params, tempImagePaths } = await buildTurnStartParams(threadId, request, serviceTier);
-    return this.observeTurn(host, threadId, request, async () => {
+    return this.observeTurn(host, threadId, request, signal, async () => {
       const turnStartResponse = await host.client.request(
         TURN_START_METHOD,
         params
@@ -15768,8 +15827,8 @@ ${text.slice(-24e3)}`
       return { turn: turnStartResponse.turn, tempImagePaths };
     });
   }
-  async runGoalTurn(host, threadId, request, objective) {
-    return this.observeTurn(host, threadId, request, async () => {
+  async runGoalTurn(host, threadId, request, objective, signal) {
+    return this.observeTurn(host, threadId, request, signal, async () => {
       const response = await host.client.request(
         THREAD_GOAL_SET_METHOD,
         { threadId, objective, status: "active" }
@@ -15778,7 +15837,15 @@ ${text.slice(-24e3)}`
       return { turn: null, tempImagePaths: [] };
     });
   }
-  async observeTurn(host, threadId, request, startTurn) {
+  async observeTurn(host, threadId, request, signal, startTurn) {
+    let stopSent = false;
+    const interruptIfStopped = () => {
+      if (!signal.aborted || stopSent) return;
+      stopSent = true;
+      void this.interruptActiveTurn().catch((error) => {
+        console.error("[CodexAspManager] Failed to interrupt a turn stopped before it started:", error);
+      });
+    };
     let resolveCompleted;
     const completed = new Promise((resolve7) => {
       resolveCompleted = resolve7;
@@ -15844,6 +15911,7 @@ ${text.slice(-24e3)}`
         completedItems.length = 0;
         agentMessageDeltas.clear();
         this.startTurn(notification.params.turn);
+        interruptIfStopped();
         linearForwarder.sendEvent(convertCodexAspNotification(notification, linearSessionId ?? ""));
       },
       [TURN_PLAN_UPDATED_METHOD]: (notification) => {
@@ -15853,6 +15921,10 @@ ${text.slice(-24e3)}`
       [ITEM_STARTED_METHOD]: (notification) => {
         if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
         if (notification.params.item.type === "contextCompaction") this.compacting = true;
+        if (notification.params.item.type === "userMessage" && notification.params.item.clientId) {
+          const steer = this.markSteerRead(notification.params.item.clientId);
+          if (steer) this.recordUserMessageEvent(steer);
+        }
         this.startItem(
           notification.params.turnId,
           itemToTranscriptItem(notification.params.item, timestampFromMilliseconds(notification.params.startedAtMs), "in_progress")
@@ -15956,6 +16028,7 @@ ${text.slice(-24e3)}`
         this.activeTurnId = started.turn.id;
         this.onCodexTurnStarted?.(threadId, started.turn.id);
         this.startTurn(started.turn);
+        interruptIfStopped();
       }
       const turn = await Promise.race([completed, disposed]);
       linearForwarder.flushThoughtAsResponse();
@@ -16322,12 +16395,7 @@ ${text.slice(-24e3)}`
       last: {
         inputTokens: tokenUsage.last.inputTokens,
         outputTokens: tokenUsage.last.outputTokens,
-        totalTokens: tokenUsage.last.totalTokens,
-        cachedInputTokens: tokenUsage.last.cachedInputTokens,
-        reasoningOutputTokens: tokenUsage.last.reasoningOutputTokens
-      },
-      total: {
-        totalTokens: tokenUsage.total.totalTokens
+        totalTokens: tokenUsage.last.totalTokens
       },
       updatedAt
     });
@@ -16432,12 +16500,6 @@ var CURSOR_CANCEL_TIMEOUT_MS = 1e4;
 var CURSOR_RECONNECT_NOTICE_DELAY_MS = 15e3;
 var TURN_ABORTED = /* @__PURE__ */ Symbol("cursor-turn-aborted");
 var CURSOR_COMPOSER_CONTEXT_WINDOW = 2e5;
-var CURSOR_CATEGORY_COLORS = {
-  input: "#3eeba3",
-  cacheRead: "#61afef",
-  cacheWrite: "#e5c07b",
-  output: "#56b6c2"
-};
 var CURSOR_TRANSPORT_ERROR_PATTERNS = [
   /connection failed/,
   /connection stalled/,
@@ -16797,31 +16859,27 @@ ${instructions}
     if (rawTotalTokens <= 0) return;
     this.onUsageUpdate(update, (/* @__PURE__ */ new Date()).toISOString());
     const maxTokens = CURSOR_COMPOSER_CONTEXT_WINDOW;
-    const { totalTokens, totalProcessedTokens } = clampTokensToWindow(rawTotalTokens, maxTokens);
+    const totalTokens = clampTokensToWindow(rawTotalTokens, maxTokens);
     const categories = [
       {
         name: "Input",
         tokens: inputTokens,
-        percentage: percentage(inputTokens, maxTokens),
-        color: CURSOR_CATEGORY_COLORS.input
+        percentage: percentage(inputTokens, maxTokens)
       },
       {
         name: "Cache read",
         tokens: cacheReadTokens,
-        percentage: percentage(cacheReadTokens, maxTokens),
-        color: CURSOR_CATEGORY_COLORS.cacheRead
+        percentage: percentage(cacheReadTokens, maxTokens)
       },
       {
         name: "Cache write",
         tokens: cacheWriteTokens,
-        percentage: percentage(cacheWriteTokens, maxTokens),
-        color: CURSOR_CATEGORY_COLORS.cacheWrite
+        percentage: percentage(cacheWriteTokens, maxTokens)
       },
       {
         name: "Output",
         tokens: outputTokens,
-        percentage: percentage(outputTokens, maxTokens),
-        color: CURSOR_CATEGORY_COLORS.output
+        percentage: percentage(outputTokens, maxTokens)
       }
     ].filter((category) => category.tokens > 0);
     const payload = {
@@ -16829,18 +16887,11 @@ ${instructions}
       source: "provider_usage",
       model: this.activeModel,
       totalTokens,
-      ...totalProcessedTokens !== void 0 ? { totalProcessedTokens } : {},
       maxTokens,
       rawMaxTokens: maxTokens,
       percentage: percentage(totalTokens, maxTokens),
       compactsAutomatically: true,
       categories,
-      apiUsage: {
-        inputTokens,
-        outputTokens,
-        cacheReadInputTokens: cacheReadTokens,
-        cacheCreationInputTokens: cacheWriteTokens
-      },
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.historyFile.append(this.emitContextUsage(payload));
@@ -17130,7 +17181,7 @@ ${typeof pending.subject.command === "string" ? pending.subject.command : JSON.s
       }, this.historyFile);
     }
   }
-  async processMessageInternal(request) {
+  async processMessageInternal(request, signal) {
     let userMessageRecorded = false;
     const dispatch = async () => {
       const model = request.model ?? DEFAULT_MUSE_MODEL;
@@ -17176,6 +17227,7 @@ ${pending}
 </workspace-instructions>
 
 ` : ""}${request.planMode ? "Plan the requested work without modifying files or running mutating commands.\n\n" : ""}${request.message}`;
+      if (signal.aborted) return;
       this.turnError = null;
       const completed = new Promise((resolve7) => {
         this.turnComplete = { resolve: resolve7 };
@@ -17241,17 +17293,6 @@ ${pending}
       turnId: this.activeTurnId
     });
   }
-  async steerRequest(request) {
-    if (!this.sessionId || !this.activeTurnId) return false;
-    await this.request("turn/steer", {
-      commandId: uuidV7(),
-      sessionId: this.sessionId,
-      expectedTurnId: this.activeTurnId,
-      input: this.createTurnInput(request.message, request.images),
-      reasoningEffort: codexReasoningEffortForThinkingLevel(request.thinkingLevel)
-    });
-    return true;
-  }
   async respondToToolInput(requestId, selectionId) {
     const approval = [...this.pendingApprovals.values()].find((pending2) => pending2.requestId === requestId);
     if (approval) {
@@ -58678,13 +58719,6 @@ var PiManager = class extends CodingAgentManager {
   async interruptActiveTurn() {
     await this.session?.abort();
   }
-  async steerRequest(request) {
-    const session = this.session;
-    if (!session?.isStreaming) return false;
-    await session.steer(request.message);
-    this.recordUserMessage(session, request);
-    return true;
-  }
   async getHistory(page2 = {}) {
     await this.historyFile.flush();
     const history = await this.historyFile.loadEventsPage(page2);
@@ -58869,7 +58903,7 @@ var PiManager = class extends CodingAgentManager {
       skillName ? { skillName } : {}
     );
   }
-  async processMessageInternal(request) {
+  async processMessageInternal(request, signal) {
     try {
       const session = await this.ensureSession(request);
       this.recordUserMessage(session, request);
@@ -58878,6 +58912,7 @@ var PiManager = class extends CodingAgentManager {
         data: image.source.data,
         mimeType: image.source.media_type
       })) : void 0;
+      if (signal.aborted) return;
       await session.prompt(request.message, images ? { images } : void 0);
     } catch (error) {
       this.recordHistoryEvent("pi-error", { message: error instanceof Error ? error.message : String(error) }, this.historyFile);
@@ -60838,6 +60873,9 @@ var ChatService = class {
       if (signal?.aborted) throw new Error("Subagent wait was cancelled");
       const result = await this.getSubagent(parentChatId, chatId);
       if (result.status === "completed") return result;
+      if (this.requireChat(parentChatId).provider.getQueue().some(({ steeredAt }) => steeredAt && Date.parse(steeredAt) >= startedAt)) {
+        return { ...result, interruptedByUserMessage: true };
+      }
       const remainingMs = timeoutMs === null ? null : timeoutMs - (Date.now() - startedAt);
       if (remainingMs !== null && remainingMs <= 0) return { ...result, timedOut: true };
       await new Promise((resolve7) => setTimeout(
@@ -61020,7 +61058,7 @@ var ChatService = class {
   }
   async interrupt(chatId) {
     const chat = this.requireChat(chatId);
-    const result = await chat.provider.interrupt();
+    const result = await chat.provider.interrupt((messageIds) => this.forgetPendingMessages(chat, messageIds));
     this.endTrackedTurn(chatId);
     chat.hasActiveTurn = false;
     chat.activeMessageId = null;
@@ -61042,7 +61080,7 @@ var ChatService = class {
     if (!chat.provider.clearGoal) {
       return { interrupted: false, queue: [], goal: null };
     }
-    const interruptResult = await chat.provider.interrupt();
+    const interruptResult = await chat.provider.interrupt((messageIds) => this.forgetPendingMessages(chat, messageIds));
     this.endTrackedTurn(chatId);
     chat.hasActiveTurn = false;
     chat.activeMessageId = null;
@@ -61190,6 +61228,14 @@ var ChatService = class {
     }
     return result;
   }
+  async sendNow(chatId, messageId) {
+    const chat = this.requireChat(chatId);
+    const result = await chat.provider.sendNow(messageId);
+    if (result.success && !result.queue.some(({ id, steeredAt }) => id === messageId && !steeredAt)) {
+      chat.pendingMessageIds = chat.pendingMessageIds.filter((pendingMessageId) => pendingMessageId !== messageId);
+    }
+    return result;
+  }
   async respondToToolInput(chatId, requestId, selectionId) {
     const chat = this.requireChat(chatId);
     if (!chat.provider.respondToToolInput) {
@@ -61205,7 +61251,7 @@ var ChatService = class {
       const target = this.chats.get(id);
       if (!target || target.persisted.deletedAt) continue;
       if (target.provider.isProcessing()) {
-        await target.provider.interrupt().catch(() => {
+        await target.provider.interrupt((messageIds) => this.forgetPendingMessages(target, messageIds)).catch(() => {
         });
         target.hasActiveTurn = false;
         target.activeMessageId = null;
@@ -63490,17 +63536,21 @@ function createV1Routes(deps) {
       return c.json(jsonError("Failed to update queued message", error instanceof Error ? error.message : "Unknown error"), 500);
     }
   });
-  app2.post("/chats/:chatId/queue/:messageId/steer", async (c) => {
-    try {
-      const result = await deps.chatService.steerFromQueue(c.req.param("chatId"), c.req.param("messageId"));
-      return c.json(result);
-    } catch (error) {
-      if (error instanceof ChatNotFoundError) {
-        return c.json(jsonError("Chat not found", error.message), 404);
+  for (const { action, failure, run } of [
+    { action: "steer", failure: "Failed to steer queued message", run: (chatId, messageId) => deps.chatService.steerFromQueue(chatId, messageId) },
+    { action: "send-now", failure: "Failed to send queued message now", run: (chatId, messageId) => deps.chatService.sendNow(chatId, messageId) }
+  ]) {
+    app2.post(`/chats/:chatId/queue/:messageId/${action}`, async (c) => {
+      try {
+        return c.json(await run(c.req.param("chatId"), c.req.param("messageId")));
+      } catch (error) {
+        if (error instanceof ChatNotFoundError) {
+          return c.json(jsonError("Chat not found", error.message), 404);
+        }
+        return c.json(jsonError(failure, error instanceof Error ? error.message : "Unknown error"), 500);
       }
-      return c.json(jsonError("Failed to steer queued message", error instanceof Error ? error.message : "Unknown error"), 500);
-    }
-  });
+    });
+  }
   app2.post("/chats/:chatId/tool-input", async (c) => {
     try {
       const body = respondToolInputSchema.parse(await c.req.json());

package/dist/src/post-tool-pr-hook.js

@@ -3,13 +3,13 @@ import { createRequire as __createRequire } from 'node:module';
 const require = __createRequire(import.meta.url);
 import {
   publishedPullRequestUrls
-} from "./chunk-YQE57AE6.js";
+} from "./chunk-6LIDXAYC.js";
 import {
   isRecord
 } from "./chunk-UZSNFLDQ.js";
 import {
   shouldRefreshPullRequests
-} from "./chunk-IIANP4GI.js";
+} from "./chunk-FWG6GISJ.js";
 import "./chunk-VEQXQN22.js";
 
 // src/services/post-tool-pr-notifier.ts

package/dist/src/subagent-mcp.js

@@ -9,7 +9,7 @@ import {
   spawnSubagentRequestSchema,
   subagentResponseSchema,
   waitSubagentRequestSchema
-} from "./chunk-IIANP4GI.js";
+} from "./chunk-FWG6GISJ.js";
 import "./chunk-VEQXQN22.js";
 
 // src/subagent-mcp.ts
@@ -101,7 +101,7 @@ server.registerTool(SUBAGENT_MCP_TOOLS.getAgent, {
   content: [{ type: "text", text: await request(`/chats/${parentChatId}/subagents/${chat_id}`, "GET") }]
 }));
 server.registerTool(SUBAGENT_MCP_TOOLS.waitAgent, {
-  description: "Wait for one of this chat\u2019s subagents to finish over a heartbeat stream. A timeout stops waiting without interrupting the child.",
+  description: "Wait for one of this chat\u2019s subagents to finish over a heartbeat stream. A timeout, or a new message from the user, stops waiting without interrupting the child.",
   inputSchema: {
     chat_id: z.string().uuid(),
     timeout_minutes: waitSubagentRequestSchema.shape.timeoutMinutes

package/package.json

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