remote-codex 0.11.31 → 0.11.33

package/apps/supervisor-api/dist/index.js

@@ -6382,6 +6382,7 @@ __export(schema_exports, {
   threadGoals: () => threadGoals,
   threadHistoryItems: () => threadHistoryItems,
   threadPendingSteers: () => threadPendingSteers,
+  threadPromptRequests: () => threadPromptRequests,
   threadTurnMetadata: () => threadTurnMetadata,
   threads: () => threads,
   viewerSessions: () => viewerSessions,
@@ -6418,6 +6419,7 @@ var threads = sqliteTable("threads", {
   fastBaseModel: text("fast_base_model"),
   fastBaseReasoningEffort: text("fast_base_reasoning_effort"),
   collaborationMode: text("collaboration_mode").notNull().default("default"),
+  activeTurnCollaborationMode: text("active_turn_collaboration_mode"),
   approvalMode: text("approval_mode"),
   sandboxMode: text("sandbox_mode"),
   status: text("status"),
@@ -6493,9 +6495,27 @@ var threadPendingSteers = sqliteTable("thread_pending_steers", {
   clientRequestId: text("client_request_id"),
   displayPrompt: text("display_prompt").notNull(),
   submittedPrompt: text("submitted_prompt").notNull(),
+  delivery: text("delivery").notNull().default("steer"),
+  turnConfigJson: text("turn_config_json"),
   createdAt: text("created_at").notNull(),
   updatedAt: text("updated_at").notNull()
 });
+var threadPromptRequests = sqliteTable(
+  "thread_prompt_requests",
+  {
+    id: text("id").primaryKey(),
+    threadId: text("thread_id").notNull(),
+    clientRequestId: text("client_request_id").notNull(),
+    status: text("status").notNull(),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (table) => ({
+    threadClientRequestUnique: uniqueIndex(
+      "thread_prompt_requests_thread_client_request_idx"
+    ).on(table.threadId, table.clientRequestId)
+  })
+);
 var threadHistoryItems = sqliteTable(
   "thread_history_items",
   {
@@ -6729,6 +6749,7 @@ function createThreadRecord(db, input) {
     fastBaseModel: input.fastBaseModel ?? null,
     fastBaseReasoningEffort: input.fastBaseReasoningEffort ?? null,
     collaborationMode: input.collaborationMode ?? "default",
+    activeTurnCollaborationMode: input.activeTurnCollaborationMode ?? null,
     approvalMode: input.approvalMode,
     sandboxMode: input.sandboxMode ?? null,
     status: "idle",
@@ -6868,6 +6889,8 @@ function createThreadPendingSteerRecord(db, input) {
     clientRequestId: input.clientRequestId ?? null,
     displayPrompt: input.displayPrompt,
     submittedPrompt: input.submittedPrompt,
+    delivery: input.delivery ?? "steer",
+    turnConfigJson: input.turnConfigJson ?? null,
     createdAt: now,
     updatedAt: now
   };
@@ -6880,6 +6903,48 @@ function deleteThreadPendingSteerRecordById(db, id) {
 function deleteThreadPendingSteerRecordsByThreadId(db, threadId) {
   db.delete(threadPendingSteers).where(eq(threadPendingSteers.threadId, threadId)).run();
 }
+function getThreadPromptRequestRecord(db, threadId, clientRequestId) {
+  return db.select().from(threadPromptRequests).where(
+    and(
+      eq(threadPromptRequests.threadId, threadId),
+      eq(threadPromptRequests.clientRequestId, clientRequestId)
+    )
+  ).get();
+}
+function createThreadPromptRequestRecord(db, threadId, clientRequestId) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.insert(threadPromptRequests).values({
+    id: randomUUID(),
+    threadId,
+    clientRequestId,
+    status: "processing",
+    createdAt: now,
+    updatedAt: now
+  }).onConflictDoNothing().run();
+  return getThreadPromptRequestRecord(db, threadId, clientRequestId);
+}
+function markThreadPromptRequestAccepted(db, threadId, clientRequestId) {
+  db.update(threadPromptRequests).set({ status: "accepted", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(
+    and(
+      eq(threadPromptRequests.threadId, threadId),
+      eq(threadPromptRequests.clientRequestId, clientRequestId)
+    )
+  ).run();
+}
+function deleteExpiredThreadPromptRequestRecords(db, cutoff) {
+  return db.delete(threadPromptRequests).where(lt(threadPromptRequests.updatedAt, cutoff)).run();
+}
+function deleteThreadPromptRequestRecord(db, threadId, clientRequestId) {
+  db.delete(threadPromptRequests).where(
+    and(
+      eq(threadPromptRequests.threadId, threadId),
+      eq(threadPromptRequests.clientRequestId, clientRequestId)
+    )
+  ).run();
+}
+function deleteThreadPromptRequestRecordsByThreadId(db, threadId) {
+  db.delete(threadPromptRequests).where(eq(threadPromptRequests.threadId, threadId)).run();
+}
 function listThreadActivityNotesByThreadId(db, threadId) {
   return db.select().from(threadActivityNotes).where(eq(threadActivityNotes.threadId, threadId)).orderBy(threadActivityNotes.createdAt).all();
 }
@@ -7863,6 +7928,14 @@ var CodexAppServerManager = class extends EventEmitter3 {
     });
     return response.data.map(mapModel);
   }
+  async readAccount() {
+    await this.ensureReady();
+    return this.client.request("account/read", { refreshToken: false });
+  }
+  async readAccountRateLimits() {
+    await this.ensureReady();
+    return this.client.request("account/rateLimits/read", null);
+  }
   async listThreads() {
     await this.ensureReady();
     const response = await this.client.request("thread/list", {
@@ -10550,6 +10623,16 @@ function mapCodexNotification(event) {
       return null;
   }
 }
+function formatRateLimitWindowLabel(durationMinutes, fallback) {
+  if (durationMinutes === null) return fallback;
+  if (durationMinutes % (60 * 24) === 0) {
+    return `${durationMinutes / (60 * 24)}d`;
+  }
+  if (durationMinutes % 60 === 0) {
+    return `${durationMinutes / 60}h`;
+  }
+  return `${durationMinutes}m`;
+}
 function mapCodexRuntimeError(error) {
   if (error instanceof AgentRuntimeError) {
     throw error;
@@ -10667,6 +10750,51 @@ var CodexRuntimeAdapter = class extends EventEmitter4 {
   getStatus() {
     return mapStatus(this.manager.getStatus());
   }
+  async getSubscriptionUsage() {
+    const account = await codexRuntimeCall(() => this.manager.readAccount());
+    if (account.account?.type === "apiKey") {
+      return {
+        provider: "codex",
+        authKind: "apiKey",
+        observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        stale: false,
+        windows: []
+      };
+    }
+    if (account.account?.type !== "chatgpt") {
+      return null;
+    }
+    const response = await codexRuntimeCall(
+      () => this.manager.readAccountRateLimits()
+    );
+    const buckets = response.rateLimitsByLimitId;
+    const snapshot = (buckets && (buckets.codex ?? Object.values(buckets)[0])) ?? response.rateLimits;
+    const record = snapshot && typeof snapshot === "object" ? snapshot : {};
+    const windows = ["primary", "secondary"].flatMap((id) => {
+      const value = record[id];
+      if (!value || typeof value !== "object") return [];
+      const window = value;
+      const usedPercent = Number(window.usedPercent);
+      if (!Number.isFinite(usedPercent)) return [];
+      const duration = Number(window.windowDurationMins);
+      const durationMinutes = Number.isFinite(duration) ? duration : null;
+      const resetsAt = Number(window.resetsAt);
+      return [{
+        id,
+        durationMinutes,
+        label: formatRateLimitWindowLabel(durationMinutes, id),
+        usedPercent: Math.max(0, Math.min(100, usedPercent)),
+        resetsAt: Number.isFinite(resetsAt) ? new Date(resetsAt * 1e3).toISOString() : null
+      }];
+    });
+    return {
+      provider: "codex",
+      authKind: "subscription",
+      observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      stale: false,
+      windows
+    };
+  }
   start() {
     return codexRuntimeCall(() => this.manager.start());
   }
@@ -12373,11 +12501,74 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
   sessionModels = /* @__PURE__ */ new Map();
   sessionApprovalModes = /* @__PURE__ */ new Map();
   liveUserPrompts = /* @__PURE__ */ new Map();
+  subscriptionUsageWindows = /* @__PURE__ */ new Map();
+  subscriptionAuthKind = "unknown";
+  subscriptionUsageObservedAt = null;
   clientApp;
   sdkLoadError = null;
   getStatus() {
     return { ...this.status };
   }
+  async getSubscriptionUsage() {
+    const observedAt = this.subscriptionUsageObservedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    const windows = [...this.subscriptionUsageWindows.entries()].map(([id, window]) => ({
+      id,
+      durationMinutes: id === "five_hour" ? 300 : 10080,
+      label: id === "five_hour" ? "5h" : "7d",
+      usedPercent: window.usedPercent,
+      resetsAt: window.resetsAt
+    }));
+    return {
+      provider: "claude",
+      authKind: this.subscriptionAuthKind,
+      observedAt,
+      stale: false,
+      windows
+    };
+  }
+  captureRateLimit(message) {
+    if (message.type !== "rate_limit_event") {
+      return;
+    }
+    const info = message.rate_limit_info;
+    if (!info || info.rateLimitType !== "five_hour" && info.rateLimitType !== "seven_day" || typeof info.utilization !== "number" || !Number.isFinite(info.utilization)) {
+      return;
+    }
+    this.subscriptionUsageWindows.set(info.rateLimitType, {
+      usedPercent: Math.max(0, Math.min(100, info.utilization * 100)),
+      resetsAt: typeof info.resetsAt === "number" ? new Date(info.resetsAt * 1e3).toISOString() : null
+    });
+    this.subscriptionAuthKind = "subscription";
+    this.subscriptionUsageObservedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  async captureStructuredSubscriptionUsage(query) {
+    const getUsage = query.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET;
+    if (!getUsage) {
+      return;
+    }
+    try {
+      const usage = await getUsage.call(query);
+      const nextWindows = /* @__PURE__ */ new Map();
+      const addWindow = (id, window) => {
+        if (typeof window?.utilization !== "number" || !Number.isFinite(window.utilization)) {
+          return;
+        }
+        nextWindows.set(id, {
+          usedPercent: Math.max(0, Math.min(100, window.utilization)),
+          resetsAt: typeof window.resets_at === "string" ? window.resets_at : null
+        });
+      };
+      addWindow("five_hour", usage.rate_limits?.five_hour);
+      addWindow("seven_day", usage.rate_limits?.seven_day);
+      this.subscriptionUsageWindows.clear();
+      for (const [id, window] of nextWindows) {
+        this.subscriptionUsageWindows.set(id, window);
+      }
+      this.subscriptionAuthKind = usage.subscription_type ? "subscription" : usage.rate_limits_available ? "subscription" : "apiKey";
+      this.subscriptionUsageObservedAt = (/* @__PURE__ */ new Date()).toISOString();
+    } catch {
+    }
+  }
   updateToolboxItemsFromSystemInit(message) {
     this.managementSchema.toolboxItems = buildClaudeToolboxItems(
       normalizeClaudeSlashCommands(message.slash_commands)
@@ -12522,9 +12713,15 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
     let providerSessionId = null;
     let model = input.model;
     const rawMessages = [];
+    let capturedStructuredUsage = false;
     try {
       for await (const message of query) {
         rawMessages.push(message);
+        if (!capturedStructuredUsage) {
+          capturedStructuredUsage = true;
+          await this.captureStructuredSubscriptionUsage(query);
+        }
+        this.captureRateLimit(message);
         if (message.type === "system" && message.subtype === "init") {
           this.updateToolboxItemsFromSystemInit(message);
           const sessionId = message.session_id;
@@ -12769,9 +12966,15 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
     const rawMessages = [];
     let terminalStatus = null;
     let terminalError = null;
+    let capturedStructuredUsage = false;
     try {
       for await (const message of state.query) {
         rawMessages.push(message);
+        if (!capturedStructuredUsage) {
+          capturedStructuredUsage = true;
+          await this.captureStructuredSubscriptionUsage(state.query);
+        }
+        this.captureRateLimit(message);
         this.consumeMessage(state, message);
         const status = queryResultStatus(message);
         if (status) {
@@ -16074,6 +16277,7 @@ var ThreadAuxiliaryStateStore = class {
       clientRequestId: record.clientRequestId ?? null,
       turnId: record.turnId,
       prompt: record.displayPrompt,
+      delivery: record.delivery === "continuation" ? "continuation" : "steer",
       createdAt: record.createdAt
     }));
   }
@@ -16090,6 +16294,11 @@ var ThreadAuxiliaryStateStore = class {
   hasPendingSteersForTurn(localThreadId, turnId) {
     return this.listPendingSteerRecordsForTurn(localThreadId, turnId).length > 0;
   }
+  hasQueuedContinuationsForTurn(localThreadId, turnId) {
+    return this.listPendingSteerRecordsForTurn(localThreadId, turnId).some(
+      (record) => record.delivery === "continuation"
+    );
+  }
   deletePendingSteerRecord(localThreadId, id, turnId) {
     deleteThreadPendingSteerRecordById(this.db, id);
     this.callbacks.invalidateThreadDetailCache(localThreadId);
@@ -17889,6 +18098,7 @@ var ThreadRuntimeEventProjector = class {
         const turnItems = event.turn.items;
         updateThreadRecord(db, record.id, {
           providerTurnId: null,
+          activeTurnCollaborationMode: null,
           status: event.turn.status === "failed" ? "failed" : event.turn.status === "interrupted" ? "interrupted" : "idle",
           lastError: event.turn.error?.message ?? null,
           lastTurnCompletedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -17910,7 +18120,9 @@ var ThreadRuntimeEventProjector = class {
           }
         }
         callbacks.clearTerminalPendingRequests(record.id, true);
-        if (event.turn.status === "completed" && callbacks.normalizeCollaborationMode(record.collaborationMode) === "plan" && turnItems.some((item) => item.kind === "plan") && !callbacks.hasPendingAskUserQuestion(record.id)) {
+        if (event.turn.status === "completed" && !preservePendingSteers && callbacks.normalizeCollaborationMode(
+          record.activeTurnCollaborationMode ?? record.collaborationMode
+        ) === "plan" && turnItems.some((item) => item.kind === "plan") && !callbacks.hasPendingAskUserQuestion(record.id)) {
           callbacks.createPendingPlanDecisionRequest(record.id, turnId, true);
         } else {
           callbacks.dismissPlanDecisionTurn(record.id);
@@ -17942,6 +18154,7 @@ var ThreadRuntimeEventProjector = class {
         const turnId = liveState.displayTurnIdForRuntimeTurn(record.id, event.providerTurnId) ?? event.providerTurnId;
         updateThreadRecord(db, record.id, {
           providerTurnId: null,
+          activeTurnCollaborationMode: null,
           status: "failed",
           lastError: event.error,
           lastTurnCompletedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -19274,6 +19487,7 @@ var ThreadPromptTurnCoordinator = class {
       model: input.effectiveModel,
       reasoningEffort: input.normalizedReasoning,
       collaborationMode: input.collaborationMode,
+      activeTurnCollaborationMode: input.collaborationMode,
       sandboxMode: input.sandboxMode
     };
     if (isAutoGeneratedTitle(record.title)) {
@@ -19396,7 +19610,8 @@ var ThreadPromptTurnCoordinator = class {
           turnId: steerTurnId,
           clientRequestId: input.clientRequestId,
           displayPrompt: input.displayPrompt,
-          submittedPrompt: input.prompt
+          submittedPrompt: input.prompt,
+          delivery: "steer"
         });
         this.callbacks.invalidateThreadDetailCache(localThreadId);
         this.callbacks.emitThreadUpdated(localThreadId, {
@@ -19445,7 +19660,16 @@ var ThreadPromptTurnCoordinator = class {
       turnId: displayTurnId,
       clientRequestId: input.clientRequestId,
       displayPrompt: input.displayPrompt,
-      submittedPrompt: input.prompt
+      submittedPrompt: input.prompt,
+      delivery: "continuation",
+      turnConfigJson: JSON.stringify({
+        effectiveModel: input.effectiveModel,
+        normalizedReasoning: input.normalizedReasoning,
+        collaborationMode: input.collaborationMode,
+        sandboxMode: input.sandboxMode,
+        performanceMode: input.performanceMode,
+        startNewTurn: input.collaborationMode !== (record.activeTurnCollaborationMode === "plan" ? "plan" : "default")
+      })
     });
     this.callbacks.invalidateThreadDetailCache(localThreadId);
     this.callbacks.emitThreadUpdated(localThreadId, {
@@ -19651,7 +19875,7 @@ var ThreadSessionCoordinator = class {
       if (!isRemoteThreadBootstrapError(error)) {
         throw error;
       }
-      return { status: "bootstrap_unavailable" };
+      return { status: "bootstrap_unavailable", error };
     }
     const effectiveModel = input.resumeInput.model ?? input.currentModel ?? response.model ?? null;
     const resumedReasoning = this.providerRuntime.normalizeReasoningForModel(
@@ -19827,6 +20051,37 @@ var ThreadSessionLifecycleCoordinator = class {
       fastMode: record.fastMode
     });
     if (resumed.status === "bootstrap_unavailable") {
+      if (!this.canRecreateUnmaterializedThread(record, resumed.error)) {
+        return;
+      }
+      const workspace = getWorkspaceRecordById(this.db, record.workspaceId);
+      const model = input.model ?? record.model;
+      if (!workspace || !model) {
+        return;
+      }
+      const recreated = await this.sessionCoordinator.startThreadSession({
+        workspacePath: workspace.absPath,
+        threadInput: {
+          workspaceId: workspace.id,
+          title: record.title,
+          provider: record.provider,
+          model,
+          reasoningEffort: record.reasoningEffort,
+          approvalMode: record.approvalMode ?? "yolo"
+        },
+        defaultTitle: record.title
+      });
+      updateThreadRecord(this.db, record.id, {
+        ...buildThreadPatch(
+          recreated.response.session,
+          model,
+          recreated.response.reasoningEffort ?? recreated.reasoningEffort
+        ),
+        providerSessionId: recreated.response.providerSessionId,
+        sandboxMode: recreated.sandboxMode,
+        isConnected: true
+      });
+      this.callbacks.invalidateThreadDetailCache(localThreadId);
       return;
     }
     updateThreadRecord(
@@ -19850,6 +20105,9 @@ var ThreadSessionLifecycleCoordinator = class {
     }
     this.callbacks.invalidateThreadDetailCache(localThreadId);
   }
+  canRecreateUnmaterializedThread(record, error) {
+    return record.provider === "codex" && record.source === "supervisor" && listThreadTurnMetadataByThreadId(this.db, record.id).length === 0 && error instanceof AgentRuntimeError && error.provider === "codex" && error.code === "remote_error" && /thread not loaded|no rollout found/i.test(error.message);
+  }
   disconnectThread(localThreadId) {
     const record = getThreadRecordById(this.db, localThreadId);
     if (!record) {
@@ -20049,6 +20307,7 @@ var ThreadDeletionCoordinator = class {
     deleteThreadGoalRecordsByThreadId(this.db, localThreadId);
     deleteThreadHistoryItemRecordsByThreadId(this.db, localThreadId);
     deleteThreadPendingSteerRecordsByThreadId(this.db, localThreadId);
+    deleteThreadPromptRequestRecordsByThreadId(this.db, localThreadId);
     deleteThreadTurnMetadataByThreadId(this.db, localThreadId);
     deleteThreadRecord(this.db, localThreadId);
     return { id: localThreadId };
@@ -21974,7 +22233,7 @@ var ThreadService = class {
         normalizeCollaborationMode,
         normalizeReasoningEffort: normalizeReasoningEffort2,
         normalizeThreadGoalStatusForThread: (goal, record) => this.goalCoordinator.normalizeThreadGoalStatusForThread(goal, record),
-        shouldPreservePendingSteersForCompletedTurn: (record, turnId) => !this.runtimeSupportsLiveRunningTurnInput(record.provider) && this.auxiliaryState.hasPendingSteersForTurn(record.id, turnId),
+        shouldPreservePendingSteersForCompletedTurn: (record, turnId) => this.shouldPreserveCompletedPendingSteer(record.id, turnId),
         scheduleQueuedContinuationDrain: (localThreadId, turnId) => this.scheduleQueuedContinuationDrain(localThreadId, turnId),
         persistLiveHistoryItem: (localThreadId, turnId, item) => this.historyPersistence.persistLiveHistoryItem(localThreadId, turnId, item),
         persistFinalTurnOrderingHints: (localThreadId, turnId, items) => this.historyPersistence.persistFinalTurnOrderingHints(localThreadId, turnId, items),
@@ -22008,6 +22267,7 @@ var ThreadService = class {
   config;
   liveState = new ThreadLiveStateStore();
   queuedContinuationDrains = /* @__PURE__ */ new Set();
+  promptRequestsInFlight = /* @__PURE__ */ new Map();
   detailAssembler;
   usageAccounting;
   requestCoordinator;
@@ -22326,6 +22586,57 @@ var ThreadService = class {
     return this.getThreadDetail(localThreadId);
   }
   async sendPrompt(localThreadId, input, options = {}) {
+    const clientRequestId = input.clientRequestId?.trim();
+    if (!clientRequestId) {
+      return this.sendPromptOnce(localThreadId, input, options);
+    }
+    const requestKey = `${localThreadId}:${clientRequestId}`;
+    const activeRequest = this.promptRequestsInFlight.get(requestKey);
+    if (activeRequest) {
+      return activeRequest;
+    }
+    const request = this.sendPromptIdempotently(
+      localThreadId,
+      { ...input, clientRequestId },
+      options
+    );
+    this.promptRequestsInFlight.set(requestKey, request);
+    try {
+      return await request;
+    } finally {
+      if (this.promptRequestsInFlight.get(requestKey) === request) {
+        this.promptRequestsInFlight.delete(requestKey);
+      }
+    }
+  }
+  async sendPromptIdempotently(localThreadId, input, options) {
+    deleteExpiredThreadPromptRequestRecords(
+      this.db,
+      new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3).toISOString()
+    );
+    const existing = getThreadPromptRequestRecord(
+      this.db,
+      localThreadId,
+      input.clientRequestId
+    );
+    if (existing) {
+      const record = this.requireThreadRecord(localThreadId);
+      return this.toThreadDto(
+        record,
+        await this.listLoadedProviderSessionIds(record.provider)
+      );
+    }
+    createThreadPromptRequestRecord(this.db, localThreadId, input.clientRequestId);
+    try {
+      const result = await this.sendPromptOnce(localThreadId, input, options);
+      markThreadPromptRequestAccepted(this.db, localThreadId, input.clientRequestId);
+      return result;
+    } catch (error) {
+      deleteThreadPromptRequestRecord(this.db, localThreadId, input.clientRequestId);
+      throw error;
+    }
+  }
+  async sendPromptOnce(localThreadId, input, options = {}) {
     let record = this.requireThreadRecord(localThreadId);
     await this.importCoordinator.assertImportedThreadReadyForPrompt({
       source: record.source,
@@ -22391,7 +22702,10 @@ var ThreadService = class {
     };
     const hasActiveProviderTurn = Boolean(record.providerTurnId) && (record.status === "running" || !turnConfig.supportsRunningTurnInput && !record.lastTurnCompletedAt) && record.status !== "failed" && record.status !== "interrupted";
     if (hasActiveProviderTurn && record.providerTurnId) {
-      if (!turnConfig.supportsRunningTurnInput) {
+      const activeTurnCollaborationMode = normalizeCollaborationMode(
+        record.activeTurnCollaborationMode ?? record.collaborationMode
+      );
+      if (!turnConfig.supportsRunningTurnInput || activeTurnCollaborationMode !== turnConfig.collaborationMode) {
         return this.promptTurnCoordinator.queueContinuationPromptTurn(localThreadId, {
           ...connectedRecord,
           providerTurnId: record.providerTurnId
@@ -22735,7 +23049,7 @@ var ThreadService = class {
     if (!record) {
       return false;
     }
-    return !this.runtimeSupportsLiveRunningTurnInput(record.provider) && this.auxiliaryState.hasPendingSteersForTurn(localThreadId, turnId);
+    return this.auxiliaryState.hasQueuedContinuationsForTurn(localThreadId, turnId);
   }
   shouldPreserveMissingPendingSteer(localThreadId, turnId) {
     const record = getThreadRecordById(this.db, localThreadId);
@@ -22745,14 +23059,11 @@ var ThreadService = class {
     if (record.status === "failed" || record.status === "interrupted") {
       return false;
     }
-    if (this.runtimeSupportsLiveRunningTurnInput(record.provider)) {
-      return false;
-    }
     const activeDisplayTurnId = this.liveState.displayTurnIdForRuntimeTurn(
       localThreadId,
       record.providerTurnId
     );
-    return record.providerTurnId === turnId || activeDisplayTurnId === turnId;
+    return (record.providerTurnId === turnId || activeDisplayTurnId === turnId) && this.auxiliaryState.hasQueuedContinuationsForTurn(localThreadId, turnId);
   }
   scheduleQueuedContinuationDrain(localThreadId, turnId) {
     const key = `${localThreadId}:${turnId}`;
@@ -22776,7 +23087,7 @@ var ThreadService = class {
     const pending = this.auxiliaryState.listPendingSteerRecordsForTurn(
       localThreadId,
       turnId
-    )[0];
+    ).find((entry) => entry.delivery === "continuation");
     if (!pending) {
       return;
     }
@@ -22795,7 +23106,8 @@ var ThreadService = class {
     const developerInstructions = combineDeveloperInstructions([
       pluginDeveloperInstructions(this.pluginService)
     ]);
-    const turnConfig = await this.sessionCoordinator.resolvePromptTurnConfig({
+    const queuedConfig = parseQueuedTurnConfig(pending.turnConfigJson);
+    const turnConfig = queuedConfig ?? await this.sessionCoordinator.resolvePromptTurnConfig({
       provider: record.provider,
       currentModel: record.model,
       currentReasoningEffort: record.reasoningEffort,
@@ -22805,14 +23117,16 @@ var ThreadService = class {
       approvalMode: record.approvalMode ?? "yolo",
       promptInput: {}
     });
-    const queuedUserItemId = `queued-continuation:${pending.id}:user`;
-    this.historyPersistence.persistProjectedHistoryItem(localThreadId, turnId, {
-      id: queuedUserItemId,
-      kind: "userMessage",
-      text: pending.displayPrompt,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      sequence: this.liveState.recordTurnItemOrder(localThreadId, turnId, queuedUserItemId)
-    });
+    if (!queuedConfig?.startNewTurn) {
+      const queuedUserItemId = `queued-continuation:${pending.id}:user`;
+      this.historyPersistence.persistProjectedHistoryItem(localThreadId, turnId, {
+        id: queuedUserItemId,
+        kind: "userMessage",
+        text: pending.displayPrompt,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sequence: this.liveState.recordTurnItemOrder(localThreadId, turnId, queuedUserItemId)
+      });
+    }
     await this.promptTurnCoordinator.startPromptTurn(localThreadId, {
       ...record,
       providerSessionId
@@ -22826,8 +23140,7 @@ var ThreadService = class {
       sandboxMode: turnConfig.sandboxMode,
       performanceMode: turnConfig.performanceMode,
       workspacePath: workspace.absPath,
-      hidden: true,
-      displayTurnId: turnId
+      ...queuedConfig?.startNewTurn ? {} : { hidden: true, displayTurnId: turnId }
     });
     this.auxiliaryState.deletePendingSteerRecord(localThreadId, pending.id, turnId);
   }
@@ -22915,6 +23228,27 @@ var ThreadService = class {
     );
   }
 };
+function parseQueuedTurnConfig(value) {
+  if (!value) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (parsed.collaborationMode !== "default" && parsed.collaborationMode !== "plan" || parsed.performanceMode !== "fast" && parsed.performanceMode !== "standard" || typeof parsed.startNewTurn !== "boolean") {
+      return null;
+    }
+    return {
+      effectiveModel: typeof parsed.effectiveModel === "string" ? parsed.effectiveModel : null,
+      normalizedReasoning: parsed.normalizedReasoning ?? null,
+      collaborationMode: parsed.collaborationMode,
+      sandboxMode: parsed.sandboxMode ?? "workspace-write",
+      performanceMode: parsed.performanceMode,
+      startNewTurn: parsed.startNewTurn
+    };
+  } catch {
+    return null;
+  }
+}
 
 // src/routes/agent-runtimes.ts
 import fs15 from "fs/promises";
@@ -22987,6 +23321,17 @@ async function registerAgentRuntimeRoutes(app2) {
     const { provider: provider2 } = providerParamSchema.parse(request.params);
     return runtimeDto(app2, provider2);
   });
+  app2.get("/api/agent-runtimes/:provider/subscription-usage", async (request) => {
+    const { provider: provider2 } = providerParamSchema.parse(request.params);
+    const runtime = app2.services.agentRuntimes.getOptional(provider2);
+    if (!runtime) {
+      throw providerNotConfigured(provider2);
+    }
+    if (!runtime.getSubscriptionUsage) {
+      return { usage: null };
+    }
+    return { usage: await runtime.getSubscriptionUsage() };
+  });
   app2.post("/api/agent-runtimes/:provider/restart", async (request) => {
     const { provider: provider2 } = providerParamSchema.parse(request.params);
     const runtime = app2.services.agentRuntimes.getOptional(provider2);
@@ -23393,9 +23738,11 @@ function parseProviderHostFileParams(params) {
 }
 async function registerSystemRoutes(app2) {
   app2.get("/healthz", async () => {
+    const activeTurnCount = app2.services.database.sqlite.prepare("SELECT COUNT(*) AS count FROM threads WHERE status = 'running'").get();
     return {
       status: "ok",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      activeTurnCount: activeTurnCount.count
     };
   });
   app2.get("/readyz", async () => {
@@ -25017,7 +25364,16 @@ async function registerWorkspaceRoutes(app2) {
       await cloneRepository(body.gitUrl.trim(), targetPath);
       validated = await validateWorkspacePath(app2.services.config.workspaceRoot, targetPath);
     } else {
-      validated = await validateWorkspacePath(app2.services.config.workspaceRoot, body.absPath, {
+      const requestedPath = body.absPath.trim();
+      const isWorkspaceName = !path22.isAbsolute(requestedPath) && /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(requestedPath) && requestedPath !== "." && requestedPath !== "..";
+      if (!path22.isAbsolute(requestedPath) && !isWorkspaceName) {
+        throw new HttpError(400, {
+          code: "bad_request",
+          message: "Use a simple directory name, an absolute path, or a Git URL."
+        });
+      }
+      const targetPath = isWorkspaceName ? path22.join(settings.devHome, requestedPath) : requestedPath;
+      validated = await validateWorkspacePath(app2.services.config.workspaceRoot, targetPath, {
         devHome: settings.devHome,
         createMissingLeaf: true
       });
@@ -27969,6 +28325,7 @@ var RelayTunnelClient = class {
   reconnectDelayMs = RELAY_RECONNECT_INITIAL_DELAY_MS;
   stopped = false;
   relayClientCleanup = /* @__PURE__ */ new Map();
+  pendingActivity = /* @__PURE__ */ new Map();
   validateConfig() {
     if (!this.config.serverUrl || !this.config.agentToken) {
       throw new Error(
@@ -27983,7 +28340,10 @@ var RelayTunnelClient = class {
     if (this.socket) {
       return;
     }
-    const url = new URL("/supervisor/tunnel", this.config.serverUrl ?? void 0);
+    const url = new URL(
+      "/supervisor/tunnel",
+      this.config.serverUrl ?? void 0
+    );
     url.searchParams.set("token", this.config.agentToken ?? "");
     url.searchParams.set("deviceToken", this.config.agentToken ?? "");
     const socket = new WebSocket(url);
@@ -27997,6 +28357,7 @@ var RelayTunnelClient = class {
       this.clearConnectTimeout();
       this.reconnectDelayMs = RELAY_RECONNECT_INITIAL_DELAY_MS;
       this.sendHeartbeat();
+      this.flushPendingActivity();
       this.clearHeartbeat();
       this.heartbeatHandle = setInterval(() => {
         this.sendHeartbeat();
@@ -28021,6 +28382,29 @@ var RelayTunnelClient = class {
     this.socket?.close();
     this.socket = null;
   }
+  sendActivity(payload) {
+    const key = `${payload.threadId}\0${payload.turnId}`;
+    const socket = this.socket;
+    if (socket?.readyState !== WebSocket.OPEN) {
+      this.pendingActivity.set(key, payload);
+      return;
+    }
+    const sent = this.sendEnvelope(socket, {
+      type: "relay.activity",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload
+    });
+    if (sent) {
+      this.pendingActivity.delete(key);
+    } else {
+      this.pendingActivity.set(key, payload);
+    }
+  }
+  flushPendingActivity() {
+    for (const payload of this.pendingActivity.values()) {
+      this.sendActivity(payload);
+    }
+  }
   sendHeartbeat() {
     const socket = this.socket;
     if (socket?.readyState !== WebSocket.OPEN) {
@@ -28040,9 +28424,12 @@ var RelayTunnelClient = class {
     }
     if (parsed.type !== "relay.request") {
       if (parsed.type === "relay.client.connected") {
-        const cleanup = this.handleClientConnected(parsed.clientId, (message) => {
-          this.sendClientMessage(parsed.clientId, message);
-        });
+        const cleanup = this.handleClientConnected(
+          parsed.clientId,
+          (message) => {
+            this.sendClientMessage(parsed.clientId, message);
+          }
+        );
         this.relayClientCleanup.set(parsed.clientId, cleanup);
         return;
       }
@@ -28052,9 +28439,13 @@ var RelayTunnelClient = class {
         return;
       }
       if (parsed.type === "relay.client.message") {
-        await this.handleClientMessage(parsed.clientId, parsed.payload, (message) => {
-          this.sendClientMessage(parsed.clientId, message);
-        });
+        await this.handleClientMessage(
+          parsed.clientId,
+          parsed.payload,
+          (message) => {
+            this.sendClientMessage(parsed.clientId, message);
+          }
+        );
         return;
       }
       return;
@@ -28064,15 +28455,12 @@ var RelayTunnelClient = class {
     if (socket?.readyState !== WebSocket.OPEN) {
       return;
     }
-    this.sendEnvelope(
-      socket,
-      {
-        type: "relay.response",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        requestId: parsed.requestId,
-        payload: response
-      }
-    );
+    this.sendEnvelope(socket, {
+      type: "relay.response",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId: parsed.requestId,
+      payload: response
+    });
   }
   sendClientMessage(clientId, message) {
     const socket = this.socket;
@@ -28089,8 +28477,10 @@ var RelayTunnelClient = class {
   sendEnvelope(socket, message) {
     try {
       socket.send(JSON.stringify(message));
+      return true;
     } catch {
       this.closeAndReconnect(socket);
+      return false;
     }
   }
   closeAndReconnect(socket) {
@@ -28158,10 +28548,7 @@ var DEFAULT_WEBVIEW_CORS_ORIGINS = /* @__PURE__ */ new Set([
   "https://localhost",
   "https://appassets.androidplatform.net"
 ]);
-var WEBVIEW_CORS_ALLOW_HEADERS = [
-  "authorization",
-  "content-type"
-].join(", ");
+var WEBVIEW_CORS_ALLOW_HEADERS = ["authorization", "content-type"].join(", ");
 var WEBVIEW_CORS_ALLOW_METHODS = [
   "GET",
   "POST",
@@ -28175,7 +28562,9 @@ function webViewCorsOrigins(env) {
     return null;
   }
   const configured = env.REMOTE_CODEX_WEBVIEW_CORS_ORIGINS?.split(",").map((origin) => origin.trim()).filter(Boolean);
-  return new Set(configured?.length ? configured : DEFAULT_WEBVIEW_CORS_ORIGINS);
+  return new Set(
+    configured?.length ? configured : DEFAULT_WEBVIEW_CORS_ORIGINS
+  );
 }
 function applyWebViewCorsHeaders(reply, origin) {
   reply.header("access-control-allow-origin", origin);
@@ -28224,7 +28613,11 @@ function createServiceLifecycle() {
         });
       }
       const repoRoot = findRepoRoot();
-      const restartScript = path28.join(repoRoot, "scripts", "service-restart.mjs");
+      const restartScript = path28.join(
+        repoRoot,
+        "scripts",
+        "service-restart.mjs"
+      );
       if (!fs26.existsSync(restartScript) || !fs26.existsSync(path28.join(repoRoot, "pnpm-workspace.yaml"))) {
         throw new HttpError(503, {
           code: "service_unavailable",
@@ -28284,7 +28677,9 @@ function buildApp(options = {}) {
     },
     disableRequestLogging: config.disableRequestLogging
   });
-  const allowedWebViewCorsOrigins = webViewCorsOrigins(options.env ?? process.env);
+  const allowedWebViewCorsOrigins = webViewCorsOrigins(
+    options.env ?? process.env
+  );
   app2.addHook("onRequest", async (request, reply) => {
     if (!allowedWebViewCorsOrigins) {
       return;
@@ -28298,15 +28693,22 @@ function buildApp(options = {}) {
       return reply.code(204).send();
     }
   });
-  app2.register(multipart, {
-    limits: {
-      files: MAX_PROMPT_ATTACHMENTS2,
-      fileSize: MAX_PROMPT_ATTACHMENT_BYTES2
+  app2.register(
+    multipart,
+    {
+      limits: {
+        files: MAX_PROMPT_ATTACHMENTS2,
+        fileSize: MAX_PROMPT_ATTACHMENT_BYTES2
+      }
     }
-  });
+  );
   const backendPluginHost = new BackendPluginHost(app2);
   backendPluginHost.register(createTerminalPluginBackendContribution());
-  const relaySocketBridge = createRelaySocketBridge(app2, eventBus, backendPluginHost);
+  const relaySocketBridge = createRelaySocketBridge(
+    app2,
+    eventBus,
+    backendPluginHost
+  );
   const relayTunnelClient = config.mode === "relay" ? options.relayTunnelClient ?? new RelayTunnelClient(
     config.relay,
     createRelayRequestHandler(app2),
@@ -28314,6 +28716,31 @@ function buildApp(options = {}) {
     relaySocketBridge.handleMessage
   ) : null;
   relayTunnelClient?.validateConfig();
+  const cleanupRelayActivity = relayTunnelClient ? eventBus.onThreadEvent((event) => {
+    if (event.type === "thread.turn.started") {
+      relayTunnelClient.sendActivity({
+        kind: "turn_started",
+        threadId: event.threadId,
+        turnId: event.payload.turnId
+      });
+      return;
+    }
+    if (event.type === "thread.turn.completed") {
+      relayTunnelClient.sendActivity({
+        kind: "turn_terminal",
+        threadId: event.threadId,
+        turnId: event.payload.turnId
+      });
+      return;
+    }
+    if (event.type === "thread.turn.failed" && event.payload.willRetry !== true) {
+      relayTunnelClient.sendActivity({
+        kind: "turn_terminal",
+        threadId: event.threadId,
+        turnId: event.payload.turnId
+      });
+    }
+  }) : null;
   app2.decorate("services", {
     config,
     database,
@@ -28494,6 +28921,7 @@ function buildApp(options = {}) {
     });
   });
   app2.addHook("onClose", async () => {
+    cleanupRelayActivity?.();
     await shellService.stop();
     relayTunnelClient?.stop();
     await Promise.all(agentRuntimes.all().map((runtime) => runtime.stop()));
@@ -28666,6 +29094,21 @@ if (fs27.existsSync(".env")) {
 }
 var app = buildApp();
 var { host, port } = app.services.config;
+var closing = false;
+async function shutdown(signal) {
+  if (closing) return;
+  closing = true;
+  app.log.info(`Supervisor API received ${signal}; closing cleanly.`);
+  try {
+    await app.close();
+    process.exit(0);
+  } catch (error) {
+    app.log.error(error);
+    process.exit(1);
+  }
+}
+process.once("SIGTERM", () => void shutdown("SIGTERM"));
+process.once("SIGINT", () => void shutdown("SIGINT"));
 app.listen({ host, port }).then(() => {
   app.log.info(`Supervisor API listening on http://${host}:${port}`);
 }).catch((error) => {