@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/web-ui/app/controllers/composer-queue-controller.js

@@ -54,7 +54,7 @@ export function createComposerQueueController({
     attachments.render();
   }
 
-  function reportFailure(scope, summary) {
+  function reportFailure(scope, summary, tone = "failed") {
     if (!isCurrentScope(scope)) return;
     state.messages.push({
       id: `queue-error-${Date.now()}`,
@@ -69,7 +69,7 @@ export function createComposerQueueController({
     recordControlEvent({
       type: "control",
       name: "Send next queue paused",
-      tone: "failed",
+      tone,
       summary,
     });
   }
@@ -99,7 +99,7 @@ export function createComposerQueueController({
     state.activeComposerQueueRecovery = null;
   }
 
-  async function drain({ environmentId, sessionId, terminalRequestId }) {
+  async function drain({ environmentId, sessionId, terminalRequestId, cancelled = false }) {
     const scope = { environmentId, sessionId };
     const key = scopeKey(scope);
     if (state.composerQueueDrainingScopes.has(key)) return;
@@ -124,6 +124,12 @@ export function createComposerQueueController({
       if (isCurrentScope(scope)) updateSendState();
       return;
     }
+    if (cancelled) {
+      state.composerQueueDrainingScopes.delete(key);
+      recoverForManualSend(scope, "Response stopped. The next queued message is back in the composer; send it when you are ready to continue.", "neutral");
+      if (isCurrentScope(scope)) updateSendState();
+      return;
+    }
     updateSendState();
     const { item, releaseToken } = released;
     let requestId;
@@ -224,7 +230,7 @@ export function createComposerQueueController({
     return true;
   }
 
-  function recoverForManualSend(scope) {
+  function recoverForManualSend(scope, message = "Send next is paused. The queued message was restored to the composer for review and will not be sent automatically.", tone = "neutral") {
     let blockedRelease;
     try {
       blockedRelease = queue.getBlockedRelease(scope);
@@ -251,7 +257,8 @@ export function createComposerQueueController({
     };
     reportFailure(
       scope,
-      "A queued message could not be confirmed after the interruption. It was restored to the composer for review and will not be sent automatically.",
+      message,
+      tone,
     );
     return true;
   }

package/dist/src/web-ui/app/controllers/composer-stop-controller.d.ts

@@ -0,0 +1,9 @@
+export declare function createComposerStopController(options: {
+  state: Record<string, any>;
+  selectedEnvironmentId(): string;
+  stopRequest(
+    scope: Record<string, unknown>,
+  ): Promise<{ accepted: boolean; reason?: string }>;
+  updateSendState(): void;
+  setMessageStatus(message: string, pending?: boolean): void;
+}): { stop(): Promise<void>; isStopping(): boolean };

package/dist/src/web-ui/app/controllers/composer-stop-controller.js

@@ -0,0 +1,64 @@
+import { waitingRequest } from "../lib/request-lifecycle-view.js";
+
+export function createComposerStopController({
+  state,
+  selectedEnvironmentId,
+  stopRequest,
+  updateSendState,
+  setMessageStatus,
+}) {
+  let pendingKey = "";
+  const requestId = () =>
+    state.activeRequestId || waitingRequest(state)?.requestId || "";
+  const currentKey = () =>
+    JSON.stringify([
+      selectedEnvironmentId(),
+      state.currentSessionId,
+      requestId(),
+    ]);
+  const isStopping = () => Boolean(requestId()) && pendingKey === currentKey();
+
+  async function stop() {
+    if (!requestId() || isStopping()) return;
+    const waiting = waitingRequest(state);
+    const scope = {
+      environmentId: selectedEnvironmentId(),
+      sessionId: state.currentSessionId,
+      requestId: requestId(),
+      ...(waiting?.wait && waiting.requestId === requestId()
+        ? {
+            generation: waiting.generation,
+            waitId: waiting.wait.waitId,
+            revision: waiting.revision,
+            commandId: `cancel:${waiting.generation}:${waiting.wait.waitId}`,
+          }
+        : {}),
+    };
+    const key = currentKey();
+    pendingKey = key;
+    updateSendState();
+    setMessageStatus("Stopping…", true);
+    try {
+      const receipt = await stopRequest(scope);
+      if (currentKey() !== key) return;
+      if (!receipt?.accepted)
+        throw new Error(
+          receipt?.reason === "request_not_active"
+            ? "This request has already ended. Waiting for its final status."
+            : "The request could not be stopped. Try again.",
+        );
+      // Keep the request active until its canonical terminal event arrives.
+    } catch (error) {
+      if (pendingKey === key) pendingKey = "";
+      if (currentKey() === key)
+        setMessageStatus(
+          error instanceof Error
+            ? error.message
+            : "Could not stop the request.",
+        );
+    } finally {
+      if (currentKey() === key) updateSendState();
+    }
+  }
+  return { stop, isStopping };
+}

package/dist/src/web-ui/app/controllers/composer-submit-controller.d.ts

@@ -26,6 +26,8 @@ export interface ComposerSubmitActions {
   primaryAction(): string;
   render(options: {
     activeRequestId: string;
+    stopping?: boolean;
+    onStop?: () => void;
     attachmentCount: number;
     busy: boolean;
     disabled: boolean;
@@ -46,6 +48,7 @@ export interface ComposerSubmitQueue {
 
 export interface ComposerSubmitChatRequests {
   sendMessage(text: string): Promise<void>;
+  stopRequest?(scope: ComposerScope & { requestId: string }): Promise<{ accepted: boolean; reason?: string }>;
 }
 
 export interface ComposerSubmitConversationSession {
@@ -69,6 +72,7 @@ export interface ComposerSubmitControllerOptions {
 }
 
 export interface ComposerSubmitController {
+  stop(): false | Promise<void>;
   dispatch(requestedAction?: string): void;
   resize(): void;
   updateSendState(): void;

package/dist/src/web-ui/app/controllers/composer-submit-controller.js

@@ -1,5 +1,13 @@
-import { captureComposerSubmissionScope, isCurrentComposerSubmissionScope } from "../lib/composer-submission-scope.js";
+import {
+  captureComposerSubmissionScope,
+  isCurrentComposerSubmissionScope,
+} from "../lib/composer-submission-scope.js";
 import { resolveComposerPrimaryAction } from "../ui-behavior.js";
+import { createComposerStopController } from "./composer-stop-controller.js";
+import {
+  hasWaitingApproval,
+  waitingRequest,
+} from "../lib/request-lifecycle-view.js";
 
 export function createComposerSubmitController({
   state,
@@ -16,6 +24,13 @@ export function createComposerSubmitController({
   onSubmissionBlocked = () => {},
   isComposerVisible = () => true,
 }) {
+  const stopping = createComposerStopController({
+    state,
+    selectedEnvironmentId,
+    setMessageStatus,
+    updateSendState,
+    stopRequest: (scope) => chatRequests.stopRequest(scope),
+  });
   function resize() {
     if (!isComposerVisible()) return;
     dom.composerInput.style.height = "auto";
@@ -31,9 +46,16 @@ export function createComposerSubmitController({
     const submissionBlock = getSubmissionBlock();
     composerActions.render({
       activeRequestId: state.activeRequestId,
+      waitingRequestId: waitingRequest(state)?.requestId,
+      stopping: stopping.isStopping(),
+      onStop: () => {
+        if (isComposerVisible()) void stopping.stop();
+      },
       attachmentCount: state.pendingAttachments.length,
       busy: state.composerSending || queueDraining,
       disabled:
+        stopping.isStopping() ||
+        hasWaitingApproval(state) ||
         Boolean(submissionBlock) ||
         !dom.composerInput.value.trim() ||
         state.composerSending ||
@@ -45,6 +67,13 @@ export function createComposerSubmitController({
 
   function dispatch(requestedAction = "") {
     if (!isComposerVisible()) return;
+    if (stopping.isStopping()) return;
+    if (hasWaitingApproval(state)) {
+      setMessageStatus(
+        "Decide or cancel the pending approval before sending a new message.",
+      );
+      return;
+    }
     const text = dom.composerInput.value.trim();
     const submissionBlock = getSubmissionBlock();
     if (text && submissionBlock) {
@@ -90,11 +119,15 @@ export function createComposerSubmitController({
           ? queue.enqueue(text)
           : chatRequests.sendMessage(text);
     const completionScope = captureComposerSubmissionScope(
-      state, selectedEnvironmentId(),
-    );
-    const isSubmissionForCurrentComposerView = () => isCurrentComposerSubmissionScope(
-      completionScope, state, selectedEnvironmentId(),
+      state,
+      selectedEnvironmentId(),
     );
+    const isSubmissionForCurrentComposerView = () =>
+      isCurrentComposerSubmissionScope(
+        completionScope,
+        state,
+        selectedEnvironmentId(),
+      );
     void operation
       .then(() => {
         if (!isSubmissionForCurrentComposerView()) return;
@@ -118,5 +151,10 @@ export function createComposerSubmitController({
       });
   }
 
-  return { dispatch, resize, updateSendState };
+  return {
+    dispatch,
+    resize,
+    updateSendState,
+    stop: () => isComposerVisible() && stopping.stop(),
+  };
 }

package/dist/src/web-ui/app/controllers/conversation-read-state-controller.js

@@ -14,6 +14,9 @@ function displayedAssistantReadBoundary(messages) {
   const numericId = Number(textOf(message.id).replace(/^msg-/, ""));
   const hasPersistedMessageId = Number.isSafeInteger(numericId) && numericId > 0;
   if (hasPersistedMessageId) return { readThroughMessageId: numericId };
+  const persistedId = message.persistedMessageId;
+  const hasPersistedStringId = typeof persistedId === "string" && persistedId.length > 0 && persistedId === message.id;
+  if (hasPersistedStringId) return { readThroughMessageId: persistedId };
   const requestId = textOf(message.requestId).trim();
   if (!requestId) return null;
   return {

package/dist/src/web-ui/app/controllers/conversation-session-controller.d.ts

@@ -35,6 +35,7 @@ export interface ConversationSessionState {
   contextWindowByRequest: Map<string, Record<string, unknown>>;
   submittedToolApprovalIds: Set<string>;
   requestMessages: Map<string, string>;
+  requestLifecycles?: Map<string, Record<string, unknown>>;
   lastSeqByRequest: Map<string, number>;
   sessions: ConversationSession[];
 }
@@ -43,7 +44,7 @@ export interface ConversationSessionClient {
   markSessionRead(options: {
     sessionId: string;
     environmentId: string;
-    readThroughMessageId: number | null;
+    readThroughMessageId: number | string | null;
     readThroughRequestId?: string;
   }): Promise<Record<string, unknown>>;
   listSessions(environmentId: string): Promise<Record<string, unknown>>;
@@ -99,6 +100,7 @@ export interface ConversationSessionControllerOptions {
   drainQueuedMessage(
     input: ConversationSessionScope & {
       terminalRequestId: unknown;
+      cancelled?: boolean;
     },
   ): void | Promise<void>;
   suspendQueueRecovery(): boolean;
@@ -149,7 +151,13 @@ export declare function createConversationSessionController(
   loadSessions(): Promise<ConversationSession[]>;
   markCurrentSessionReadSoon(): void;
   normalizeMessage(raw: unknown): ConversationMessage;
-  openSession(sessionId: string): Promise<void>;
+  openSession(
+    sessionId: string,
+    options?: {
+      isRouteCurrent(): boolean;
+      commitRouteNavigation(): boolean;
+    },
+  ): Promise<void>;
   requestBelongsToCurrentView(requestId: string): boolean;
   resetLiveRequestView(): void;
   restoreLastSession(): Promise<void>;

package/dist/src/web-ui/app/controllers/conversation-session-controller.js

@@ -4,18 +4,33 @@ import { normalizeScheduleReference } from "../lib/schedule-message.js";
 import { createWebSessionId, escapeHtml, textOf } from "../lib/text-format.js";
 import { insertRequestUserMessageBeforeAssistant } from "../ui-behavior.js";
 import { normalizeRealtimeMessage } from "../lib/realtime-message.js";
+import { sparkProposalId } from "../lib/spark-proposal-message.js";
+import {
+  isStoppedRequest,
+  restoreStoppedResponses,
+} from "../lib/request-stop-state.js";
+import {
+  isApprovalPresentation,
+  requestLifecycles,
+  rememberRequestLifecycle,
+  sameConversationMessage,
+} from "../lib/request-lifecycle-view.js";
 
 export function normalizeConversationMessage(raw, fallbackIndex = 0) {
   const message =
     raw?.message && typeof raw.message === "object" ? raw.message : raw;
   return {
     id: textOf(message?.id) || `local-${fallbackIndex + 1}`,
+    persistedMessageId: message?.id ?? null,
+    kind: textOf(message?.kind),
+    approvalRequest: message?.approvalRequest,
     role: textOf(message?.role, "assistant"),
     text: textOf(message?.text ?? message?.content ?? message?.output),
     createdAt: message?.createdAt || Date.now(),
     requestId: textOf(message?.requestId),
     streaming: false,
     schedule: normalizeScheduleReference(message?.schedule),
+    sparkProposalId: sparkProposalId(message),
     events: Array.isArray(message?.events)
       ? message.events.map((event) => textOf(event)).filter(Boolean)
       : [],
@@ -86,15 +101,9 @@ export function createConversationSessionController({
   function addOrMergeMessage(message) {
     const id = textOf(message.id);
     const requestId = textOf(message.requestId);
-    const existingIndex = state.messages.findIndex((item) => {
-      if (id && item.id === id) return true;
-      return Boolean(
-        requestId &&
-        item.requestId === requestId &&
-        item.role === message.role &&
-        item.role === "assistant",
-      );
-    });
+    const existingIndex = state.messages.findIndex((item) =>
+      sameConversationMessage(item, message),
+    );
     if (existingIndex >= 0) {
       state.messages[existingIndex] = {
         ...state.messages[existingIndex],
@@ -106,7 +115,11 @@ export function createConversationSessionController({
     } else {
       state.messages.push(message);
     }
-    if (requestId && message.role === "assistant") {
+    if (
+      requestId &&
+      message.role === "assistant" &&
+      !isApprovalPresentation(message)
+    ) {
       state.requestMessages.set(requestId, message.id);
     }
   }
@@ -116,7 +129,7 @@ export function createConversationSessionController({
     const existing = state.messages.find(
       (message) => message.id === existingId,
     );
-    if (existing) return existing;
+    if (existing && !isApprovalPresentation(existing)) return existing;
 
     const message = {
       id: `assistant-${requestId}`,
@@ -141,6 +154,7 @@ export function createConversationSessionController({
     conversationView.reset();
     state.submittedToolApprovalIds.clear();
     state.requestMessages.clear();
+    requestLifecycles(state).clear();
     state.sessionViewVersion += 1;
     setMessageStatus("");
     updateComposerSendState();
@@ -168,7 +182,8 @@ export function createConversationSessionController({
   function requestBelongsToCurrentView(requestId) {
     if (!requestId) return true;
     return Boolean(
-      state.activeRequestId && requestId === state.activeRequestId,
+      requestLifecycles(state).has(requestId) ||
+      (state.activeRequestId && requestId === state.activeRequestId),
     );
   }
 
@@ -221,7 +236,9 @@ export function createConversationSessionController({
       if (hydrateRequestIds.has(requestId)) continue;
       const assistant = state.messages.find(
         (message) =>
-          message.role === "assistant" && message.requestId === requestId,
+          message.role === "assistant" &&
+          message.requestId === requestId &&
+          !isApprovalPresentation(message),
       );
       if (assistant) assistant.thinkingText = thinkingText;
     }
@@ -269,6 +286,9 @@ export function createConversationSessionController({
       sessionId,
       environment: selectedEnvironmentId(),
     });
+    const hasActiveRequestInSession =
+      sessionId === state.currentSessionId && Boolean(state.activeRequestId);
+    if (hasActiveRequestInSession) resumeRequest(state.activeRequestId);
   }
 
   function subscribeRequest(requestId) {
@@ -391,7 +411,22 @@ export function createConversationSessionController({
     if (targetSession?.id) await openSession(targetSession.id);
   }
 
-  async function openSession(sessionId) {
+  async function openSession(
+    sessionId,
+    { isRouteCurrent, commitRouteNavigation } = {},
+  ) {
+    const routeOwned = typeof commitRouteNavigation === "function";
+    let payload;
+    if (routeOwned) {
+      const environmentId = selectedEnvironmentId();
+      const viewVersion = state.sessionViewVersion;
+      const currentSessionId = state.currentSessionId;
+      payload = await client.loadSession(sessionId, environmentId);
+      if (environmentId !== selectedEnvironmentId()) return;
+      if (viewVersion !== state.sessionViewVersion) return;
+      if (currentSessionId !== state.currentSessionId) return;
+      if (isRouteCurrent?.() !== true) return;
+    }
     if (
       state.currentSessionId &&
       state.currentSessionId !== sessionId &&
@@ -399,6 +434,7 @@ export function createConversationSessionController({
     ) {
       return;
     }
+    if (routeOwned && commitRouteNavigation() !== true) return;
     const viewVersion = state.sessionViewVersion + 1;
     state.currentSessionId = sessionId;
     preferences.saveSessionIdForEnvironment(selectedEnvironmentId(), sessionId);
@@ -415,10 +451,9 @@ export function createConversationSessionController({
     renderMessages();
     subscribeSession(sessionId);
 
-    const payload = await client.loadSession(
-      sessionId,
-      selectedEnvironmentId(),
-    );
+    if (!routeOwned) {
+      payload = await client.loadSession(sessionId, selectedEnvironmentId());
+    }
     if (
       state.currentSessionId !== sessionId ||
       state.sessionViewVersion !== viewVersion
@@ -433,11 +468,17 @@ export function createConversationSessionController({
     sessions.applyTitle(sessionId, payload.title);
     sessions.applyReadState(sessionId, payload.readState);
     for (const message of state.messages) {
-      if (message.role === "assistant" && message.requestId) {
+      if (
+        message.role === "assistant" &&
+        message.requestId &&
+        !isApprovalPresentation(message)
+      ) {
         state.requestMessages.set(message.requestId, message.id);
       }
     }
     const requests = Array.isArray(payload.requests) ? payload.requests : [];
+    for (const request of requests)
+      rememberRequestLifecycle(state, request.lifecycle);
     applyConversationChrome();
     renderSessions();
     const streamingRequestIds = new Set(
@@ -465,6 +506,7 @@ export function createConversationSessionController({
     for (const requestId of streamingRequestIds) {
       activeAssistantForRequest(requestId);
     }
+    restoreStoppedResponses(state.messages, requests);
     restoreSessionEventState(requests, streamingRequestIds);
     for (const request of requests) {
       if (request.status === "streaming" && request.requestId) {
@@ -493,6 +535,7 @@ export function createConversationSessionController({
         await drainQueuedMessage({
           ...scope,
           terminalRequestId: terminal.requestId,
+          cancelled: isStoppedRequest(terminal),
         });
       }
     }

package/dist/src/web-ui/app/controllers/conversation-view-feature.js

@@ -1,10 +1,14 @@
 import { createConversationView } from "../components/conversation-view.js";
 import { createConversationFilePreviewFeature } from "./conversation-file-preview-feature.js";
+import { createSparkConversationActions } from "../components/spark-conversation-actions.js";
 
 export function createConversationViewFeature({
   filePreviewClient,
   getFileEnvironmentId,
   getFileSessionId,
+  preferences,
+  archiveSession,
+  onSparkArchived,
   ...viewOptions
 }) {
   const {
@@ -24,5 +28,15 @@ export function createConversationViewFeature({
     documentRoot,
     viewport,
   });
-  return createConversationView({ ...viewOptions, filePreview });
+  const sparkActions = createSparkConversationActions({
+    getScope: () => ({ environmentId: getFileEnvironmentId?.(), sessionId: getFileSessionId?.() }),
+    getMessages: viewOptions.getMessages,
+    getActiveRequestId,
+    preferences,
+    archiveSession,
+    onArchived: onSparkArchived,
+    notify: viewOptions.notify,
+    documentRoot,
+  });
+  return createConversationView({ ...viewOptions, filePreview, sparkActions });
 }

package/dist/src/web-ui/app/controllers/daily-memory-review.js

@@ -0,0 +1,151 @@
+import { localReviewDay } from "../services/home-guidance-preferences.js";
+
+const reviewLimit = 10;
+const recentLimit = 50;
+
+function hasCoWorkerSource(record) {
+  if (record.origin === "passive_observation") return true;
+  return Array.isArray(record.observationSources) && record.observationSources.length > 0;
+}
+
+function isMemoryPageUnavailable(page) {
+  return page.status?.enabled === false || page.status?.available === false;
+}
+
+function hasValidMemoryTotal(page) {
+  return Number.isSafeInteger(page.total) && page.total >= 0;
+}
+
+/** Uses existing stored-memory APIs; Keep is a UI receipt, never a promotion. */
+export function createDailyMemoryReview({ client, getEnvironmentId, preferences, render, now = () => new Date() }) {
+  let revision = 0;
+  let environment = "";
+  let attemptedDay = "";
+  let items = [];
+  let index = 0;
+  let busy = false;
+  let error = "";
+  let abort;
+  let pendingLoad;
+  let active = false;
+  const snapshot = () => ({ items, index, busy, error, remaining: items.length - index });
+  const publish = () => render(snapshot());
+  const isCurrent = (operation, target) => operation === revision && target === getEnvironmentId();
+
+  function reset() {
+    revision += 1;
+    abort?.abort();
+    abort = null;
+    pendingLoad = null;
+    items = [];
+    index = 0;
+    busy = false;
+    error = "";
+    attemptedDay = "";
+    active = false;
+    publish();
+  }
+
+  async function load(manual = false) {
+    const target = getEnvironmentId();
+    const day = localReviewDay(now());
+    if (!active) return false;
+    if (!manual && attemptedDay === day) return false;
+    attemptedDay = day;
+    const operation = ++revision;
+    abort = new AbortController();
+    const input = { environmentId: target, origin: "passive_observation", signal: abort.signal };
+    error = "";
+    try {
+      const first = await client.listLongTermMemories({ ...input, limit: 1 });
+      if (!isCurrent(operation, target) || !active) return false;
+      if (isMemoryPageUnavailable(first)) throw new Error("Memory unavailable");
+      if (!hasValidMemoryTotal(first)) throw new Error("Invalid memory count");
+      if (first.total === 0) {
+        items = [];
+        index = 0;
+        publish();
+        return true;
+      }
+      const recent = await client.listLongTermMemories({ ...input, limit: recentLimit, offset: Math.max(0, first.total - recentLimit) });
+      if (!isCurrent(operation, target) || !active) return false;
+      if (isMemoryPageUnavailable(recent)) throw new Error("Memory unavailable");
+      items = (recent.items || []).filter(hasCoWorkerSource)
+        .filter((record) => !preferences.hasReviewed(target, record))
+        .sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt)))
+        .slice(0, reviewLimit);
+      index = 0;
+      publish();
+      return true;
+    } catch {
+      // An optional invitation must not interrupt Home or retry in a loop.
+      if (!manual || !isCurrent(operation, target) || !active) return false;
+      error = "Saved memories could not be loaded. Close this review and try again.";
+      publish();
+      return true;
+    }
+  }
+
+  function requestReview(manual = false) {
+    if (pendingLoad) return pendingLoad;
+    const request = load(manual);
+    pendingLoad = request;
+    void request.finally(() => { if (pendingLoad === request) pendingLoad = null; });
+    return request;
+  }
+
+  function markOffered() {
+    if (!items.length || environment !== getEnvironmentId()) return false;
+    const day = localReviewDay(now());
+    if (preferences.wasOffered(environment, day)) return false;
+    preferences.markOffered(environment, day);
+    return true;
+  }
+
+  async function decide(action) {
+    if (!active || busy || environment !== getEnvironmentId()) return false;
+    const record = items[index];
+    if (!record || !["keep", "delete"].includes(action)) return false;
+    const target = environment;
+    const operation = revision;
+    error = "";
+    if (action === "delete") {
+      busy = true;
+      publish();
+      try {
+        const result = await client.deleteLongTermMemory({ environmentId: target, id: record.id });
+        if (!isCurrent(operation, target)) return false;
+        if (result?.deleted !== true) throw new Error("Delete not confirmed");
+      } catch {
+        if (isCurrent(operation, target)) error = "This memory could not be deleted. Try again, or keep it for now.";
+        return false;
+      } finally {
+        if (isCurrent(operation, target)) { busy = false; publish(); }
+      }
+    }
+    if (!isCurrent(operation, target)) return false;
+    preferences.markReviewed(target, record);
+    index += 1;
+    publish();
+    return true;
+  }
+
+  return {
+    snapshot, decide, markOffered, reset,
+    async loadForReview() {
+      const operation = revision;
+      const target = environment;
+      if (pendingLoad) await pendingLoad;
+      if (!active || !isCurrent(operation, target)) return false;
+      if (items.length > index) return true;
+      return requestReview(true);
+    },
+    update(enabled, { automatic = true } = {}) {
+      const target = getEnvironmentId();
+      if (target !== environment) { reset(); environment = target; }
+      if (!enabled) { if (active) reset(); return; }
+      active = true;
+      if (automatic) void requestReview();
+    },
+  };
+}